ElasticSearch入门安装与SpringBoot集成实战
介绍
Elasticsearch 是一个实时分布式搜索和分析引擎，一般用于全文搜索、结构化搜索，分析或者三者混用。
它的底层是基于Apache Lucene（TM）的开源搜索引擎，但是lucene只是一个库，需要java开发然后集成到应用。
基础概念
应用场景
ES安装
- centos7安装
https://blog.csdn.net/u012069313/article/details/121660147
https://www.likecs.com/show-308251870.html#sc=600
修改config/elasticsearch.yml
-
windows安装
-
启动
# 后台启动
./bin/elasticsearch -d
安装Head插件
https://github.com/mobz/elasticsearch-head
下载解压。
-
安装node8+
cd根目录，npm install -
解决：前端npm install 报错PhantomJS not found on PATH
https://blog.csdn.net/qq_34254090/article/details/120313282
npm run start
集群配置
- 主节点
- 新建slave1, slave2 两个es
增删改查
https://www.bbsmax.com/A/kmzL44gGzG/
https://blog.csdn.net/weixin_47600880/article/details/119034733
- 创建索引
{
"settings": {
"number_of_shards": 3,
"number_of_replicas": 1
},
"mappings": {
"properties": {
"name": {
"type": "text"
},
"age": {
"type": "integer"
}
}
}
}
参数说明：
number_of_shards：索引分片数量
number_of_replicas：索引备份数量
mappings：索引结构化格式映射关键字
properties：设置索引的属性
-
插入文档
http://localhost:9200/people/_doc/1/ -
更新文档
http://localhost:9200/people/_update/1 -
查询文档
http://localhost:9200/people/_doc/1
http://localhost:9200/people/_search
{
"query": {
"match_all": {}
}
}
- 条件查询
http://localhost:9200/people/_search
{
"query": {
"match": {
"name": "治"
}
},
"from": 1,
"size": 1,
"sort": [
{
"_id": {
"order": "asc"
}
- 聚合查询
http://localhost:9200/people/_search
{
"aggs": {
"group_by_id": {
"terms": {
"field": "_id"
}
}
}
}
高级查询
- 习语查询
- 多字段查询
- query_string
- 范围查询
Springboot集成es实战
依赖：SpringBoot 2.3.7.RELEASE + ElasticSearch 8.1.1
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.test.java</groupId>
<artifactId>springboot_es_house</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.3.7.RELEASE</spring-boot.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!--Spring Boot Web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.44</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>co.elastic.clients</groupId>
<artifactId>elasticsearch-java</artifactId>
<version>8.1.1</version>
</dependency>
<dependency>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-api</artifactId>
<version>2.0.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
esclient配置类
package com.test.java.config;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @Author laoxu
* @Date 2023/2/17 15:06
* @Desc 配置ES客户端
*/
@Configuration
public class ESConfig {
@Bean
public ElasticsearchClient elasticsearchClient(){
RestClient client = RestClient.builder(new HttpHost("localhost", 9200,"http")).build();
ElasticsearchTransport transport = new RestClientTransport(client,new JacksonJsonpMapper());
return new ElasticsearchClient(transport);
}
}
product实体类
package com.test.java.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
/**
* @Author laoxu
* @Date 2023/2/17 15:26
* @Desc 商品实体类
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class Product {
private String productName;
private double price;
private Integer stock;
public String geIndexId() {
int id = 1;
id += id;
String indexId = String.valueOf(id);
return indexId;
}
}
Junit测试类
package com.test.java;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.query_dsl.MatchQuery;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch._types.query_dsl.RangeQuery;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.bulk.BulkResponseItem;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.core.search.TotalHits;
import co.elastic.clients.elasticsearch.core.search.TotalHitsRelation;
import co.elastic.clients.elasticsearch.indices.*;
import co.elastic.clients.elasticsearch.indices.ExistsRequest;
import co.elastic.clients.json.JsonData;
import co.elastic.clients.transport.endpoints.BooleanResponse;
import com.test.java.entity.Product;
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 java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* @Author laoxu
* @Date 2023/2/17 15:28
* @Desc 测试ES增删改查API
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class ESApiTest {
@Autowired
private ElasticsearchClient esClient;
/**
* 判断索引是否存在
* @throws IOException
*/
@Test
public void existsIndex() throws IOException {
ExistsRequest existsRequest = new ExistsRequest.Builder().index("product").build();
BooleanResponse existsResponse = esClient.indices().exists(existsRequest);
System.out.println("是否存在："+existsResponse.value());
}
/**
* 创建索引
* 创建索引时，必须是小写，否则创建报错
* @throws IOException
*/
@Test
public void createIndex() throws IOException {
CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder().index("product").build();
CreateIndexResponse createIndexResponse = esClient.indices().create(createIndexRequest);
System.out.println("是否成功："+createIndexResponse.acknowledged());
}
/**
* 删除索引
* @throws IOException
*/
@Test
public void deleteIndex() throws IOException {
DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest.Builder().index("product").build();
DeleteIndexResponse deleteIndexResponse = esClient.indices().delete(deleteIndexRequest);
System.out.println("是否成功："+deleteIndexResponse.acknowledged());
}
/**
* 同步方式
* 向索引中添加信息,此操作不存在索引时会直接创建索引，使用时需要各种校验使逻辑更严谨
* @throws IOException
*/
@Test
public void setIndex() throws IOException {
Product product = new Product("帽子",44.5,9);
IndexRequest<Product> indexRequest = new IndexRequest.Builder<Product>().index("product")
.id(String.valueOf(product.getStock()))
.document(product)
.build();
IndexResponse indexResponse = esClient.index(indexRequest);
System.out.println(indexResponse);
}
/**
* 批量写入数据
* @throws IOException
*/
@Test
public void bulkIndex() throws IOException{
List<Product> products = new ArrayList<Product>();
products.add(new Product("香烟",135,1));
products.add(new Product("瓜子",154,2));
products.add(new Product("矿泉水",613,3));
products.add(new Product("酱油",72,4));
products.add(new Product("大米",771,5));
BulkRequest.Builder bk = new BulkRequest.Builder();
int indexId = 4;
for (Product product:products) {
bk.operations(op->op.index(i->i.index("product")
.id(UUID.randomUUID().toString())
.document(product)));
}
BulkResponse response = esClient.bulk(bk.build());
if (response.errors()) {
System.out.println("Bulk had errors");
for (BulkResponseItem item: response.items()) {
if (item.error() != null) {
System.out.println(item.error().reason());
}
}
}
}
/**
* 根据索引文档id获取文档信息
* @throws IOException
*/
@Test
public void getIndexById() throws IOException {
GetRequest getRequest = new GetRequest.Builder().index("product")
.id("9")
.build();
GetResponse<Product> response = esClient.get(getRequest, Product.class);
if (response.found()) {
Product product = response.source();
System.out.println("Product name " + product.getProductName());
System.out.println("Product price " + product.getPrice());
} else {
System.out.println("Product not found");
}
}
/**
* 简单查询文档信息
* @throws IOException
*/
@Test
public void getSearch() throws IOException{
/*此处 .from(1).size(2) 表示分页查询，从第一页开始查询，大小为两条*/
SearchRequest searchRequest = new SearchRequest.Builder().index("product")
.query(q -> q.match(m -> m.field("productName").query("烟"))).from(1).size(2).build();
SearchResponse<Product> response = esClient.search(searchRequest,Product.class);
TotalHits total = response.hits().total();
boolean isExactResult = total.relation() == TotalHitsRelation.Eq;
if (isExactResult) {
System.out.println("There are " + total.value() + " results");
} else {
System.out.println("There are more than " + total.value() + " results");
}
List<Hit<Product>> hits = response.hits().hits();
for (Hit<Product> hit: hits) {
Product product = hit.source();
System.out.println("Found product " + product.getProductName() + ", score " + hit.score());
}
}
/**
* 多条件嵌套查询文档信息
* @throws IOException
*/
@Test
public void getSearchs() throws IOException{
String productName = "衣服";
double price = 115;
//按照产品名称搜索
Query byname = MatchQuery.of(m -> m.field("productName")
.query(productName))._toQuery();
//按照产品价格搜索
Query byprice = RangeQuery.of(r -> r
.field("price")
.gte(JsonData.of(price))
)._toQuery();
//结合名称和价格查询
SearchResponse<Product> response = esClient.search(s -> s
.index("product")
.query(q -> q
.bool(b -> b
.must(byname)
.must(byprice)
)
)
.from(1)
.size(2),
Product.class
);
List<Hit<Product>> hits = response.hits().hits();
for (Hit<Product> hit : hits){
Product product = hit.source();
System.out.println(product.getProductName()+" "+product.getPrice());
}
}
}
效果展示
