目录
[创建索引库和映射( * ):](#创建索引库和映射( * ):)
Elasticsearch:用于数据存储、计算和搜索
-
Mysql:擅长事务类型操作,可以确保数据的安全和一致性
-
Elasticsearch:擅长海量数据的搜索、分析、计算
基于这个特点我打算改造用户方面的功能,基于用户量比较多,可能达到一万以上甚至更多,需要对用户进行搜索或者各种操作,我相信es也比较适合。
在这篇文章前面是实战,后面是具体讲解,对于某些方法可以在后面讲解中对应查找来使用
一、docker中安装Elasticsearch
先说命令,后面再说可能会出现的问题。
1、创建es专有的网络
因为测试需要部署kibana容器作为一个图形化界面,创建一个网络方便让es和kibana容器互联。
docker network create es-net
2、开放端口
宝塔:
腾讯云:
5601
9200
9300
3、在es-net网络上安装es和kibana
这里我安装7.12.1版本的es和kibana,因为之前学习有现有的镜像包安装更快
分别执行这两条指令:
docker run -d \
--name es \
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
-e "discovery.type=single-node" \
-v es-data:/usr/share/elasticsearch/data \
-v es-plugins:/usr/share/elasticsearch/plugins \
--privileged \
--network es-net \
-p 9200:9200 \
-p 9300:9300 \
elasticsearch:7.12.1
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601 \
kibana:7.12.1
4、可能出现的问题
这里我是在宝塔上部署的,由于我之前创建容器的时候没有开启防火墙的端口,应该先去开启防火墙再去安装docker容器,我这些流程出现混淆,导致出现下面这些类似的报错:
设置失败!500 Server Error for http+docker://localhost/v1.45/containers/1e013
Error response from daemon: Failed to Setup IP tables:
Unable to enable SKIP DNAT rule:
(iptables failed: iptables --wait -t nat -I DOCKER -i br-b649822bbcff -j RETURN: iptables:
No chain/target/match by that name. (exit status 1))
解决办法是先去开放端口然后重启docker服务再去安装es和kibana
重启docker:
systemctl restart docker
然后再去重新安装就行
5、测试
es:
服务器ip:9200
kibana:
服务器ip:5601
选择Explore on my own
之后,进入主页面:
测试安装成功!
查看docker:
或者使用指令:
docker ps
记住kibana是用于你开发的时候测试使用,比较方便的图形化界面,实际开发也只是用es。
6、安装IK分词器
docker exec -it es ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip
重启es容器使其生效:
docker restart es
7、测试IK分词器
IK分词器包含两种模式:
ik_smart
:智能语义切分
ik_max_word
:最细粒度切分
进入Dev tools:
先测试Elasticsearch官方提供的标准分词器:
POST /_analyze
{
"analyzer": "standard",
"text": "在CSDN学习java太棒了"
}
测试IK分词器:
POST /_analyze
{
"analyzer": "ik_smart",
"text": "在CSDN学习java太棒了"
}
测试成功,安装分词器成功!
二、结合业务实战
原理:当mysql数据发生改变时发送消息到mq,es服务接收消息,进行更新
es操作步骤:
java
1.创建Request
2.准备请求参数
3.聚合参数
4.发送请求
5.解析聚合结果
5.1.获取聚合
5.2.获取聚合中的桶
5.3.遍历桶内数据
1、准备依赖
XML
<properties>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
2、配置yml
XML
quick:
elasticsearch:
host: ${quick.elasticsearch.host} # 服务器IP地址
port: ${quick.elasticsearch.port} # 服务器端口号
3、读取yml配置
java
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/*
* @读取yml配置
*/
@Component
@Data
@ConfigurationProperties(prefix = "quick.elasticsearch")
public class ElasticSearchProperties {
// es地址
private String host;
// es端口
private int port;
}
4、准备es配置类
java
import com.quick.properties.ElasticSearchProperties;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* es配置类
*/
@Configuration
public class ElasticSearchConfig {
@Bean(destroyMethod = "close") //程序开始时交给bean对象注入, 指定了当bean被销毁时应该调用其close方法
@ConditionalOnMissingBean//保证spring容器里面只有一个utils对象(当没有这个bean对象再去创建,有就没必要去创建了)
public RestHighLevelClient client(ElasticSearchProperties elasticSearchProperties){
return new RestHighLevelClient(RestClient.builder(
new HttpHost(
elasticSearchProperties.getHost(),
elasticSearchProperties.getPort(),
"http"
)
));
}
}
5、编写测试代码
UserDoc:
java
/*
User索引库实体类
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserDoc {
// 这里设计为String类型,因为在发送消息的时候是以字符的形式
@Schema(description = "用户ID")
private String id;
@Schema(description = "用户编号")
private String quickUserId;
@Schema(description = "姓名")
private String name;
@Schema(description = "手机号")
private String phone;
@Schema(description = "关注数")
private Long follow;
@Schema(description = "粉丝数")
private Long fan;
@Schema(description = "性别 0 女 1 男")
private String sex;
@Schema(description = "头像")
private String avatar;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@Schema(description = "注册时间")
private LocalDateTime createTime;
@Schema(description = "用龄,单位:年")
private Long useTime;
@Schema(description = "收藏数")
private Long collectNumber;
@Schema(description = "评分数")
private Long markNumber;
@Schema(description = "个人简介")
private String briefIntroduction;
}
UserDocHandleResponseVO:
java
/**
* 用户文档处理响应
*/
@Data
@Builder
public class UserDocHandleResponseVO {
List<UserDoc>userDocList;
Long total;
}
controller:
java
@RestController
@RequestMapping("/user/es-user")
@Tag(name="C端-用户es相关接口")
@Slf4j
public class EsUserController {
@Resource
private UserService userService;
@Operation(summary = "es查询所有用户")
@GetMapping("/query-all-user")
public Result<UserDocHandleResponseVO> queryAllUser() throws IOException {
return Result.success(userService.queryAllUser());
}
}
service:
java
public interface UserService extends IService<User> {
UserDocHandleResponseVO queryAllUser() throws IOException;
}
impl:
java
@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
@Resource
private RestHighLevelClient restHighLevelClient;
@Override
public UserDocHandleResponseVO queryAllUser() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("user");
// 2.组织请求参数
request.source().query(QueryBuilders.matchAllQuery());
// 3.发送请求
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
// 4.解析响应
return handleResponse(response);
}
private static UserDocHandleResponseVO handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 4.1 获取总条数
long total = 0L;
if (searchHits.getTotalHits() != null) {
total = searchHits.getTotalHits().value;
}
// 4.2 获取命中的数据
SearchHit[] hits = searchHits.getHits();
List<UserDoc> userDocList=new ArrayList<>();
for (SearchHit hit : hits) {
// 4.2.1 获取source结果(结果是一个json对象)
String json = hit.getSourceAsString();
// 4.2.2 转为实体对象
UserDoc userDoc = JSONUtil.toBean(json, UserDoc.class);
userDocList.add(userDoc);
}
System.out.println("userDocList = " + userDocList);
System.out.println("total = " + total);
return UserDocHandleResponseVO.builder()
.userDocList(userDocList)
.total(total)
.build();
}
}
测试:
测试成功!!!
这里我将解析es的代码封装成一个工具类的方法
java
import com.quick.es.GenericSearchResponseVO;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.List;
/**
* es处理搜索响应的工具类
*/
public class SearchResponseUtil {
/**
* 处理ES搜索响应
*
* @param response ES搜索响应对象
* @param clazz 目标文档对象的类类型
* @return 封装后的搜索响应对象
* @param <T> 泛型,表示文档的类型,用于封装返回对应类型文档的返回结果
*/
public static <T> GenericSearchResponseVO<T> handleResponse(SearchResponse response, Class<T> clazz) {
// 获取搜索命中的结果
SearchHits searchHits = response.getHits();
// 初始化总命中数为0
long total = 0L;
// 如果总命中数不为空,则赋值
if (searchHits.getTotalHits() != null) {
total = searchHits.getTotalHits().value;
}
// 初始化文档列表
List<T> docList = new ArrayList<>();
// 获取所有命中的文档
SearchHit[] hits = searchHits.getHits();
// 遍历所有命中的文档
for (SearchHit hit : hits) {
// 获取文档的JSON字符串
String json = hit.getSourceAsString();
// 将JSON字符串解析为目标类型的对象
//T doc = JSON.parseObject(json, clazz); 使用这个的话如果反序列化会报错
T doc = JSONUtil.toBean(json, clazz);
// 将解析后的文档对象添加到列表中
docList.add(doc);
}
// 构建并返回封装后的搜索响应对象
return GenericSearchResponseVO.<T>builder()
.total(total) // 设置总命中数
.docList(docList) // 设置文档列表
.build();
}
}
T doc = JSON.parseObject(json, clazz); 如果工具类用这个解析json的话反序列化会报错,具体怎么解决欢迎在评论区说一下。
将返回的对象封装成一个目标返回对象
java
@Data
@Builder
public class GenericSearchResponseVO<T> {
private Long total;
private List<T> docList;
}
修改impl的代码
java
@Override
public GenericSearchResponseVO<UserDoc> queryAllUser() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("user");
// 2.组织请求参数
request.source().query(QueryBuilders.matchAllQuery());
// 3.发送请求
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
// 4.解析响应
/*return handleResponse(response);*/
return SearchResponseUtil.handleResponse(response, UserDoc.class);
}
6、使用mq异步修改es的表数据
可以参考:五、2、(3) ===>修改操作
service:
java
public interface EsUserDocService {
GenericSearchResponseVO<UserDoc> queryAllUserDoc() throws IOException;
// 修改UserDoc
void updateUserDocByOne(UserDoc userDoc) throws IOException;
}
impl:
java
import cn.hutool.json.JSONUtil;
import com.quick.vo.GenericSearchResponseVO;
import com.quick.entity.UserDoc;
import com.quick.service.EsUserDocService;
import com.quick.utils.ElasticsearchUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.stereotype.Service;
import java.io.IOException;
@Slf4j
@Service
public class EsUserDocServiceImpl implements EsUserDocService {
@Resource
private RestHighLevelClient restHighLevelClient;
@Override
public GenericSearchResponseVO<UserDoc> queryAllUserDoc() throws IOException {
// 页码
int pageNumber = 2;
// 每页数量
int pageSize = 10;
// 计算起始位置
int from = ElasticsearchUtil.calculateFrom(pageNumber,pageSize);
// 1.创建Request
SearchRequest request = new SearchRequest("user");
// 2.组织请求参数
request.source()
.query(QueryBuilders.matchAllQuery())
.from(from)
.size(pageSize);
// 3.发送请求
SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
// 4.解析响应
/*return handleResponse(response);*/
return ElasticsearchUtil.handleResponse(response, UserDoc.class,pageNumber);
}
@Override
public void updateUserDocByOne(UserDoc userDoc) throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("user",userDoc.getId() );
// 2.准备请求参数
// 将UserDoc转json
String doc = JSONUtil.toJsonStr(userDoc);
// 准备Json文档,XContentType.JSON表示json格式
request.doc(doc, XContentType.JSON);
// 3.发送请求
restHighLevelClient.update(request, RequestOptions.DEFAULT);
log.info("更新用户在es中数据成功,修改后文档为:{}",doc);
}
}
编写mq监听:
java
import com.quick.entity.UserDoc;
import com.quick.service.EsUserDocService;
import lombok.RequiredArgsConstructor;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.io.IOException;
/**
* Es中UserDoc相关 接收消息
*/
@Component
@RequiredArgsConstructor
public class EsUserDocListener {
public static final String UPDATE_USER_DOC_QUEUE_NAME = "userDoc.updateUserDocByOne.queue";
public static final String UPDATE_USER_DOC_EXCHANGE_NAME = "updateUserDocByOne.direct";
public static final String UPDATE_USER_DOC_ROUTING_KEY = "updateUserDocByOne.success";
private final EsUserDocService esUserDocService;
@RabbitListener(bindings = @QueueBinding(
value=@Queue(name = UPDATE_USER_DOC_QUEUE_NAME,durable = "true"),
exchange = @Exchange(name = UPDATE_USER_DOC_EXCHANGE_NAME),
key = UPDATE_USER_DOC_ROUTING_KEY
),
// 在@RabbitListener注解中指定容器工厂
containerFactory = "customContainerFactory")
public void listenUpdateUserDoc(UserDoc userDoc) throws IOException {
esUserDocService.updateUserDocByOne(userDoc);
}
}
编写实现修改操作的发送消息端:
java
@Override
public void update(UserDTO userDTO) {
User user=userMapper.selectById(userDTO.getUserId());
BeanUtils.copyProperties(userDTO,user);
userMapper.updateById(user);
UserDoc userDoc = BeanUtil.copyProperties(user, UserDoc.class);
//发送mq异步消息修改
try {
rabbitTemplate.convertAndSend(
EsUserDocListener.UPDATE_USER_DOC_EXCHANGE_NAME, // 交换机名称
EsUserDocListener.UPDATE_USER_DOC_ROUTING_KEY, // 路由键
userDoc // 消息内容
);
} catch (AmqpException e) {
log.error("发送消息失败", e);
}
}
测试:
其他的es业务逻辑也是差不多这两个实现, 可以参考后面的一些语法进行对应的操作,后续我还会持续更新一些es拓展和升级的操作。
三、简单介绍Elasticsearch
这里只做演示和介绍,如果只需要了解在Java中使用可跳过,去看第四部分,但是这些还是很有必要了解一下。
具体的DSL操作参考:Docs
1、表结构与Mysql的对比
MySQL | Elasticsearch | 说明 |
---|---|---|
Table | Index | 索引(index),就是文档的集合,类似数据库的表(table) |
Row | Document | 文档(Document),就是一条条的数据,类似数据库中的行(Row),文档都是JSON格式 |
Column | Field | 字段(Field),就是JSON文档中的字段,类似数据库中的列(Column) |
Schema | Mapping | Mapping(映射)是索引中文档的约束,例如字段类型约束。类似数据库的表结构(Schema) |
SQL | DSL | DSL是elasticsearch提供的JSON风格的请求语句,用来操作elasticsearch,实现CRUD |
2、Mapping映射属性
Mapping是对索引库中文档的约束,常见的Mapping属性包括:
type
:字段数据类型,常见的简单类型有:(1)字符串:
text
(可分词的文本)、keyword
(精确值,例如:品牌、国家、ip地址)(2)数值:
long
、integer
、short
、byte
、double
、float
、(3)布尔:
boolean
(4)日期:
date
(5)对象:
object
index
:是否创建索引,默认为true
analyzer
:使用哪种分词器
properties
:该字段的子字段
3、索引库的CRUD
因为到时候具体创建索引库还是需要使用这个语法操作,文档的CRUD可以使用Java代码替代,还是需要重视的
创建索引库和映射 ( *):
基本语法:
-
请求方式:
PUT
-
请求路径:
/索引库名
,可以自定义 -
请求参数:
mapping
映射
示例:
PUT /索引库名称
{
"mappings": {
"properties": {
"字段名":{
"type": "text",
"analyzer": "ik_smart"
},
"字段名2":{
"type": "keyword",
"index": "false"
},
"字段名3":{
"properties": {
"子字段": {
"type": "keyword"
}
}
},
// ...略
}
}
}
索引库的其他CRUD如下:
查询索引库:
GET /索引库名
修改索引库:
PUT /索引库名/_mapping
{
"properties": {
"新字段名":{
"type": "integer"
}
}
}
删除索引库:
DELETE /索引库名
4、文档操作的CRUD
了解即可,毕竟是使用Java实现比较实际,但是语法的熟悉还是很重要的,就像Mysql有mybatisplus,但是还要了解sql。
新增文档:
POST /索引库名/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
"字段3": {
"子属性1": "值3",
"子属性2": "值4"
},
}
查询文档:
GET /{索引库名称}/_doc/{id}
删除文档:
DELETE /{索引库名}/_doc/id值
修改文档:
全量修改(覆盖之前,如果改id不存在则为新增):
PUT /{索引库名}/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
// ... 略
}
局部修改(局部某个字段):
POST /{索引库名}/_update/文档id
{
"doc": {
"字段名": "新的值",
}
}
批处理:
批处理采用POST请求,基本语法如下:
POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }
注意:批操作,顾名思义,几个操作一起执行,可以多种操作,也可以一个操作多条。
其中:
index
代表新增操作
_id
指定要操作的文档id
{ "field1" : "value1" }
:则是要新增的文档内容
delete
代表删除操作
_index
:指定索引库名
_id
指定要操作的文档id
update
代表更新操作
_index
:指定索引库名
_id
指定要操作的文档id
{ "doc" : {"field2" : "value2"} }
:要更新的文档字段
四、RestAPI
为什么要使用:
ES官方提供了各种不同语言的客户端,用来操作ES。这些客户端的本质就是组装DSL语句,通过http请求发送给ES。
官方文档地址:Elasticsearch Clients | Elastic
针对我们的版本:
在这里有该版本的各种操作API,可以参考来写代码
1、初始化RestClient
(1)引入es
的RestHighLevelClient
依赖
依赖:
XML
<properties>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>${elasticsearch.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
(2)初始化RestHighLevelClient
基本语法如下:
java
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://服务器IP地址:9200")
));
做一个测试类测试一下:
成功有输出,测试代码参考如下:
java
package com.quick.es;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
public class EsTest {
private RestHighLevelClient client;
// 初始化
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://你的服务器IP地址:9200")
));
}
// 测试连接es
@Test
void testConnect() {
System.out.println("client: "+client);
}
// 销毁
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
2、在kibana的客户端准备创建索引库
下面为我对应我的用户表创建的索引库
注意:上面演示的图片中quick_user_id位置type后面多加了给逗号,当时不注意到时候记得注意这个错误,后面的Json没有问题。
java
PUT /user
{
"mappings": {
"properties": {
"id": {
"type": "keyword"
},
"quick_user_id":{
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_max_word"
},
"sex":{
"type": "keyword"
},
"avatar":{
"type": "keyword",
"index": false
},
"phone":{
"type": "text",
"analyzer": "ik_max_word"
},
"follow":{
"type": "integer"
},
"fan":{
"type": "integer"
},
"use_time":{
"type": "integer"
},
"collect_number":{
"type": "integer",
"index": false
},
"mark_number":{
"type": "integer",
"index": false
},
"brief_introduction":{
"type": "text",
"index": false
},
"create_time":{
"type": "date"
}
}
}
}
拿着上面这些创建好的映射在Java客户端创建
3、Java客户端创建索引库
关于一些知识点,这里我拿之前在b站学习的PPT的内容展示一下,我觉得这个已经很直观的体现出创建索引库的一些解释:
下面给出测试类所有代码,记得服务器IP地址替换成自己的。
java
package com.quick.es;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
public class EsTest {
private RestHighLevelClient client;
static final String USER_MAPPING_TEMPLATE ="{\n" +
" \"mappings\": {\n" +
" \"properties\": {\n" +
" \"id\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"quick_user_id\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"name\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_max_word\"\n" +
" },\n" +
" \"sex\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"avatar\":{\n" +
" \"type\": \"keyword\",\n" +
" \"index\": false\n" +
" },\n" +
" \"phone\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_max_word\"\n" +
" },\n" +
" \"follow\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"fan\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"use_time\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"collect_number\":{\n" +
" \"type\": \"integer\",\n" +
" \"index\": false\n" +
" },\n" +
" \"mark_number\":{\n" +
" \"type\": \"integer\",\n" +
" \"index\": false\n" +
" },\n" +
" \"brief_introduction\":{\n" +
" \"type\": \"text\",\n" +
" \"index\": false\n" +
" },\n" +
" \"create_time\":{\n" +
" \"type\": \"date\"\n" +
" }\n" +
" }\n" +
" }\n" +
"}";
// 初始化
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://服务器IP地址:9200")
));
}
// 测试连接es
@Test
void testConnect() {
System.out.println("client: "+client);
}
// 创建索引库
@Test
void testCreateIndex() throws IOException {
// 1.创建Request对象
CreateIndexRequest request = new CreateIndexRequest("user");
// 2.准备请求参数
request.source(USER_MAPPING_TEMPLATE, XContentType.JSON);
// 3.发送请求
client.indices().create(request, RequestOptions.DEFAULT);
}
// 销毁
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
测试:
去kibana客户端测试:
创建成功!
五、RestClient操作文档(重在方法理解)
1、准备实体类
准备一个对接索引库的es实体类
java
/*
User索引库实体类
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserDoc {
// 这里设计为String类型,因为在发送消息的时候是以字符的形式
@Schema(description = "用户ID")
private String id;
@Schema(description = "用户编号")
private String quickUserId;
@Schema(description = "姓名")
private String name;
@Schema(description = "手机号")
private String phone;
@Schema(description = "关注数")
private Long follow;
@Schema(description = "粉丝数")
private Long fan;
@Schema(description = "性别 0 女 1 男")
private String sex;
@Schema(description = "头像")
private String avatar;
@Schema(description = "注册时间")
private LocalDateTime createTime;
@Schema(description = "用龄,单位:年")
private Long useTime;
@Schema(description = "收藏数")
private Long collectNumber;
@Schema(description = "评分数")
private Long markNumber;
@Schema(description = "个人简介")
private String briefIntroduction;
}
这里的id用的是String类型,因为使用RestClient去根据id查,需要传过去的是字符类型的数据,所以在这里需要进行一个转变。
2、Java实现CRUD(重点)
下面讲解一下简单的crud的代码和需要注意的东西,在代码的后面会对注意的东西进行讲解。我会给出测试类全部代码,防止有些同学测试类跑不通,然后会对增删改查逐一给代码,也方便各位同学以后针对性的拿那些方法去改造自己的代码。
注意!注意!注意!===>重要的事情说三遍
代码:
java
package com.quick.es;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import com.quick.entity.User;
import com.quick.service.UserService;
import jakarta.annotation.Resource;
import org.apache.http.HttpHost;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
@SpringBootTest(properties = "spring.profiles.active=dev")
public class EsDocTest {
@Resource
private UserService userService;
private RestHighLevelClient client;
// 初始化
@BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://服务器IP地址:9200")
));
}
// 测试连接es
@Test
void testConnect() {
System.out.println("client: "+client);
}
// 测试添加文档信息
@Test
void testAddDocument() throws IOException {
// 1.根据id查询商品数据
User user = userService.getById(1L);
System.out.println("user = " + user);
// 2.转换为文档类型
UserDoc userDoc = BeanUtil.copyProperties(user, UserDoc.class);
System.out.println("userDoc = " + userDoc);
// 3.将UserDoc转json
String doc = JSONUtil.toJsonStr(userDoc);
// 1.准备Request对象
/*IndexRequest request = new IndexRequest("user").id(String.valueOf(userDoc.getId()));*/
IndexRequest request = new IndexRequest("user").id(userDoc.getId());
// 2.准备Json文档
request.source(doc, XContentType.JSON);
// 3.发送请求
client.index(request, RequestOptions.DEFAULT);
}
// 测试删除文档
@Test
void testDeleteDocument() throws IOException {
// 1.准备Request,两个参数,第一个是索引库名,第二个是文档id
DeleteRequest request = new DeleteRequest("user", "1");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}
// 测试更新文档
@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("user", "1");
// 2.准备请求参数
// 方法一
/*request.doc(
"userTime", 1,
"briefIntroduction", "hello world"
);*/
// 方法二
/*UserDoc userDoc=new UserDoc();
userDoc.setUseTime(1L);
userDoc.setBriefIntroduction("hello world");
// 构造参数
Map<String, Object> jsonMap = new HashMap<>();
jsonMap.put("userTime", userDoc.getUseTime());
jsonMap.put("briefIntroduction", userDoc.getBriefIntroduction());
// 将数据放入请求参数
request.doc(jsonMap);*/
// 方法三
UserDoc userDoc=new UserDoc();
//userDoc.setUseTime(1L);
userDoc.setBriefIntroduction("hello world!");
// 将UserDoc转json
String doc = JSONUtil.toJsonStr(userDoc);
// 准备Json文档,XContentType.JSON表示json格式
request.doc(doc, XContentType.JSON);
// 3.发送请求
client.update(request, RequestOptions.DEFAULT);
}
// 测试根据id查询文档
@Test
void testGetDocumentById() throws IOException {
// 1.准备Request对象
GetRequest request = new GetRequest("user").id("1");
// 2.发送请求
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.获取响应结果中的source
String json = response.getSourceAsString();
UserDoc userDoc = JSONUtil.toBean(json, UserDoc.class);
System.out.println("userDoc= " + userDoc);
}
// 销毁
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
其中:
(1)增:
java
// 测试添加文档信息
@Test
void testAddDocument() throws IOException {
// 1.根据id查询商品数据
User user = userService.getById(1L);
System.out.println("user = " + user);
// 2.转换为文档类型
UserDoc userDoc = BeanUtil.copyProperties(user, UserDoc.class);
System.out.println("userDoc = " + userDoc);
// 3.将UserDoc转json
String doc = JSONUtil.toJsonStr(userDoc);
// 1.准备Request对象
/*IndexRequest request = new IndexRequest("user").id(String.valueOf(userDoc.getId()));*/
IndexRequest request = new IndexRequest("user").id(userDoc.getId());
// 2.准备Json文档
request.source(doc, XContentType.JSON);
// 3.发送请求
client.index(request, RequestOptions.DEFAULT);
}
(2)删:
java
// 测试删除文档
@Test
void testDeleteDocument() throws IOException {
// 1.准备Request,两个参数,第一个是索引库名,第二个是文档id
DeleteRequest request = new DeleteRequest("user", "1");
// 2.发送请求
client.delete(request, RequestOptions.DEFAULT);
}
(3)改:
java
// 测试更新文档
@Test
void testUpdateDocument() throws IOException {
// 1.准备Request
UpdateRequest request = new UpdateRequest("user", "1");
// 2.准备请求参数
UserDoc userDoc=new UserDoc();
userDoc.setUseTime(1L);
userDoc.setBriefIntroduction("hello world!");
// 将UserDoc转json
String doc = JSONUtil.toJsonStr(userDoc);
// 准备Json文档,XContentType.JSON表示json格式
request.doc(doc, XContentType.JSON);
// 3.发送请求
client.update(request, RequestOptions.DEFAULT);
}
(4)查:
java
// 测试根据id查询文档
@Test
void testGetDocumentById() throws IOException {
// 1.准备Request对象
GetRequest request = new GetRequest("user").id("1");
// 2.发送请求
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.获取响应结果中的source
String json = response.getSourceAsString();
UserDoc userDoc = JSONUtil.toBean(json, UserDoc.class);
System.out.println("userDoc= " + userDoc);
}
注意:
可以看到在增加和修改那边会构造请求参数,我在改那边提供了三个方法,在上面测试类的完整代码中有那三种方法,其实添加的构造请求参数的实现也是一样的,下面我来逐一讲解一下构造的实现:
官方API文档位置:Update API | Java REST Client [7.12] | Elastic
在前面有教过怎么去找到对应版本文档
方法一:
官网的链式编程也很推荐,下面就是浓缩的修改操作:
java
UpdateRequest request = new UpdateRequest("posts", "1")
.doc("updated", new Date(),
"reason", "daily update");
client.update(request, RequestOptions.DEFAULT);
方法二:
因为根据方法一可知那个数据的格式类似 Map<String, Object> 这样的格式,可以通过map来构造。官网示例如下:
方法三:
官网在这里也提到,可以先构造默认Json格式,然后再换一种类型的Json
此外官网还提供了一个方法我觉得也很优雅,当然还不只这个。
java
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{
builder.timeField("updated", new Date());
builder.field("reason", "daily update");
}
builder.endObject();
UpdateRequest request = new UpdateRequest("posts", "1")
.doc(builder);
3、批量导入文档:
我们需要导入我们用户表里面的数据,非常多,不可能一个一个操作,基本上是批操作,这就需要我们学会批量导入文档
我们利用
BulkRequest
实现这个操作。BulkRequest
本身其实并没有请求参数,其本质就是将多个普通的CRUD请求组合在一起发送,利用他的add方法来实现这个过程,BulkRequest
中提供了add
方法,用以添加其它CRUD的请求。能添加的请求有:
IndexRequest
,也就是新增
UpdateRequest
,也就是修改
DeleteRequest
,也就是删除
在我的理解add相当于加入你的请求到那里面,然后再根据具体请求的实现来执行各样的操作
基本语法如下:
java
@Test
void testBulk() throws IOException {
// 1.创建Request
BulkRequest request = new BulkRequest();
// 2.准备请求参数
request.add(new IndexRequest("items").id("1").source("json doc1", XContentType.JSON));
request.add(new IndexRequest("items").id("2").source("json doc2", XContentType.JSON));
// 3.发送请求
client.bulk(request, RequestOptions.DEFAULT);
}
下面是实战,用于添加我用户表信息:
在之前那个EsDocTest测试类里面加上这么一个测试方法:
java
@Test
void testLoadUserDocs() throws IOException {
// 分页查询商品数据
int pageNo = 1;
int size = 100;
while (true) {
Page<User> page = userService.lambdaQuery().page(new Page<User>(pageNo, size));
// 非空校验
List<User> users = page.getRecords();
if (CollUtil.isEmpty(users)) {
return;
}
log.info("加载第{}页数据,共{}条", pageNo, users.size());
// 1.创建Request
BulkRequest request = new BulkRequest("user");
// 2.准备参数,添加多个新增的Request
for (User user : users) {
// 2.1.转换为文档类型ItemDTO
UserDoc userDoc = BeanUtil.copyProperties(user, UserDoc.class);
// 2.2.创建新增文档的Request对象
request.add(new IndexRequest()
.id(userDoc.getId())
.source(JSONUtil.toJsonStr(userDoc), XContentType.JSON));
}
// 3.发送请求
client.bulk(request, RequestOptions.DEFAULT);
// 翻页
pageNo++;
}
}
运行:
再去随便搜一个id的用户:
来到kibana:
六、JavaRestClient查询
基本步骤(重点)
查询的基本步骤是:
- 创建 SearchRequest 对象
- 准备 Request.source () ,也就是 DSL 。
① QueryBuilders 来构建查询条件
② 传入 Request.source () 的 query() 方法- 发送请求,得到结果
- 解析结果(参考 JSON 结果,从外到内,逐层解析)
java
@Test
void testSearch() throws IOException {
// 1.创建Request
SearchRequest request = new SearchRequest("user");
// 2.组织请求参数
request.source().query(QueryBuilders.matchAllQuery());
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
}
private static void handleResponse(SearchResponse response) {
SearchHits searchHits = response.getHits();
// 4.1 获取总条数
long total = 0;
if (searchHits.getTotalHits() != null) {
total = searchHits.getTotalHits().value;
}
// 4.2 获取命中的数据
SearchHit[] hits = searchHits.getHits();
List<UserDoc> userDocList=new ArrayList<>();
for (SearchHit hit : hits) {
// 4.2.1 获取source结果(结果是一个json对象)
String json = hit.getSourceAsString();
// 4.2.2 转为实体对象
UserDoc userDoc = JSONUtil.toBean(json, UserDoc.class);
userDocList.add(userDoc);
}
System.out.println("userDocList = " + userDocList);
System.out.println("total = " + total);
}
下面是对一些查询的讲解,这里我用学习的资料总结展示一下,如果只想实战可以参考后面实战
1、叶子查询
全文检索查询(Full Text Queries):利用分词器对用户输入搜索条件先分词,得到词条,然后再利用倒排索引搜索词条。例如:
match
(全文检索查询的一种,会对用户输入内容分词,然后去倒排索引库检索)
java
// 单字段查询
QueryBuilders.matchQuery("name", "脱脂牛奶");
multi_match
( 与match查询类似,只不过允许同时查询多个字段)
java
// 多字段查询
QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category");
精确查询(Term-level queries):不对用户输入搜索条件分词,根据字段内容精确值匹配。但只能查找keyword、数值、日期、boolean类型的字段。例如
term
( 词条查询)
java
equest.source().query(QueryBuilders.termQuery("brand", "华为"));
range(
范围查询)
java
request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000))
2、复合查询
bool查询(基于逻辑运算组合叶子查询,实现组合条件)
java
// 创建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 添加filter条件
boolQuery.must(QueryBuilders.termQuery("brand", "华为"));
// 添加filter条件
boolQuery.filter(QueryBuilders.rangeQuery("price").lte(2500));
3、排序和分页
排序:elasticsearch默认是根据相关度算分(
_score
)来排序,但是也支持自定义方式对搜索结果排序。不过分词字段无法排序,能参与排序字段类型有:keyword
类型、数值类型、地理坐标类型、日期类型等。
分页:elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。elasticsearch中通过修改from
、size
参数来控制要返回的分页结果:
from
:从第几个文档开始
size
:总共查询几个文档
java
// 查询
request.source().query(QueryBuilders.matchAllQuery());
// 分页
request.source().from(0).size(5);
// 价格排序
request.source().sort("price", SortOrder.ASC);
4、高亮
java
// 1.创建Request
SearchRequest request = new SearchRequest("items");
// 2.组织请求参数
// 2.1.query条件
request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
// 2.2.高亮条件
request.source().highlighter(
SearchSourceBuilder.highlight()
.field("name")
.preTags("<em>")
.postTags("</em>")
);
// 3.发送请求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析响应
handleResponse(response);
java
SearchHits searchHits = response.getHits();
// 1.获取总条数
long total = searchHits.getTotalHits().value;
System.out.println("共搜索到" + total + "条数据");
// 2.遍历结果数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
// 3.得到_source,也就是原始json文档
String source = hit.getSourceAsString();
// 4.反序列化
ItemDoc item = JSONUtil.toBean(source, ItemDoc.class);
// 5.获取高亮结果
Map<String, HighlightField> hfs = hit.getHighlightFields();
if (CollUtils.isNotEmpty(hfs)) {
// 5.1.有高亮结果,获取name的高亮结果
HighlightField hf = hfs.get("name");
if (hf != null) {
// 5.2.获取第一个高亮结果片段,就是商品名称的高亮值
String hfName = hf.getFragments()[0].string();
item.setName(hfName);
}
}
System.out.println(item);
}
七、数据聚合
聚合(aggregations
)可以让我们极其方便的实现对数据的统计、分析、运算。
java
request.source().size(0); // 分页
request.source().aggregation(
AggregationBuilders
.terms("brand_agg") // 聚合名称
.field("brand") // 聚合字段
.size(20)); // 聚合结果条数
java
// 解析聚合结果
Aggregations aggregations = response.getAggregations();
// 根据名称获取聚合结果
Terms brandTerms = aggregations.get("brand_agg");
// 获取桶
List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
// 遍历
for (Terms.Bucket bucket : buckets) {
// 获取key,也就是品牌信
String brandName = bucket.getKeyAsString();
System.out.println(brandName);
}