Elasticsearch7.x使用(六) 集成SpringBoot

朱雀 2023-02-26 05:26 181阅读 0赞

原文转载至：[https://www.cnblogs.com/tigerlion/p/12961737.html][https_www.cnblogs.com_tigerlion_p_12961737.html]

Elasticsearch已迭代到7.X.X版本，建议使用high-level-client进行链接。

## pom.xml ##

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.1.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.example</groupId>
        <artifactId>es_demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>es_demo</name>d
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-rest</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.elasticsearch</groupId>
                <artifactId>elasticsearch</artifactId>
                <version>7.7.0</version>
            </dependency>
            <dependency>
                <groupId>org.elasticsearch.client</groupId>
                <artifactId>elasticsearch-rest-high-level-client</artifactId>
                <version>7.7.0</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.56</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

## 存储的对象 ##

package com.ah.es.pojo;
    
    public class Book {
    	private Integer bookId;
    	private String name;
    
    	public Book() {
    	}
    
    	public Book(Integer bookId, String name) {
    		this.bookId = bookId;
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return "Book [bookId=" + bookId + ", name=" + name + "]";
    	}
    
    	public Integer getBookId() {
    		return bookId;
    	}
    
    	public void setBookId(Integer bookId) {
    		this.bookId = bookId;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    }

## EsEntity·Es保存的对象 ##

package com.ah.es.util;
    
    public final class EsEntity<T> {
    
    	private String id;
    	private T data;
    
    	public EsEntity() {
    	}
    
    	public EsEntity(String id, T data) {
    		this.data = data;
    		this.id = id;
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	public T getData() {
    		return data;
    	}
    
    	public void setData(T data) {
    		this.data = data;
    	}
    }

## INDEX内容 ##

> src/main/resources/es.txt

{
      "properties": {
        "id":{
          "type":"integer"
        },
        "bookId":{
          "type":"integer"
        },
        "name":{
          "type":"text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_smart"
        }
      }
    }

## EsUtil·工具类 ##

package com.ah.es.util;
    
    import com.alibaba.fastjson.JSON;
    import org.apache.http.HttpHost;
    import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
    import org.elasticsearch.action.bulk.*;
    import org.elasticsearch.action.delete.DeleteRequest;
    import org.elasticsearch.action.index.*;
    import org.elasticsearch.action.search.*;
    import org.elasticsearch.action.support.master.AcknowledgedResponse;
    import org.elasticsearch.client.*;
    import org.elasticsearch.client.indices.*;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.elasticsearch.index.query.QueryBuilder;
    import org.elasticsearch.index.reindex.*;
    import org.elasticsearch.search.*;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import javax.annotation.PostConstruct;
    import java.io.*;
    import java.util.*;
    @Component
    public class EsUtil {
    	@Value("192.168.16.128")
    	public String host;
    	@Value("9200")
    	public int port;
    	@Value("http")
    	public String scheme;
    	public static final String INDEX_NAME = "book-index";
    	public static String CREATE_INDEX;
    	public static RestHighLevelClient restClient = null;
    
    	private static String readFileToString(String filePath) {
    		File file = new File(filePath);
    		System.out.println(file.getAbsolutePath());
    		try (FileReader reader = new FileReader(file)) {
    			BufferedReader bReader = new BufferedReader(reader);
    			StringBuilder sb = new StringBuilder();
    			String s = "";
    			while ((s = bReader.readLine()) != null) {
    				sb.append(s + "\n");
    			}
    			return sb.toString();
    		} catch (IOException e1) {
    			e1.printStackTrace();
    		}
    		return "";
    	}
    
    	@PostConstruct
    	public void init() {
    		CREATE_INDEX = readFileToString("src/main/resources/es.txt");
    		System.out.println("CREATE_INDEX = " + CREATE_INDEX);
    		try {
    			if (restClient != null) {
    				restClient.close();
    			}
    			restClient = new RestHighLevelClient(RestClient.builder(new HttpHost(host, port, scheme)));
    			if (this.indexExist(INDEX_NAME)) {
    				return;
    			}
    			CreateIndexRequest request = new CreateIndexRequest(INDEX_NAME);
    			request.settings(Settings.builder().put("index.number_of_shards", 3).put("index.number_of_replicas", 2));
    			request.mapping(CREATE_INDEX, XContentType.JSON);
    			CreateIndexResponse res = restClient.indices().create(request, RequestOptions.DEFAULT);
    			if (!res.isAcknowledged()) {
    				throw new RuntimeException("初始化失败");
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.exit(0);
    		}
    	}
    
    	public boolean indexExist(String index) throws Exception {
    		GetIndexRequest request = new GetIndexRequest(index);
    		request.local(false);
    		request.humanReadable(true);
    		request.includeDefaults(false);
    		return restClient.indices().exists(request, RequestOptions.DEFAULT);
    	}
    
    	public IndexResponse insertOrUpdateOne(String index, EsEntity entity) {
    		IndexRequest request = new IndexRequest(index);
    		request.id(entity.getId());
    		request.source(JSON.toJSONString(entity.getData()), XContentType.JSON);
    		try {
    			return restClient.index(request, RequestOptions.DEFAULT);
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	public BulkResponse insertBatch(String index, List<EsEntity> list) {
    		BulkRequest request = new BulkRequest();
    		for (EsEntity item : list) {
    			String _json = JSON.toJSONString(item.getData());
    			String _id = item.getId();
    			IndexRequest indexRequest = new IndexRequest(index).id(_id).source(_json, XContentType.JSON);
    			request.add(indexRequest);
    		}
    		try {
    			return restClient.bulk(request, RequestOptions.DEFAULT);
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	public <T> List<T> search(String index, SearchSourceBuilder searchSourceBuilder, Class<T> resultClass) {
    		SearchRequest request = new SearchRequest(index);
    		request.source(searchSourceBuilder);
    		try {
    			SearchResponse response = restClient.search(request, RequestOptions.DEFAULT);
    
    			SearchHits hits1 = response.getHits();
    			SearchHit[] hits2 = hits1.getHits();
    			List<T> retList = new ArrayList<>(hits2.length);
    			for (SearchHit hit : hits2) {
    				String strJson = hit.getSourceAsString();
    				retList.add(JSON.parseObject(strJson, resultClass));
    			}
    			return retList;
    		} catch (Exception e) {
    			e.printStackTrace();
    			throw new RuntimeException(e);
    		}
    	}
    
    	public AcknowledgedResponse deleteIndex(String index) {
    		try {
    			IndicesClient indicesClient = restClient.indices();
    			DeleteIndexRequest request = new DeleteIndexRequest(index);
    			AcknowledgedResponse response = indicesClient.delete(request, RequestOptions.DEFAULT);
    			return response;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	public BulkByScrollResponse deleteByQuery(String index, QueryBuilder builder) {
    		DeleteByQueryRequest request = new DeleteByQueryRequest(index);
    		request.setQuery(builder);
    		request.setBatchSize(10000);
    		request.setConflicts("proceed");
    		try {
    			BulkByScrollResponse response = restClient.deleteByQuery(request, RequestOptions.DEFAULT);
    			return response;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	public <T> BulkResponse deleteBatch(String index, Collection<T> idList) {
    		BulkRequest request = new BulkRequest();
    		for (T t : idList) {
    			request.add(new DeleteRequest(index, t.toString()));
    		}
    		try {
    			BulkResponse response = restClient.bulk(request, RequestOptions.DEFAULT);
    			return response;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    }

## ES调用方 ##

package com.ah.es;
    
    import org.elasticsearch.action.bulk.BulkResponse;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.index.query.*;
    import org.elasticsearch.index.reindex.BulkByScrollResponse;
    import org.elasticsearch.search.builder.SearchSourceBuilder;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import com.ah.es.pojo.Book;
    import com.ah.es.util.*;
    
    import java.util.*;
    
    @Component
    public class EsService {
    
    	@Autowired
    	private EsUtil esUtil;
    
    	public List<Book> getAll() {
    		return esUtil.search(EsUtil.INDEX_NAME, new SearchSourceBuilder(), Book.class);
    	}
    
    	public Book getByBookId(int bookId) {
    		SearchSourceBuilder builder = new SearchSourceBuilder();
    		builder.query(new TermQueryBuilder("bookId", bookId));
    		List<Book> res = esUtil.search(EsUtil.INDEX_NAME, builder, Book.class);
    		if (res.size() > 0) {
    			return res.get(0);
    		} else {
    			return null;
    		}
    	}
    
    	public List<Book> searchByKey(String key) {
    		BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
    		boolQueryBuilder.must(QueryBuilders.matchQuery("name", key));
    		SearchSourceBuilder builder = new SearchSourceBuilder();
    		builder.size(10).query(boolQueryBuilder);
    		return esUtil.search(EsUtil.INDEX_NAME, builder, Book.class);
    	}
    
    	public IndexResponse putOne(Book book) {
    		EsEntity<Book> entity = new EsEntity<>(book.getBookId() + "", book);
    		return esUtil.insertOrUpdateOne(EsUtil.INDEX_NAME, entity);
    	}
    
    	public BulkResponse putBatch(List<Book> books) {
    		List<EsEntity> list = new ArrayList<>();
    		books.forEach(item -> list.add(new EsEntity<>(item.getBookId() + "", item)));
    		return esUtil.insertBatch(EsUtil.INDEX_NAME, list);
    	}
    
    	public BulkByScrollResponse deleteById(int id) {
    		return esUtil.deleteByQuery(EsUtil.INDEX_NAME, new TermQueryBuilder("bookId", id));
    	}
    
    	public BulkResponse deleteBatch(List<Integer> list) {
    		return esUtil.deleteBatch(EsUtil.INDEX_NAME, list);
    	}
    
    }

## 测试类 ##

package com.ah.es;
    
    import org.elasticsearch.action.bulk.BulkResponse;
    import org.elasticsearch.action.index.IndexResponse;
    import org.elasticsearch.index.reindex.BulkByScrollResponse;
    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 com.ah.es.pojo.Book;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class EsTest {
    
    	@Autowired
    	private EsService bookService;
    	
    	@Test
    	public void testAll() throws InterruptedException {
    		t1AddOne();
    		t2AddBatch();
    		Thread.sleep(1000);
    		t3FindAll();
    		t4search();
    		t5deleteOne();
    		t6deleteBatch();
    		Thread.sleep(1000);
    		t7FindAll();
    		
    	}
    
    	@Test
    	public void t1AddOne() {
    		IndexResponse putOne = bookService.putOne(new Book(1, "西游记"));
    		System.out.println("【1】putOne：" + putOne);
    	}
    
    	@Test
    	public void t2AddBatch() {
    		List<Book> list = new ArrayList<>();
    		list.add(new Book(2, "水浒传"));
    		list.add(new Book(3, "三国演义"));
    		BulkResponse putBatch = bookService.putBatch(list);
    		System.out.println("【2】putBatch：" + putBatch.status());
    	}
    
    	@Test
    	public void t3FindAll() {
    		System.out.println("【3】");
    		List<Book> res = bookService.getAll();
    		System.out.println("↓↓↓findAll");
    		res.forEach(System.out::println);
    		System.out.println("↑↑↑findAll");
    	}
    
    	@Test
    	public void t4search() {
    		System.out.println("【4】");
    		List<Book> searchByKey = bookService.searchByKey("水传");
    		searchByKey.forEach(System.out::println);
    
    		Book book = bookService.getByBookId(2);
    		System.out.println("【4】getByBookId：" + book);
    	}
    
    	@Test
    	public void t5deleteOne() {
    		BulkByScrollResponse deleteById = bookService.deleteById(1);
    		System.out.println("【5】deleteById：" + deleteById.getStatus());
    	}
    
    	@Test
    	public void t6deleteBatch() {
    		List<Integer> ids = new ArrayList<>();
    		ids.add(2);
    		ids.add(3);
    		BulkResponse deleteBatch = bookService.deleteBatch(ids);
    		System.out.println("【6】deleteBatch：" + deleteBatch.status());
    	}
    
    	@Test
    	public void t7FindAll() {
    		System.out.println("【7】");
    		List<Book> res = bookService.getAll();
    		System.out.println("↓↓↓findAll");
    		res.forEach(System.out::println);
    		System.out.println("↑↑↑findAll");
    	}
    }

运行结果：

【1】putOne：IndexResponse[index=book-index,type=_doc,id=1,version=5,result=created,seqNo=51,primaryTerm=1,shards={"total":3,"successful":1,"failed":0}]
    【2】putBatch：OK
    【3】
    ↓↓↓findAll
    Book [bookId=2, name=水浒传]
    Book [bookId=3, name=三国演义]
    Book [bookId=1, name=西游记]
    ↑↑↑findAll
    【4】
    Book [bookId=2, name=水浒传]
    【4】getByBookId：Book [bookId=2, name=水浒传]
    【5】deleteById：BulkIndexByScrollResponse[sliceId=null,updated=0,created=0,deleted=1,batches=1,versionConflicts=0,noops=0,retries=0,throttledUntil=0s]
    【6】deleteBatch：OK
    【7】
    ↓↓↓findAll
    ↑↑↑findAll

[https_www.cnblogs.com_tigerlion_p_12961737.html]: https://www.cnblogs.com/tigerlion/p/12961737.html