我要评论es增删改查常用语法
我们日常开发中，操作数据库写sql倒是不可能忘记，但是操作es的dsl语句有时候很容易忘记，特地记录一下方便查找。
注意，如果有些字段设置的text类型，那么在查询的时候加上.keyword，比如查询code字段
{
"query": {
"terms": {
"code.keyword": ["aaa","bbb"]
}
}
}
dsl语句
1、创建索引
-- 创建索引
put /my_index
{
"mappings": {
"properties": {
"title": {
"type": "text"
},
"description": {
"type": "text"
},
"timestamp": {
"type": "date"
}
}
}
}
2、插入文档
-- 插入文档
post /my_index/_doc/主键值
{
"title": "sample document",
"description": "this is a sample document for elasticsearch",
"timestamp": "2022-01-01"
}
3、更新文档
-- 更新一个文档
post /my_index/_update/1 // 主键
{
"doc": {
"字段1": "内容1",
"字段2": "内容2",
"字段3": "内容3"
// 添加需要更新的多个字段及对应的内容
}
}
-- 批量更新多个文档字段
post /my_index/_update_by_query
{
"query": {
"terms": {
"_id": [111, 222] // 指定id为111和222的文档
},
"script": {
"source": "ctx._source.aaa= 1; ctx._source.bbb= 2" // 更新aaa和bbb字段为1和2
}
}
-- 批量更新多个文档字，指定字段内容为另外一个字段的内容
post /search_order_index/_update_by_query
{
"query": {
"terms": {
"orderno": [
"1111", // 指定更新订单编号为111和222的记录
"222"
]
}
},
"script": {
"source": "
ctx._source.字段1= 1; // 指定字段1 为1
ctx._source.字段2= 1; // 指定字段2 为1
ctx._source.字段3= 0; // 指定字段3为0
ctx._source.字段4= ctx._source.字段5" // 指定字段4为字段5的内容
}
}
-- 更新所有文档字段
post /my_index/_update_by_query
{
"query": {
"match_all": {} // 匹配所有文档
},
"script": {
"source": "ctx._source.aaa = 1; ctx._source.bbb = 1" // 批量更新aaa和bbb字段为1
}
}
4、删除文档（单独、多个、全部）
-- 删除单条文档
delete /my_index/_doc/主键值
或者
-- 删除单条文档
post 索引名/_delete_by_query
{
"query":{
"term":{
"_id":4043
}
}
}
-- 删除多条文档
post 索引名/_delete_by_query
{
"query": {
"terms": {
"_id": [4043, 4044, 4045] // 添加多个id值
}
}
}
-- 删除索引中的所有数据
post my_index/_delete_by_query
{
"query": {
"match_all": {
}
}
}
5、删除索引
-- 删除索引 delete /my_index
6、设置索引别名
-- 设置索引别名
post /_aliases
{
"actions": [
{"add": {"index": "my_index2", "alias": "my_index"}}
]
}
7、设置切片和副本数量
-- 设置切片和副本数量
put your_index
{
"mappings" : {
"properties" : {
#索引字段（略）
}
}
"settings" : {
"number_of_shards" : 3,
"number_of_replicas" : 1
}
}
8、查询
-- 查询单个字段内容
post /my_index/_search
{
"query": {
"bool": {
"must": {
"term": {
"messageid": "cs202303160008-2"
}
}
}
}
}
-- 查询单个字段的多个内容 类似mysql中的in 用terms 多了个s
post /my_index/_search
{
"query": {
"bool": {
"must": {
"terms": {
"messageid": ["22222","1111"]
}
}
}
}
}
-- 分页排序查询 不带其他条件
post /my_index/_search
{
"query": {
"match_all": {}
},
"from": 0,
"size": 20,
"sort": [
{
"createdat": {
"order": "desc"
}
}
]
}
-- 分页排序查询 带其他条件
{
"query": {
"bool": {
"must": [
{
"prefix": {
"action": "aa开头"
}
},
{
"wildcard": {
"param": "*左右匹配内容*"
}
}
],
"must_not": [],
"should": []
}
},
"from": 0,
"size": 10,
"sort": [
{
"createdat": {
"order": "desc"
}
}
]
}
9、统计
post /my_index/_count
{
"query": {
"bool": {
"must": {
"term": {
"messageid": "cs202303160008-2"
}
}
}
}
}
代码
pom依赖
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelversion>4.0.0</modelversion>
<groupid>com.demo.sdk</groupid>
<artifactid>elasticsearch-util</artifactid>
<version>1.0.0-snapshot</version>
<packaging>jar</packaging>
<name>elasticsearch-util</name>
<description>spring boot support for elasticsearch-util</description>
<properties>
<java.version>11</java.version>
<elasticsearch.version>7.10.0</elasticsearch.version>
<spring-boot.version>2.7.0</spring-boot.version>
<hutool.version>5.8.15</hutool.version>
<pagehelper.version>1.4.2</pagehelper.version>
</properties>
<dependencies>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-autoconfigure</artifactid>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-configuration-processor</artifactid>
<version>${spring-boot.version}</version>
<optional>true</optional>
</dependency>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-logging</artifactid>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupid>org.elasticsearch.client</groupid>
<artifactid>elasticsearch-rest-high-level-client</artifactid>
<version>${elasticsearch.version}</version>
</dependency>
<dependency>
<groupid>com.github.pagehelper</groupid>
<artifactid>pagehelper-spring-boot-starter</artifactid>
<version>${pagehelper.version}</version>
</dependency>
<dependency>
<groupid>cn.hutool</groupid>
<artifactid>hutool-all</artifactid>
<version>${hutool.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupid>org.apache.maven.plugins</groupid>
<artifactid>maven-compiler-plugin</artifactid>
<version>3.8.1</version>
<configuration>
<source>11</source>
<target>11</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
<plugin>
<groupid>org.apache.maven.plugins</groupid>
<artifactid>maven-source-plugin</artifactid>
<configuration>
<attach>true</attach>
</configuration>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
1、es配置类
import cn.hutool.core.text.charsequenceutil;
import org.apache.http.auth.authscope;
import org.apache.http.auth.usernamepasswordcredentials;
import org.apache.http.client.credentialsprovider;
import org.apache.http.impl.client.basiccredentialsprovider;
import org.springframework.boot.context.properties.configurationproperties;
/**
* es配置类
* @author ppp
* @date 2023/3/21
*/
@configurationproperties(prefix = "elasticsearch.config")
public class elasticsearchproperties {
/**
* 域名
*/
private string host;
/**
* 端口
*/
private string port;
/**
* 用户名
*/
private string username;
/**
* 密码
*/
private string password;
/**
* 连接超时时间
*/
private int connecttimeout;
/**
* 连接超时时间
*/
private int sockettimeout;
/**
* 获取连接的超时时间
*/
private int connectionrequesttimeout;
/**
* 获取搜索的超时时间
*/
private long searchrequesttimeout = 10000l;
/**
* 最大连接数
*/
private int maxconnectnum;
/**
* 最大路由连接数
*/
private int maxconnectperroute;
public string gethost() {
return host;
}
public void sethost(string host) {
this.host = host;
}
public string getport() {
return port;
}
public void setport(string port) {
this.port = port;
}
public int getconnecttimeout() {
return connecttimeout;
}
public void setconnecttimeout(int connecttimeout) {
this.connecttimeout = connecttimeout;
}
public int getsockettimeout() {
return sockettimeout;
}
public void setsockettimeout(int sockettimeout) {
this.sockettimeout = sockettimeout;
}
public int getconnectionrequesttimeout() {
return connectionrequesttimeout;
}
public void setconnectionrequesttimeout(int connectionrequesttimeout) {
this.connectionrequesttimeout = connectionrequesttimeout;
}
public long getsearchrequesttimeout() {
return searchrequesttimeout;
}
public void setsearchrequesttimeout(long searchrequesttimeout) {
this.searchrequesttimeout = searchrequesttimeout;
}
public int getmaxconnectnum() {
return maxconnectnum;
}
public void setmaxconnectnum(int maxconnectnum) {
this.maxconnectnum = maxconnectnum;
}
public int getmaxconnectperroute() {
return maxconnectperroute;
}
public void setmaxconnectperroute(int maxconnectperroute) {
this.maxconnectperroute = maxconnectperroute;
}
public string getusername() {
return username;
}
public void setusername(string username) {
this.username = username;
}
public string getpassword() {
return password;
}
public void setpassword(string password) {
this.password = password;
}
public credentialsprovider getcredentialsprovider() {
if (charsequenceutil.isnotblank(username) && charsequenceutil.isnotblank(password)) {
credentialsprovider credentialsprovider = new basiccredentialsprovider();
credentialsprovider.setcredentials(authscope.any, new usernamepasswordcredentials(username, password));
return credentialsprovider;
}
return null;
}
}
2、es工具自动配置类
import cn.hutool.core.text.charsequenceutil;
import com.demo.sdk.elasticsearch.template.elasticsearchutiltemplate;
import org.apache.http.httphost;
import org.elasticsearch.client.restclient;
import org.elasticsearch.client.restclientbuilder;
import org.elasticsearch.client.resthighlevelclient;
import org.springframework.boot.autoconfigure.condition.conditionalonclass;
import org.springframework.boot.autoconfigure.condition.conditionalonmissingbean;
import org.springframework.boot.context.properties.enableconfigurationproperties;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
/**
* es工具自动配置类
* @author ppp
* @date 2023/3/21
*/
@configuration
@conditionalonclass(elasticsearchutiltemplate.class)
@enableconfigurationproperties(elasticsearchproperties.class)
public class elasticsearchutilautoconfiguration {
@bean
@conditionalonmissingbean
public resthighlevelclient esrestclient(elasticsearchproperties esearchproperties) {
if (esearchproperties == null) {
throw new nullpointerexception("es configuration properties is null");
}
string host = esearchproperties.gethost();
string port = esearchproperties.getport();
restclientbuilder builder;
if (charsequenceutil.isnotblank(host) && charsequenceutil.isblank(port)) {
builder = restclient.builder(httphost.create(host));
}else {
builder = restclient.builder(new httphost(host, integer.parseint(port)));
}
// 异步httpclient连接延时配置
builder.setrequestconfigcallback(requestconfigbuilder -> {
requestconfigbuilder.setconnecttimeout(esearchproperties.getconnecttimeout());
requestconfigbuilder.setsockettimeout(esearchproperties.getsockettimeout());
requestconfigbuilder.setconnectionrequesttimeout(esearchproperties.getconnectionrequesttimeout());
return requestconfigbuilder;
});
// 异步httpclient连接数配置
builder.sethttpclientconfigcallback(httpclientbuilder -> {
httpclientbuilder.setmaxconntotal(esearchproperties.getmaxconnectnum());
httpclientbuilder.setmaxconnperroute(esearchproperties.getmaxconnectperroute());
httpclientbuilder.setdefaultcredentialsprovider(esearchproperties.getcredentialsprovider());
return httpclientbuilder;
});
return new resthighlevelclient(builder);
}
@bean
@conditionalonmissingbean
public elasticsearchutiltemplate elasticsearchutiltemplate(resthighlevelclient esrestclient, elasticsearchproperties elasticsearchproperties) {
if (esrestclient == null) {
throw new nullpointerexception("resthighlevelclient init error");
}
return new elasticsearchutiltemplate(esrestclient,elasticsearchproperties.getsearchrequesttimeout());
}
}
3、自动装配配置
装配要生效需要elasticsearchutilautoconfiguration加入springboot的自动装配文件spring.factories
这是spring配置的特定目录文件，自己新建一个，名字和目录要一致
# auto configure org.springframework.boot.autoconfigure.enableautoconfiguration=\ com.demo.sdk.elasticsearch.config.elasticsearchutilautoconfiguration
4、定义一个模板工具类
import cn.hutool.json.jsonutil;
import com.github.pagehelper.page;
import com.github.pagehelper.page.pagemethod;
import com.demo.sdk.elasticsearch.exception.elasticsearcherrorexception;
import org.elasticsearch.action.admin.indices.delete.deleteindexrequest;
import org.elasticsearch.action.bulk.bulkrequest;
import org.elasticsearch.action.bulk.bulkresponse;
import org.elasticsearch.action.delete.deleterequest;
import org.elasticsearch.action.delete.deleteresponse;
import org.elasticsearch.action.get.getrequest;
import org.elasticsearch.action.get.getresponse;
import org.elasticsearch.action.index.indexrequest;
import org.elasticsearch.action.index.indexresponse;
import org.elasticsearch.action.search.searchrequest;
import org.elasticsearch.action.search.searchresponse;
import org.elasticsearch.action.support.master.acknowledgedresponse;
import org.elasticsearch.action.update.updaterequest;
import org.elasticsearch.action.update.updateresponse;
import org.elasticsearch.client.requestoptions;
import org.elasticsearch.client.resthighlevelclient;
import org.elasticsearch.client.core.countrequest;
import org.elasticsearch.client.core.countresponse;
import org.elasticsearch.client.indices.createindexrequest;
import org.elasticsearch.client.indices.createindexresponse;
import org.elasticsearch.common.unit.timevalue;
import org.elasticsearch.common.xcontent.xcontenttype;
import org.elasticsearch.search.searchhit;
import org.elasticsearch.search.builder.searchsourcebuilder;
import java.util.arraylist;
import java.util.list;
import java.util.map;
/**
* es搜索引擎模板
* @author ppp
* @date 2023/3/21
*/
public class elasticsearchutiltemplate {
private final resthighlevelclient esrestclient;
private final long searchrequesttimeout;
public elasticsearchutiltemplate(resthighlevelclient esrestclient, long searchrequesttimeout) {
this.searchrequesttimeout = searchrequesttimeout;
this.esrestclient = esrestclient;
}
/**
* 列表查询
*
* @param searchsourcebuilder searchsourcebuilder
* @param clazz 返回结果class对象
* @param indices es索引
* @return java.util.list 对象列表
*/
public <t> list<t> listsearch(searchsourcebuilder searchsourcebuilder, class<t> clazz, string... indices) {
page<t> resultpage = pagemethod.getlocalpage();
boolean isresultpage = resultpage != null;
if (isresultpage) {
pagemethod.clearpage();
searchsourcebuilder.from((int) resultpage.getstartrow());
searchsourcebuilder.size(resultpage.getpagesize());
}
if (isresultpage && resultpage.iscount()) {
resultpage.settotal(count(searchsourcebuilder, indices));
}
searchresponse searchresponse = search(searchsourcebuilder, indices);
list<t> resultlist = formatsearchresult(searchresponse, clazz);
if (isresultpage && resultpage.iscount()) {
resultpage.addall(resultlist);
return resultpage;
}
return resultlist;
}
public searchresponse search(searchsourcebuilder searchsourcebuilder, string... indices) {
searchrequest searchrequest = new searchrequest(indices);
searchsourcebuilder.timeout(timevalue.timevaluemillis(searchrequesttimeout));
searchrequest.source(searchsourcebuilder);
return search(searchrequest);
}
public searchresponse search(searchrequest searchrequest) {
try {
return esrestclient.search(searchrequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 统计数量
*
* @param searchsourcebuilder searchsourcebuilder
* @param indices es索引
* @return countresponse
*/
public long count(searchsourcebuilder searchsourcebuilder, string... indices) {
countrequest countrequest = new countrequest(indices);
searchsourcebuilder.timeout(timevalue.timevaluemillis(searchrequesttimeout));
countrequest.query(searchsourcebuilder.query());
return count(countrequest, requestoptions.default).getcount();
}
public countresponse count(countrequest countrequest, requestoptions options) {
try {
return esrestclient.count(countrequest, options);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 创建索引
*
* @param createindexrequest createindexrequest
* @return createindexresponse
*/
public createindexresponse createindices(createindexrequest createindexrequest) {
try {
return esrestclient.indices().create(createindexrequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 删除索引（谨慎操作，索引下所有数据都将清空）
*
* @param index 索引名称
* @return acknowledgedresponse
*/
public acknowledgedresponse deleteindex(string index) {
deleteindexrequest deleteindexrequest = new deleteindexrequest();
deleteindexrequest.indices(index);
return deleteindices(deleteindexrequest);
}
/**
* 删除索引（谨慎操作，索引下所有数据都将清空）
*
* @param deleteindexrequest deleteindexrequest
* @return acknowledgedresponse
*/
public acknowledgedresponse deleteindices(deleteindexrequest deleteindexrequest) {
try {
return esrestclient.indices().delete(deleteindexrequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 插入数据
*
* @param index 索引
* @param id 唯一id
* @param source 插入对象
* @return indexresponse
*/
public indexresponse add(string index, object id, object source) {
indexrequest indexrequest = new indexrequest(index).id(string.valueof(id));
indexrequest.source(jsonutil.tojsonstr(source), xcontenttype.json);
try {
return esrestclient.index(indexrequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 批量插入数据
* 建议：数量控制在5000以内
*
* @param index 索引
* @param sourcemap 数据<唯一id,对象>
* @return bulkresponse
*/
public bulkresponse addbulk(string index, map<string, object> sourcemap) {
bulkrequest request = new bulkrequest();
sourcemap.foreach((id, source) -> {
request.add(new indexrequest(index).id(id).source(jsonutil.tojsonstr(source), xcontenttype.json));
});
try {
return esrestclient.bulk(request, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 获取数据
*
* @param getrequest getrequest
* @return getresponse
*/
public getresponse get(getrequest getrequest) {
try {
return esrestclient.get(getrequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 更新数据
*
* @param updaterequest updaterequest
* @return updateresponse
*/
public updateresponse update(updaterequest updaterequest) {
try {
return esrestclient.update(updaterequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 删除数据
*
* @param deleterequest deleterequest
* @return deleteresponse
*/
public deleteresponse delete(deleterequest deleterequest) {
try {
return esrestclient.delete(deleterequest, requestoptions.default);
} catch (exception e) {
throw new elasticsearcherrorexception(e.getmessage(), e.getcause());
}
}
/**
* 格式化搜索结果
*
* @param searchresponse 搜索结果
* @param clazz 返回对象
* @return java.util.list
*/
public <t> list<t> formatsearchresult(searchresponse searchresponse, class<t> clazz) {
searchhit[] searchhits = searchresponse.gethits().gethits();
list<t> resultlist = new arraylist<t>();
for (searchhit searchhit : searchhits) {
resultlist.add(jsonutil.tobean(searchhit.getsourceasstring(), clazz));
}
return resultlist;
}
}
5、定义一个异常
/**
* 错误异常
* @author ppp
* @date 2023/3/21
*/
public class elasticsearcherrorexception extends runtimeexception {
public elasticsearcherrorexception(string message) {
super(message);
}
public elasticsearcherrorexception(string message, throwable cause) {
super(message, cause);
}
}
6、application.yml配置
# elasticsearch
elasticsearch.config:
host: 127.0.0.1
port: 9200
username: admin
password: admin123
connect-time-out: 1000
socket-time-out: 30000
connection-request-time-out: 500
search-request-time-out: 5000
max-connect-num: 100
max-connect-per-route: 100
7、测试
class demoapplicationtests {
/**
* 获取elasticsearchutiltemplate模板
*/
@autowired
private elasticsearchutiltemplate elasticsearchtemplate;
/**
* 分页查询
*/
@test
void getlistpage() {
// 分页
pagehelper.startpage(1, 10);
searchsourcebuilder searchsourcebuilder = new searchsourcebuilder();
boolquerybuilder boolquerybuilder = querybuilders.boolquery();
// 筛选 filter比must要好一点，filter会对条件进行缓存，这有助于提高查询性能，特别是对于频繁使用的过滤条件
boolquerybuilder.filter(querybuilders.termquery("ip", "192.168.0.1"));
// 筛选多个值 类似mysql的in效果 termsquery和termquery区别
boolquerybuilder.filter(querybuilders.termsquery("name", arrays.aslist("张三","李四"));
// 模糊
boolquerybuilder.must(querybuilders.wildcardquery("ext1", "*测试*"));
searchsourcebuilder.query(boolquerybuilder);
// 排序
searchsourcebuilder.sort("createtime", sortorder.desc);
list<studylogindex> logindexlist = this.elasticsearchtemplate.listsearch(searchsourcebuilder, studylogindex.class, index);
pageinfo<studylogindex> studylogindexpageinfo = new pageinfo<>(logindexlist);
system.out.println(jsonutil.tojsonstr(studylogindexpageinfo));
}
/**
* 统计
*/
@test
void counttest() {
// 分页
pagehelper.startpage(1, 10);
searchsourcebuilder searchsourcebuilder = new searchsourcebuilder();
boolquerybuilder boolquerybuilder = querybuilders.boolquery();
// 筛选
boolquerybuilder.filter(querybuilders.termquery("ip", "127.0.0.1"));
// 模糊
boolquerybuilder.must(querybuilders.wildcardquery("ext2", "*用*"));
searchsourcebuilder.query(boolquerybuilder);
countresponse count = elasticsearchtemplate.count(searchsourcebuilder, index);
system.out.println("统计总数："+ count.getcount());
}
/**
* 删除索引
*/
@test
void deleteindicestest() {
elasticsearchtemplate.deleteindex(index);
}
/**
* 创建es索引
*/
@test
void createindicestest() {
createindexrequest createindexrequest = new createindexrequest(index);
createindexrequest.mapping("{\n" +
" \"properties\": {\n" +
" \"globalid\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"site\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"tag\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"uid\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"classid\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"courseid\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"videoid\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"starttime\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"time\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"ip\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"start\": {\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"end\": {\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"createtime\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"ext1\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"ext2\": {\n" +
" \"type\": \"keyword\"\n" +
" }\n" +
" }\n" +
"}", xcontenttype.json);
elasticsearchtemplate.createindices(createindexrequest);
}
/**
* 插入es数据
*/
@test
void adddatatest() {
for (int i = 0; i < 10; i++) {
studylogindex studylogindex = new studylogindex();
studylogindex.setglobalid("cx"+i);
studylogindex.setsite("cx");
studylogindex.settag("success");
studylogindex.setuid(12000000l+i);
studylogindex.setclassid(123456l);
studylogindex.setcourseid(123456l);
studylogindex.setvideoid(123456l);
studylogindex.setstarttime(123456l);
studylogindex.settime(123456l);
studylogindex.setip("127.0.0.1");
studylogindex.setstart(0);
studylogindex.setend(0);
studylogindex.setcreatetime(0l);
studylogindex.setext1("测试es工具");
studylogindex.setext2("备用");
elasticsearchtemplate.add(index, studylogindex.getglobalid(), studylogindex);
}
}
/**
* 批量插入es
*/
@test
void bulkadddatatest() {
map<string, object> map = new hashmap<>(16);
for (int i = 100; i < 1000; i++) {
studylogindex studylogindex = new studylogindex();
studylogindex.setglobalid(idutil.getsnowflakenextidstr());
studylogindex.setsite("zj");
studylogindex.settag("success");
studylogindex.setuid(12000000l+i);
studylogindex.setclassid(123456l);
studylogindex.setcourseid(123456l);
studylogindex.setvideoid(123456l);
studylogindex.setstarttime(123456l);
studylogindex.settime(123456l);
studylogindex.setip("192.168.0.3");
studylogindex.setstart(0);
studylogindex.setend(0);
studylogindex.setcreatetime(0l);
studylogindex.setext1("批量测试es工具");
studylogindex.setext2("备用");
map.put(studylogindex.getglobalid(), studylogindex);
}
elasticsearchtemplate.addbulk(index, map);
}
/**
* 聚合检索
*/
@test
void aggregatetest() {
searchsourcebuilder searchsourcebuilder = new searchsourcebuilder();
// 聚合检索不设置大小会默认只返回10个统计结果
termsaggregationbuilder field = aggregationbuilders.terms("group_by_ip").field("ip").size(1000);
searchsourcebuilder.aggregation(field).size(10);
searchresponse search = elasticsearchtemplate.search(searchsourcebuilder, index);
system.out.println(jsonutil.tojsonstr(search));
map<string, long> countmap = aggregationsutil.getcountmap(search.getaggregations());
system.out.println(jsonutil.tojsonstr(countmap));
}
}
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论