【Es】jest操作elasticsearch

操作es的客房端有多个，在此例出三种（具体区别自行百度），本文讲的是jest操作es的api

1、TransportClient

2、Jest

3、RestClient

springboot的配置文件：

spring.elasticsearch.jest.uris=http://192.168.106.235:9200

pom依赖：

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>6.0.0</version>
        </dependency>

        <dependency>
            <groupId>io.searchbox</groupId>
            <artifactId>jest</artifactId>
            <version>5.3.3</version>
        </dependency>

        <dependency>
            <groupId>io.searchbox</groupId>
            <artifactId>jest-common</artifactId>
            <version>5.3.3</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.0.5</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version>
        </dependency>

 

实体类：

package com.ireport.demo.es;

import lombok.Data;
import java.io.Serializable;

@Data
public class Article implements Serializable {

    private Long titleId;
    private String title;
    private String author;
    private String content;
    private String publishDate;

    @Override
    public String toString() {
        return "Article{" +
                "titleId=" + titleId +
                ", title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", content='" + content + '\'' +
                ", publishDate='" + publishDate + '\'' +
                '}';
    }
}

连接mysql数据库：

package com.ireport.demo.util;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

@Slf4j
@Data
@Component
public class MysqlJdbcFactory {

    private static String driver = "com.mysql.jdbc.Driver";
    private static String url = "jdbc:mysql://localhost:3306/test";
    private static String user = "root";
    private static String pwd = "root";

    //连接数据库  mysql
    public static Connection getConnection(){
        Connection conn=null;
        try {
            Class.forName(driver);
            conn=DriverManager.getConnection(url,user,pwd);
            log.info("[数据库连接成功...]");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("[数据库连接失败...]", e.getMessage());
        }
        return conn;
    }

    //关闭数据库
    public static void closeAll(Connection conn, Statement st, ResultSet rs){
        try {
            if(rs!=null){
                rs.close();
            }
            if(st!=null){
                st.close();
            }
            if(conn!=null){
                conn.close();
            }
            log.info("[数据库关闭...]");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

查询所有数据：

package com.ireport.demo.kafka;

import com.ireport.demo.es.Article;
import com.ireport.demo.util.MysqlJdbcFactory;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

@Data
@Slf4j
@Component
public class ArticleService {



    public Connection conn=null;
    public Statement st=null;
    public ResultSet rs=null;

    @Autowired
    MysqlJdbcFactory factory;

    public List<Article> getAllArticle() {
        List<Article> list=new ArrayList<Article>();
        try{
            String sql="select * from article";
            conn=factory.getConnection();
            st=conn.createStatement();
            rs=st.executeQuery(sql);
            while(rs.next()){
                Article article=new Article();
                article.setTitleId(rs.getLong("id"));
                article.setTitle(rs.getString("title"));
                article.setAuthor(rs.getString("author"));
                article.setContent(rs.getString("content"));
                article.setPublishDate(rs.getString("publish_date"));
                list.add(article);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            factory.closeAll(conn, st, rs);
        }
        return list;
    }
}

数据结构：

客户端类：

package com.ireport.demo.es;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.JsonObject;
import io.searchbox.client.JestClient;
import io.searchbox.client.JestResult;
import io.searchbox.core.*;
import io.searchbox.indices.CreateIndex;
import io.searchbox.indices.DeleteIndex;
import io.searchbox.indices.mapping.GetMapping;
import io.searchbox.indices.mapping.PutMapping;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.common.settings.Settings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.IOException;

import static com.google.common.base.Preconditions.checkArgument;

@Slf4j
@Component
public class EsJestClient {


    @Autowired
    private JestClient esClient;


    public static final String INDEX = "es-article";
    public static final String TYPE = "articles";

    /**
     * 创建所引
     * @throws IOException
     */
    public void createIndex() throws IOException {
        Settings.Builder builder = Settings.builder();
        builder.put("number_of_shards",5);
        builder.put("number_of_replicas",1);

        //创建索引
        CreateIndex createIndex = new CreateIndex.Builder(INDEX)
                .settings(builder.build().getAsMap())
                .build();
        JestResult result = esClient.execute(createIndex);
        log.info("【创建索引:{}...】", INDEX);
        checkArgument(result.isSucceeded(), result.getErrorMessage());
        createMapping();
    }

    /**
     * 删除索引
     * @param index
     * @throws IOException
     */
    public void deleteIndex(String index) throws IOException {
        DeleteIndex deleteIndex = new DeleteIndex.Builder(index).build();
        JestResult result =  esClient.execute(deleteIndex);
        log.info("【删除索引:{}...】", index);
        checkArgument(result.isSucceeded(), result.getErrorMessage());
    }

    /**
     * put映射
     * @throws IOException
     */
    public void createMapping() throws IOException {

        JSONObject objSource = new JSONObject().fluentPut("properties", new JSONObject()
                .fluentPut("title", new JSONObject()
                        .fluentPut("type", "text")
                )
                .fluentPut("author", new JSONObject()
                        .fluentPut("type", "text")
                )
                .fluentPut("content", new JSONObject()
                        .fluentPut("type", "text")
                )
                .fluentPut("publishDate", new JSONObject()
                        .fluentPut("type", "date")
                )
        );
        PutMapping putMapping = new PutMapping.Builder(INDEX,TYPE, objSource.toJSONString()).build();
        JestResult result = esClient.execute(putMapping);

        log.info("【创建mapping映射成功...】");
        checkArgument(result.isSucceeded(), result.getErrorMessage());

    }

    /**
     * 向es中插入数据
     * @param source
     * @param id
     * @throws Exception
     */
    public void putSource(Object source, String id) throws Exception{
        JestResult result = esClient.execute(
                new Index.Builder(source)
                        .index(INDEX)
                        .type(TYPE)
                        .id(id)
                        .refresh(true)
                        .build());
        checkArgument(result.isSucceeded(), result.getErrorMessage());
    }

    /**
     * 根据条件查询
     * @param query
     * @return
     * @throws IOException
     */
    public SearchResult searchWithQuery(String query) throws IOException {
        log.info(">>>>查询条件：\\\r query:{}", query);
        Search search = new Search.Builder(query)
                .addIndex(INDEX)
                .addType(TYPE)
                .build();
        SearchResult result = esClient.execute(search);
        checkArgument(result.isSucceeded(), result.getErrorMessage());
        return result;
    }

    /**
     * 根据id查询
     * @param id
     * @return
     */
    public JestResult searchById(long id) throws Exception {
        Get build = new Get.Builder(INDEX, String.valueOf(id))
                .index(INDEX)
                .type(TYPE)
                .build();
        JestResult result = esClient.execute(build);
        return result;
    }


    /**
     * 根据id删除数据
     * @param id
     * @return
     * @throws Exception
     */
    public boolean delete(Long id) throws Exception{
        Delete build = new Delete.Builder(String.valueOf(id))
                .index(INDEX)
                .type(TYPE)
                .build();
        JestResult result = esClient.execute(build);
        checkArgument(result.isSucceeded(), result.getErrorMessage());
        return result.isSucceeded();

    }


    /**
     * 获取index下的映射
     * @return
     * @throws Exception
     */
    public String getMapping() throws Exception{
        GetMapping build = new GetMapping.Builder().addIndex(INDEX).addType(TYPE).build();
        JestResult result = esClient.execute(build);
        checkArgument(result.isSucceeded(), result.getErrorMessage());
        return result.getSourceAsObject(JsonObject.class).toString();
    }


}

测试类：

package com.ireport.demo;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ireport.demo.es.Article;
import com.ireport.demo.es.EsJestClient;
import com.ireport.demo.kafka.ArticleService;
import io.searchbox.client.JestResult;
import io.searchbox.core.SearchResult;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.swing.text.Highlighter;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.List;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class EsTest {

    @Autowired
    EsJestClient esClient;

    @Autowired
    ArticleService articleService;


    /**
     * 初始化索引并创建映射
     */
    @Test
    public void init(){
        try {
            esClient.deleteIndex("es-article");
            esClient.createIndex();
        }catch (IOException e){
            e.printStackTrace();
            log.error("【es-article索引建立失败...】", e.getMessage());
        }
    }

    /**
     * 获取映射信息
     */
    @Test
    public void getMappingTest(){
        try {
            String mapping = esClient.getMapping();
            log.error("【获取映射信息:{}】", mapping);
        }catch (Exception e){
            e.printStackTrace();
            log.error("【获取映射信息失败...】", e.getMessage());
        }
    }

    /**
     * 添加数据
     */
    @Test
    public void putDataTest(){

        try{
            List<Article> list = articleService.getAllArticle();
            for (Article article: list) {
                esClient.putSource(article, article.getTitleId().toString());
                log.info("【《{}》保存成功...】", article.getTitle());
            }
        }catch(Exception e){
            e.printStackTrace();
            log.error("【数据保存失败...】", e.getMessage());
        }

    }


    /**
     * 查询type下的所有数据
     */
    @Test
    public void searchType(){

        JSONObject resultJson = new JSONObject();
        JSONArray retJsonArray = new JSONArray();
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.sort("publishDate", SortOrder.ASC); //根据发版日期排序
        SearchResult result;
        try {
            result = esClient.searchWithQuery(searchSourceBuilder.toString());
            for(SearchResult.Hit<JSONObject, Void> item : result.getHits(JSONObject.class)) {
                retJsonArray.add(item.source);
            }
        } catch (IOException e) {
            e.printStackTrace();
            log.error("【查询数据失败...】", e.getMessage());
        }
        resultJson.fluentPut("data", retJsonArray);
        log.info("【result:{}】", resultJson.toString());

    }

    /**
     * 根据条件查询并设置高亮显示内容
     */
    @Test
    public void searchByTj() {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.query(QueryBuilders.queryStringQuery(MessageFormat.format("title:{0} OR content:{0}", "作品")));
            searchSourceBuilder.sort("publishDate", SortOrder.DESC);
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.field("title");
            highlightBuilder.field("content");
            highlightBuilder.preTags("<em>").postTags("</em>");//高亮标签
            highlightBuilder.fragmentSize(100);
            searchSourceBuilder.highlighter(highlightBuilder);
            SearchResult result = esClient.searchWithQuery(searchSourceBuilder.toString());
            for (SearchResult.Hit<JSONObject, Void> item : result.getHits(JSONObject.class)){
                if (item.highlight.containsKey("title")) {
                    item.source.fluentPut("highlight", item.highlight.get("title").get(0));
                }
                if (item.highlight.containsKey("content")) {
                    item.source.fluentPut("highlight_content", item.highlight.get("content").get(0));
                }
                item.source.remove("content");
                log.info("sss:{}", JSONArray.toJSON(item).toString());
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【查询数据失败...】", e.getMessage());
        }
    }


    /**
     * 根据id查询
     */
    @Test
    public void searchByIdTest() {
        try {
            JestResult jestResult = esClient.searchById(1L);
            Article article = jestResult.getSourceAsObject(Article.class);
            log.info("【《{}》查询成功,{}...】", article.getTitle(), article);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【查询数据失败...】", e.getMessage());
        }
    }


    /**
     * 删除数据
     */
    @Test
    public void deleteTest() {
        try {
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            SearchResult  result = esClient.searchWithQuery(searchSourceBuilder.toString());
            for (SearchResult.Hit<JSONObject, Void> item : result.getHits(JSONObject.class)) {
                esClient.delete(item.source.getLong("titleId"));
                log.info("【《{}》删除成功...】", item.source.getString("title"));
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【删除数据失败...】", e.getMessage());
        }
    }


}