java程序连接ES方式比较

转载

云端创新者 2024-11-25 20:52:35

文章标签 java程序连接ES方式比较 API java elasticsearch Test 文章分类 Java 后端开发

1. Client

说明：Client是Elasticsearch所有API的主入口，主要方法有：

AdminClient admin()	获取ES管理客户端
GetRequestBuilder prepareGet()	准备一个GET请求
IndexRequestBuilder prepareIndex(String index, String type)	准备一个新增文档的请求
DeleteRequestBuilder prepareDelete()	准备一个删除文档的请求
BulkRequestBuilder prepareBulk()	准备一个批量操作的请求
SearchRequestBuilder prepareSearch(String... indices)	准备一个查询请求
UpdateRequestBuilder prepareUpdate()	准备一个更新的请求（更新的本质是先查询索引替换更新的值后进行替换，所以反而比插入更耗性能）

AdminClient
说明：对ES进行管理的客户端，主要方法有：

ClusterAdminClient cluster()	产生一个允许从集群中执行action或操作的client
IndicesAdminClient indices()	产生一个允许从索引中执行action或操作的client

IndicesAdminClient
说明：对ES的index进行管理的客户端，主要方法有：

IndicesExistsRequestBuilder prepareExists(String... indices)	准备一个判断索引是否存在的请求
TypesExistsRequestBuilder prepareTypesExists(String... index)	准备一个判断类型是否存在的请求
CreateIndexRequestBuilder prepareCreate(String index)	准备一个创建索引的请求
DeleteIndexRequestBuilder prepareDelete(String... indices)	准备一个删除索引的请求
AnalyzeRequestBuilder prepareAnalyze(@Nullable String index, String text)	准备一个对字符串进行分词的请求
PutIndexTemplateRequestBuilder preparePutTemplate(String name)	准备一个设置模板的请求
DeleteIndexTemplateRequestBuilder prepareDeleteTemplate(String name)	准备一个删除模板的请求
UpdateSettingsRequestBuilder prepareUpdateSettings(String... indices)	准备一个更新设置的请求，如更新副本数量等
PutMappingRequestBuilder preparePutMapping(String... indices)	准备一个新建映射关系的请求

QueryBuilders
说明：为prepareSearch组装查询参数,如：

Java代码

client.prepareSearch(esIndex).setTypes(esType).setQuery(QueryBuilders.matchQuery("global_ana_ch", "杭州西湖")).setFrom(0).setSize(1).get();

matchAllQuery()	构造匹配所有文档的查询
matchQuery(String name, Object text)	构造查询一个被分析器分析过的字段的查询(match查询)
matchPhraseQuery(String name, Object text)	它和matchQuery的区别是它不会对传入的参数（text）进行分词，而是以其做为一个完整的词进行查询（类似百度查询时加引号的功能）如“有限公司”会分词成“有限”和“公司”，根据分词规则，“有限企业”、“大公司”这样的数据也会被查询出来，使用此方法后则必须包含“有限公司”才会被查询出
matchPhrasePrefixQuery(String name, Object text)	中文查询时matchPhraseQuery和matchPhrasePrefixQuery并没有什么区别，英文查询时matchPhrasePrefixQuery会以短语形式查询，查询时关键字不会被分词，而是直接以一个字符串的形式查询
commonTermsQuery(String name, Object text)	对query进行重写，区分低频词和高频词，并根据Elasticsearch传递的highFreqOccur和lowFreqOccur将高频词和低频词构造成BooleanQuery它的好处是减少了对高频词（如and）查询的性能影响，增加的查询效率
termQuery(String name, Object value)	多字段查询
termsQuery(String name, Object... values)	和termQuery类似，多个term组合
fuzzyQuery(String name, Object value)	模糊查询（like）
prefixQuery(String name, String prefix)	前缀匹配查询
rangeQuery(String name)	范围区间查询
wildcardQuery(String name, String query)	使用通配符查询（*，?）
regexpQuery(String name, String regexp)	正则查询org.apache.lucene.util.automaton.RegExp
queryStringQuery(String queryString)	字符串查询
boolQuery()	布尔型判断的查询must::多个查询条件的完全匹配,相当于 andmustNot::多个查询条件的相反匹配，相当于 notshould::至少有一个查询条件匹配, 相当于 or
SpanQuery	SpanQuery是按照词在文章中的距离或者查询几个相邻词的查询。
spanFirstQuery	接受另一个跨度查询的匹配必须出现在第N的位置
spanNearQuery	接受多个跨度查询的匹配必须在指定的距离,并可能在相同的顺序
spanNotQuery	包装另一个跨度查询,排除了任何文档匹配查询
spanOrQuery	结合多个跨度查询,返回文档的匹配任何指定的查询
spanWithinQuery	和spanContainingQuery类似
spanContainingQuery	这个查询内部会有多个子查询，但是会设定某个子查询优先级更高，作用更大，通过关键字little和big来指定
spanMultiTermQueryBuilder	包装了 term, range, prefix, wildcard, regexp,或 fuzzy查询
spanTermQuery	和spanQuery类似，同时可以做为spanQuery的子句

初始化elasticsearch客户端

Settings settings = Settings.builder() 
                .put("cluster.name", "my-application")// 集群名称yml配置
                .put("client.transport.ping_timeout", "60s")// 超时时间
                .put("client.transport.sniff", false)//是否开启自动发现,非局域网关闭
                .put("client.transport.ignore_cluster_name", false).build();
        try {
            client = new PreBuiltTransportClient(settings).addTransportAddress(new TransportAddress(InetAddress.getByName(ip), 9300));
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

elasticsearch常使用的用法

package com.xue;

 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.commons.io.FileUtils;
 import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
 import org.elasticsearch.action.get.GetResponse;
 import org.elasticsearch.action.search.SearchRequestBuilder;
 import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.client.Client;
import org.elasticsearch.client.IndicesAdminClient;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.search.aggregations.AggregationBuilders;
 import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
 import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
 import org.elasticsearch.search.sort.SortOrder;
 import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.io.File;
import java.io.IOException;
 import java.util.Map;

/**
 * Created by xuehan on 2018/12/10.
 */
/**1. index的操作*/
 public class ElSearch {
    private Client client = null;
    @Before
    public void init(){
        ESTest esTest = new ESTest();
        client = esTest.getClient();
    }
    /**2. mapping映射操作*/
     @Test
    public void testCreateIndex() {
        IndicesAdminClient indices = client.admin().indices();
        String esIndex = "myindex";
        // 判断inedx是否存在
        IndicesExistsResponse indicesExistsResponse = indices.prepareExists(esIndex).get();
        if (indicesExistsResponse.isExists()) {
            // 存在时先删除index
            indices.prepareDelete(esIndex).get();
        }
        // 创建前校验（index不存在）
        indicesExistsResponse = indices.prepareExists(esIndex).get();
        Assert.assertFalse(indicesExistsResponse.isExists());
        // 开始创建index
        indices.prepareCreate(esIndex).get();
        // 创建后校验（index存在）
        indicesExistsResponse = indices.prepareExists(esIndex).get();
        Assert.assertTrue(indicesExistsResponse.isExists());
    }
    @Test
    public void testMapping() throws IOException {
        String esIndex = "testMapping";
        IndicesAdminClient indices = client.admin().indices();
        // 判断inedx是否存在
        IndicesExistsResponse indicesExistsResponse = indices.prepareExists(esIndex).get();
        if (indicesExistsResponse.isExists()) {
            // 存在时先删除index
            indices.prepareDelete(esIndex).get();
        }
        // 创建新的index
        indices.prepareCreate(esIndex).get();
        // 执行前判断（mapping不存在）
        String esType = "esType";
        GetMappingsResponse getMappingsResponse = indices.prepareGetMappings(esIndex).setTypes(esType).get();
        Assert.assertTrue(getMappingsResponse.mappings().isEmpty());
        // 执行mapping
        PutMappingRequestBuilder builder = indices.preparePutMapping(esIndex).setType(esType);
        String mappingFile = getClass().getResource("/").getPath() + "search/lg_line_mapping.json";
        String mappingSource = FileUtils.readFileToString(new File(mappingFile));
        builder.setSource(mappingSource).get();
        // 执行后判断（mapping存在）
        getMappingsResponse = indices.prepareGetMappings(esIndex).setTypes(esType).get();
        Assert.assertFalse(getMappingsResponse.mappings().isEmpty());
    }
    @Test
    public void testIndexing() {
        String esType = "esType";
        String esIndex = "myindex";
        // 不管有没有，先删除数据
        client.prepareDelete(esIndex, esType, "1").execute();

        // 执行前判断（数据不存在）
        GetResponse response = client.prepareGet(esIndex, esType, "1").get();
        Assert.assertNull(response.getSourceAsString());

        // 插入数据
        LineIndexingVO lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(1L);
        lineIndexingVO.setLineNo("LM2017041913250001");
        lineIndexingVO.setGlobal_ana_ch("浙江,杭州,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map = JSONObject.parseObject(lineIndexingVOStr, Map.class);
        client.prepareIndex(esIndex, esType, "1").setSource(map).execute();

        // 执行后判断（数据存在）
        response = client.prepareGet(esIndex, esType, "1").get();
        Assert.assertNotNull(response.getSourceAsString());
    }
    /**4. matchQuery查询**/
    /**
     * 关键词匹配，global_ana_ch是一个分词的字段可以进行搜索匹配
     */
    @Test
    public void testMatchQuery() {
        String esType = "esType";
        String esIndex = "myindex";
         // 插入数据
        LineIndexingVO lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(1L);
        lineIndexingVO.setLineNo("LM2017041913250001");
        lineIndexingVO.setGlobal_ana_ch("浙江,杭州,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map = JSONObject.parseObject(lineIndexingVOStr, Map.class);
        client.prepareIndex(esIndex, esType, "1").setSource(map).execute();

        // 执行matchQuery查询
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch(esIndex).setTypes(esType);
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("global_ana_ch", "杭州西湖");
        SearchResponse response = searchRequestBuilder.setQuery(matchQuery).setFrom(0).setSize(1).get();
        Assert.assertEquals(1, response.getHits().getTotalHits());
    }
    /**
     * 过滤查询
     */
    @Test
    public void testTerm() {
        String esType = "esType";
        String esIndex = "myindex";
        // 插入数据
        LineIndexingVO lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(1L);
        lineIndexingVO.setLineNo("LM2017041913250001");
        lineIndexingVO.setGlobal_ana_ch("浙江,杭州,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map = JSONObject.parseObject(lineIndexingVOStr, Map.class);
        client.prepareIndex(esIndex, esType, "1").setSource(map).execute();

        // 执行term查询，相当于select * from lg_line where id=1 and lineNo="LM2017041913250001"
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch(esIndex).setTypes(esType);
         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.termQuery("lineNo", "LM2017041913250001"));
       // boolQueryBuilder.must(QueryBuilders.termQuery("id", 1));
        SearchResponse response = searchRequestBuilder.setQuery(boolQueryBuilder).get();
        Assert.assertEquals(1, response.getHits().getTotalHits());

        // 执行term查询，相当于select * from lg_line where id=1 and lineNo="LM2017041913250001" and lineNo!="LM2017041913250001"
        boolQueryBuilder.mustNot(QueryBuilders.termQuery("lineNo", "LM2017041913250001"));
        response = searchRequestBuilder.setQuery(boolQueryBuilder).setFrom(0).setSize(1).get();
        Assert.assertEquals(0, response.getHits().getTotalHits());
    }
    /**
     * 排序测试
     */
    @Test
    public void testOrder() {
        String esType = "esType";
        String esIndex = "myindex";
         // 插入数据
        LineIndexingVO lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(1L);
        lineIndexingVO.setLineNo("LM2017041913250001");
        lineIndexingVO.setGlobal_ana_ch("浙江,杭州,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map = JSONObject.parseObject(lineIndexingVOStr, Map.class);

        client.prepareIndex(esIndex, esType, "1").setSource(map).execute();
        // 第二条数据比第一条少了“杭州”
        lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(2L);
        lineIndexingVO.setLineNo("LM2017041913250002");
        lineIndexingVO.setGlobal_ana_ch("浙江,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr1 = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map1 = JSONObject.parseObject(lineIndexingVOStr1, Map.class);

        client.prepareIndex(esIndex, esType, "2").setSource(map1).execute();

        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("global_ana_ch", "浙江杭州");
        // 根据匹配度倒序排列，匹配度高的排在前面
        SearchResponse response = client.prepareSearch(esIndex).setTypes(esType).setQuery(matchQuery).setFrom(0).setSize(2)
                .addSort("_score", SortOrder.DESC).get();
        Assert.assertEquals("1", response.getHits().iterator().next().getId());
        // 根据匹配度顺序排列，匹配度低的排在前面
        response = client.prepareSearch(esIndex).setTypes(esType).setQuery(matchQuery).setFrom(0).setSize(2).addSort("_score", SortOrder.ASC).get();
        Assert.assertEquals("2", response.getHits().iterator().next().getId());
    }
    /**7.统计查询**/
     @Test
    public void testAggs() {
        String esType = "esType1";
        String esIndex = "aggs";
         // 插入数据
        LineIndexingVO lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(1L);
        lineIndexingVO.setLineType("1");
        lineIndexingVO.setGlobal_ana_ch("浙江,杭州,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr1 = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map1 = JSONObject.parseObject(lineIndexingVOStr1, Map.class);
        client.prepareIndex(esIndex, esType, "1").setSource(map1).execute();

        lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(2L);
        lineIndexingVO.setLineType("1");
        lineIndexingVO.setGlobal_ana_ch("浙江,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr2 = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map2 = JSONObject.parseObject(lineIndexingVOStr2, Map.class);
        client.prepareIndex(esIndex, esType, "2").setSource(map2).execute();

        lineIndexingVO = new LineIndexingVO();
        lineIndexingVO.setId(3L);
        lineIndexingVO.setLineType("2");
        lineIndexingVO.setGlobal_ana_ch("浙江,冬瓜,西瓜,地铁,番茄泡");
        String lineIndexingVOStr3 = JSONObject.toJSONString(lineIndexingVO);
        Map<String, Object> map3 = JSONObject.parseObject(lineIndexingVOStr3, Map.class);
        client.prepareIndex(esIndex, esType, "3").setSource(map3).execute();

         /**
          * 需要设置索引
          * {
          "properties": {
          "lineType": {
          "type":     "text",
          "fielddata": true
          }
          }
          }
          http://47.105.74.94:9200/aggs/_mapping/esType1
          */
        // 根据lineType进行分类统计，type=1的有2条，type=2的有1条
        TermsAggregationBuilder termsBuilder = AggregationBuilders.terms("by_lineType").field("lineType");
        SearchResponse response = client.prepareSearch(esIndex).setTypes(esType).addAggregation(termsBuilder).setSize(10).get();
        StringTerms aggregation = response.getAggregations().get("by_lineType");
        Assert.assertEquals(2, aggregation.getBucketByKey("1").getDocCount());
        Assert.assertEquals(1, aggregation.getBucketByKey("2").getDocCount());
    }
    class LineIndexingVO{
         private double id;
        private String lineNo;
        private String lineType;
        private String global_ana_ch;

        public double getId() {
            return id;
        }

        public void setId(double id) {
            this.id = id;
        }

        public String getLineNo() {
            return lineNo;
        }

        public void setLineNo(String lineNo) {
            this.lineNo = lineNo;
        }

        public String getGlobal_ana_ch() {
            return global_ana_ch;
        }

        public void setGlobal_ana_ch(String global_ana_ch) {
            this.global_ana_ch = global_ana_ch;
        }

        public String getLineType() {
            return lineType;
        }

        public void setLineType(String lineType) {
            this.lineType = lineType;
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。