布道

Elasticsearch笔记（八）：客户端连接

本节将讲解Elasticsearch提供的Client API，而重点讲解Java API。在之前的章节中讲过《es的架构》，在这个架构图中包含了两个很重要的ES交互客户端模块：RESTful style API（HTTP REST API ，端口 9200）和Transport（TCP方式，端口 9300）。

目录

1. 多语言支持

2. Java API

2.1 Node Client

2.2 Transport client

2.3 Document API

2.4 Search API

2.5 Aggregation

2.6 Query DSL

2.6 Java API Administration

2.7 spring-data-elasticsearch

3. Java REST Client

3.1 Java Low Level REST Client

3.2 Java High Level REST Client

3.2 API

1. 多语言支持

es的client支持很多语言，它们有：

Java API
Java REST Client
JavaScript API
Groovy API [2.4] — other versions
.NET API [6.x] — other versions
PHP API [6.0] — other versions
Perl API
Python API
Ruby API
Community Contributed Clients

2. Java API

它提供的功能：

在现有群集上执行标准 index, get, delete 和 search 操作
在正在运行的群集上执行管理任务

获取ES Client很简单，获取客户机的最常见方法是创建连接到集群的TransportClient。另外，它也有一个很可怕的缺点：client版本必须和ES有相同的主要版本（这都让很多开发者深受其害）。

警告
我们计划在Elasticsearch 7.0中对TransportClient进行弃用，并在8.0中完全删除它，替而代之，你应该使用Java高级REST客户端，它执行HTTP请求而不是序列化的Java请求。迁移指南描述了迁移所需的所有步骤。

Java高级REST客户端目前支持更常用的API，但还有很多东西需要补充，您可以通过告诉我们您的应用程序需要哪些缺失的API来帮助我们优化优先级，通过向这个issue添加注释:Java高级REST客户端完整性。

任何丢失的API都可以通过使用具有JSON请求和响应主体的低级Java REST客户端来实现。

2.1 Node Client

Node client，也叫节点客户端。它是官方ES发行版的一部分，需要客户端运行Java等，但也有一些显着的差异。它作为一个非数据节点加入到本地集群中。它本身不保存任何数据，但是它知道数据在集群中的哪个节点中，并且可以把请求转发到正确的节点。这意味着节点客户端的存在被存储在群集状态，并且群集中的所有其他节点将尝试建立到客户端的几个tcp连接。如果群集很大或使用多个客户端，这可能是一个显着的缺点。

2.2 Transport client

Transport client，轻量级传输客户端。它可以将请求发送到远程集群，它本身不加入集群，但是它可以将请求转发到集群中的一个节点上。需要客户端用Java编写（或至少在JVM上运行）。它非常快，在JVM上本机运行。序列化是有效的，发送到ES实例的消息和操作中几乎没有开销。在Elasticsearch 1.0之前，将需要完全相同的版本，但较新的版本（1.0和更高版本）支持版本之间的交互。由于异常序列化和更新之间的其他潜在细微差异，在客户端和服务器上运行相同的JVM更新版本也是有益的。目前不支持加密或身份验证，但是宣布不久会满足这些需求。

首先，添加maven中添加6.2.4版本。它封装了比较好，支持同步和异步。

public class Client_test {    
    private TransportClient client;
    @Before
    public void setUp() throws UnknownHostException {
        if(client == null) {           
            // 连接集群的设置
            Settings settings = Settings.builder()
                    //.put("cluster.name", "myClusterName")
                    .put("client.transport.sniff", true)
                    .build();   
            //client = new PreBuiltTransportClient(Settings.EMPTY)
            client = new PreBuiltTransportClient(settings)
                //.addTransportAddress(new TransportAddress(InetAddress.getByName("localhost"), 9300));//访问默认端口9300，
                .addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));          
            
            /*
             * 参数说明:
             *
            cluster.name                             指定集群的名字，如果集群的名字不是默认的elasticsearch，需指定。
            client.transport.sniff                   设置为true,将自动嗅探整个集群，自动加入集群的节点到连接列表中。    
            client.transport.ignore_cluster_name     设置true，忽略连接节点集群名验证
            client.transport.ping_timeout            ping一个节点的响应时间 默认5秒.
            client.transport.nodes_sampler_interval  sample/ping 节点的时间间隔，默认是5s
            
            */            
        }      
    }
}

2.3 Document API

单文档API

Index API
Get API
Delete API
Update API

多文档API

Multi Get API
Bulk API
Reindex API
Update By Query API
Delete By Query API

@Test
public void opDoc() {
    //这里和RESTful风格不同
    try{
        // 1、创建索引请求
        IndexRequest request = new IndexRequest(
                "mess",   //索引
                "_doc",     // mapping type
                "11");     //文档id  
        
        // 2、准备文档数据
        // 方式一：直接给JSON串
        String jsonString = "{" +
                "\"user\":\"kimchy\"," +
                "\"postDate\":\"2013-01-30\"," +
                "\"message\":\"trying out Elasticsearch\"" +
                "}";
        request.source(jsonString, XContentType.JSON); 
        
        // 方式二：以map对象来表示文档
        /*
        Map jsonMap = new HashMap<>();
        jsonMap.put("user", "kimchy");
        jsonMap.put("postDate", new Date());
        jsonMap.put("message", "trying out Elasticsearch");
        request.source(jsonMap); 
        */
        
        // 方式三：用XContentBuilder来构建文档
        /*
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("user", "kimchy");
            builder.field("postDate", new Date());
            builder.field("message", "trying out Elasticsearch");
        }
        builder.endObject();
        request.source(builder); 
        */
        
        // 方式四：直接用key-value对给出
        /*
        request.source("user", "kimchy",
                        "postDate", new Date(),
                        "message", "trying out Elasticsearch");
        */
        
        //3、其他的一些可选设置
        /*
        request.routing("routing");  //设置routing值
        request.timeout(TimeValue.timeValueSeconds(1));  //设置主分片等待时长
        request.setRefreshPolicy("wait_for");  //设置重刷新策略
        request.version(2);  //设置版本号
        request.opType(DocWriteRequest.OpType.CREATE);  //操作类别  
        */
        
        //4、发送请求
        IndexResponse indexResponse = null;
        try {
            //方式一： 用client.index 方法，返回是 ActionFuture，再调用get获取响应结果
            indexResponse = client.index(request).get();
            
            //方式二：client提供了一个 prepareIndex方法，内部为我们创建IndexRequest
            /*IndexResponse indexResponse = client.prepareIndex("mess","_doc","11")
                    .setSource(jsonString, XContentType.JSON)
                    .get();*/
            
            //方式三：request + listener
            //client.index(request, listener);    
            
        } catch(ElasticsearchException e) {
            // 捕获，并处理异常
            //判断是否版本冲突、create但文档已存在冲突
            if (e.status() == RestStatus.CONFLICT) {
                logger.error("冲突了，请在此写冲突处理逻辑！\n" + e.getDetailedMessage());
            }
            
            logger.error("索引异常", e);
        }catch (InterruptedException | ExecutionException e) {
            logger.error("索引异常", e);
        }
        
        //5、处理响应
        if(indexResponse != null) {
            String index = indexResponse.getIndex();
            String type = indexResponse.getType();
            String id = indexResponse.getId();
            long version = indexResponse.getVersion();
            if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
                System.out.println("新增文档成功，处理逻辑代码写到这里。");
            } else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
                System.out.println("修改文档成功，处理逻辑代码写到这里。");
            }
            // 分片处理信息
            ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
            if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
                
            }
            // 如果有分片副本失败，可以获得失败原因信息
            if (shardInfo.getFailed() > 0) {
                for (ReplicationResponse.ShardInfo.Failure failure : shardInfo.getFailures()) {
                    String reason = failure.reason(); 
                    System.out.println("副本失败原因：" + reason);
                }
            }
        }        
        
        //listener 方式
        /*ActionListener listener = new ActionListener() {
            @Override
            public void onResponse(IndexResponse indexResponse) {
                
            }

            @Override
            public void onFailure(Exception e) {
                
            }
        };
        client.index(request, listener);
        */
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2.4 Search API

搜索API允许用户执行搜索查询并返回与查询匹配的搜索结果。它可以跨一个或多个索引执行，也可以跨一个或多个类型执行。可以使用query Java API提供查询。使用SearchSourceBuilder生成搜索请求的正文。它用法包含：

Using scrolls in Java
MultiSearch API
Using Aggregations
Terminate After
Search Template

@Test
public void opSearch() {
    try{        
        // 1、创建search请求
        //SearchRequest searchRequest = new SearchRequest();
        SearchRequest searchRequest = new SearchRequest("bank"); 
        searchRequest.types("_doc");
        
        // 2、用SearchSourceBuilder来构造查询请求体 ,请仔细查看它的方法，构造各种查询的方法都在这。
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); 
        
        //构造QueryBuilder
        /*QueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("user", "kimchy")
                .fuzziness(Fuzziness.AUTO)
                .prefixLength(3)
                .maxExpansions(10);
        sourceBuilder.query(matchQueryBuilder);*/
        
        sourceBuilder.query(QueryBuilders.termQuery("age", 24)); 
        sourceBuilder.from(0); 
        sourceBuilder.size(10); 
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS)); 
        
        //是否返回_source字段
        //sourceBuilder.fetchSource(false);
        
        //设置返回哪些字段
        /*String[] includeFields = new String[] {"title", "user", "innerObject.*"};
        String[] excludeFields = new String[] {"_type"};
        sourceBuilder.fetchSource(includeFields, excludeFields);*/
        
        //指定排序
        //sourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC)); 
        //sourceBuilder.sort(new FieldSortBuilder("_uid").order(SortOrder.ASC));
        
        // 设置返回 profile 
        //sourceBuilder.profile(true);
        
        //将请求体加入到请求中
        searchRequest.source(sourceBuilder);
        
        // 可选的设置
        //searchRequest.routing("routing");
        
        // 高亮设置
        /*
        HighlightBuilder highlightBuilder = new HighlightBuilder(); 
        HighlightBuilder.Field highlightTitle =
                new HighlightBuilder.Field("title"); 
        highlightTitle.highlighterType("unified");  
        highlightBuilder.field(highlightTitle);  
        HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("user");
        highlightBuilder.field(highlightUser);
        sourceBuilder.highlighter(highlightBuilder);*/        
        
        //加入聚合
        /*TermsAggregationBuilder aggregation = AggregationBuilders.terms("by_company")
                .field("company.keyword");
        aggregation.subAggregation(AggregationBuilders.avg("average_age")
                .field("age"));
        sourceBuilder.aggregation(aggregation);*/
        
        //做查询建议
        /*SuggestionBuilder termSuggestionBuilder =
                SuggestBuilders.termSuggestion("user").text("kmichy"); 
            SuggestBuilder suggestBuilder = new SuggestBuilder();
            suggestBuilder.addSuggestion("suggest_user", termSuggestionBuilder); 
        sourceBuilder.suggest(suggestBuilder);*/
        
        //3、发送请求        
        SearchResponse searchResponse = client.search(searchRequest).get();
        
        
        //4、处理响应
        //搜索结果状态信息
        RestStatus status = searchResponse.status();
        TimeValue took = searchResponse.getTook();
        Boolean terminatedEarly = searchResponse.isTerminatedEarly();
        boolean timedOut = searchResponse.isTimedOut();
        
        //分片搜索情况
        int totalShards = searchResponse.getTotalShards();
        int successfulShards = searchResponse.getSuccessfulShards();
        int failedShards = searchResponse.getFailedShards();
        for (ShardSearchFailure failure : searchResponse.getShardFailures()) {
            // failures should be handled here
        }
        
        //处理搜索命中文档结果
        SearchHits hits = searchResponse.getHits();
        
        long totalHits = hits.getTotalHits();
        float maxScore = hits.getMaxScore();
        
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            // do something with the SearchHit
            
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            
            //取_source字段值
            String sourceAsString = hit.getSourceAsString(); //取成json串
            Map sourceAsMap = hit.getSourceAsMap(); // 取成map对象
            //从map中取字段值
            /*
            String documentTitle = (String) sourceAsMap.get("title"); 
            List