首先，引入坐标这事我直接放在了本文最下面
其次，各种操作也比较简单，我放在了一个代码块上，需要找操作的同学，例如：聚合操作，直接ctrl+f搜索"聚合"就能快速找到了。
1, 在 resource 文件夹下面创建 application.yml 文件
elasticsearch:
host: 127.0.0.1
port: 9200
2,创建启动类，此处略
3，创建配置类，ElasticSearchConfig，读取配置文件，创建RestHighLevelClient操作ES对象，并放入IOC容器。
@Configuration
@ConfigurationProperties(prefix = "elasticsearch")
public class ElasticSearchConfig {
private String host;
private int port;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
@Bean
public RestHighLevelClient client(){
return new RestHighLevelClient(RestClient.builder(
new HttpHost(
host,
port,
"http"
)
));
}
}
4，新建测试类，用来操作ES，创建索引库，操作索引库的操作都在下面，我代码中有注释，每一个操作一个测试方法
package xyz.zhoupf.test;
import com.alibaba.fastjson.JSON;
import org.apache.lucene.search.TotalHits;
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.client.IndicesClient;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.client.indices.GetIndexResponse;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.*;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilder;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
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 xyz.zhoupf.domain.Goods;
import xyz.zhoupf.domain.Person;
import xyz.zhoupf.mapper.GoodsMapper;
import javax.naming.directory.SearchResult;
import java.io.IOException;
import java.util.*;
@RunWith(SpringRunner.class)
@SpringBootTest
public class ElasticsearchTest {
@Autowired
private RestHighLevelClient client;
@Autowired
private GoodsMapper goodsMapper;
@Test
public void contextLoads(){
System.out.println(client);
//虽然client是全局变量，但是我们此时是在@Test方法内，与外界隔离，因此即便是client = null;也不会影响原值
client = null;
this.client = client;
}
/**高亮查询
* 高亮三要素：高亮字段 前缀 后缀
* 1. 设置高亮
* 高亮字段
* 前缀
* 后缀
* 2. 将高亮了的字段数据，替换原有数据
*/
@Test
public void testHighLightQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,rangeQuery范围查询
MatchQueryBuilder query = QueryBuilders.matchQuery("title", "手机");
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//5.1 设置高亮
HighlightBuilder highlighter = new HighlightBuilder();
//5.2 设置三要素
highlighter.field("title");
highlighter.preTags("<font color='red'>");
highlighter.postTags("</font>");
//5.3
//添加高亮对象到查询条件构建器中
searchSourceBuilder.highlighter(highlighter);
/** 5.4 聚合查询， 查询品牌列表
参数：
1. 自定义的名称，将来用于获取数据
2. 分组的字段
*/
AggregationBuilder agg = AggregationBuilders.terms("goods_brands").field("brandName").size(100);
searchSourceBuilder.aggregation(agg);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
// 获取高亮结果，替换goods中的title
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
HighlightField highlightField = highlightFields.get("title");
Text[] fragments = highlightField.fragments();
//替换，就是在原来的基础上加上了高亮---><font color='red'></font>
//title='小米手机'--->title=小米<font color='red'>手机</font>
goods.setTitle(fragments[0].toString());
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 21. 聚合查询
* • 指标聚合：相当于MySQL的聚合函数。max、min、avg、sum等
* • 桶聚合：相当于MySQL的 group by 操作。不要对text类型的数据进行分组，会失败。
* 1. 查询title包含手机的数据, 2. 查询品牌列表
*/
@Test
public void testAggQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,rangeQuery范围查询
MatchQueryBuilder query = QueryBuilders.matchQuery("title", "手机");
//5. 在查询条件构建器中指定查询条件, 使用boolQuery连接
searchSourceBuilder.query(query);
/*查询品牌列表
参数：
1. 自定义的名称，将来用于获取数据
2. 分组的字段
*/
AggregationBuilder agg = AggregationBuilders.terms("goods_brands").field("brandName").size(100);
searchSourceBuilder.aggregation(agg);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 20. 布尔查询
* boolQuery：对多个查询条件连接。连接方式：
* • must（and）：条件必须成立
* • must_not（not）：条件必须不成立
* • should（or）：条件可以成立
* • filter：条件必须成立，性能比must高。不会计算得分
* 1. 查询品牌名称为:华为. 2. 查询标题包含：手机. 3. 查询价格在：2000-3000
*/
@Test
public void testBoolQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,rangeQuery范围查询
BoolQueryBuilder query = QueryBuilders.boolQuery();
//6.1 构建各个查询条件
//6.1 查询品牌名称为:华为
TermQueryBuilder termQuery = QueryBuilders.termQuery("brandName", "华为");
query.must(termQuery);
//6.2 查询标题包含：手机
MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("title", "手机");
query.filter(matchQuery);
//6.3 查询价格在：2000-3000
QueryBuilder rangeQuery = QueryBuilders.rangeQuery("price");
((RangeQueryBuilder) rangeQuery).gte(2000);
((RangeQueryBuilder) rangeQuery).lte(3000);
query.filter(rangeQuery);
//5. 在查询条件构建器中指定查询条件, 使用boolQuery连接
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 19. queryString查询-脚本
* • 会对查询条件进行分词。
* • 然后将分词后的查询条件和词条进行等值匹配
* • 默认取并集（OR）
* • 可以指定多个查询字段
*/
@Test
public void testQueryStringQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,rangeQuery范围查询
QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("华为手机")
.field("title")
.field("categoryName")
.field("brandName")
.defaultOperator(Operator.AND);
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 18，范围查询和排序
* 1. 范围查询：rangeQuery
* 2. 排序
*/
@Test
public void testRangeQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,rangeQuery范围查询
RangeQueryBuilder query = QueryBuilders.rangeQuery("price");
//指定下限 gte大于等于
query.gte(2000);
//指定上限 小于等于
query.lte(3000);
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//排序
searchSourceBuilder.sort("price", SortOrder.DESC);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 17. 模糊查询:perfixQuery
*/
@Test
public void testPrefixQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,wildcardQuery模糊查询
/**
* WildcardQueryBuilder query = QueryBuilders.prefixQuery("title", "三");
* 这是侯面向接口编程的优势就出现了，你现在构建出来的实体类是PrefixQueryBuilder而不是WildcardQueryBuilder就会报错
* 如果声明引用使用QueryBuilder接口类型，那么就会解耦，就不会报错，因为两个类都间接实现类QueryBuilder接口
*/
PrefixQueryBuilder query = QueryBuilders.prefixQuery("title", "三");
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 16，模糊查询:WildcardQuery
* wildcard查询：会对查询条件进行分词。
* 还可以使用通配符 ?（任意单个字符） 和 * （0个或多个字符）
*/
@Test
public void testWildcardQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件,wildcardQuery模糊查询
WildcardQueryBuilder query = QueryBuilders.wildcardQuery("title", "华*");
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 15, matchQuery:词条分词查询，分词之后的等值匹配
* match查询：
* • 会对查询条件进行分词。
* • 然后将分词后的查询条件和词条进行等值匹配
* • 默认取并集（OR）
*/
@Test
public void testMatchQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件
//设置matchQuery分词查询以title属性中关系是Operator.AND的华为手机的分词条件
//即title里面的值，既要有“华为”也要有“手机” 一共查出51条，如果把条件换为Operator.OR则会查“手机”和“华为”的并集，共查出718条数据
MatchQueryBuilder query = QueryBuilders.matchQuery("title", "华为手机").operator(Operator.OR);
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 14, termQuery:词条查询
* term查询：不会对查询条件进行分词。
*/
@Test
public void testTermQuery() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest request = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//6. 查询条件，matchAllQuery，即查询该索引库的所有的信息
TermQueryBuilder query = QueryBuilders.termQuery("title", "小米");
//5. 在查询条件构建器中指定查询条件
searchSourceBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
request.source(searchSourceBuilder);
//1. 查询,获取查询结果
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
TotalHits.Relation relation = searchHits.getTotalHits().relation;
System.out.println("关系为： " + relation);
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 13, 查询所有
* 1. matchAll
* 2. 将查询结果封装为Goods对象，装载到List中
* 3. 分页。默认显示10条
*/
@Test
public void testMatchAll() throws IOException {
//2. 构建查询请求对象，指定查询的索引名称
SearchRequest searchRequest = new SearchRequest("goods");
//4. 创建查询条件构建器SearchSourceBuilder
SearchSourceBuilder searchBuilder = new SearchSourceBuilder();
//6. 查询条件，matchAllQuery，即查询该索引库的所有的信息
QueryBuilder query = QueryBuilders.matchAllQuery();//查询所有文档
//5. 在查询条件构建器中指定查询条件
searchBuilder.query(query);
//3. 添加查询条件构建器 SearchSourceBuilder
searchRequest.source(searchBuilder);
//8. 添加分页信息
searchBuilder.from(0);
searchBuilder.size(10);
//1. 查询,获取查询结果
SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
//7. 获取命中对象 SearchHits
SearchHits searchHits = response.getHits();
//8. 获取总记录数
long value = searchHits.getTotalHits().value;
System.out.println("总记录数："+value);
List<Goods> goodsList = new ArrayList<>();
//9. 获取Hits数据 数组
SearchHit[] hits = searchHits.getHits();
for (SearchHit hit : hits) {
//获取json字符串格式的数据
String sourceAsString = hit.getSourceAsString();
//字符串转化为Java对象
Goods goods = JSON.parseObject(sourceAsString, Goods.class);
//把good对象添加到集合中
goodsList.add(goods);
}
for (Goods goods : goodsList) {
System.out.println(goods);
}
}
/**
* 12，MySQL中数据导入es，并查询数据
*/
@Test
public void importData() throws IOException {
//1.查询所有数据，mysql
List<Goods> goodsList = goodsMapper.findAll();
//2，批量导入数据到es
BulkRequest bulkRequest = new BulkRequest();
//2.1 循环goodsList，创建IndexRequest添加数据
for (Goods goods : goodsList) {
//2.2 设置spec规格信息 Map的数据 specStr:{}
//将json格式字符串转为Map集合
Map map = JSON.parseObject(goods.getSpecStr(), Map.class);
//设置spec map
goods.setSpec(map);
//将goods对象转换为json字符串
String data = JSON.toJSONString(goods);
IndexRequest indexRequest = new IndexRequest("goods").id(goods.getId() + "").source(data, XContentType.JSON);
bulkRequest.add(indexRequest);
}
BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
System.out.println(response.status());
}
/**
* 11, 批量操作-脚本 bulk
* 1 删除1号记录
* 2 添加8号记录
* 3 修改2号记录 名称为二号
*/
@Test
public void testBulk() throws IOException {
//创建bulkrequest对象，整合所有操作
BulkRequest bulkRequest = new BulkRequest();
/**
# 1. 删除1号记录
# 2. 添加6号记录
# 3. 修改2号记录 名称为 “二号”
*/
//1. 删除1号记录
DeleteRequest deleteRequest = new DeleteRequest("atguigu").id("1");
bulkRequest.add(deleteRequest);
//2. 添加6号记录
Map<String, Object> map = new HashMap<>();
map.put("name","六号");
map.put("id","6");
map.put("address","西安");
map.put("phone","1813763637");
IndexRequest indexRequest = new IndexRequest("atguigu").id("6").source(map);
bulkRequest.add(indexRequest);
//3. 修改2号记录 名称为"二号"
Map map2 = new HashMap();
map2.put("name","二号");
UpdateRequest updateRequest = new UpdateRequest("atguigu", "2").doc(map2);
bulkRequest.add(updateRequest);
//执行批量操作
BulkResponse response = client.bulk(bulkRequest, RequestOptions.DEFAULT);
RestStatus status = response.status();
System.out.println(status);
}
/**
* 10, 根据id删除文档
*/
@Test
public void delDoc() throws IOException {
DeleteRequest deleteRequest = new DeleteRequest("atguigu").id("3");
DeleteResponse response = client.delete(deleteRequest, RequestOptions.DEFAULT);
System.out.println(response.getId());
}
/**
* 9, 根据id查询文档
*/
@Test
public void findDocById() throws IOException {
GetRequest request = new GetRequest("atguigu").id("2");
GetResponse response = client.get(request, RequestOptions.DEFAULT);
//获取数据对应的json
System.out.println(response.getSourceAsString());
}
/**
* 8, 修改文档：添加文档时，如果id存在则修改，id不存在则添加
*/
@Test
public void updateDoc() throws IOException {
//数据对象，javaObject
Person p = new Person();
p.setId("2");
p.setName("硅谷");
p.setAge(30);
p.setAddress("北京昌平区");
//将对象转为json
String data = JSON.toJSONString(p);
//获取操作文档的对象
IndexRequest request = new IndexRequest("atguigu").id(p.getId()).source(data, XContentType.JSON);
//添加数据，获取结果
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//打印响应结果
System.out.println(response.getId());
}
/**
* 7，添加文档,使用对象作为数据
*/
@Test
public void addDoc2() throws IOException {
//数据对象，person
Person person = new Person();
person.setAddress("北京东城");
person.setAge(30);
person.setName("王五");
person.setId("3");
//将对象转为json
String data = JSON.toJSONString(person);
//获取操作文档的对象
IndexRequest request = new IndexRequest("atguigu").id("3").source(data, XContentType.JSON);
//添加数据，获取结果
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//打印响应结果
System.out.println(response.getId());
}
/**
* 6, 添加文档,使用map作为数据
*/
@Test
public void addDoc() throws IOException {
//数据对象，map
Map<String, Object> data = new HashMap<>();
data.put("address", "深圳南山");
data.put("age", 20);
data.put("name", "王五");
//1.获取操作文档的对象，相当于post atguigu/_doc/1 + {"properties"...}
IndexRequest request = new IndexRequest("atguigu").id("2").source(data);
//添加数据，获取结果，client在IOC容器中，已经对elasticsearch进行了连接
//client相当于MySQL中的connection连接
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
//打印响应结果
System.out.println(response.getId());
}
/**
* 5, 判断索引是否存在
*/
@Test
public void existIndex() throws IOException {
IndicesClient indices = client.indices();
GetIndexRequest getRequest = new GetIndexRequest("atguigu");
boolean exists = indices.exists(getRequest, RequestOptions.DEFAULT);
System.out.println(exists);
}
/**
* 4, 删除索引
*/
@Test
public void deleteIndex() throws Exception{
//1.使用client获取操作索引的对象
IndicesClient indices = client.indices();
//2，创建要请求的索引库的对象
DeleteIndexRequest atguigu = new DeleteIndexRequest("atguigu");
//使用操作索引的对象创建索引库
AcknowledgedResponse response = indices.delete(atguigu, RequestOptions.DEFAULT);
System.out.println(response.isAcknowledged());
}
/**
* 3，查询索引
* get atguigu/_mapping
*/
@Test
public void queryIndex() throws Exception{
IndicesClient indices = client.indices();
GetIndexRequest getReqeust = new GetIndexRequest("atguigu");
GetIndexResponse response = indices.get(getReqeust, RequestOptions.DEFAULT);
Map<String, MappingMetaData> mappings = response.getMappings();
Set<String> strings = mappings.keySet();
for (String key : strings) {
System.out.println(key+":" + mappings.get(key).getSourceAsMap());
}
Set<Map.Entry<String, MappingMetaData>> entries = mappings.entrySet();
for (Map.Entry<String, MappingMetaData> entry : entries) {
String key = entry.getKey();
System.out.println(key);
MappingMetaData value = entry.getValue();
System.out.println(value.getSourceAsMap());
}
}
/**
* 2, 创建索引库并添加映射信息
*/
@Test
public void addIndexAndMapping() throws IOException{
//1.使用client获取操作索引的对象
IndicesClient indicesClient = client.indices();
//2，创建要请求的索引库的对象
CreateIndexRequest createRequest = new CreateIndexRequest("atguigu");
//3, 设置mappings
String mapping = "{\n" +
" \"properties\" : {\n" +
" \"address\" : {\n" +
" \"type\" : \"text\",\n" +
" \"analyzer\" : \"ik_max_word\"\n" +
" },\n" +
" \"age\" : {\n" +
" \"type\" : \"long\"\n" +
" },\n" +
" \"name\" : {\n" +
" \"type\" : \"keyword\"\n" +
" }\n" +
" }\n" +
" }";
//设置索引库的mapping，即数据结构
createRequest.mapping(mapping, XContentType.JSON);
//使用客户端创建索引库
CreateIndexResponse response = indicesClient.create(createRequest, RequestOptions.DEFAULT);
//6, 根据返回值判断结果
System.out.println(response.isAcknowledged());
}
/**
* 1，添加索引库
* #创建索引库
* PUT person
*/
@Test
public void addIndex() throws IOException {
//1，使用client获取操作索引的对象
IndicesClient indicesClient = client.indices();
//2，具体操作，创建名为"atguigu"的索引库，参数名为默认值RequestOptions.DEFAULT，并获取返回值
CreateIndexRequest createRequest = new CreateIndexRequest("atguigu");
CreateIndexResponse response = indicesClient.create(createRequest, RequestOptions.DEFAULT);
boolean acknowledged = response.isAcknowledged();
System.out.println(acknowledged);
}
}
5，Pom文件
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.1.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--引入es的坐标-->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.4.0</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-client</artifactId>
<version>7.4.0</version>
</dependency>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>7.4.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.4</version>
</dependency>
</dependencies>
158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
