Elasticsearch7.6.0java代码的基本操作

记录用Java代码操作Elasticsearch的经验

第一次写博客，希望能够点滴记录自己在项目中用到的一些技术，方便日后自己查看。

一、加载ElasticSearch客户端

在config中编写注入ElasticSearch客户端的方法，这里没有创建集群的方式，集群的方式是采用数组的方式注入。

// An highlighted block
@Configuration
public class ElasticSearchClientConfig {

    //ES的访问地址，本地地址127.0.0.1，测试环境正式环境根据实际定义
    @Value("${es.website}")
    private String website;

    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient cline = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost(website,9200,"http")
                )
        );
        return cline;
    }
}

二、基本的操作语法（返回对象可以根据实际场景自定义）

2.0、前提条件

//面向对象操作,注入客户端
    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

2.1、创建索引的方法（所有的ES的操作编写一个utils工具类）

// An highlighted block
//创建索引
public boolean createIndex(String index) {
    //创建索引
    CreateIndexRequest request = new CreateIndexRequest(index);
    //客户端执行
    try {
    CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
      return true;
    } catch (IOException e) {
      e.printStackTrace();
    }
  	return false;
    }

2.2、判断索引是否存在

// An highlighted block
 //判断索引是否存在，存在True，反之false
    public boolean existIndex(String index) {
        GetIndexRequest request = new GetIndexRequest(index);
        boolean exists = false;
        try {
            exists = client.indices().exists(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return exists;
    }

2.3、删除索引

// An highlighted block
//删除索引
    public void deleteIndex(String index) {
        DeleteIndexRequest request = new DeleteIndexRequest(index);
        try {
            AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
            System.out.println(delete);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2.4、添加文档

// An highlighted block
    //添加文档(需要添加文档的数据，需要写入的索引参数定义)
    public void addDocument(List<Map<String, Object>> maps, String index) {
        //创建对象，直接用Map储存数据，就是把查询出来数据储存到ES
        List<Map<String, Object>> mapList = maps;
        //创建请求
        IndexRequest request = new IndexRequest(index);
        //规则
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1S");
        //数据放入请求 JSON
        request.source(com.alibaba.fastjson.JSON.toJSONString(mapList), XContentType.JSON);
        //客户端发送请求，获取相应结果
        try {
            IndexResponse response = client.index(request, RequestOptions.DEFAULT);
            System.out.println(response.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

2.5、批处理数据

// An highlighted block
//批量插入
    public void addAll(List<Map<String, Object>> Object, String index) {
        BulkRequest request = new BulkRequest();
        //request.timeout("10S");
        ArrayList<CustomPojo> list = new ArrayList<>();
        //将查询到的数据遍历写入ES
        for (Map map : Object) {
            Integer companyCount = (Integer) map.get("companyCount");
            Integer goodsCategory = (Integer) map.get("goodsCategory");
            list.add(new CustomPojo(companyCount, (String) map.get("regionName"), goodsCategory));
        }
        //批处理请求, 写入ES库
        for (int i = 0; i < list.size(); i++) {
            request.add(
                    new IndexRequest(index)
                            .id("" + (i + 1))
                            .source(JSON.toJSONString(list.get(i)), XContentType.JSON)
            );
        }
        ;
        try {
            BulkResponse bulk = client.bulk(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2.6、查询的方法（查询方法较多，根据实际场景使用适合项目的方法）

// An highlighted block
 //查询ES数据库的方法，默认基本查询的方法（查询10条数据）
    public List<Map<String, Object>> serach(String index) {
        //需要查询的索引库
        SearchRequest searchRequest = new SearchRequest(index);
        //构造查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询所有
        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        //执行查询
        searchSourceBuilder.query(matchAllQueryBuilder);
        try {
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            //将查询到的全部数据写入到list中
            List<Map<String, Object>> listMap = new ArrayList<>();
            for (SearchHit searchHit : searchResponse.getHits().getHits()) {
            	//根据实际查询到的数据遍历
                Map<String, Object> map = new HashMap<>();
                map.put("companyCount", searchHit.getSourceAsMap().get("companyCount"));
                map.put("goodsCategory", searchHit.getSourceAsMap().get("goodsCategory"));
                map.put("regionName", searchHit.getSourceAsMap().get("regionName"));
                listMap.add(map);
            }
            return listMap;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

2.7、多条件查询(多条件也要根据实际场景使用，包含分页)

// An highlighted block
public List<Company> listSearch(String index,String regionName,String label) {

     // 1.创建搜索请求
    SearchRequest searchRequest = new SearchRequest(index);
    // 2.构建搜索条件：条件构造器SearchSourceBuilder
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    //text查询语法，MatchPhrasePrefixQueryBuilder无单词约束
	//多条件设置
    MatchPhrasePrefixQueryBuilder mpq1 = 
    	QueryBuilders.matchPhrasePrefixQuery("regionName",regionName);
   MatchPhrasePrefixQueryBuilder mpq2 = QueryBuilders.matchPhrasePrefixQuery("label", label);
   QueryBuilder qb2 = QueryBuilders.boolQuery()
                        .must(mpq1)
                        .must(mpq2);
	//根据条件判断是否需要查询label
    sourceBuilder.query(qb2);
	// 条件构造器，默认查询10条数据，自定义覆盖，查询全部数据，分页可以传入from、size参数来实现，当然有更好用的方法，下次用到了再记录吧。
    sourceBuilder.from(0);
    sourceBuilder.size(1000);//最大9999，需要查询比9999数据还多的需要拓展
    // 条件构造器，搜索请求超时时间60s
    sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
    // 将条件构造器放入搜索请求
    searchRequest.source(sourceBuilder);
    // 执行搜索请求，并获得searchResponse响应
    try {
    SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
    //创建list集合储存遍历的对象
    List<Company> list = new ArrayList<>();

    // 搜索得到的所有结果都封装在hits里面,拿数据从hits里面获取
    for (SearchHit searchHit : searchResponse.getHits().getHits()) {
    //创建对象，将查询出的数据赋予对象封装
    Company company = new Company();
    company.setId((String) searchHit.getSourceAsMap().get("id"));//商家ID
 	.....
    //遍历出来的对象储存到集合中
    list.add(company);
    }
     return list;
   } catch (IOException e) {
     e.printStackTrace();
   }
     return null;
   }

2.8、精准匹配or模糊匹配

// An highlighted block
    void serach(String index，String regionName){
        //需要查询的索引库
        SearchRequest searchRequest = new SearchRequest(index);
        //构造查询条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        /*
        //查询所有
		QueryBuilders.matchAllQuery();
		//模糊匹配
		QueryBuilders.matchPhrasePrefixQuery("label", label);
		*/
        //精确匹配
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("regionName", regionName);
        //执行查询
        searchSourceBuilder.query(termQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        try {
            SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
            System.out.println(searchResponse);
            //将查询到的全部数据写入到list中
            List<Map<String,Object>> listMap = new ArrayList<>();
            for(SearchHit searchHit: searchResponse.getHits().getHits()){
                ....
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

这次的记录就到这里，下次记录ES的聚合查询，多索引聚合查询等。。。