ElasticSearch6.5.4高亮搜索

坐标

<modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
    </parent>
    <groupId>com.test.es</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>demo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <elasticsearch.version>6.2.4</elasticsearch.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.7</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.7</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

application.yml(注意：同一台电脑部署ES集群，所以端口有2个。
正确做法是配置多个node)

elasticsearch:
  cluster:
    name: es
    nodes: localhost
    port: 9300,9301

工具类

package com.test.es.demo;

import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.net.InetAddress;
import java.net.UnknownHostException;

@Configuration
public class MyConfig {

    @Value("${elasticsearch.cluster.name}")
    private String esName;

    @Value("${elasticsearch.cluster.nodes}")
    private String esHost;

    @Value("${elasticsearch.cluster.port}")
    private int[] esPort;


    @Bean("client")
    public TransportClient getClient() throws UnknownHostException {
        // 指定ES集群
        //自动嗅探
        Settings settings = Settings.builder().put("cluster.name", esName)
                .put("client.transport.sniff", true).build();
        // 创建访问es服务器的客户端
        TransportAddress node = new TransportAddress(InetAddress.getByName(esHost), esPort[0]);
        TransportAddress node2 = new TransportAddress(InetAddress.getByName(esHost), esPort[1]); //测试用，后期使用foreach遍历esHost
        TransportClient client = new PreBuiltTransportClient(settings)
                .addTransportAddresses(node,node2);
        return client;
    }



    /**
     * 用于关闭elasticSearch
     */
    public static void closeClient(TransportClient client){
        if(client != null){
            try {
                client.close();
            } catch (Exception e) {
                throw new RuntimeException("连接关闭失败");
            }
        }
    }

}

测试代码（高亮搜索）

package com.syaccp.es.demo;

import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@SpringBootApplication
@RestController
public class Application {

    @Autowired
    private TransportClient client;

    private TransportClient esClient;

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

    @GetMapping("/")
    public String index(){return "index";}

    @GetMapping("/get/market/product")
    @ResponseBody
    public ResponseEntity get(@RequestParam(name="id",defaultValue="") String id){

        if(id.isEmpty()){
            return new ResponseEntity(HttpStatus.NOT_FOUND);
        }

        GetResponse result = client.prepareGet("market", "product", id).get();

        if(!result.isExists()){
            return new ResponseEntity(HttpStatus.NOT_FOUND);
        }

        return new ResponseEntity(result.getSource(), HttpStatus.OK);
    }

    @PostMapping("add/market/product")
    @ResponseBody
    public ResponseEntity add(@RequestParam(name="name") String name,
            @RequestParam(name="age") Integer age,
            @RequestParam(name="birthday")@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date birthday
    ) {
        try {
            XContentBuilder content = XContentFactory.jsonBuilder().startObject()
                    .field("name", name)
                    .field("age", age)
                    .field("birthday", birthday.getTime()).endObject();
            IndexResponse result = this.client.prepareIndex("market", "product")
                    .setSource(content).get();
            return new ResponseEntity(result.getId(),HttpStatus.OK);
        } catch (IOException e) {
            e.printStackTrace();
            return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @DeleteMapping("delete/market/product")
    @ResponseBody
    public ResponseEntity delete(@RequestParam(name="id") String id){
        DeleteResponse result = this.client.prepareDelete("market","product",id).get();
        return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
    }

    @PutMapping("update/market/product")
    @ResponseBody
    public ResponseEntity update(@RequestParam("id") String id,
        @RequestParam(name="name",required = false) String name,
        @RequestParam(name = "age",required = false) Integer age,
        @RequestParam(name = "birthday",required = false)@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date birthday
    ) {
        UpdateRequest update = new UpdateRequest("market","product",id);
        try {
            XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
            if(name!=null){
                builder.field("name",name);
            }
            if(age!=null){
                builder.field("age",age);
            }
            if(birthday!=null){
                builder.field("birthday",birthday);
            }
            builder.endObject();
            update.doc(builder);
        } catch (IOException e) {
            return  new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
        }

        try {
            UpdateResponse result = this.client.update(update).get();
            return new ResponseEntity(result.getResult().toString(),HttpStatus.OK);
        }catch (Exception e){
            return new ResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
        }

    }

    @PostMapping("query/market/product")
    @ResponseBody
    public ResponseEntity query(
            @RequestParam(name="name",required = false) String name,
            @RequestParam(name = "age",required = false) Integer age,
            @RequestParam(name = "birthday",required = false)@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date birthday/*,
            @RequestParam(name="gt_word_count",defaultValue = "0") Integer gtWordCount,
            @RequestParam(name = "lt_word_count",required = false) Integer ltWordCount*/
    ) {
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        if(name!=null){
            boolQuery.must(QueryBuilders.matchQuery("name",name));
        }
        if(age!=null){
            boolQuery.must(QueryBuilders.matchQuery("age",age));
        }
        if(birthday!=null){
            boolQuery.must(QueryBuilders.matchQuery("birthday",birthday));
        }
//      RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("word_count")
//              .from(gtWordCount);
//      if(ltWordCount!=null && ltWordCount>0){
//          rangeQuery.to(ltWordCount);
//      }
//      boolQuery.filter(rangeQuery);
        SearchRequestBuilder builder = this.esTemplate().prepareSearch("market")
                .setTypes("product")
                .setSearchType(SearchType.DFS_QUERY_THEN_FETCH) //QUERY_THEN_FETCH 非精确搜索，效率高
                .setQuery(boolQuery)
                .highlighter(new HighlightBuilder().field("name")/*.preTags("<es>").postTags("</es>")*/)
                .setFrom(0)
                .setSize(10);

//      System.out.println(builder);
        SearchResponse response = builder.get();
        List<Map<String,Object>> result = new ArrayList<Map<String,Object>>();
        for (SearchHit hit : response.getHits()) {
            Text[] text = hit.getHighlightFields().get("name").fragments();
            String highlightFields = text[0].toString();    //高亮字段，赋值给对象
            hit.getSourceAsMap().put("name",highlightFields);
            result.add(hit.getSourceAsMap());
        }
        return new ResponseEntity(result,HttpStatus.OK);
    }

    private static String parSetName(String fieldName) {
        if (null == fieldName || "".equals(fieldName)) {
            return null;
        }
        int startIndex = 0;
        if (fieldName.charAt(0) == '_')
            startIndex = 1;
        return "set" + fieldName.substring(startIndex, startIndex + 1).toUpperCase()
                + fieldName.substring(startIndex + 1);
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}