第9章-全文检索（下）.md 52 KB
第9章-全文检索-站内搜索（下）
学习目标：
- 基于ES完成电商搜索列表
- 完成搜索页面渲染
1、 利用es开发电商的搜索列表功能
商品检索流程：
1.1 搜索结果预期数据展示
利用DSL 语句查询es 数据-看懂即可
GET goods/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"title": {
"query": "手机",
"operator": "and"
}
}
}
],
"filter": [
{
"term": {
"tmName": "华为"
}
},
{
"bool": {
"must": [
{
"nested": {
"path": "attrs",
"query": {
"bool": {
"must": [
{
"term": {
"attrs.attrName": {
"value": "机身存储"
}
}
},
{
"term": {
"attrs.attrValue": {
"value": "256G"
}
}
}
]
}
}
}
}
]
}
}
]
}
},
"from": 0,
"size": 10,
"highlight": {
"pre_tags": "<font style='color:red'>",
"post_tags": "</font>",
"fields": {
"title": {}
}
},
"sort": [
{
"price": {
"order": "desc"
}
}
],
"_source": {
"includes": [
"id",
"title",
"price",
"defaultImg"
]
},
"aggs": {
"tmIdAgg": {
"terms": {
"field": "tmId",
"size": 20
},
"aggs": {
"tmNameAgg": {
"terms": {
"field": "tmName",
"size": 10
}
},
"tmLogoUrlAgg": {
"terms": {
"field": "tmLogoUrl",
"size": 10
}
}
}
},
"attrAggs": {
"nested": {
"path": "attrs"
},
"aggs": {
"attrIdAgg": {
"terms": {
"field": "attrs.attrId",
"size": 10
},
"aggs": {
"atrrNameAgg": {
"terms": {
"field": "attrs.attrName",
"size": 10
}
},
"attrValueAgg": {
"terms": {
"field": "attrs.attrValue",
"size": 10
}
}
}
}
}
}
}
}
1.2 封装搜索相关实体对象
1.2.1 请求参数对象
搜索参数实体：SearchParam
package com.atguigu.gmall.list.model;
import lombok.Data;
// 封装查询条件
// ?category3Id=61&trademark=2:华为&props=23:4G:运行内存&order=1:desc
@Data
public class SearchParam {
private Long category1Id;;//三级分类id
private Long category2Id;
private Long category3Id;
// trademark=2:华为
private String trademark;//品牌
private String keyword;//检索的关键字
// 排序规则
// 1:hotScore 2:price
private String order = ""; // 1：综合排序/热度 2：价格
// props=23:4G:运行内存
//平台属性Id 平台属性值名称 平台属性名
private String[] props;//页面提交的数组
private Integer pageNo = 1;//分页信息
private Integer pageSize = 3; // 每页默认显示的条数
}
1.2.2 响应结果对象
检索结果:SearchResponseVo
package com.atguigu.gmall.list.model;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
// 总的数据
@Data
public class SearchResponseVo implements Serializable {
//品牌 此时vo对象中的id字段保留（不用写） name就是“品牌” value: [{id:100,name:华为,logo:xxx},{id:101,name:小米,log:yyy}]
private List<SearchResponseTmVo> trademarkList;
//所有商品的顶头显示的筛选属性
private List<SearchResponseAttrVo> attrsList = new ArrayList<>();
//检索出来的商品信息
private List<Goods> goodsList = new ArrayList<>();
private Long total;//总记录数
private Integer pageSize;//每页显示的内容
private Integer pageNo;//当前页面
private Long totalPages;
}
结果集品牌实体:SearchResponseTmVo
package com.atguigu.gmall.list.model;
import lombok.Data;
import java.io.Serializable;
// 品牌数据
@Data
public class SearchResponseTmVo implements Serializable {
//当前属性值的所有值
private Long tmId;
//属性名称
private String tmName;//网络制式，分类
//图片名称
private String tmLogoUrl;//网络制式，分类
}
结果集平台属性实体:SearchResponseAttrVo
package com.atguigu.gmall.list.model;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
// 平台属性相关对象
@Data
public class SearchResponseAttrVo implements Serializable {
// 平台属性Id
private Long attrId;//1
//当前属性值的集合
private List<String> attrValueList = new ArrayList<>();
//属性名称
private String attrName;//网络制式，分类
}
1.3 控制器ListApiController
/**
* 商品检索
*
* @param searchParam
* @return
*/
@PostMapping("/inner")
public Result search(@RequestBody SearchParam searchParam) {
SearchResponseVo responseVo = searchService.search(searchParam);
return Result.ok(responseVo);
}
1.4 搜索业务接口
/**
* 商品检索
*
* @param searchParam
* @return
*/
SearchResponseVo search(SearchParam searchParam);
1.5 搜索业务实现类
SearchServiceImpl
package com.atguigu.gmall.list.service.impl;
import com.alibaba.fastjson.JSON;
import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.list.model.*;
import com.atguigu.gmall.list.service.SearchService;
import com.atguigu.gmall.product.client.ProductFeignClient;
import com.atguigu.gmall.product.model.BaseAttrInfo;
import com.atguigu.gmall.product.model.BaseCategoryView;
import com.atguigu.gmall.product.model.BaseTrademark;
import com.atguigu.gmall.product.model.SkuInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.aspectj.weaver.ast.Var;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.NestedQueryBuilder;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.nested.NestedAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.nested.ParsedNested;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedLongTerms;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
/**
* @author: atguigu
* @create: 2023-03-03 10:39
*/
@Slf4j
@Service
@SuppressWarnings("all")
public class SearchServiceImpl implements SearchService {
//索引库名称
private static final String index_name = "goods";
@Autowired
private ProductFeignClient productFeignClient;
@Autowired
private RestHighLevelClient restHighLevelClient;
@Autowired
private RedisTemplate redisTemplate;
/**
* 商品检索 使用SDE通过调用ES提供JavaClientAPI构建DSL语句-请求地址,请求体参数;解析ES响应结果
* 业务数据检索
* 过滤项条件聚合
*
* @param searchParam
* @return
*/
@Override
public SearchResponseVo search(SearchParam searchParam) {
try {
//一.根据用户查询条件构建SearchRequest 构建DSL语句:查询方式;分页;高亮;排序;字段过滤;聚合
SearchRequest searchRequest = this.builderDSL(searchParam);
System.err.println(searchRequest.source().toString());
System.out.println("--------------------");
//二.执行检索,得到响应结果
SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
//三.按照要求封装响应结果
return this.parseResult(response, searchParam);
} catch (IOException e) {
e.printStackTrace();
log.error("[检索商品]异常:{}", e);
}
return new SearchResponseVo();
}
/**
* 目的:构建调用ES Http接口 请求信息(请求地址,方式,路径参数,请求体参数)
*
* @param searchParam
* @return
*/
private SearchRequest builderDSL(SearchParam searchParam) {
//1.创建SearchRequest对象-封装操作索引库请求方式--请求地址 GET goods/_search
SearchRequest searchRequest = new SearchRequest(index_name);
//2.创建SearchSourceBuilder对象-封装请求体JSON对象参数--请求参数
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//2.1 设置查询方式 .query()设置请求体参数:"query"部分
//2.1.1 构建完整的多条件封装Query对象-BoolQueryBuilder
BoolQueryBuilder allBoolQueryBuilder = QueryBuilders.boolQuery();
//2.1.2 设置关键字条件设置
if (StringUtils.isNotBlank(searchParam.getKeyword())) {
allBoolQueryBuilder.must(QueryBuilders.matchQuery("title", searchParam.getKeyword()).operator(Operator.AND));
}
//2.1.3 设置 "品牌" 条件过滤 形式=品牌ID:品牌名称
if (StringUtils.isNotBlank(searchParam.getTrademark())) {
String[] split = searchParam.getTrademark().split(":");
if (split != null && split.length == 2) {
allBoolQueryBuilder.filter(QueryBuilders.termQuery("tmId", split[0]));
}
}
//2.1.4 设置 "分类" 条件过滤
if (searchParam.getCategory1Id() != null) {
allBoolQueryBuilder.filter(QueryBuilders.termQuery("category1Id", searchParam.getCategory1Id()));
}
if (searchParam.getCategory2Id() != null) {
allBoolQueryBuilder.filter(QueryBuilders.termQuery("category2Id", searchParam.getCategory2Id()));
}
if (searchParam.getCategory3Id() != null) {
allBoolQueryBuilder.filter(QueryBuilders.termQuery("category3Id", searchParam.getCategory3Id()));
}
//2.1.5 设置 "平台属性" 条件过滤 形式-平台属性Id:平台属性值名称:平台属性名
//2.1.5.1 获取所有的用户提交平台属性条件数组
String[] props = searchParam.getProps();
if (props != null && props.length > 0) {
BoolQueryBuilder attrBoolQueryBuilder = QueryBuilders.boolQuery();
//2.2.5.2 遍历平台属性过滤条件 每遍历一次 构建"nested"布尔查询对象
for (String prop : props) {
String[] split = prop.split(":");
if (split != null && split.length == 3) {
BoolQueryBuilder attrIdAndAttrValueBoolQueryBuilder = QueryBuilders.boolQuery();
attrIdAndAttrValueBoolQueryBuilder.must(QueryBuilders.termQuery("attrs.attrId", split[0]));
attrIdAndAttrValueBoolQueryBuilder.must(QueryBuilders.termQuery("attrs.attrValue", split[1]));
NestedQueryBuilder nestedQueryBuilder =
QueryBuilders.nestedQuery("attrs", attrIdAndAttrValueBoolQueryBuilder, ScoreMode.None);
attrBoolQueryBuilder.must(nestedQueryBuilder);
}
}
allBoolQueryBuilder.filter(attrBoolQueryBuilder);
}
sourceBuilder.query(allBoolQueryBuilder);
//2.2 设置分页 .from() .size 设置请求参数: "from","size"
int from = (searchParam.getPageNo() - 1) * searchParam.getPageSize();
sourceBuilder.from(from).size(searchParam.getPageSize());
//2.3 设置高亮 highlighter()设置请求参数中:"highlight"
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font style='color:red'>");
highlightBuilder.postTags("</font>");
highlightBuilder.field("title");
sourceBuilder.highlighter(highlightBuilder);
//2.4 设置排序 sort()设置请求参数中"sort" 形式: 排序规则:asc/desc 排序规则1:商品热度 排序规则2:价格
if (StringUtils.isNotBlank(searchParam.getOrder())) {
//2.4.1 获取排序条件值 按照":"进行分割
String[] split = searchParam.getOrder().split(":");
if (split != null && split.length == 2) {
String orderField = "";
switch (split[0]) {
case "1":
orderField = "hotScore";
break;
case "2":
orderField = "price";
break;
}
//2.4.2 通过排序规则判断得到排序字段
sourceBuilder.sort(orderField, "asc".equals(split[1]) ? SortOrder.ASC : SortOrder.DESC);
}
}
//2.5 设置过滤字段 fetchSource() 设置请求参数中:"_source"
sourceBuilder.fetchSource(new String[]{"id", "title", "price", "defaultImg"}, null);
//2.6 设置聚合 aggregation() 设置请求参数中:"aggs"
//2.6.1 设置"品牌"聚合 聚合三要素:聚合名称;聚合类型;聚合字段 terms("聚合名称").field("字段")
//2.6.1.1 创建品牌ID聚合
TermsAggregationBuilder tmIdAgg = AggregationBuilders.terms("tmIdAgg").field("tmId");//.size(30);
//2.6.1.2 基于品牌ID聚合创建品牌名称子聚合
tmIdAgg.subAggregation(AggregationBuilders.terms("tmNameAgg").field("tmName"));//.size(1);
//2.6.1.3 基于品牌ID聚合创建品牌Logo图片子聚合
tmIdAgg.subAggregation(AggregationBuilders.terms("tmLgoUrlAgg").field("tmLogoUrl"));//.size(1);
sourceBuilder.aggregation(tmIdAgg);
//2.6.2 设置"平台属性"聚合
//2.6.2.1 创建"nested"聚合对象-对平台属性聚合
NestedAggregationBuilder attrAgg = AggregationBuilders.nested("attrsAgg", "attrs");
//2.6.2.2 创建平台属性ID子聚合对象
TermsAggregationBuilder attrIdAgg = AggregationBuilders.terms("attrIdAgg").field("attrs.attrId");
//2.6.2.2.1 基于平台属性ID聚合创建 平台属性名称聚合
attrIdAgg.subAggregation(AggregationBuilders.terms("attrNameAgg").field("attrs.attrName"));
//2.6.2.2.2 基于平台属性ID聚合创建 平台属性值聚合
attrIdAgg.subAggregation(AggregationBuilders.terms("attrValueAgg").field("attrs.attrValue"));
//将平台属性ID聚合加入到平属性聚合中
attrAgg.subAggregation(attrIdAgg);
sourceBuilder.aggregation(attrAgg);
//3.将SearchSourceBuilder对象关联到SearchRequest
return searchRequest.source(sourceBuilder);
}
/**
* 解析ES响应结果:业务数据结果;聚合结果
*
* @param response
* @param searchParam
* @return
*/
private SearchResponseVo parseResult(SearchResponse response, SearchParam searchParam) {
//1.创建搜索响应VO对象
SearchResponseVo vo = new SearchResponseVo();
//2.封装分页信息
vo.setPageNo(searchParam.getPageNo());
Integer pageSize = searchParam.getPageSize();
vo.setPageSize(pageSize);
//2.1 获取总记录数
long total = response.getHits().getTotalHits().value;
vo.setTotal(total);
//2.2 计算总页数 总数%页大小能整除=总数/页大小 反之+1
Long totalPage = total % pageSize == 0 ? total / pageSize : total / pageSize + 1;
vo.setTotalPages(totalPage);
//3.封装检索到商品数据-注意处理高亮字段
SearchHit[] hits = response.getHits().getHits();
List<Goods> goodsList = new ArrayList<>();
if (hits != null && hits.length > 0) {
for (SearchHit hit : hits) {
//3.1 将得到商品JSON字符串转为Java对象
Goods goods = JSON.parseObject(hit.getSourceAsString(), Goods.class);
//3.2 处理高亮
if(!CollectionUtils.isEmpty(hit.getHighlightFields())){
Text[] titles = hit.getHighlightFields().get("title").getFragments();
if (titles != null && titles.length > 0) {
goods.setTitle(titles[0].toString());
}
}
goodsList.add(goods);
}
}
vo.setGoodsList(goodsList);
//4.封装品牌聚合结果
Map<String, Aggregation> allAggregationMap = response.getAggregations().asMap();
//4.1 获取品牌ID聚合对象 通过获取品牌ID桶得到聚合品牌ID
ParsedLongTerms tmIdAgg = (ParsedLongTerms) allAggregationMap.get("tmIdAgg");
if (tmIdAgg != null) {
List<SearchResponseTmVo> tmVoList = tmIdAgg.getBuckets().stream().map(bucket -> {
SearchResponseTmVo tmVo = new SearchResponseTmVo();
long tmId = ((Terms.Bucket) bucket).getKeyAsNumber().longValue();
tmVo.setTmId(tmId);
//4.2 从品牌Id桶内获取品牌名称聚合对象,遍历品牌名称桶得到桶中品牌名称-只有一个
ParsedStringTerms tmNameAgg = ((Terms.Bucket) bucket).getAggregations().get("tmNameAgg");
if (tmNameAgg != null) {
String tmName = tmNameAgg.getBuckets().get(0).getKeyAsString();
tmVo.setTmName(tmName);
}
//4.3 从品牌Id桶内获取品牌图片聚合对象,遍历品牌图片桶得到桶中图片Logo-只有一个
ParsedStringTerms tmLgoUrlAgg = ((Terms.Bucket) bucket).getAggregations().get("tmLgoUrlAgg");
if (tmLgoUrlAgg != null) {
String tmLogoUrl = tmLgoUrlAgg.getBuckets().get(0).getKeyAsString();
tmVo.setTmLogoUrl(tmLogoUrl);
}
return tmVo;
}).collect(Collectors.toList());
//为响应对象封装聚合品牌列表
vo.setTrademarkList(tmVoList);
}
//5.封装平台属性聚合结果
//5.1 获取平台属性聚合对象
ParsedNested attrsAgg = (ParsedNested) allAggregationMap.get("attrsAgg");
//5.2 通过平台数据聚合对象获取平台属性ID的聚合对象,获取平台属性ID聚合桶集合
if (attrsAgg != null) {
ParsedLongTerms attrIdAgg = attrsAgg.getAggregations().get("attrIdAgg");
if (attrIdAgg != null) {
//5.3 遍历ID桶集合 获取平台属性ID 以及平台属性名称跟属性值
List<SearchResponseAttrVo> attrVoList = attrIdAgg.getBuckets().stream().map(bucket -> {
SearchResponseAttrVo attrVo = new SearchResponseAttrVo();
//获取平台属性Id
long atrrId = ((Terms.Bucket) bucket).getKeyAsNumber().longValue();
attrVo.setAttrId(atrrId);
//5.3.1 基于平台属性ID聚合对象 获取平台属性名称子聚合对象.获取平台名称桶内平台属性名称 只有一个
ParsedStringTerms attrNameAgg = ((Terms.Bucket) bucket).getAggregations().get("attrNameAgg");
if (attrNameAgg != null) {
String attrName = attrNameAgg.getBuckets().get(0).getKeyAsString();
attrVo.setAttrName(attrName);
}
//5.3.2 基于平台属性ID聚合对象 获取平台属性值子聚合对象.获取平台属性值桶内平台属性值名称
ParsedStringTerms attrValueAgg = ((Terms.Bucket) bucket).getAggregations().get("attrValueAgg");
if (attrValueAgg != null) {
//遍历平台属性值桶,得到桶内每个平台属性值
List<String> attrValueList = attrValueAgg.getBuckets().stream().map(attrValueBucket -> {
return ((Terms.Bucket) attrValueBucket).getKeyAsString();
}).collect(Collectors.toList());
attrVo.setAttrValueList(attrValueList);
}
return attrVo;
}).collect(Collectors.toList());
//给响应VO对象赋值:平台属性集合
vo.setAttrsList(attrVoList);
}
}
return vo;
}
}
说明：http://localhost:8203/doc.html，左上角下拉框选择 webApi进行测试
测试参数：
#根据分类检索
{
"category3Id": 61
}
#根据分类，关键字检索
{
"keyword":"手机"
"category3Id": 61
}
#根据分类品牌关键字检索
{
"keyword":"手机",
"category3Id": 61,
"trademark":"2:苹果"
}
#加入排序
{
"keyword":"手机",
"category3Id": 61,
"trademark":"2:苹果",
"order":"2:desc"
}
#加入排序
{
"keyword":"手机",
"category3Id": 61,
"trademark":"2:苹果",
"order":"2:desc",
"props":["23:6G:运行内存","24:128G:机身内存"]
}
2、在service-list-client模块添加接口
在service-list-client模块ListFeignClient远程调用Feign接口中增加方法
package com.atguigu.gmall.list.client;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.impl.ListDegradeFeignClient;
import com.atguigu.gmall.list.model.SearchParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(value = "service-list", fallback = ListDegradeFeignClient.class)
public interface ListFeignClient {
//...
/**
* 搜索商品
* @param listParam
* @return
*/
@PostMapping("/api/list/inner")
Result list(@RequestBody SearchParam listParam);
/**
* 上架商品
* @param skuId
* @return
*/
@GetMapping("/api/list/inner/upperGoods/{skuId}")
Result upperGoods(@PathVariable("skuId") Long skuId);
/**
* 下架商品
* @param skuId
* @return
*/
@GetMapping("/api/list/inner/lowerGoods/{skuId}")
Result lowerGoods(@PathVariable("skuId") Long skuId);
}
远程调用接口的服务降级类
package com.atguigu.gmall.list.client.impl;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.ListFeignClient;
import com.atguigu.gmall.list.model.SearchParam;
import com.atguigu.gmall.list.model.SearchResponseVo;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class ListDegradeFeignClient implements ListFeignClient {
@Override
public Result incrHotScore(Long skuId) {
return null;
}
@Override
public Result<Map> search(SearchParam searchParam) {
return null;
}
}
3、修改web-all模块
3.1 修改pom.xml文件
在web-all模块中的pom.xml中增加依赖
<dependency>
<groupId>com.atguigu.gmall</groupId>
<artifactId>service-list-client</artifactId>
<version>1.0</version>
</dependency>
3.2 在ListController控制器调用接口
在web-all模块中处理前端搜索请求
package com.atguigu.gmall.all.controller;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.ListFeignClient;
import com.atguigu.gmall.list.model.SearchParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.Map;
/**
* <p>
* 产品列表接口
* </p>
*
*/
@Controller
public class ListController {
@Autowired
private ListFeignClient listFeignClient;
/**
* 门户页面中商品检索页面渲染
*
* @param searchParam
* @param model
* @return
*/
@GetMapping("/list.html")
public String search(SearchParam searchParam, Model model) {
Result<Map> result = listFeignClient.list(searchParam);
model.addAllAttributes(result.getData());
return "list/index";
}
}
3.3 配置网关
在 gmall-gateway 网关模块，增加web-all服务的动态路由，需要在Nacos配置列表中，对server-gateway-dev.yaml配置进行编辑增加以下信息
#==================web-all服务==========================
- id: web-comment
uri: lb://web-all
predicates:
- Host=comment.gmall.com
3.4 页面渲染
列表显示
<li class="yui3-u-1-5" th:each="goods: ${goodsList}">
<div class="list-wrap">
<div class="p-img">
<a th:href="@{http://item.gmall.com/{id}.html(id=${goods.id})}" target="_blank"><img th:src="${goods.defaultImg}"/></a>
</div>
<div class="price">
<strong>
<em>¥</em>
<i th:text="${goods.price}">6088.00</i>
</strong>
</div>
<div class="attr">
<a th:href="@{http://item.gmall.com/{id}.html(id=${goods.id})}" target="_blank" th:utext="${goods.title}">Apple苹果iPhone 6s (A1699)Apple苹果iPhone 6s (A1699)Apple苹果iPhone 6s (A1699)Apple苹果iPhone 6s (A1699)</a>
</div>
<div class="commit">
<i class="command">已有<span>2000</span>人评价</i>
</div>
<div class="operate">
<a href="javascript:void(0);" class="sui-btn btn-bordered btn-danger">自营</a>
<a href="javascript:void(0);" class="sui-btn btn-bordered">收藏</a>
</div>
</div>
</li>
3.5 搜索条件处理
3.5.1 根据搜索对象SearchParam拼接url
ListController
package com.atguigu.gmall.web;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.ListFeignClient;
import com.atguigu.gmall.list.model.SearchAttr;
import com.atguigu.gmall.list.model.SearchParam;
import com.atguigu.gmall.product.model.BaseAttrInfo;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: atguigu
* @create: 2023-03-06 10:45
*/
@Controller
public class ListController {
@Autowired
private ListFeignClient listFeignClient;
/**
* 渲染搜索业务
*
* @param searchParam
* @return
*/
@GetMapping("/list.html")
public String searchHtml(SearchParam searchParam, Model model) {
//远程调用搜索微服务查询业务数据,以及过滤数据,回显业务所需数据
//1.进行站内搜搜索渲染业务数据,过滤项数据
Result<Map> result = listFeignClient.search(searchParam);
model.addAllAttributes(result.getData());
//2.为了渲染搜索页面除了以上Feign接口响应数据外 还需要四项数据
//2.1 封装数据 key:searchParam val:用户提交的搜索条件
model.addAttribute("searchParam", searchParam);
//2.2 封装回显页面地址栏请求参数数据 key:urlParam val:用户提交参数完成url地址 "list.html?keyword=手机&props="
model.addAttribute("urlParam", this.makeUrlParam(searchParam));
//2.3 封装回显页面选中平台属性效果数据 key:propsParamList val:选中平台属性过滤条件
//2.4 封装回显排序信息数据 key:orderMap val:排序信息 包含两个属性:1type-1综合 2价格 2sort-asc/desc
//2.5 封装回显品牌数据 key:trademarkParam val:选中品牌
return "/list/index";
}
/**
* 用来制作回显浏览器地址栏中请求地址
*
* @param searchParam
* @return
*/
private String makeUrlParam(SearchParam searchParam) {
StringBuilder urlStringBuilder = new StringBuilder("/list.html?");
if (StringUtils.isNotBlank(searchParam.getKeyword())) {
urlStringBuilder.append("&keyword=" + searchParam.getKeyword());
}
if (StringUtils.isNotBlank(searchParam.getTrademark())) {
urlStringBuilder.append("&trademark=" + searchParam.getTrademark());
}
if (searchParam.getCategory1Id() != null) {
urlStringBuilder.append("&category1Id=" + searchParam.getCategory1Id());
}
if (searchParam.getCategory2Id() != null) {
urlStringBuilder.append("&category2Id=" + searchParam.getCategory2Id());
}
if (searchParam.getCategory3Id() != null) {
urlStringBuilder.append("&category3Id=" + searchParam.getCategory3Id());
}
String[] props = searchParam.getProps();
if (props != null && props.length > 0) {
for (String prop : props) {
urlStringBuilder.append("&props=" + prop);
}
}
if (StringUtils.isNotBlank(searchParam.getOrder())) {
urlStringBuilder.append("&order=" + searchParam.getOrder());
}
return urlStringBuilder.toString();
}
}
页面处理属性：平台属性处理 web-all/resources/templates/list/index.html
<div class="type-wrap" th:each="baseAttrInfo:${attrsList}" th:unless="${#strings.contains(urlParam, 'props='+baseAttrInfo.attrId)}">
<div class="fl key" th:text="${baseAttrInfo.attrName}">网络制式</div>
<div class="fl value">
<ul class="type-list">
<li th:each="attrValue:${baseAttrInfo.attrValueList}">
<a href="" th:text="${attrValue}" >属性值111</a>
</li>
</ul>
</div>
<div class="fl ext"></div>
</div>
说明：
1，这样平台属性就拼接到url中，并且能保持参数了
2，点击平台属性，改平台属性就不在列表中显示了，控制如下：
th:unless="${#strings.contains(urlParam, 'props='+baseAttrInfo.attrId)}"
页面处理品牌显示
说明：th:if="${searchParam.trademark == null}" 控制品牌是否显示
<div class="type-wrap logo" th:if="${searchParam.trademark == null}">
<div class="fl key brand">品牌</div>
<div class="value logos">
<ul class="logo-list">
<li th:each="trademark:${trademarkList}">
<a href="" th:text="${trademark.tmName}">属性值</a>
</li>
</ul>
</div>
</div>
说明：目前页面已经渲染，但是搜索条件我们怎么处理，搜索条件值如何保持等问题还没解决，如图：
说明：所有的搜索条件都拼接到了一个url上面，除分页参数与排序
页面处理分页
<div class="sui-pagination pagination-large">
<ul>
<li class="prev" th:if="${pageNo != 1}">
<a th:href="${urlParam}+'&pageNo='+${pageNo - 1}">上一页</a>
</li>
<li class="prev disabled" th:if="${pageNo == 1}">
<a href="javascript:">上一页</a>
</li>
<li th:each="i : ${#numbers.sequence(1,totalPages)}" th:class="${i == pageNo} ? 'active' : ''">
<a th:href="${urlParam}+'&pageNo='+${i}"><span th:text="${i}"></span></a>
</li>
<li class="next" th:if="${pageNo < totalPages}">
<a th:href="${urlParam}+'&pageNo='+${pageNo + 1}">下一页</a>
</li>
<li class="next disabled" th:if="${pageNo == totalPages}">
<a href="javascript:">下一页</a>
</li>
</ul>
<div><span>共<span th:text="${totalPages }"></span>页 </span><span></div>
</div>
3.5.2 面包屑处理
品牌与平台属性
ListController 修改 search方法
package com.atguigu.gmall.web;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.ListFeignClient;
import com.atguigu.gmall.list.model.SearchAttr;
import com.atguigu.gmall.list.model.SearchParam;
import com.atguigu.gmall.product.model.BaseAttrInfo;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: atguigu
* @create: 2023-03-06 10:45
*/
@Controller
public class ListController {
@Autowired
private ListFeignClient listFeignClient;
/**
* 渲染搜索业务
*
* @param searchParam
* @return
*/
@GetMapping("/list.html")
public String searchHtml(SearchParam searchParam, Model model) {
//远程调用搜索微服务查询业务数据,以及过滤数据,回显业务所需数据
//1.进行站内搜搜索渲染业务数据,过滤项数据
Result<Map> result = listFeignClient.search(searchParam);
model.addAllAttributes(result.getData());
//2.为了渲染搜索页面除了以上Feign接口响应数据外 还需要四项数据
//2.1 封装数据 key:searchParam val:用户提交的搜索条件
model.addAttribute("searchParam", searchParam);
//2.2 封装回显页面地址栏请求参数数据 key:urlParam val:用户提交参数完成url地址 "list.html?keyword=手机&props="
model.addAttribute("urlParam", this.makeUrlParam(searchParam));
//2.3 封装回显页面选中平台属性效果数据 key:propsParamList val:选中平台属性过滤条件
model.addAttribute("propsParamList", this.makePropPramList(searchParam.getProps()));
//2.4 封装回显排序信息数据 key:orderMap val:排序信息 包含两个属性:1type-1综合 2价格 2sort-asc/desc
//2.5 封装回显品牌数据 key:trademarkParam val:选中品牌
model.addAttribute("trademarkParam", this.makeTrademarkParam(searchParam.getTrademark()));
return "/list/index";
}
/**
* 制作回显的品牌信息 结果: 品牌:品牌名称 提交参数:2:华为
* @param trademark
* @return
*/
private String makeTrademarkParam(String trademark) {
if(StringUtils.isNotBlank(trademark)){
String[] split = trademark.split(":");
if(split!=null && split.length==2){
return "品牌:"+split[1];
}
}
return null;
}
/**
* 处理用户回显平台属性选中 面包屑
*
* @param props
* @return
*/
private List<SearchAttr> makePropPramList(String[] props) {
List<SearchAttr> searchAttrs = new ArrayList<>();
if (props != null && props.length > 0) {
for (String prop : props) {
String[] split = prop.split(":");
//平台属性过滤条件 - 平台属性ID:平台属性值:平台属性名称
if (split != null && split.length == 3) {
SearchAttr searchAttr = new SearchAttr();
searchAttr.setAttrId(Long.valueOf(split[0]));
searchAttr.setAttrValue(split[1]);
searchAttr.setAttrName(split[2]);
searchAttrs.add(searchAttr);
}
}
}
return searchAttrs;
}
}
前台页面数据展示：
页面处理
1，关键字
<ul class="fl sui-breadcrumb">
<li>
<a href="#">全部结果</a>
</li>
<li class="active">
<span th:text="${searchParam.keyword}"></span>
</li>
</ul>
2，品牌处理
<ul class="fl sui-tag">
<li th:if="${searchParam.trademark != null}" class="with-x">
<span th:text="${trademarkParam}"></span>
<a th:href="@{${#strings.replace(urlParam,'trademark='+searchParam.trademark,'')}}">×</a>
</li>
</ul>
说明：urlParam里面已经包含品牌参数，该链接必须去除该参数，所以我们可以使用thymeleaf 字符串替换函数，把品牌参数替换了就可以了，
${#strings.replace(urlParam,'trademark='+searchParam.trademark,'')}
3，平台属性处理
<ul class="fl sui-tag">
<li th:if="${searchParam.props != null}" th:each="prop : ${propsParamList}" class="with-x">
<span th:text="${prop.attrName}+'：'+${prop.attrValue}"></span>
<a th:href="@{${#strings.replace(urlParam+'&order='+searchParam.order,'props='+prop.attrId+':'+prop.attrValue+':'+prop.attrName,'')}}">×</a>
</li>
</ul>
说明：与品牌一样，替换掉对应的平台属性值即可
${#strings.replace(urlParam,'props='+prop.attrId+':'+prop.attrValue+':'+prop.attrName,'')}
3.5.3 排序处理
注意：只要做了排序回显，业务数据就可以渲染
ListController
package com.atguigu.gmall.web;
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.list.client.ListFeignClient;
import com.atguigu.gmall.list.model.SearchAttr;
import com.atguigu.gmall.list.model.SearchParam;
import com.atguigu.gmall.product.model.BaseAttrInfo;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author: atguigu
* @create: 2023-03-06 10:45
*/
@Controller
public class ListController {
@Autowired
private ListFeignClient listFeignClient;
/**
* 渲染搜索业务
*
* @param searchParam
* @return
*/
@GetMapping("/list.html")
public String searchHtml(SearchParam searchParam, Model model) {
//远程调用搜索微服务查询业务数据,以及过滤数据,回显业务所需数据
//1.进行站内搜搜索渲染业务数据,过滤项数据
Result<Map> result = listFeignClient.search(searchParam);
model.addAllAttributes(result.getData());
//2.为了渲染搜索页面除了以上Feign接口响应数据外 还需要四项数据
//2.1 封装数据 key:searchParam val:用户提交的搜索条件
model.addAttribute("searchParam", searchParam);
//2.2 封装回显页面地址栏请求参数数据 key:urlParam val:用户提交参数完成url地址 "list.html?keyword=手机&props="
model.addAttribute("urlParam", this.makeUrlParam(searchParam));
//2.3 封装回显页面选中平台属性效果数据 key:propsParamList val:选中平台属性过滤条件
model.addAttribute("propsParamList", this.makePropPramList(searchParam.getProps()));
//2.4 封装回显排序信息数据 key:orderMap val:排序信息 包含两个属性:1type-1综合 2价格 2sort-asc/desc
model.addAttribute("orderMap", this.makeOrderMap(searchParam.getOrder()));
//2.5 封装回显品牌数据 key:trademarkParam val:选中品牌
model.addAttribute("trademarkParam", this.makeTrademarkParam(searchParam.getTrademark()));
return "/list/index";
}
/**
* 制作回显的品牌信息 结果: 品牌:品牌名称 提交参数:2:华为
* @param trademark
* @return
*/
private String makeTrademarkParam(String trademark) {
if(StringUtils.isNotBlank(trademark)){
String[] split = trademark.split(":");
if(split!=null && split.length==2){
return "品牌:"+split[1];
}
}
return null;
}
/**
* 处理用户回显平台属性选中 面包屑
*
* @param props
* @return
*/
private List<SearchAttr> makePropPramList(String[] props) {
List<SearchAttr> searchAttrs = new ArrayList<>();
if (props != null && props.length > 0) {
for (String prop : props) {
String[] split = prop.split(":");
//平台属性过滤条件 - 平台属性ID:平台属性值:平台属性名称
if (split != null && split.length == 3) {
SearchAttr searchAttr = new SearchAttr();
searchAttr.setAttrId(Long.valueOf(split[0]));
searchAttr.setAttrValue(split[1]);
searchAttr.setAttrName(split[2]);
searchAttrs.add(searchAttr);
}
}
}
return searchAttrs;
}
/**
* 用来制作回显浏览器地址栏中请求地址
*
* @param searchParam
* @return
*/
private String makeUrlParam(SearchParam searchParam) {
StringBuilder urlStringBuilder = new StringBuilder("/list.html?");
if (StringUtils.isNotBlank(searchParam.getKeyword())) {
urlStringBuilder.append("&keyword=" + searchParam.getKeyword());
}
if (StringUtils.isNotBlank(searchParam.getTrademark())) {
urlStringBuilder.append("&trademark=" + searchParam.getTrademark());
}
if (searchParam.getCategory1Id() != null) {
urlStringBuilder.append("&category1Id=" + searchParam.getCategory1Id());
}
if (searchParam.getCategory2Id() != null) {
urlStringBuilder.append("&category2Id=" + searchParam.getCategory2Id());
}
if (searchParam.getCategory3Id() != null) {
urlStringBuilder.append("&category3Id=" + searchParam.getCategory3Id());
}
String[] props = searchParam.getProps();
if (props != null && props.length > 0) {
for (String prop : props) {
urlStringBuilder.append("&props=" + prop);
}
}
//前端排序没有做替换处理导致地址栏中拼接多个排序条件.后端代码去掉追加排序条件
//if (StringUtils.isNotBlank(searchParam.getOrder())) {
// urlStringBuilder.append("&order=" + searchParam.getOrder());
//}
return urlStringBuilder.toString();
}
/**
* 制作用户回显排序页面效果方法
*
* @param order
* @return
*/
private Map makeOrderMap(String order) {
if (StringUtils.isNotBlank(order)) {
String[] split = order.split(":");
if (split != null && split.length == 2) {
HashMap<String, String> orderMap = new HashMap<>();
orderMap.put("type", split[0]);
orderMap.put("sort", split[1]);
return orderMap;
}
}else{
//如果前端页面没有提交排序字段,需要给他设置默认排序
HashMap<String, String> orderMap = new HashMap<>();
orderMap.put("type", "1");
orderMap.put("sort", "desc");
return orderMap;
}
return null;
}
}
页面
<ul class="sui-nav">
<li th:class="${orderMap.type == '1' ? 'active': ''}">
<a th:href="${urlParam}+'&order=1:'+${orderMap.sort == 'asc' ? 'desc' : 'asc'}">
综合<span th:if="${orderMap.type == '1'}" th:text="${orderMap.sort == 'asc' ? '↑' : '↓'}"></span>
</a>
</li>
<li th:class="${orderMap.type == '2' ? 'active': ''}">
<a th:href="${urlParam}+'&order=2:'+${orderMap.sort == 'asc' ? 'desc' : 'asc'}">
价格<span th:if="${orderMap.type == '2'}" th:text="${orderMap.sort == 'asc' ? '↑' : '↓'}"></span>
</a>
</li>
<li>
<a href="#">新品</a>
</li>
<li>
<a href="#">评价</a>
</li>
</ul>
说明：
1，排序没有拼接到urlParam中，原因：如果拼接会重复出现
2，为了保持排序条件，所以其他所有链接都需加上排序参数
改造其他连接
分页
<a th:href="${urlParam}+'&pageNo='+${i}+'&order='+${searchParam.order}"><span th:text="${i}"></span></a>
1，平台属性
<a th:href="${urlParam}+'&props='+${baseAttrInfo.attrId}+':'+${attrValue}+':'+${baseAttrInfo.attrName}+'&order='+${searchParam.order}" th:text="${attrValue}" >属性值111</a>
</li>
2，品牌
<a th:href="${urlParam}+'&trademark='+${trademark.tmId}+':'+${trademark.tmName}+'&order='+${searchParam.order}" th:text="${trademark.tmName}">属性值111</a>
</li>
3，面包屑
<ul class="fl sui-tag">
<li th:if="${searchParam.trademark != null}" class="with-x">
<span th:text="${trademarkParam}"></span>
<a th:href="@{${#strings.replace(urlParam+'&order='+searchParam.order,'trademark='+searchParam.trademark,'')}}">×</a>
</li>
<li th:if="${searchParam.props != null}" th:each="prop : ${propsParamList}" class="with-x">
<span th:text="${prop.attrName}+'：'+${prop.attrValue}"></span>
<a th:href="@{${#strings.replace(urlParam+'&order='+searchParam.order,'props='+prop.attrId+':'+prop.attrValue+':'+prop.attrName,'')}}">×</a>
</li>
</ul>
4、在service-list模块中配置logstash
4.1 安装logstash
看电商软件环境安装.md
ELK/EFK
- E ElasticSearch作用:检索存储分析/分词
- L Logstash作用
- K Kibana作用:操作ES的图形化客户端,各种数据报表仪表盘
- F FileBeats 作用跟logstash相同
4.2 在service模块中添加依赖
<dependency>
<groupId>net.logstash.logback</groupId>
<artifactId>logstash-logback-encoder</artifactId>
<version>5.1</version>
</dependency>
4.3 将日志配置文件放入到resources目录下！
创建logback-spring.xml配置文件，内存如下：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<contextName>logback</contextName>
<!-- 日志的输出目录 -->
<property name="log.path" value="D:/logs/gmall/list" />
<!--控制台日志格式：彩色日志-->
<!-- magenta:洋红 -->
<!-- boldMagenta:粗红-->
<!-- cyan:青色 -->
<!-- white:白色 -->
<!-- magenta:洋红 -->
<property name="CONSOLE_LOG_PATTERN"
value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) %highlight([%-5level]) %green(%logger) %msg%n"/>
<!--文件日志格式-->
<property name="FILE_LOG_PATTERN"
value="%date{yyyy-MM-dd HH:mm:ss} [%-5level] %thread %file:%line %logger %msg%n" />
<!--编码-->
<property name="ENCODING"
value="UTF-8" />
<!-- 控制台日志 -->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<!-- 临界值过滤器 -->
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>INFO</level>
</filter>
<encoder>
<!--CONSOLE_LOG_PATTERN 控制台格式 FILE_LOG_PATTERN 文件格式-->
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
<charset>${ENCODING}</charset>
</encoder>
</appender>
<!-- 文件日志 -->
<appender name="FILE" class="ch.qos.logback.core.FileAppender">
<!--日志输出的目录是在哪?-->
<file>${log.path}/log.log</file>
<append>true</append>
<encoder>
<pattern>${FILE_LOG_PATTERN}</pattern>
<charset>${ENCODING}</charset>
</encoder>
</appender>
<appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- 级别过滤器 -->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch><!-- 当前要输出的日志如果是ERROR级别，则输出 -->
<onMismatch>DENY</onMismatch><!-- 当前要输出的日志如果不是ERROR级别，则拒绝输出 -->
</filter>
<!-- 要区别于其他的appender中的文件名字 -->
<file>${log.path}/log-rolling-error.log</file>
<encoder>
<pattern>${FILE_LOG_PATTERN}</pattern>
<charset>${ENCODING}</charset>
</encoder>
<!-- 设置滚动日志记录的滚动策略 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 日志归档路径以及格式 -->
<fileNamePattern>${log.path}/info/log-rolling-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<!--归档日志文件保留的最大数量-->
<maxHistory>15</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
</appender>
<!-- logstash日志 -->
<appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
<!-- logstash ip和暴露的端口，logback就是通过这个地址把日志发送给logstash -->
<destination>192.168.200.128:5044</destination>
<encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />
</appender>
<!-- 开发环境 -->
<springProfile name="dev">
<!-- com.atguigu日志记录器：业务程序INFO,debug,warn,error级别 -->
<logger name="com.atguigu" level="INFO" />
<!-- 根日志记录器：INFO级别 -->
<root level="INFO">
<!--控制台输出模式-->
<appender-ref ref="CONSOLE" />
<!--FILE 文件基本输出-->
<!--<appender-ref ref="FILE" />-->
<!--有回滚日志记录-->
<appender-ref ref="ROLLING_FILE" />
<!--配置logstash 日志！-->
<appender-ref ref="LOGSTASH" />
</root>
</springProfile>
<!-- 生产或和试环境 -->
<!-- <springProfile name="test,prod">-->
<!-- <logger name="com.atguigu" level="INFO" additivity="false">-->
<!-- <appender-ref ref="CONSOLE" />-->
<!-- </logger>-->
<!-- <root level="ERROR">-->
<!-- <appender-ref ref="CONSOLE" />-->
<!-- <appender-ref ref="ROLLING_FILE" />-->
<!-- </root>-->
<!-- </springProfile>-->
</configuration>