SpringBoot集成Elasticsearch 進階，實現中文、拼音分詞，繁簡體轉換高級搜索

Elasticsearch 分詞

分詞分爲讀時分詞和寫時分詞。
讀時分詞發生在用戶查詢時，ES 會即時地對用戶輸入的關鍵詞進行分詞，分詞結果只存在內存中，當查詢結束時，分詞結果也會隨即消失。而寫時分詞發生在文檔寫入時，ES 會對文檔進行分詞後，將結果存入倒排索引，該部分最終會以文件的形式存儲於磁盤上，不會因查詢結束或者 ES 重啓而丟失。
寫時分詞器需要在 mapping 中指定，而且一經指定就不能再修改，若要修改必須新建索引。

分詞一般在ES中有分詞器處理。英文爲Analyzer,它決定了分詞的規則，Es默認自帶了很多分詞器，如：
Standard、english、Keyword、Whitespace等等。默認的分詞器爲Standard，通過它們各自的功能可組合
成你想要的分詞規則。分詞器具體詳情可查看官網：分詞器
另外，在常用的中文分詞器、拼音分詞器、繁簡體轉換插件。國內用的就多的分別是：
elasticsearch-analysis-ik
elasticsearch-analysis-pinyin
elasticsearch-analysis-stconvert
可在以上鍊接找到自己對於的elasticsearch版本安裝插件。
這裏提供一個我自己封裝的elasticsearch 5.5.0 的Docker鏡像，裏面在官方鏡像的基礎上加入了以上三個個插件，鏈接：
liaodashuai/elasticsearch:1.0.2

簡單瞭解至此，下面用SpringBoot 集成
實現：

打造匹配搜索和高亮搜索API  
使用中文、拼音和繁簡體都能搜索到    
擴展另外衆多的搜索方式，簡單使用測試用例實現

集成SpringBoot 實現高亮顯示、拼音搜索

1. 導入jar包,springboot 2.0.4只支持5.X版本的Es,注意版本對應，避免坑。

    compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-elasticsearch', version: '2.0.6.RELEASE'
    compile 'org.elasticsearch.client:x-pack-transport:5.5.0'

2. 配置連接Es

@Configuration
public class EsConfiguration {

    private Client esClient;

    /**
     * Transport client transport client.
     * 如果配置X-PACK ,則需要在此處配置用戶信息
     *
     * @return the transport client
     */
    @Bean
    public Client transportClient() {
        TransportClient client = null;
        try {
            client = new PreBuiltXPackTransportClient(Settings.builder()
                    //嗅探集羣狀態
//                    .put("client.transport.sniff", true)
                    .put("cluster.name", "docker-cluster")
                    //如果有配置xpack插件，需要配置登錄
                    .put("xpack.security.user", "elastic:changeme")
                    .build())
                    .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("120.79.58.138"), 9300));
        } catch (UnknownHostException e) {
            log.error("elasticsearch 連接失敗 !");
        }
        return client;
    }

    /**
     * 避免TransportClient每次使用創建和釋放
     */
    public Client esTemplate() {
        if (StringUtils.isEmpty(esClient) || StringUtils.isEmpty(esClient.admin())) {
            esClient = transportClient();
            return esClient;
        }
        return esClient;
    }
}

3. 配置實體Mapping

@Document(indexName = "film-entity", type = "film")
@Setting(settingPath = "/json/film-setting.json")
@Mapping(mappingPath = "/json/film-mapping.json")
public class FilmEntity {

    @Id
    private Long id;
//    @Field(type = FieldType.Text, searchAnalyzer = "ik_max_word", analyzer = "ik_smart")
    private String name;
    private String nameOri;
    private String publishDate;
    private String type;
    private String language;
    private String fileDuration;
    private String director;
//    @Field(type = FieldType.Date)
    private Date created ;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNameOri() {
        return nameOri;
    }

    public void setNameOri(String nameOri) {
        this.nameOri = nameOri;
    }

    public String getPublishDate() {
        return publishDate;
    }

    public void setPublishDate(String publishDate) {
        this.publishDate = publishDate;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public String getFileDuration() {
        return fileDuration;
    }

    public void setFileDuration(String fileDuration) {
        this.fileDuration = fileDuration;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "FilmEntity [id=" + id + ", name=" + name + ", director=" + director + "]";
    }
}

上面的Model有必要解釋一下，SpringBoot 有爲我們提供多種方式設置mapping，你可以按喜好選擇使用，我選擇
的使用@Mapping註解配置，使用es原生的方式進行設置，雖然有點小麻煩，但是更加直觀了，也不僅限於java，也可以直接用curl或es控制檯創建。
film-mapping.json

{
  "film": {
    "_all": {
      "enabled": true
    },
    "properties": {
      "id": {
        "type": "integer"
      },
      "name": {
        "type": "text",
        "analyzer": "ikSearchAnalyzer",
        "search_analyzer": "ikSearchAnalyzer",
        "fields": {
          "pinyin": {
            "type": "text",
            "analyzer": "pinyinSimpleIndexAnalyzer",
            "search_analyzer": "pinyinSimpleIndexAnalyzer"
          }
        }
      },
      "nameOri": {
        "type": "text"
      },
      "publishDate": {
        "type": "text"
      },
      "type": {
        "type": "text"
      },
      "language": {
        "type": "text"
      },
      "fileDuration": {
        "type": "text"
      },
      "director": {
        "type": "text",
        "index": "true",
        "analyzer": "ikSearchAnalyzer"
      },
      "created": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
      }
    }
  }
}

另外，除了@Mapping，SpringBoot還爲我們提供了另一強大的註解@Setting，該註解可以讓我們爲當前索引設置一些相關屬性,相當於
elasticsearch中的settings配置，例如：
film-setting.json

{
  "index": {
    "analysis": {
      "filter": {
        "edge_ngram_filter": {
          "type": "edge_ngram",
          "min_gram": 1,
          "max_gram": 50
        },
        "pinyin_simple_filter": {
          "type": "pinyin",
          "first_letter": "prefix",
          "padding_char": " ",
          "limit_first_letter_length": 50,
          "lowercase": true
        }
      },
      "char_filter": {
        "tsconvert": {
          "type": "stconvert",
          "convert_type": "t2s"
        }
      },
      "analyzer": {
        "ikSearchAnalyzer": {
          "type": "custom",
          "tokenizer": "ik_max_word",
          "char_filter": [
            "tsconvert"
          ]
        },
        "pinyinSimpleIndexAnalyzer": {
          "tokenizer": "keyword",
          "filter": [
            "pinyin_simple_filter",
            "edge_ngram_filter",
            "lowercase"
          ]
        }
      }
    }
  }
}

上面的JSON作用是創建兩個分析器名爲ikSearchAnalyzer，pinyinSimpleIndexAnalyzer,前者使用ik中文分詞器加繁體轉簡體char_filter過濾，使得引用此分詞器的字段在設置時，將會自動對中文進行分詞和繁簡體轉換。
pinyinSimpleIndexAnalyzer 使用pinyin分詞器，並進行edge_ngram 過濾，大寫轉小寫過濾。
上述設置完後，啓動應用，打開head插件，也可以使用google擴展，elasticsearch-head。

創建好索引後，便可開始測試查詢了。
使用SpringBoot提供的ElasticsearchRepository<T,ID>構建簡單查詢，當然它也是有侷限的，一些較複雜的查詢，只能通過
SearchResponse 自定義設置。
首先我們實現簡單的普通查詢,可以配合Repository，繼承ElasticsearchRepository<T,ID>,簡單的CRUD都提供了。

public interface FilmDao extends ElasticsearchRepository<FilmEntity, Long> {

}

先創建幾條測試數據：

service類,構建查詢

    /**
     * 拼接搜索條件
     *
     * @param name     the name
     * @param director the director
     * @return list
     */
    public List<FilmEntity> search(String name, String director) {
        //使用中文拼音混合搜索，取分數最高的，具體評分規則可參照：
        //  https://blog.csdn.net/paditang/article/details/79098830
        SearchQuery searchQuery = new NativeSearchQueryBuilder()
                .withQuery(structureQuery(name))
                .build();
        List<FilmEntity> list = filmDao.search(searchQuery).getContent();
        return list;
    }

    /**
     * 中文、拼音混合搜索
     *
     * @param content the content
     * @return dis max query builder
     */
    public DisMaxQueryBuilder structureQuery(String content) {
        //使用dis_max直接取多個query中，分數最高的那一個query的分數即可
        DisMaxQueryBuilder disMaxQueryBuilder = QueryBuilders.disMaxQuery();
        //boost 設置權重,只搜索匹配name和disrector字段
        QueryBuilder ikNameQuery = QueryBuilders.matchQuery("name", content).boost(2f);
        QueryBuilder pinyinNameQuery = QueryBuilders.matchQuery("name.pinyin", content);
        QueryBuilder ikDirectorQuery = QueryBuilders.matchQuery("director", content).boost(2f);
        disMaxQueryBuilder.add(ikNameQuery);
        disMaxQueryBuilder.add(pinyinNameQuery);
        disMaxQueryBuilder.add(ikDirectorQuery);
        return disMaxQueryBuilder;
    }

輸入拼音搜索“ceshi”可看到對應結果，當然中文也是可以的：

輸入簡體字搜索"測試",可看到對應結果

service類，構建高亮查詢

 public List<FilmEntity> search(String query) {
        Client client = esConfig.esTemplate();
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        //高亮顯示規則
        highlightBuilder.preTags("<span style='color:green'>");
        highlightBuilder.postTags("</span>");
        //指定高亮字段
        highlightBuilder.field("name");
        highlightBuilder.field("name.pinyin");
        highlightBuilder.field("director");
        String[] fileds = {"name", "name.pinyin", "director"};
        QueryBuilder matchQuery = QueryBuilders.multiMatchQuery(query, fileds);
        //搜索數據
        SearchResponse response = client.prepareSearch("film-entity")
                .setQuery(matchQuery)
                .highlighter(highlightBuilder)
                .execute().actionGet();

        SearchHits searchHits = response.getHits();
        System.out.println("記錄數-->" + searchHits.getTotalHits());

        List<FilmEntity> list = new ArrayList<>();

        for (SearchHit hit : searchHits) {
            FilmEntity entity = new FilmEntity();
            Map<String, Object> entityMap = hit.getSourceAsMap();
            System.out.println(hit.getHighlightFields());
            //高亮字段
            if (!StringUtils.isEmpty(hit.getHighlightFields().get("name"))) {
                Text[] text = hit.getHighlightFields().get("name").getFragments();
                entity.setName(text[0].toString());
                entity.setDirector(String.valueOf(entityMap.get("director")));
            }
            if (!StringUtils.isEmpty(hit.getHighlightFields().get("name.pinyin"))) {
                Text[] text = hit.getHighlightFields().get("name.pinyin").getFragments();
                entity.setName(text[0].toString());
                entity.setDirector(String.valueOf(entityMap.get("director")));
            }
            if (!StringUtils.isEmpty(hit.getHighlightFields().get("director"))) {
                Text[] text = hit.getHighlightFields().get("director").getFragments();
                entity.setDirector(text[0].toString());
                entity.setName(String.valueOf(entityMap.get("name")));
            }

            //map to object
            if (!CollectionUtils.isEmpty(entityMap)) {
                if (!StringUtils.isEmpty(entityMap.get("id"))) {
                    entity.setId(Long.valueOf(String.valueOf(entityMap.get("id"))));
                }
                if (!StringUtils.isEmpty(entityMap.get("language"))) {
                    entity.setLanguage(String.valueOf(entityMap.get("language")));
                }
            }
            list.add(entity);
        }
        return list;
}

上面配置了高亮搜索字段[name,name.pinyin,director],也就是說匹配到這三個字段的高亮結果，則會加上自定義的
高亮顯示規則:

<span style='color:green'>...</span>   

輸入拼音搜索“ceshi”可看到對應結果，當然中文也是可以的：

輸入簡體字搜索"測試",可看到對應結果

輸入繁體字搜索"認爲",可看到對應結果，由於pinyin分詞器影響還會取到小王。

實際上有搜索到有多個高亮結果的，這裏只取第一個演示查看。

大家肯定很好奇這分詞到底是怎麼分的，爲此我專門提供一個接口，可以查看我們輸入的搜索內容是怎樣被分詞的。
api測試：

結果如下：

{
  "result": [
    {
      "term": "xiao",
      "startOffset": 0,
      "endOffset": 2,
      "position": 0,
      "positionLength": 1,
      "attributes": null,
      "type": "CN_WORD",
      "fragment": false
    },
    {
      "term": "xm",
      "startOffset": 0,
      "endOffset": 2,
      "position": 0,
      "positionLength": 1,
      "attributes": null,
      "type": "CN_WORD",
      "fragment": false
    },
    {
      "term": "ming",
      "startOffset": 0,
      "endOffset": 2,
      "position": 1,
      "positionLength": 1,
      "attributes": null,
      "type": "CN_WORD",
      "fragment": false
    }
  ],
  "msg": "",
  "code": 200,
  "is_success": true
}

可以看到，我們的分詞器已經生效。

以上示例源碼以上傳至GitHub：https://github.com/liaozihong/SpringBoot-Learning/tree/master/SpringBoot-Elasticsearch-Query

參考鏈接：
Elasticsearch 分詞檢索
Java API 5.5.0
Elasticsearch 結合SpringBoot 高亮顯示查詢