最近在项目使用了Elasticsearch，整理如下的整合流程。

一. 版本的匹配

根据自己项目要求的版本进行匹配

我们这里用Spring Boot 2.2.0

二. 导入引用的Spring-data-elasticsearch

<!-- https://docs.spring.io/spring-data/elasticsearch/docs/3.2.x/reference/html -->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-elasticsearch</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>

三. Elasticsearch Config

@Configuration
@ConfigurationProperties(prefix = "elastic-search")
@EnableElasticsearchRepositories(
    basePackages = "com.XX.repository")
public class ElasticsearchConfig extends AbstractElasticsearchConfiguration {

  private String host;
  private int port;
  private String userName;
  private String password;
  private String certificateBase64;
  private static final String HTTPS = "https";

  @Autowired
  private LogService logService;

  @Bean
  @Override
  public RestHighLevelClient elasticsearchClient() {
    if (StringUtils.isEmpty(certificateBase64)) {
      logService.info(getClass(), "Run the mode of JRE installation certificate.");
      final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
      credentialsProvider.setCredentials(AuthScope.ANY,
          new UsernamePasswordCredentials(userName, password));

      RestClientBuilder builder = RestClient.builder(new HttpHost(host, port, HTTPS))
          .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder
              .setDefaultCredentialsProvider(credentialsProvider));

      return new RestHighLevelClient(builder);
    } else {
      ClientConfiguration clientConfiguration = ClientConfiguration.builder()
          .connectedTo(host + ":" + port).usingSsl(this.getSSLContext(certificateBase64))
          .withBasicAuth(userName, password).build();
      return RestClients.create(clientConfiguration).rest();
    }
  }

  @Bean
  @Override
  public EntityMapper entityMapper() {
    ElasticsearchEntityMapper entityMapper = new ElasticsearchEntityMapper(
        elasticsearchMappingContext(), new DefaultConversionService());
    entityMapper.setConversions(elasticsearchCustomConversions());

    return entityMapper;
  }

  private SSLContext getSSLContext(String base64Cert) {
    SSLContext sslContext = null;
    try {
      sslContext = SSLContext.getInstance("TLSv1.2");
      InputStream is = new ByteArrayInputStream(Base64.getDecoder().decode(base64Cert));
      CertificateFactory cf = CertificateFactory.getInstance("X.509");
      X509Certificate caCert = (X509Certificate) cf.generateCertificate(is);
      TrustManagerFactory tmf =
          TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
      KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
      ks.load(null);
      ks.setCertificateEntry("caCert", caCert);
      tmf.init(ks);
      sslContext.init(null, tmf.getTrustManagers(), null);
    } catch (Exception e) {
      logService.error(getClass(), "load ssl error." + e.getMessage());
    }
    return sslContext;
  }

四. 写实体类和Repository

• Entity

@Document(indexName = "es_knowledge", type = "knowledge")
public class KnowledgeEs {
  
  @Id
  private String id;
  private String updatedBy;
  private Date updatedOn;
  private Map<String, Integer> ratings = new HashMap<>();

• CrudRepository

public interface KnowledgeEsRepository extends ElasticsearchRepository<KnowledgeEs, String> {

  @Query("{\"bool\" : {\"must\" : {\"field\" : {\"subject.keyword\" : \"?\"}}}}")
  Page<KnowledgeEs> findBySubject(String subject, Pageable pageable);

  @Query("{\"bool\" : {\"must\" : {\"field\" : {\"content.keyword\" : \"?\"}}}}")
  Page<KnowledgeEs> findByContent(String content, Pageable pageable);
}

• CustomRepository 利用了RestHighLevelClient的rest client
  里面包含(权重，高亮)的查询

@Repository
public class KnowledgeCustomEsRepositoryImpl implements KnowledgeCustomEsRepository {

  @Autowired
  RestHighLevelClient highLevelClient;

 @Override
  public List<Knowledge> getKnowledgesVisible(String enterpriseId, String teamId, String channelId,
      String keyword) {
    SearchRequest searchRequest = new SearchRequest(INDEX);
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    // search by keyword
    this.enrichKeywordQuery(keyword, boolQueryBuilder);

    // Boost
    this.enrichShouldBoostQuery(boolQueryBuilder, enterpriseId, teamId, channelId);

    sourceBuilder.query(boolQueryBuilder);

    // Highlight
    this.enrichHighlightBuilder(sourceBuilder);

    searchRequest.source(sourceBuilder);

    SearchResponse response;
    try {
      response = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    } catch (IOException e) {
      logService.error(getClass(), "es query fail." + e.getMessage());
      return new ArrayList<>();
    }
    // deal result
    List<Knowledge> knowledges = new ArrayList<>();
    for (SearchHit hit : response.getHits()) {
      try {
        Knowledge knowledge =
            new ObjectMapper().readValue(hit.getSourceAsString(), Knowledge.class);
        Map<String, HighlightField> highlightMap = hit.getHighlightFields();
        if (!highlightMap.isEmpty()) {
          if (highlightMap.get(CONTENT) != null
              && !ArrayUtils.isEmpty(highlightMap.get(CONTENT).getFragments())) {
            knowledge.setContent(highlightMap.get(CONTENT).getFragments()[0].toString());
          }
          if (highlightMap.get(SUBJECT) != null
              && !ArrayUtils.isEmpty(highlightMap.get(SUBJECT).getFragments())) {
            knowledge.setSubject(highlightMap.get(SUBJECT).getFragments()[0].toString());
          }
        }
        knowledge.setId(hit.getId());
        knowledges.add(knowledge);
      } catch (JsonProcessingException e) {
        logService.error(getClass(), "SearchHit to enity excption." + e.getMessage());
      }
    }
    return knowledges;
  }

/**
   * search by keyword
   * 
   * @param filters
   * @param queryBuilder
   */
  private void enrichKeywordQuery(String keyword, BoolQueryBuilder queryBuilder) {
    if (!StringUtils.isEmpty(keyword)) {
      String queryString = keyword.trim();
      if (queryString.contains(",")) {
        String[] queryArray = queryString.split(",");
        for (String value : queryArray) {
          // if query value is a comma separated values, then use AND operator between values
          if (!value.isEmpty()) {
            queryBuilder.must(QueryBuilders.queryStringQuery(value).analyzer(STOP_ANALYZER));
          }
        }
      } else if (queryString.startsWith("\"") && queryString.endsWith("\"")) {
        // exact match
        queryBuilder.must(QueryBuilders.queryStringQuery(queryString));
      } else if (!queryString.contains(" ")) {
        // to prevent elasticsearch from parsing email
        StringBuilder queryValue = new StringBuilder();
        queryValue.append("\"" + queryString + "\"");
        queryBuilder.must(QueryBuilders.queryStringQuery(queryValue.toString()));
      } else {
        queryBuilder.must(QueryBuilders.queryStringQuery(queryString).analyzer(STOP_ANALYZER));
      }
    }
  }

/**
   * HighlightBuilder
   * 
   * @param sourceBuilder
   */
  private void enrichHighlightBuilder(SearchSourceBuilder sourceBuilder) {
    // highlight
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.preTags("*");
    highlightBuilder.postTags("*");
    highlightBuilder.fields().addAll(
        Arrays.asList(new HighlightBuilder.Field(SUBJECT), new HighlightBuilder.Field(CONTENT)));
    sourceBuilder.highlighter(highlightBuilder);
  }

/**
   * Boost
   * 
   * @param boolQueryBuilder
   * @param enterpriseId
   * @param teamId
   * @param channelId
   */
  private void enrichShouldBoostQuery(BoolQueryBuilder boolQueryBuilder, String enterpriseId,
      String teamId, String channelId) {
    BoolQueryBuilder shouldBoolQueryBuilder = QueryBuilders.boolQuery();

    // Query according to enterpriseId, teamId, channelId, with the highest weight
    BoolQueryBuilder queryEnterpriseTeamChannel = QueryBuilders.boolQuery();
    queryEnterpriseTeamChannel
        .must(QueryBuilders.termQuery(FieldNames.CHANNEL_ID + KEYWORD, channelId).boost(2.0f))
        .must(QueryBuilders.termQuery(FieldNames.TEAM_ID + KEYWORD, teamId).boost(2.0f))
        .must(StringUtils.isEmpty(enterpriseId)
            ? QueryBuilders.termsQuery(FieldNames.ENTERPRISE_ID + KEYWORD, Arrays.asList("", null))
            : QueryBuilders.termQuery(FieldNames.ENTERPRISE_ID + KEYWORD, enterpriseId)
                .boost(2.0f));
    shouldBoolQueryBuilder.should(queryEnterpriseTeamChannel.boost(2.0f));

    // Query according to enterpriseId, teamId , level is ENTERPRISE ,WORKSPACE
    BoolQueryBuilder queryEnterpriseTeam = QueryBuilders.boolQuery();
    queryEnterpriseTeam.must(QueryBuilders.termQuery(FieldNames.TEAM_ID + KEYWORD, teamId))
        .must(StringUtils.isEmpty(enterpriseId)
            ? QueryBuilders.termsQuery(FieldNames.ENTERPRISE_ID + KEYWORD, Arrays.asList("", null))
            : QueryBuilders.termQuery(FieldNames.ENTERPRISE_ID + KEYWORD, enterpriseId))
        .mustNot(QueryBuilders.termQuery(FieldNames.CHANNEL_ID + KEYWORD, channelId))
        .must(QueryBuilders.termsQuery(FIELD_LEVEL + KEYWORD, Arrays
            .asList(KnowledgeLevel.ENTERPRISE.getName(), KnowledgeLevel.WORKSPACE.getName())));
    shouldBoolQueryBuilder.should(queryEnterpriseTeam);

    // Query according to enterpriseId ,level is ENTERPRISE
    BoolQueryBuilder queryEnterprise = QueryBuilders.boolQuery();
    queryEnterprise
        .must(StringUtils.isEmpty(enterpriseId)
            ? QueryBuilders.termsQuery(FieldNames.ENTERPRISE_ID + KEYWORD, Arrays.asList("", null))
            : QueryBuilders.termQuery(FieldNames.ENTERPRISE_ID + KEYWORD, enterpriseId))
        .mustNot(QueryBuilders.termQuery(FieldNames.TEAM_ID + KEYWORD, teamId))
        .mustNot(QueryBuilders.termQuery(FieldNames.CHANNEL_ID + KEYWORD, channelId))
        .must(QueryBuilders.termQuery(FIELD_LEVEL + KEYWORD, KnowledgeLevel.ENTERPRISE.getName())
            .boost(1.7f));
    shouldBoolQueryBuilder.should(queryEnterprise);

    boolQueryBuilder.must(shouldBoolQueryBuilder.minimumShouldMatch(1));
  }