day07

  feture 专辑首页置顶分类热门专辑，ELK

model/src/main/java/com/atguigu/tingshu/model/search/SuggestIndex.java

@@ -14,18 +14,37 @@ import org.springframework.data.elasticsearch.core.suggest.Completion;
 @JsonIgnoreProperties(ignoreUnknown = true)//目的：防止json字符串转成实体对象时因未识别字段报错
 public class SuggestIndex {
 
+    /**
+     * 提词文档ID
+     * 跟专辑ID一致：提词文档基于上架专辑同步
+     */
     @Id
-    private String id;
+    private Long id;
 
+    /**
+     * 存储给用户返回中文提示词:百家讲坛，万历兴亡录
+     */
     @Field(type = FieldType.Text, analyzer = "standard")
     private String title;
 
+    /**
+     * 用于建议补全检索字段： 录入:百家
+     * 百家讲坛
+     */
     @CompletionField(analyzer = "standard", searchAnalyzer = "standard", maxInputLength = 20)
     private Completion keyword;
 
+    /**
+     * 用于建议补全检索字段 录入:baijia
+     * baijiajaingtan,wanlixingwanglu
+     */
     @CompletionField(analyzer = "standard", searchAnalyzer = "standard", maxInputLength = 20)
     private Completion keywordPinyin;
 
+    /**
+     * 用于建议补全检索字段 录入:bj
+     * bjjt,wlxwl
+     */
     @CompletionField(analyzer = "standard", searchAnalyzer = "standard", maxInputLength = 20)
     private Completion keywordSequence;
 

service-client/service-album-client/src/main/java/com/atguigu/tingshu/album/AlbumFeignClient.java

@@ -3,11 +3,14 @@ package com.atguigu.tingshu.album;
 import com.atguigu.tingshu.album.impl.AlbumDegradeFeignClient;
 import com.atguigu.tingshu.common.result.Result;
 import com.atguigu.tingshu.model.album.AlbumInfo;
+import com.atguigu.tingshu.model.album.BaseCategory3;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 
+import java.util.List;
+
 /**
  * <p>
  * 专辑模块远程调用Feign接口
@@ -30,4 +33,8 @@ public interface AlbumFeignClient {
     @GetMapping("/category/getCategoryView/{category3Id}")
     public Result<BaseCategoryView> getCategoryView(@PathVariable("category3Id") Long category3Id);
 
+
+    @GetMapping("/category/findTopBaseCategory3/{category1Id}")
+    public Result<List<BaseCategory3>> findTopBaseCategory3(@PathVariable("category1Id") Long category1Id);
+
 }

service-client/service-album-client/src/main/java/com/atguigu/tingshu/album/impl/AlbumDegradeFeignClient.java

@@ -4,10 +4,13 @@ package com.atguigu.tingshu.album.impl;
 import com.atguigu.tingshu.album.AlbumFeignClient;
 import com.atguigu.tingshu.common.result.Result;
 import com.atguigu.tingshu.model.album.AlbumInfo;
+import com.atguigu.tingshu.model.album.BaseCategory3;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
+
 @Slf4j
 @Component
 public class AlbumDegradeFeignClient implements AlbumFeignClient {
@@ -25,5 +28,11 @@ public class AlbumDegradeFeignClient implements AlbumFeignClient {
         return null;
     }
 
+    @Override
+    public Result<List<BaseCategory3>> findTopBaseCategory3(Long category1Id) {
+        log.error("[专辑服务]提供远程{}调用执行服务降级", "findTopBaseCategory3");
+        return null;
+    }
+
 
 }

service/pom.xml

@@ -23,6 +23,11 @@
     </modules>
 
     <dependencies>
+        <dependency>
+            <groupId>net.logstash.logback</groupId>
+            <artifactId>logstash-logback-encoder</artifactId>
+            <version>5.1</version>
+        </dependency>
         <dependency>
             <groupId>com.atguigu.tingshu</groupId>
             <artifactId>service-util</artifactId>

service/service-album/src/main/java/com/atguigu/tingshu/album/api/BaseCategoryApiController.java

@@ -77,5 +77,17 @@ public class BaseCategoryApiController {
         return Result.ok(list);
     }
 
+
+    /**
+     * 根据1级分类ID查询到1级分类对象（包含所属二级分类，所属三级分类列表）
+     * @param category1Id
+     * @return
+     */
+    @Operation(summary = "根据1级分类ID查询到1级分类对象（包含所属二级分类，所属三级分类列表）")
+    @GetMapping("/category/getBaseCategoryList/{category1Id}")
+    public Result<JSONObject> getBaseCategoryListByCategory1Id(@PathVariable("category1Id") Long category1Id) {
+        JSONObject jsonObject = baseCategoryService.getBaseCategoryListByCategory1Id(category1Id);
+        return Result.ok(jsonObject);
+    }
 }
 

service/service-album/src/main/java/com/atguigu/tingshu/album/service/BaseCategoryService.java

@@ -32,4 +32,11 @@ public interface BaseCategoryService extends IService<BaseCategory1> {
      * @return
      */
     List<BaseCategory3> findTopBaseCategory3(Long category1Id);
+
+    /**
+     * 根据1级分类ID查询到1级分类对象（包含所属二级分类，所属三级分类列表）
+     * @param category1Id
+     * @return
+     */
+    JSONObject getBaseCategoryListByCategory1Id(Long category1Id);
 }

service/service-album/src/main/java/com/atguigu/tingshu/album/service/impl/BaseCategoryServiceImpl.java

@@ -148,4 +148,54 @@ public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, Ba
         }
         return null;
     }
+
+    /**
+     * 根据1级分类ID查询到1级分类对象（包含所属二级分类，所属三级分类列表）
+     * @param category1Id
+     * @return
+     */
+    @Override
+    public JSONObject getBaseCategoryListByCategory1Id(Long category1Id) {
+        //1.处理封装1级分类对象
+        //1.1 创建1级分类JSON对象
+        JSONObject jsonObject1 = new JSONObject();
+        //1.2 根据1级分类ID查询分类视图
+        List<BaseCategoryView> baseCategory1ViewList = baseCategoryViewMapper.selectList(
+                new LambdaQueryWrapper<BaseCategoryView>().eq(BaseCategoryView::getCategory1Id, category1Id)
+        );
+        //1.3 封装1级分类对象ID以及名称
+        jsonObject1.put("categoryId", baseCategory1ViewList.get(0).getCategory1Id());
+        jsonObject1.put("categoryName", baseCategory1ViewList.get(0).getCategory1Name());
+
+        //2.处理封装2级分类
+        //2.1 创建二级分类JSON对象集合
+        List<JSONObject> jsonObject2List = new ArrayList<>();
+        //2.2 对"1级分类列表"按2级分类ID进行分组，得到"二级分类Map<2级分类ID，"二级分类"列表>"
+        Map<Long, List<BaseCategoryView>> entry2 = baseCategory1ViewList
+                .stream()
+                .collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
+        //2.3 遍历"二级分类Map<2级分类ID，"二级分类"列表>"，封装二级分类JSON对象集合
+        entry2.forEach((key, value) -> {
+            JSONObject jsonObject2 = new JSONObject();
+            jsonObject2.put("categoryId", value.get(0).getCategory2Id());
+            jsonObject2.put("categoryName", value.get(0).getCategory2Name());
+            //3.处理封装3级分类
+            //3.1 创建三级分类JSON对象集合
+            List<JSONObject> jsonObject3List = new ArrayList<>();
+            //3.2 遍历"2级分类列表"得到三级分类对象
+            for (BaseCategoryView baseCategoryView : value) {
+                JSONObject jsonObject3 = new JSONObject();
+                jsonObject3.put("categoryId", baseCategoryView.getCategory3Id());
+                jsonObject3.put("categoryName", baseCategoryView.getCategory3Name());
+                jsonObject3List.add(jsonObject3);
+            }
+            //3.3 将3级分类集合加入2级分类对象categoryChild属性中
+            jsonObject2.put("categoryChild", jsonObject3List);
+            jsonObject2List.add(jsonObject2);
+        });
+        //2.4 将2级分类JSON对象集合放入到1级分类JSON对象categoryChild属性中
+        jsonObject1.put("categoryChild", jsonObject2List);
+
+        return jsonObject1;
+    }
 }

service/service-album/src/main/resources/logback-spring.xml

@@ -45,11 +45,11 @@
     </appender>
 
     <!-- logstash日志 -->
-<!--    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">-->
-<!--        &lt;!&ndash; logstash ip和暴露的端口，logback就是通过这个地址把日志发送给logstash &ndash;&gt;-->
-<!--        <destination>139.198.127.41:8044</destination>-->
-<!--        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />-->
-<!--    </appender>-->
+    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
+        <!-- logstash ip和暴露的端口，logback就是通过这个地址把日志发送给logstash -->
+        <destination>192.168.200.6:5044</destination>
+        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />
+    </appender>
 
     <!-- 开发环境 -->
     <springProfile name="dev">
@@ -58,8 +58,9 @@
         <!-- 根日志记录器：INFO级别  -->
         <root level="INFO">
             <appender-ref ref="CONSOLE" />
+            <appender-ref ref="LOGSTASH" />
 <!--            <appender-ref ref="FILE" />-->
         </root>
     </springProfile>
 
-</configuration>
+</configuration>

service/service-search/pom.xml

@@ -18,6 +18,21 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>io.github.biezhi</groupId>
+            <artifactId>TinyPinyin</artifactId>
+            <version>2.0.3.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>com.belerweb</groupId>
+            <artifactId>pinyin4j</artifactId>
+            <version>2.5.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.stuxuhai</groupId>
+            <artifactId>jpinyin</artifactId>
+            <version>1.1.8</version>
+        </dependency>
         <dependency>
             <groupId>com.atguigu.tingshu</groupId>
             <artifactId>rabbit-util</artifactId>

service/service-search/src/main/java/com/atguigu/tingshu/search/api/SearchApiController.java

@@ -9,6 +9,9 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.List;
+import java.util.Map;
+
 @Tag(name = "搜索专辑管理")
 @RestController
 @RequestMapping("api/search")
@@ -53,5 +56,29 @@ public class SearchApiController {
         AlbumSearchResponseVo vo = searchService.search(albumIndexQuery);
         return Result.ok(vo);
     }
+
+    /**
+     * 得到置顶三级分类热门专辑TOP6列表
+     * @param category1Id
+     * @return [{baseCategory3:{催眠音乐分类信息},list:[{专辑1},{专辑2}]},{},{}]
+     */
+    @Operation(summary = "得到置顶三级分类热门专辑TOP6列表")
+    @GetMapping("/albumInfo/channel/{category1Id}")
+    public Result<List<Map<String, Object>>> channel(@PathVariable("category1Id") Long category1Id) {
+        List<Map<String, Object>> list = searchService.getBaseCategoryListByCategory1Id(category1Id);
+        return Result.ok(list);
+    }
+
+    /**
+     * 根据用户已录入字符返回提示词列表,自动补全效果
+     * @param keyword
+     * @return
+     */
+    @Operation(summary = "根据用户已录入字符返回提示词列表")
+    @GetMapping("/albumInfo/completeSuggest/{keyword}")
+    public Result<List<String>> completeSuggest(@PathVariable("keyword") String keyword) {
+        List<String> list = searchService.completeSuggest(keyword);
+        return Result.ok(list);
+    }
 }
 

service/service-search/src/main/java/com/atguigu/tingshu/search/repository/SuggestIndexRepository.java

@@ -0,0 +1,7 @@
+package com.atguigu.tingshu.search.repository;
+
+import com.atguigu.tingshu.model.search.SuggestIndex;
+import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
+
+public interface SuggestIndexRepository extends ElasticsearchRepository<SuggestIndex, Long> {
+}

service/service-search/src/main/java/com/atguigu/tingshu/search/service/SearchService.java

@@ -3,9 +3,14 @@ package com.atguigu.tingshu.search.service;
 import co.elastic.clients.elasticsearch.core.SearchRequest;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
 import com.atguigu.tingshu.model.search.AlbumInfoIndex;
+import com.atguigu.tingshu.model.search.SuggestIndex;
 import com.atguigu.tingshu.query.search.AlbumIndexQuery;
 import com.atguigu.tingshu.vo.search.AlbumSearchResponseVo;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
 public interface SearchService {
 
 
@@ -43,4 +48,32 @@ public interface SearchService {
      * @return
      */
     AlbumSearchResponseVo parseResult(SearchResponse<AlbumInfoIndex> searchResponse, AlbumIndexQuery albumIndexQuery);
+
+    /**
+     * 得到置顶三级分类热门专辑TOP6列表
+     * @param category1Id
+     * @return
+     */
+    List<Map<String, Object>> getBaseCategoryListByCategory1Id(Long category1Id);
+
+    /**
+     * 将专辑名称存入提词索引库
+     * @param albumInfoIndex
+     */
+    void saveSuggest(AlbumInfoIndex albumInfoIndex);
+
+    /**
+     * 根据用户已录入字符返回提示词列表,自动补全效果
+     * @param keyword
+     * @return
+     */
+    List<String> completeSuggest(String keyword);
+
+    /**
+     * 解析建议词结果
+     * @param suggestIndexSearchResponse ES响应对象
+     * @param suggestName 自定义名称
+     * @return
+     */
+    Collection<String> parseSuggestResult(SearchResponse<SuggestIndex> suggestIndexSearchResponse, String suggestName);
 }

service/service-search/src/main/java/com/atguigu/tingshu/search/service/impl/SearchServiceImpl.java

@@ -4,21 +4,31 @@ import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.util.RandomUtil;
+import cn.hutool.extra.pinyin.PinyinUtil;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch._types.FieldValue;
 import co.elastic.clients.elasticsearch._types.SortOrder;
+import co.elastic.clients.elasticsearch._types.aggregations.LongTermsAggregate;
+import co.elastic.clients.elasticsearch._types.aggregations.LongTermsBucket;
 import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
 import co.elastic.clients.elasticsearch.core.SearchRequest;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
+import co.elastic.clients.elasticsearch.core.search.CompletionSuggestOption;
 import co.elastic.clients.elasticsearch.core.search.Hit;
 import co.elastic.clients.elasticsearch.core.search.HitsMetadata;
+import co.elastic.clients.elasticsearch.core.search.Suggestion;
+import com.alibaba.fastjson.JSON;
 import com.atguigu.tingshu.album.AlbumFeignClient;
 import com.atguigu.tingshu.model.album.AlbumAttributeValue;
 import com.atguigu.tingshu.model.album.AlbumInfo;
+import com.atguigu.tingshu.model.album.BaseCategory3;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import com.atguigu.tingshu.model.search.AlbumInfoIndex;
 import com.atguigu.tingshu.model.search.AttributeValueIndex;
+import com.atguigu.tingshu.model.search.SuggestIndex;
 import com.atguigu.tingshu.query.search.AlbumIndexQuery;
 import com.atguigu.tingshu.search.repository.AlbumInfoIndexRepository;
+import com.atguigu.tingshu.search.repository.SuggestIndexRepository;
 import com.atguigu.tingshu.search.service.SearchService;
 import com.atguigu.tingshu.user.client.UserFeignClient;
 import com.atguigu.tingshu.vo.search.AlbumInfoIndexVo;
@@ -27,11 +37,12 @@ import com.atguigu.tingshu.vo.user.UserInfoVo;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.elasticsearch.core.suggest.Completion;
 import org.springframework.stereotype.Service;
 
+import java.io.IOException;
 import java.math.BigDecimal;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.stream.Collectors;
@@ -58,6 +69,9 @@ public class SearchServiceImpl implements SearchService {
     @Autowired
     private ElasticsearchClient elasticsearchClient;
 
+    @Autowired
+    private SuggestIndexRepository suggestIndexRepository;
+
     //@Autowired
     //@Qualifier("threadPoolTaskExecutor")
     //private Executor executor;
@@ -96,7 +110,7 @@ public class SearchServiceImpl implements SearchService {
             return albumInfo;
         }, threadPoolTaskExecutor);
 
-        //3.封装专辑索引库分类信息
+        ////3.封装专辑索引库分类信息
         CompletableFuture<Void> categoryCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
             log.info("子线程:{}，执行查询分类", Thread.currentThread().getName());
             BaseCategoryView categoryView = albumFeignClient.getCategoryView(albumInfo.getCategory3Id()).getData();
@@ -104,16 +118,16 @@ public class SearchServiceImpl implements SearchService {
             albumInfoIndex.setCategory1Id(categoryView.getCategory1Id());
             albumInfoIndex.setCategory2Id(categoryView.getCategory2Id());
         }, threadPoolTaskExecutor);
-
-        //4.封装专辑索引库主播信息
+        //
+        ////4.封装专辑索引库主播信息
         CompletableFuture<Void> userCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
             log.info("子线程:{}，执行查询用户", Thread.currentThread().getName());
             UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(albumInfo.getUserId()).getData();
             Assert.notNull(userInfoVo, "用户:{}不存在", albumInfo.getUserId());
             albumInfoIndex.setAnnouncerName(userInfoVo.getNickname());
         }, threadPoolTaskExecutor);
-
-        //5.封装专辑索引库统计信息 暂时采用随机生成方式 TODO 上线后需要实际查询统计数值
+        //
+        ////5.封装专辑索引库统计信息 暂时采用随机生成方式 TODO 上线后需要实际查询统计数值
         CompletableFuture<Void> statCompletableFuture = CompletableFuture.runAsync(() -> {
             //5.1 随机产生四个数值对应 播放数，订阅数，购买数，评论数
             int num1 = RandomUtil.randomInt(1000, 5000);
@@ -144,6 +158,9 @@ public class SearchServiceImpl implements SearchService {
 
         //7.将专辑索引库信息保存到索引库
         albumInfoIndexRepository.save(albumInfoIndex);
+
+        //8.保存专辑名称到提词索引库
+        this.saveSuggest(albumInfoIndex);
     }
 
     /**
@@ -154,6 +171,7 @@ public class SearchServiceImpl implements SearchService {
     @Override
     public void lowerAlbum(Long albumId) {
         albumInfoIndexRepository.deleteById(albumId);
+        suggestIndexRepository.deleteById(albumId);
     }
 
     /**
@@ -180,6 +198,7 @@ public class SearchServiceImpl implements SearchService {
     }
 
     private static final String INDEX_NAME = "albuminfo";
+    private static final String SUGGEST_INDEX_NAME = "suggestinfo";
 
     /**
      * 基于检索条件封装完整检索请求对象
@@ -323,4 +342,169 @@ public class SearchServiceImpl implements SearchService {
         //4.响应vo
         return vo;
     }
+
+    /**
+     * 得到置顶三级分类热门专辑TOP6列表
+     *
+     * @param category1Id
+     * @return
+     */
+    @Override
+    public List<Map<String, Object>> getBaseCategoryListByCategory1Id(Long category1Id) {
+        try {
+            //1.根据1级分类ID获取置顶的7个三级分类列表,获取7个三级分类ID
+            //1.1 远程调用专辑服务获取置顶三级分类列表
+            List<BaseCategory3> baseCategory3List = albumFeignClient.findTopBaseCategory3(category1Id).getData();
+            Assert.notNull(baseCategory3List, "根据一级分类ID获取置顶的7个三级分类列表失败");
+            //1.2 将三级分类对象处理得到ES检索需要的FiledValue类型
+            List<FieldValue> fieldValueList = baseCategory3List.stream()
+                    .map(baseCategory3 -> FieldValue.of(baseCategory3.getId()))
+                    .collect(Collectors.toList());
+
+            //1.3 为了封装结果中得到三级分类对象，将三级分类列表转为Map<三级分类ID，三级分类对象>
+            Map<Long, BaseCategory3> category3Map =
+                    baseCategory3List.stream().collect(Collectors.toMap(c3 -> c3.getId(), c3 -> c3));
+
+            //2.采用多关键字精确查询+聚合执行检索ES
+            SearchResponse<AlbumInfoIndex> searchResponse = elasticsearchClient.search(
+                    s -> s.index(INDEX_NAME)
+                            .size(0)
+                            .query(q -> q.terms(t -> t.field("category3Id").terms(t1 -> t1.value(fieldValueList))))
+                            .aggregations(
+                                    "category_agg", a -> a.terms(t -> t.field("category3Id").size(7))
+                                            .aggregations("top6", a1 -> a1.topHits(t -> t.size(6).sort(s1 -> s1.field(f -> f.field("hotScore").order(SortOrder.Desc))).source(s1 -> s1.filter(f -> f.excludes("attributeValueIndexList")))))
+                            ),
+                    AlbumInfoIndex.class
+            );
+            //3.解析响应结果封装置顶分类热门专辑列表
+            //3.1 获取分类聚合结果对象
+            LongTermsAggregate categoryAgg = searchResponse.aggregations().get("category_agg").lterms();
+            //3.2 获取分类聚合结果对象中的桶集合
+            List<LongTermsBucket> cagegoryTermsBucketList = categoryAgg.buckets().array();
+            if (CollUtil.isNotEmpty(cagegoryTermsBucketList)) {
+                //3.3 遍历桶集合，每遍历一个桶，封装一个置顶分类热门专辑Map对象
+                List<Map<String, Object>> list = cagegoryTermsBucketList
+                        .stream()
+                        .map(categoryBucket -> {
+                            //3.4 封装置顶分类热门专辑Map
+                            Map<String, Object> map = new HashMap<>();
+                            //3.4.1 处理分类信息：获取桶中的三级分类ID，得到三级分类对象
+                            map.put("baseCategory3", category3Map.get(categoryBucket.key()));
+                            //3.4.2 处理热门专辑信息：获取桶中的热门专辑Top6聚合结果，得到热门专辑对象集合
+                            List<AlbumInfoIndex> top6AlbumList = categoryBucket.aggregations().get("top6").topHits().hits().hits()
+                                    .stream()
+                                    .map(hit -> {
+                                        String albumInfoIndexStr = hit.source().toString();
+                                        AlbumInfoIndex albumInfoIndex = JSON.parseObject(albumInfoIndexStr, AlbumInfoIndex.class);
+                                        return albumInfoIndex;
+                                    }).collect(Collectors.toList());
+                            map.put("list", top6AlbumList);
+                            return map;
+                        }).collect(Collectors.toList());
+                return list;
+            }
+            return null;
+        } catch (IOException e) {
+            log.error("[搜索服务]首页置顶分类热门专辑检索异常：{}", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * 将专辑名称存入提词索引库
+     *
+     * @param albumInfoIndex
+     */
+    @Override
+    public void saveSuggest(AlbumInfoIndex albumInfoIndex) {
+        SuggestIndex suggestIndex = new SuggestIndex();
+        suggestIndex.setId(albumInfoIndex.getId());
+        String albumTitle = albumInfoIndex.getAlbumTitle();
+        suggestIndex.setTitle(albumTitle);
+        //存入汉字
+        suggestIndex.setKeyword(new Completion(new String[]{albumTitle}));
+        //将汉字转为汉语拼音
+        String pinyin = PinyinUtil.getPinyin(albumTitle, "");
+        suggestIndex.setKeywordPinyin(new Completion(new String[]{pinyin}));
+        //获取拼音首字母
+        String firstLetter = PinyinUtil.getFirstLetter(albumTitle, "");
+        suggestIndex.setKeywordSequence(new Completion(new String[]{firstLetter}));
+        suggestIndexRepository.save(suggestIndex);
+    }
+
+    /**
+     * 根据用户已录入字符返回提示词列表,自动补全效果
+     *
+     * @param keyword
+     * @return
+     */
+    @Override
+    public List<String> completeSuggest(String keyword) {
+        try {
+            //1.采用自动补全API尝试分别查询：汉字、拼音、首字母自动补全字段
+            SearchResponse<SuggestIndex> suggestIndexSearchResponse = elasticsearchClient.search(
+                    s -> s.index(SUGGEST_INDEX_NAME)
+                            .suggest(s1 -> s1.suggesters(
+                                            "letter-suggest", s2 -> s2.prefix(keyword).completion(c -> c.field("keywordSequence").size(10).skipDuplicates(true))
+                                    ).suggesters("pinyin-suggest", s2 -> s2.prefix(keyword).completion(c -> c.field("keywordPinyin").size(10).skipDuplicates(true).fuzzy(f -> f.fuzziness("2").minLength(4))))
+                                    .suggesters("keyword-suggest", s2 -> s2.prefix(keyword).completion(c -> c.field("keyword").size(10).skipDuplicates(true).fuzzy(f -> f.fuzziness("2").minLength(4))))
+                            )
+                    ,
+                    SuggestIndex.class
+            );
+            //2.解析ES自动补全结果,将结果放入HashSet去重
+            Set<String> hashSet = new HashSet<>();
+            hashSet.addAll(this.parseSuggestResult(suggestIndexSearchResponse, "letter-suggest"));
+            hashSet.addAll(this.parseSuggestResult(suggestIndexSearchResponse, "pinyin-suggest"));
+            hashSet.addAll(this.parseSuggestResult(suggestIndexSearchResponse, "keyword-suggest"));
+
+            //3.如果返回自动补全结果集合长度 小于10个，采用全文检索：检索专辑标题即可，补全到10个
+            if (hashSet.size() < 10) {
+                SearchResponse<AlbumInfoIndex> searchResponse = elasticsearchClient.search(
+                        s -> s.index(INDEX_NAME)
+                                .size(10)
+                                .query(q -> q.match(m -> m.field("albumTitle").query(keyword))
+                                ), AlbumInfoIndex.class);
+                List<Hit<AlbumInfoIndex>> hitList = searchResponse.hits().hits();
+                if (CollUtil.isNotEmpty(hitList)) {
+                    for (Hit<AlbumInfoIndex> hit : hitList) {
+                        AlbumInfoIndex source = hit.source();
+                        hashSet.add(source.getAlbumTitle());
+                        if (hashSet.size() >= 10) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            //4.如果返回自动补全结果集合长度 大于等于10个，则截取10个返回
+            if (hashSet.size() >= 10) {
+                return new ArrayList<>(hashSet).subList(0, 10);
+            }
+            return new ArrayList<>(hashSet);
+        } catch (IOException e) {
+            log.error("[搜索服务]自动补全检索异常：{}", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * 解析建议词结果
+     *
+     * @param suggestIndexSearchResponse ES响应对象
+     * @param suggestName                自定义名称
+     * @return
+     */
+    @Override
+    public Collection<String> parseSuggestResult(SearchResponse<SuggestIndex> suggestIndexSearchResponse, String suggestName) {
+        List<String> list = new ArrayList<>();
+        List<Suggestion<SuggestIndex>> suggestions = suggestIndexSearchResponse.suggest().get(suggestName);
+        for (Suggestion<SuggestIndex> suggestion : suggestions) {
+            for (CompletionSuggestOption<SuggestIndex> option : suggestion.completion().options()) {
+                SuggestIndex suggestIndex = option.source();
+                list.add(suggestIndex.getTitle());
+            }
+        }
+        return list;
+    }
 }

service/service-search/src/main/resources/logback-spring.xml

@@ -39,27 +39,28 @@
         <file>${log.path}//log.log</file>
         <append>true</append>
         <encoder>
-            <pattern>%date{yyyy-MM-dd HH:mm:ss} %msg%n</pattern>
+            <pattern>${FILE_LOG_PATTERN}</pattern>
             <charset>${ENCODING}</charset>
         </encoder>
     </appender>
 
     <!-- logstash日志 -->
-<!--    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">-->
-<!--        &lt;!&ndash; logstash ip和暴露的端口，logback就是通过这个地址把日志发送给logstash &ndash;&gt;-->
-<!--        <destination>139.198.127.41:8044</destination>-->
-<!--        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />-->
-<!--    </appender>-->
+    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
+        <!-- logstash ip和暴露的端口，logback就是通过这个地址把日志发送给logstash -->
+        <destination>192.168.200.6:5044</destination>
+        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder" />
+    </appender>
 
     <!-- 开发环境 -->
     <springProfile name="dev">
         <!-- com.atguigu日志记录器：业务程序INFO级别  -->
-        <logger name="com.atguigu" level="INFO" />
+        <logger name="com.atguigu" level="WARN" />
         <!-- 根日志记录器：INFO级别  -->
         <root level="INFO">
             <appender-ref ref="CONSOLE" />
-<!--            <appender-ref ref="FILE" />-->
+           <!-- <appender-ref ref="FILE" />-->
+            <appender-ref ref="LOGSTASH" />
         </root>
     </springProfile>
 
-</configuration>
+</configuration>

service/service-search/src/test/java/com/atguigu/tingshu/ServiceSearchApplicationTest.java

@@ -4,10 +4,12 @@ import com.atguigu.tingshu.album.AlbumFeignClient;
 import com.atguigu.tingshu.common.result.Result;
 import com.atguigu.tingshu.model.album.AlbumInfo;
 import com.atguigu.tingshu.search.service.SearchService;
+import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+@Slf4j
 @SpringBootTest
 class ServiceSearchApplicationTest {
 
@@ -39,4 +41,18 @@ class ServiceSearchApplicationTest {
         }
     }
 
+
+    /**
+     * 日志规范：Sl4j
+     * 常见日志框架实现类：Log4j,log4j2,logback(Springboot默认日志框架)
+     * 日志级别：debug,info,warn,error
+     */
+    @Test
+    public void testLog(){
+        log.debug("debug级别日志");
+        log.info("info级别日志");
+        log.warn("warn级别日志");
+        log.error("error级别日志");
+    }
+
 }