第9章-全文检索（下）.md 53 KB
第9章-全文检索-站内搜索（下）
学习目标：
- 基于ES完成电商搜索列表(重点)
- 完成搜索页面渲染
1、 利用es开发电商的搜索列表功能
商品检索流程：
1.1 搜索结果预期数据展示
利用DSL 语句查询es 数据-看懂即可
#不仅要给用户响应检索到业务数据,为了提高检索商品用户体验,还需要根据响应业务数据,进行聚合得到过滤项条件:品牌,其他的平台属性
#在前面基础上 增加聚合(类似于MySQL中分组Group By)
#聚合三个要素: 1.聚合名称-获取聚合结果用到 2.聚合字段 3.聚合类型(如何聚合)
GET goods/_search
{
"query": {
"bool": {
"must": [
{
"match": {
"title": {
"query": "手机",
"operator": "and"
}
}
}
],
"filter": [
{
"term": {
"tmName": "华为"
}
},
{
"bool": {
"must": [
{
"nested": {
"path": "attrs",
"query": {
"bool": {
"must": [
{
"term": {
"attrs.attrId": {
"value": "24"
}
}
},
{
"term": {
"attrs.attrValue": {
"value": "256G"
}
}
}
]
}
}
}
},
{
"nested": {
"path": "attrs",
"query": {
"bool": {
"must": [
{
"term": {
"attrs.attrId": {
"value": "114"
}
}
},
{
"term": {
"attrs.attrValue": {
"value": "骁龙8 Gen2"
}
}
}
]
}
}
}
}
]
}
}
]
}
},
"from": 0,
"size": 1,
"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": 10
},
"aggs": {
"tmNameAgg": {
"terms": {
"field": "tmName",
"size": 10
}
},
"tmLogoAgg": {
"terms": {
"field": "tmLogoUrl",
"size": 10
}
}
}
},
"attrAgg": {
"nested": {
"path": "attrs"
},
"aggs": {
"attrIdAgg": {
"terms": {
"field": "attrs.attrId",
"size": 10
},
"aggs": {
"attrNameAgg": {
"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({"", "/"})
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;
/**
* 完成根据条件检索ES索引库得到业务数据跟过滤条件
*
* @param searchParam 检索条件
* @return
*/
@Override
public SearchResponseVo search(SearchParam searchParam) {
try {
//一.构建搜索请求对象-(封装请求方式,路径,请求体参数)
SearchRequest searchRequest = this.builderDSL(searchParam);
//二.执行检索
SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
//三.封装响应结果
return this.parseResult(response);
} catch (Exception e) {
log.error("[搜索服务]检索异常:{},条件:{}", e, searchParam);
throw new RuntimeException(e);
}
}
/**
* 构建查询请求对象,构建DSL语句中请求跟请求参数
*
* @param searchParam
* @return
*/
private SearchRequest builderDSL(SearchParam searchParam) {
//1.构建搜索请求对象 封装 GET /goods/_search 请求方式;请求路径参数中索引库名称
SearchRequest searchRequest = new SearchRequest(index_name);
//2.构建请求体构建器对象 封装请求体JSON参数 例如:查询;分页;高亮;排序;字段指定;聚合
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//2.1 设置查询条件,请求参数中"query"部分
//2.1.1 构建所有封装布尔查询条件对象
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 设置布尔查询条件中过滤 1.品牌过滤 2.平台属性过滤
//2.1.3.1 设置品牌过滤
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.3.1 设置分类过滤
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.3.3 设置平台属性过滤
//构建封装所有平台属性布尔查询
BoolQueryBuilder allAttrBoolQueryBuilder = QueryBuilders.boolQuery();
if (searchParam.getProps() != null && searchParam.getProps().length > 0) {
//动态构建某个平台属性过滤条件
for (String prop : searchParam.getProps()) {
String[] split = prop.split(":");
if (split != null && split.length == 3) {
// 每循环一次构建一个nested查询 每一组平台属性过滤条件 又是一个布尔查询
BoolQueryBuilder attrBoolQueryBuilder = QueryBuilders.boolQuery();
attrBoolQueryBuilder.must(QueryBuilders.termQuery("attrs.attrId", split[0]));
attrBoolQueryBuilder.must(QueryBuilders.termQuery("attrs.attrValue", split[1]));
NestedQueryBuilder nestedQuery = QueryBuilders.nestedQuery("attrs", attrBoolQueryBuilder, ScoreMode.None);
allAttrBoolQueryBuilder.must(nestedQuery);
}
}
}
allBoolQueryBuilder.filter(allAttrBoolQueryBuilder);
sourceBuilder.query(allBoolQueryBuilder);
//2.2 设置高亮,请求参数中"highlight"部分 高亮前提:用户采用关键字检索
if (StringUtils.isNotBlank(searchParam.getKeyword())) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
//2.2.1 设置前置标签
highlightBuilder.preTags("<font style='color:red'>");
//2.2.2 设置后置标签
highlightBuilder.postTags("</font>");
//2.2.3 设置高亮字段
highlightBuilder.field("title");
sourceBuilder.highlighter(highlightBuilder);
}
//2.3 设置分页,请求参数 "from" "size"
//2.3.1 计算起始位置索引 (pageNo-1)*pageSize
int from = (searchParam.getPageNo() - 1) * searchParam.getPageSize();
sourceBuilder.from(from).size(searchParam.getPageSize());
//2.4 设置排序,请求参数 "sort" 前提:前端提交排序条件 参数形式: 2:asc 1:按照热度排 2:价格
if (StringUtils.isNotBlank(searchParam.getOrder())) {
String[] split = searchParam.getOrder().split(":");
if (split != null && split.length == 2) {
String orderField = "";
if (split[0].equals("1")) {
//按照热度排名
orderField = "hotScore";
} else if (split[0].equals("2")) {
//按照价格排名
orderField = "price";
}
sourceBuilder.sort(orderField, "asc".equals(split[1]) ? SortOrder.ASC : SortOrder.DESC);
}
}
//2.5 设置响应文档字段列表,请求参数 "_source"
sourceBuilder.fetchSource(new String[]{"id", "title", "price", "defaultImg"}, null);
//2.6 设置聚合,请求参数 "aggs"
//2.6.1 设置品牌聚合
//2.6.1.1 先创建品牌ID聚合对象 terms("聚合名称")
TermsAggregationBuilder tmIdAggregation = AggregationBuilders.terms("tmIdAgg").field("tmId");
//2.6.1.1 基于品牌ID聚合对象设置子聚合-品牌名称聚合
tmIdAggregation.subAggregation(AggregationBuilders.terms("tmNameAgg").field("tmName"));
//2.6.1.2 基于品牌ID聚合对象设置子聚合-品牌Logo聚合
tmIdAggregation.subAggregation(AggregationBuilders.terms("tmLogoAgg").field("tmLogoUrl"));
sourceBuilder.aggregation(tmIdAggregation);
//2.6.2 设置平台属性聚合
//2.6.2.1 创建嵌套类型nested平台属性聚合对象
NestedAggregationBuilder nestedAggregation = AggregationBuilders.nested("attrAgg", "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"));
//2.6.2.3 将平台属性ID聚合对象加入到平台属性聚合对象中
nestedAggregation.subAggregation(attrIdAgg);
sourceBuilder.aggregation(nestedAggregation);
//3.在搜索请求对象中添加请求体构建器对象
System.err.println(sourceBuilder.toString());
return searchRequest.source(sourceBuilder);
}
/**
* 从ES封装响应对象中获取所需要的数据封装为自定义VO对象
*
* @param response ES响应结果JSON对象
* @param searchParam 用户查询过滤条件
* @return
*/
private SearchResponseVo parseResult(SearchResponse response, SearchParam searchParam) {
//构建响应Vo对象
SearchResponseVo searchResponseVo = new SearchResponseVo();
//1.封装响应Vo对象中分页信息
searchResponseVo.setPageNo(searchParam.getPageNo());
Integer pageSize = searchParam.getPageSize();
searchResponseVo.setPageSize(pageSize);
long total = response.getHits().getTotalHits().value;
searchResponseVo.setTotal(total);
Long totalPages = total % pageSize == 0 ? (total / pageSize) : (total / pageSize + 1);
searchResponseVo.setTotalPages(totalPages);
//2.封装响应Vo对象中当前页业务数据
SearchHit[] hits = response.getHits().getHits();
if (hits != null && hits.length > 0) {
//遍历命中数据得到业务JSON-将JSON反序列化为Java对象Goods
List<SearchHit> searchHits = Arrays.asList(hits);
List<Goods> goodsList = searchHits.stream().map(hit -> {
//获取商品文档JSON数据
String goodsJsonStr = hit.getSourceAsString();
//转为Goods对象
Goods goods = JSON.parseObject(goodsJsonStr, Goods.class);
//获取高亮结果
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (!CollectionUtils.isEmpty(highlightFields)) {
//获取标题高亮结果对象
HighlightField highlightField = highlightFields.get("title");
if (highlightField != null) {
//获取高亮片段数组
Text[] fragments = highlightField.getFragments();
if (fragments != null && fragments.length > 0) {
//获取高亮内容
String titleHightLight = fragments[0].toString();
goods.setTitle(titleHightLight);
}
}
}
return goods;
}).collect(Collectors.toList());
searchResponseVo.setGoodsList(goodsList);
}
//3.封装响应Vo对象中用于展示过滤项-品牌聚合结果
//3.1 获取到所有的聚合结果-Map
Map<String, Aggregation> allAggregationMap = response.getAggregations().asMap();
//3.2 获取品牌ID聚合结果对象 将聚合结果Aggregation接口转为实现类 ParsedXXTerms
ParsedLongTerms tmIdAgg = (ParsedLongTerms) allAggregationMap.get("tmIdAgg");
//3.2.1 从tmId聚合对象中获取bucket数组
List<? extends Terms.Bucket> buckets = tmIdAgg.getBuckets();
if (!CollectionUtils.isEmpty(buckets)) {
List<SearchResponseTmVo> responseTmVos = buckets.stream().map(bucket -> {
SearchResponseTmVo searchResponseTmVo = new SearchResponseTmVo();
//遍历bucket数组获取品牌bucket对象
//获取到聚合到品牌ID
long tmId = bucket.getKeyAsNumber().longValue();
//3.2.2 基于品牌ID聚合结果对象获取子聚合对象-品牌名称
//3.2.3 基于品牌ID聚合结果对象获取子聚合对象-品牌Logo
Map<String, Aggregation> tmNameAndLogoAggregation = bucket.getAggregations().asMap();
if (!CollectionUtils.isEmpty(tmNameAndLogoAggregation)) {
//获取到品牌名称
ParsedStringTerms tmNameAgg = (ParsedStringTerms) tmNameAndLogoAggregation.get("tmNameAgg");
String tmName = tmNameAgg.getBuckets().get(0).getKeyAsString();
ParsedStringTerms tmLogoAgg = (ParsedStringTerms) tmNameAndLogoAggregation.get("tmLogoAgg");
String tmLogoUrl = tmLogoAgg.getBuckets().get(0).getKeyAsString();
searchResponseTmVo.setTmName(tmName);
searchResponseTmVo.setTmLogoUrl(tmLogoUrl);
}
searchResponseTmVo.setTmId(tmId);
return searchResponseTmVo;
}).collect(Collectors.toList());
searchResponseVo.setTrademarkList(responseTmVos);
}
//4.封装响应Vo对象中用于展示过滤项-平台属性聚合结果
//4.1 获取平台属性(nested)聚合对象
ParsedNested attrAgg = (ParsedNested) allAggregationMap.get("attrAgg");
//4.2 基于平台属性聚合对象 获取 平台属性ID子聚合对象
ParsedLongTerms attrIdAgg = attrAgg.getAggregations().get("attrIdAgg");
//4.3 通过平台属性聚合对象 获取 聚合结果bucket数组 遍历bucket数组-获取平台属性,以及名称,属性值
List<? extends Terms.Bucket> attrIdAggBuckets = attrIdAgg.getBuckets();
if (!CollectionUtils.isEmpty(attrIdAggBuckets)) {
List<SearchResponseAttrVo> attrVoList = attrIdAggBuckets.stream().map(bucket -> {
SearchResponseAttrVo attrVo = new SearchResponseAttrVo();
//4.3.1 通过bucket对象获取聚合到平台属性ID
long attrId = bucket.getKeyAsNumber().longValue();
attrVo.setAttrId(attrId);
//4.3.2 通过bucket对象获取平台属性名称子聚合对象
ParsedStringTerms attrNameAgg = bucket.getAggregations().get("attrNameAgg");
if (!CollectionUtils.isEmpty(attrNameAgg.getBuckets())) {
String attrName = attrNameAgg.getBuckets().get(0).getKeyAsString();
attrVo.setAttrName(attrName);
}
//4.3.3 通过bucket对象获取平台属性值子聚合对象
ParsedStringTerms attrValueAgg = bucket.getAggregations().get("attrValueAgg");
List<? extends Terms.Bucket> valueAggBuckets = attrValueAgg.getBuckets();
if (!CollectionUtils.isEmpty(valueAggBuckets)) {
//直接映射bucket集合,获取每个桶中key转为字符串
List<String> attrValueList = valueAggBuckets
.stream().map(MultiBucketsAggregation.Bucket::getKeyAsString)
.collect(Collectors.toList());
attrVo.setAttrValueList(attrValueList);
}
return attrVo;
}).collect(Collectors.toList());
searchResponseVo.setAttrsList(attrVoList);
}
return searchResponseVo;
}
}
说明：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":["106:安卓手机:手机系统","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;
import java.util.Map;
@FeignClient(value = "service-list", fallback = ListDegradeFeignClient.class)
public interface ListFeignClient {
/**
* 提供给详情服务调用:更新商品热度分值
* @param skuId
*/
@GetMapping("/api/list/inner/incrHotScore/{skuId}")
public void incrHotScore(@PathVariable("skuId") Long skuId);
/**
* 提供给前端服务/移动端,商品检索
*
* @param searchParam
* @return
*/
@PostMapping({"/api/list"})
public Result<Map> search(@RequestBody SearchParam searchParam);
}
远程调用接口的服务降级类
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 org.springframework.stereotype.Component;
/**
* @author: atguigu
* @create: 2023-03-03 14:36
*/
@Component
public class ListDegradeFeignClient implements ListFeignClient {
@Override
public void incrHotScore(Long skuId) {
}
@Override
public Result 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.controller;
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 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 java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author: atguigu
* @create: 2023-04-28 11:23
*/
@Controller
public class ListController {
@Autowired
private ListFeignClient listFeignClient;
/**
* 渲染搜索页面
*
* @param searchParam
* @return
*/
@GetMapping("/list.html")
public String listHtml(SearchParam searchParam, Model model) {
//1.用户提交请求参数 ${searchParam}
model.addAttribute("searchParam", searchParam);
//2.用户回显地址栏中请求 包含搜索条件完整链接 ${urlParam}
model.addAttribute("urlParam", this.makeUrlParam(searchParam));
//3.回显用户已选中品牌面包屑 ${trademarkParam}
model.addAttribute("trademarkParam", this.makeTrademarkParam(searchParam));
//4.回显用户已选中平台属性 ${propsParamList}
model.addAttribute("propsParamList", this.makePropsParamList(searchParam));
//5.回显页面排序效果 type:排序方式 sort:升降序
model.addAttribute("orderMap", this.makeOrderMap(searchParam.getOrder()));
//6.远程调用搜索微服务获取到业务vo对象
Result<Map> result = listFeignClient.search(searchParam);
model.addAllAttributes(result.getData());
return "/list/index";
}
/**
* 根据用户提交选中平台属性过滤条件,返回用户已选择平台属性过滤条件
*
* @param searchParam
* @return
*/
private List<SearchAttr> makePropsParamList(SearchParam searchParam) {
String[] props = searchParam.getProps();
if (props != null && props.length > 0) {
List<String> propList = Arrays.asList(props);
List<SearchAttr> searchAttrList = propList.stream().map(attrInfoStr -> {
String[] split = attrInfoStr.split(":");
if (split != null && split.length == 3) {
SearchAttr searchAttr = new SearchAttr();
searchAttr.setAttrId(Long.valueOf(split[0]));
searchAttr.setAttrValue(split[1]);
searchAttr.setAttrName(split[2]);
return searchAttr;
}
return null;
}).collect(Collectors.toList());
return searchAttrList;
}
return null;
}
/**
* 根据用户提交选中品牌参数,返回用户已选品牌字符串
*
* @param searchParam
* @return
*/
private String makeTrademarkParam(SearchParam searchParam) {
if (StringUtils.isNotBlank(searchParam.getTrademark())) {
String[] split = searchParam.getTrademark().split(":");
if (split != null && split.length == 2) {
return "品牌: " + split[1];
}
}
return null;
}
/**
* 制作用户已选中所有条件URl请求
*
* @param searchParam
* @return
*/
private String makeUrlParam(SearchParam searchParam) {
StringBuilder stringBuilder = new StringBuilder("/list.html?");
if (StringUtils.isNotBlank(searchParam.getKeyword())) {
stringBuilder.append("&keyword=" + searchParam.getKeyword());
}
if (StringUtils.isNotBlank(searchParam.getTrademark())) {
stringBuilder.append("&trademark=" + searchParam.getTrademark());
}
if (searchParam.getCategory1Id() != null) {
stringBuilder.append("&category1Id=" + searchParam.getCategory1Id());
}
if (searchParam.getCategory2Id() != null) {
stringBuilder.append("&category2Id=" + searchParam.getCategory2Id());
}
if (searchParam.getCategory3Id() != null) {
stringBuilder.append("&category3Id=" + searchParam.getCategory3Id());
}
//将用户选中平台属性数组遍历拼接到url地址栏中
if (searchParam.getProps() != null && searchParam.getProps().length > 0) {
for (String prop : searchParam.getProps()) {
String[] split = prop.split(":");
if (split != null && split.length == 3) {
stringBuilder.append("&props=").append(prop);
}
}
}
return stringBuilder.toString();
}
/**
* 根据用户提交排序方式,回显页面排序效果 type:排序方式 sort:升降序
*
* @param order
* @return
*/
private Map makeOrderMap(String order) {
HashMap<String, String> orderMap = new HashMap<>();
if (StringUtils.isNotBlank(order)) {
String[] split = order.split(":");
orderMap.put("type", split[0]);
orderMap.put("sort", split[1]);
} else {
//没有选择排序
orderMap.put("type", "3");
orderMap.put("sort", "asc");
}
return orderMap;
}
}
页面
<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作用:检索存储分析/分词
- K Kibana作用:操作ES的图形化客户端,各种数据报表仪表盘
- L Logstash作用
- 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>