Elasticsearch系列(五)----JAVA客户端之TransportClient操作详解

Elasticsearch JAVA操作有三种客户端:

1、TransportClient

2、JestClient

3、RestClient

还有种是2.3中有的NodeClient,在5.5.1中好像没有了。还有种是spring-data-elasticsearch,这里先以TransportClient来讲解CRUD,所用环境为:

JDK1.8

ES5.5.1

TransportClient5.5.1

POM.XML文件如下:

<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 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.fendo</groupId>
  <artifactId>TransportClient</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>TransportClient Maven Webapp</name>
  <url>http://maven.apache.org</url>

   <!-- 初始化框架的版本号 -->
    <properties>
        <spring.version>4.2.7.RELEASE</spring.version>
    </properties>

  <dependencies>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!-- 加入ServletAPI -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>4.2.0.Final</version>
     </dependency>

        <!-- MySQL依赖 start -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>

        <!-- MySQL依赖 end -->


        <!-- 加入MyBatis 依赖 start -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.5</version>
        </dependency>
        <!-- 加入MyBatis 依赖 end -->

        <!-- Log4j start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-1.2-api</artifactId>
            <version>2.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.7</version>
        </dependency>

        <!-- Log4j end -->


        <!-- 引用c3p0 依赖 start-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.2.1</version>
        </dependency>
        <!-- 引用c3p0 依赖 end-->

        <!-- 引用插件依赖：MyBatis整合Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

                <!-- JSTL -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--  -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>



    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.12</version>
    </dependency>



    <!-- Elasticserach5 -->
    <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>5.5.1</version>
        </dependency>


   <!--  <dependency>
            <groupId>org.elasticsearch.module</groupId>
            <artifactId>reindex</artifactId>
            <version>2.4.3</version>
        </dependency> -->


    <dependency>
              <groupId>com.google.collections</groupId>
          <artifactId>google-collections</artifactId>
           <version>1.0</version>
    </dependency>

    <!-- transport客户端 -->
    <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>5.5.1</version>
        </dependency>

    <!-- IK分词器 -->
    <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch-analysis-ik</artifactId>
            <version>5.5.1</version>
        </dependency>



  </dependencies>

  <repositories>
        <repository>
            <id>spring-libs-snapshot</id>
            <name>Spring Snapshot Repository</name>
            <url>http://repo.spring.io/libs-snapshot</url>
        </repository>
        <repository>
            <id>elasticsearch-releases</id>
            <url>https://artifacts.elastic.co/maven</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

  <build>
    <finalName>TransportClient</finalName>
         <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
  </build>
</project>

详细代码如下:

package com.fendo.temp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;

import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest;
import org.elasticsearch.action.admin.indices.analyze.AnalyzeResponse;
import org.elasticsearch.script.Script;
import org.elasticsearch.script.ScriptType;
import org.elasticsearch.index.query.MultiMatchQueryBuilder;
import org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder;
import org.elasticsearch.index.query.MatchPhraseQueryBuilder;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
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.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.sum.Sum;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.elasticsearch.action.bulk.BackoffPolicy;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.unit.TimeValue;

import org.wltea.analyzer.lucene.IKAnalyzer;
import org.joda.time.DateTime;
import org.junit.Before;
import org.junit.Test;

import com.alibaba.fastjson.JSONObject;



public class TransportClientTest {


    private TransportClient client;


    private final static String article="article";
    private final static String content="content";

    @Before
    public void getClient() throws Exception{
        //设置集群名称
        Settings settings = Settings.builder().put("cluster.name", "my-application").build();// 集群名
        //创建client
        client  = new PreBuiltTransportClient(settings)
                .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
    }

    /**
     * -----------------------------------------增(创建索引,增加映射,新增文档)
     */


    /**
     * 创建索引的四种方法
     */

    @Test
    public void JSON(){
        String json = "{" +
                ""id":"kimchy"," +
                ""postDate":"2013-01-30"," +
                ""message":"trying out Elasticsearch"" +
            "}";

    }

    /**
     * 创建索引并添加映射
     * @throws IOException
     */
    @Test
    public void CreateIndexAndMapping() throws Exception{

        CreateIndexRequestBuilder  cib=client.admin().indices().prepareCreate(article);
            XContentBuilder mapping = XContentFactory.jsonBuilder()
                    .startObject()
                        .startObject("properties") //设置之定义字段
                          .startObject("author")
                            .field("type","string") //设置数据类型
                          .endObject()
                          .startObject("title")
                             .field("type","string")
                          .endObject()
                          .startObject("content")
                             .field("type","string")
                          .endObject()
                          .startObject("price")
                             .field("type","string")
                          .endObject()
                          .startObject("view")
                             .field("type","string")
                          .endObject()
                          .startObject("tag")
                             .field("type","string")
                          .endObject()
                          .startObject("date")
                             .field("type","date")  //设置Date类型
                             .field("format","yyyy-MM-dd HH:mm:ss") //设置Date的格式
                          .endObject()
                      .endObject()
                    .endObject();
            cib.addMapping(content, mapping);

            CreateIndexResponse res=cib.execute().actionGet();

            System.out.println("----------添加映射成功----------");
    }

    /**
     *  创建索引并添加文档
     * @throws Exception
     */
    @Test
    public void addIndexAndDocument() throws Exception{

        Date time = new Date();

        IndexResponse response = client.prepareIndex(article, content)
        .setSource(XContentFactory.jsonBuilder().startObject()
        .field("id","447")
        .field("author","fendo")
        .field("title","192.138.1.2")
        .field("content","这是JAVA有关的书籍")
        .field("price","20")
        .field("view","100")
        .field("tag","a,b,c,d,e,f")
        .field("date",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time))
        .endObject())
        .get();
        System.out.println("添加索引成功,版本号："+response.getVersion());
    }


    /**
     * -------------------------------------Bulk---------------------------------
     */


    /**
     * bulkRequest
     * @throws Exception
     */
    @Test
    public void bulkRequest() throws Exception {
        BulkRequestBuilder bulkRequest = client.prepareBulk();

        Date time = new Date();

        // either use client#prepare, or use Requests# to directly build index/delete requests
        bulkRequest.add(client.prepareIndex(article, content, "199")
                .setSource(XContentFactory.jsonBuilder()
                        .startObject()
                        .field("id","199")
                        .field("author","fendo")
                        .field("title","BULK")
                        .field("content","这是BULK有关的书籍")
                        .field("price","40")
                        .field("view","300")
                        .field("tag","a,b,c")
                        .field("date",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time))
                        .endObject()
                )
        );

        bulkRequest.add(client.prepareIndex(article,content, "101")
                .setSource(XContentFactory.jsonBuilder()
                        .startObject()
                        .field("id","101")
                        .field("author","fendo")
                        .field("title","ACKSE")
                        .field("content","这是ACKSE有关的书籍")
                        .field("price","50")
                        .field("view","200")
                        .field("tag","a,b,c")
                        .field("date",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time))
                        .endObject()
                )
        );

        BulkResponse bulkResponse = bulkRequest.get();
        if (bulkResponse.hasFailures()) {
            // process failures by iterating through each bulk response item
            //System.out.println(bulkResponse.getTook());
        }
    }



    /**设置自动提交文档
     * BulkProcessor
     * @throws Exception
     */
    @Test
    public void autoBulkProcessor() throws Exception {

        BulkProcessor bulkProcessor = BulkProcessor.builder(client,
        new BulkProcessor.Listener() {
            @Override
            public void beforeBulk(long executionId,
                                   BulkRequest request) {
                //提交前调用

            }

            @Override
            public void afterBulk(long executionId,
                                  BulkRequest request,
                                  BulkResponse response) {
                //提交结束后调用（无论成功或失败）
                System.out.println( "提交" + response.getItems().length + "个文档，用时"+ response.getTookInMillis() + "MS" + (response.hasFailures() ? " 有文档提交失败！" : ""));

            }

            @Override
            public void afterBulk(long executionId,
                                  BulkRequest request,
                                  Throwable failure) {
                 //提交结束且失败时调用
                 System.out.println( " 有文档提交失败！after failure=" + failure);

            }
        })
        //当请求超过10000个（default=1000）或者总大小超过1GB（default=5MB）时，触发批量提交动作。
        .setBulkActions(10000)//文档数量达到1000时提交
        .setBulkSize(new ByteSizeValue(5, ByteSizeUnit.MB))//总文档体积达到5MB时提交
        .setFlushInterval(TimeValue.timeValueSeconds(5))//每5S提交一次（无论文档数量、体积是否达到阈值）
        .setConcurrentRequests(1)//加1后为可并行的提交请求数，即设为0代表只可1个请求并行，设为1为2个并行
        .setBackoffPolicy(
                BackoffPolicy.exponentialBackoff(TimeValue.timeValueMillis(100), 3))
        .build();

        //提交单个
        //String json = "{"id":"66","author":"ckse","title":"windows编程","content":"windows 32 API编程","price":"99","view":"222","date":"2017-08-01 17:21:18"}";
        //bulkProcessor.add(new IndexRequest("设置的index name", "设置的type name","要插入的文档的ID").source(json));//添加文档，以便自动提交
         for(int i=0;i<80080;i++){
              //业务对象
              String json = "{"id":""+i+"","author":"ckse","title":"windows编程","content":"windows 32 API编程","price":"99","view":"222","date":"2017-08-01 17:21:18"}";
              System.out.println(json);
              bulkProcessor.add(new IndexRequest("article", "content",""+i).source(json));//添加文档，以便自动提交

         }

         System.out.println("创建成功!!!");

    }

    //手动 批量更新
    @Test
    public void multipleBulkProcessor() throws Exception {

         BulkRequestBuilder bulkRequest = client.prepareBulk();
         for(int i=500;i<1000;i++){
              //业务对象
              String jsons = "{"id":""+i+"","author":"ckse","title":"windows编程","content":"windows 32 API编程","price":"99","view":"222","date":"2017-08-01 17:21:18"}";
              IndexRequestBuilder indexRequest = client.prepareIndex("article", "content")
                      //指定不重复的ID
                      .setSource(jsons).setId(String.valueOf(i));
              //添加到builder中
              bulkRequest.add(indexRequest);
         }
         BulkResponse bulkResponse = bulkRequest.execute().actionGet();
         if (bulkResponse.hasFailures()) {
              // process failures by iterating through each bulk response item
              System.out.println(bulkResponse.buildFailureMessage());
         }
         System.out.println("创建成功!!!");
    }

    /**
     * 使用Bulk批量添加导入数据
     *
     */
    @Test
    public void ImportBulk(){
        FileReader fr = null;
        BufferedReader bfr = null;
        String line=null;
        try {
                File file = new File("F:\Source\Elasticsearch\TransportClient\src\main\resources\bulk.txt");
                fr=new FileReader(file);
                bfr=new BufferedReader(fr);
                BulkRequestBuilder bulkRequest=client.prepareBulk();
                int count=0;
                while((line=bfr.readLine())!=null){
                    bulkRequest.add(client.prepareIndex(article,content).setSource(line));
                    if (count%10==0) {
                        bulkRequest.execute().actionGet();
                    }
                    count++;
                }
                bulkRequest.execute().actionGet();
                System.out.println("导入成功!!!");
        } catch (Exception e) {
                e.printStackTrace();
        }finally {
            try {
                bfr.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 使用Bulk批量导出数据
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void ExportBulk() throws Exception{


        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        SearchResponse response = client.prepareSearch("article").setQuery(queryBuilder).get();

        SearchHits resultHits = response.getHits();

        System.out.println(JSONObject.toJSON(resultHits));

        FileWriter fw=null;
        BufferedWriter bfw =null;
        try {
            File file = new File("F:\Source\Elasticsearch\TransportClient\src\main\resources\bulk.txt");
            fw = new FileWriter(article);
            bfw = new BufferedWriter(fw);

            if (resultHits.getHits().length == 0) {
                System.out.println("查到0条数据!");

            } else {
                for (int i = 0; i < resultHits.getHits().length; i++) {
                    String jsonStr = resultHits.getHits()[i]
                            .getSourceAsString();
                    System.out.println(jsonStr);
                    bfw.write(jsonStr);
                    bfw.write("
");
                }
            }
        } catch (Exception e) {
           e.printStackTrace();
        }finally {
            try {
                bfw.close();
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * -----------------------------------------删(删除索引,删除文档)
     */


    /**
     * 删除整个索引库
     */
    @Test
    public void deleteAllIndex(){

        String indexName="article";

        /**
         * 两种方式如下:
         */

        //1)
        //可以根据DeleteIndexResponse对象的isAcknowledged()方法判断删除是否成功,返回值为boolean类型.
        DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(indexName)
                .execute().actionGet();
        System.out.println("是否删除成功:"+dResponse.isAcknowledged());


        //2)
        //如果传人的indexName不存在会出现异常.可以先判断索引是否存在：
        IndicesExistsRequest inExistsRequest = new IndicesExistsRequest(indexName);

        IndicesExistsResponse inExistsResponse = client.admin().indices()
                .exists(inExistsRequest).actionGet();

        //根据IndicesExistsResponse对象的isExists()方法的boolean返回值可以判断索引库是否存在.
        System.out.println("是否删除成功:"+inExistsResponse.isExists());
    }


    /**
     * 通过ID删除
     */
    @Test
    public void deleteById(){
        DeleteResponse dResponse = client.prepareDelete(article,content, "AV49wyfCWmWw7AxKFxeb").execute().actionGet();
        if ("OK".equals(dResponse.status())) {
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败");
        }
    }


    /**
     * 通过Query delete删除
     */
    @Test
    public void queryDelete() {
//         String guid="AV49wyfCWmWw7AxKFxeb";
//         String author="kkkkk";
//         DeleteByQueryAction.INSTANCE.newRequestBuilder(client)
//               .source(article)
//               .filter(QueryBuilders.boolQuery().must(QueryBuilders.termQuery("id", guid)).must(QueryBuilders.termQuery("author", author)).must(QueryBuilders.typeQuery(content)))
//               .get();
    }


    /**
     * 使用matchAllQuery删除所有文档
     */
    @Test
    public void deleteAll(){
//         DeleteByQueryAction.INSTANCE.newRequestBuilder(client)
//           .source(article)
//           .filter(QueryBuilders.matchAllQuery())
//           .get();
    }


    /**
     * bulk批量通过指定id删除方法
     */
    @Test
    public void batchUndercarriageFamilies() {
       List<String> publishIds=new ArrayList<>();
       publishIds.add("AV49wyfCWmWw7AxKFxeY");
       publishIds.add("AV49wyfCWmWw7AxKFxea");
       BulkRequestBuilder builder=client.prepareBulk();
       for(String publishId:publishIds){
          System.out.println(publishId);
          builder.add(client.prepareDelete(article, content, publishId).request());

       }
       BulkResponse bulkResponse = builder.get();
       System.out.println(bulkResponse.status());
    }




    /**
     * -----------------------------------------改()
     */


    /**
     * 更新文档
     * @throws Exception
     */
    @Test
    public void updateDocument() throws Exception{

        Date time = new Date();

        //创建修改请求
        UpdateRequest updateRequest = new UpdateRequest();
        updateRequest.index(article);
        updateRequest.type(content);
        updateRequest.id("AV4xv5gAZLX8AvCc6ZWZ");
        updateRequest.doc(XContentFactory.jsonBuilder()
        .startObject()
        .field("author","FKSE")
        .field("title","JAVA思想")
        .field("content","注意:这是JAVA有关的书籍")
        .field("date",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(time))
        .endObject());

        UpdateResponse response = client.update(updateRequest).get();
        System.out.println("更新索引成功");
    }



    /**
     * -----------------------------有问题：要引入:reindex
     */


    /**
     * UpdateByQueryRequestBuilder
     * @throws Exception
     */
    @Test
    public void updateByQueryRequestBuilder() throws Exception {
//        UpdateByQueryRequestBuilder updateByQueryRequestBuilder = UpdateByQueryAction.INSTANCE.newRequestBuilder(client);
//        updateByQueryRequestBuilder
//                .script(new Script(ScriptType.INLINE,"painless","ctx_source.likes++",null))
//                .source()
//                .setQuery(QueryBuilders.termQuery("author","kkkkk"))
//                .setIndices(article)
//                .get();
    }


    /**
     * updateByQueryRequestBuilders
     */
    @Test
    public void updateByQueryRequestBuilders(){

//      Map<String, Object> maps=new HashMap<>();
//      maps.put("orgin_session_id", 10);
//      maps.put("orgin_session_id", 11);
//      maps.put("orgin_session_id", 12);
//      maps.put("orgin_session_id", 13);
//
//      Set<Map<String, Object>> docs = new HashSet<>();
//      docs.add(maps);
//
//      UpdateByQueryRequestBuilder  ubqrb = UpdateByQueryAction.INSTANCE.newRequestBuilder(client);
//        for (Map<String, Object> doc : docs) {
//            if (doc==null || doc.isEmpty()){
//                return;
//            }
//            Script script = new Script("ctx._source.price = ctx._version");
//
//            System.out.println(doc.get("orgin_session_id"));
//
//            //BulkIndexByScrollResponse
//            BulkByScrollResponse scrollResponse = ubqrb.source(article).script(script)
//                            .filter(QueryBuilders.matchAllQuery()).get();
//            for (BulkItemResponse.Failure failure : scrollResponse.getBulkFailures()) {
//              System.out.println(failure.getMessage());
//            }
//        }
    }

    /**
     * prepareUpdate
     * @throws Exception
     */
    @Test
    public void prepareUpdate() throws Exception {

        XContentBuilder endObject = XContentFactory.jsonBuilder().startObject().field("author","AAAAAAAAAAAAAAA").endObject();
        UpdateResponse response = client.prepareUpdate(article, content, "AV49wyfCWmWw7AxKFxeb").setDoc(endObject).get();
        System.out.println(response.getVersion());

    }


    /**
     * -----------------------------------------查()
     */



    /**
     * 根据index、type、id进行查询
     */
    @Test
    public void searchByIndex(){

        GetResponse response = client.prepareGet(article,content,"AV49wyfCWmWw7AxKFxec").execute()
                .actionGet();
        String json = response.getSourceAsString();
        if (null != json) {
            System.out.println(json);
        } else {
            System.out.println("未查询到任何结果！");
        }
    }


    /**
     * 查询article索引下的所有数据
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-query-dsl-match-all-query.html'>
     * @throws Exception
     */
    @Test
    public  void matchAllQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * 查询article索引下的articledate的所有数据
     * @throws Exception
     */
    @Test
    public void searchmethod1() throws Exception{
        SearchResponse response = client.prepareSearch(article).setTypes(content).get();
        println(response);
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * spanFirstQuery
     */
    @Test
    public void spanFirstQuery(){

         // Span First
        QueryBuilder queryBuilder =QueryBuilders.spanFirstQuery(
                QueryBuilders.spanTermQuery("title", "C"),  // Query
                30000                                             // Max查询范围的结束位置
        );
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * spanNearQuery
     */
    @Test
    public void spanNearQuery(){

        // Span Near TODO NotSolved
        QueryBuilder queryBuilder =QueryBuilders.spanNearQuery(QueryBuilders.spanTermQuery("title", "C"),1000)
                .addClause(QueryBuilders.spanTermQuery("name", "葫芦580娃")) // Span Term Queries
                .addClause(QueryBuilders.spanTermQuery("name", "葫芦3812娃"))
                .addClause(QueryBuilders.spanTermQuery("name", "葫芦7139娃"));
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * spanNotQuery
     */
    @Test
    public void spanNotQuery(){
         // Span Not TODO NotSolved
        QueryBuilder queryBuilder =QueryBuilders.spanNotQuery(QueryBuilders.spanTermQuery("title", "C"), null);
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * spanOrQuery
     */
    @Test
    public void spanOrQuery(){
        QueryBuilder queryBuilder =QueryBuilders.spanOrQuery(QueryBuilders.spanTermQuery("title", "C"));
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }


    public void moreLikeThisQuery(){

    }

     /**
     * 指定单查询条件
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-full-text-queries.html#java-query-dsl-simple-query-string-query'>
     * @throws Exception
     */
    @Test
    public  void matchQuery() throws Exception{
        QueryBuilder qb = QueryBuilders.matchQuery(
                "title" ,
                "C"
            );
        SearchResponse response = client.prepareSearch(article).setQuery(qb).get();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }
    }




    /**
     * termQuery 查询
     * @throws Exception
     */
    @Test
    public void termQuery() throws Exception{

        QueryBuilder queryBuilder = QueryBuilders.termQuery("id","11");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * termQuery 查询
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public  void termsQuerys() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.termsQuery("id","1","2");
        SearchResponse response = client.prepareSearch("article").setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

     /**
     * 范围查询RangeQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public void rangeQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.rangeQuery("price")
                .from(1)
                .to(100)
                .includeLower(false)
                .includeUpper(false);
        // A simplified form using gte, gt, lt or lte
        QueryBuilder _qb = QueryBuilders.rangeQuery("price")
            .gte("10")
            .lt("20");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * multiMatchQuery 查询
     * multiMatchQuery针对的是多个field,当fieldNames有多个参数时，如field1和field2，那查询的结果中，要么field1中包含text，要么field2中包含text。
     */
    @Test
    public void multiMatchQuery(){
        QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery("JAVA编程思想","title", "content");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * MultiMatchQueryBuilder
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-full-text-queries.html#java-query-dsl-simple-query-string-query'>
     * @throws Exception
     */
    @Test
    public void MultiMatchQueryBuilder() throws Exception {
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("JAVA编程思想","title", "content");

        multiMatchQueryBuilder.analyzer("standard");
        multiMatchQueryBuilder.cutoffFrequency(0.001f);
        multiMatchQueryBuilder.field("title",20);
        multiMatchQueryBuilder.fuzziness(Fuzziness.TWO);
        multiMatchQueryBuilder.maxExpansions(100);
        multiMatchQueryBuilder.prefixLength(10);
        multiMatchQueryBuilder.tieBreaker(20);
        multiMatchQueryBuilder.type(MultiMatchQueryBuilder.Type.BEST_FIELDS);
        multiMatchQueryBuilder.boost(20);



       SearchResponse searchResponse =  client.prepareSearch()
                .setIndices(article)
                .setTypes(content)
                .setQuery(multiMatchQueryBuilder)
                .execute()
                .actionGet();

       for (SearchHit  searchHit: searchResponse.getHits()) {
           println(searchHit);
       }
    }


    /**
     * MatchQueryBuilder
     * @throws Exception
     */
    @Test
    public void MatchQueryBuilder() throws Exception {

        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title","JAVA编程思想");
        matchQueryBuilder.fuzziness(Fuzziness.AUTO);
        SearchResponse searchResponse = client.prepareSearch()
                .setIndices(article)
                .setTypes(content)
                .setQuery(matchQueryBuilder)
                .execute()
                .actionGet();
        println(searchResponse);
    }


     /**
     * 和matchQuery一样
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-full-text-queries.html#java-query-dsl-simple-query-string-query'>
     * @throws Exception
     */
    @Test
    public  void commonTermsQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.commonTermsQuery("id",
                "1");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * MultiGetResponse  查询多个xxx的值
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-docs-multi-get.html'>
     * @throws Exception
     */
    @Test
    public void MultiGetResponse() throws Exception {
        MultiGetResponse multiGetItemResponses = client.prepareMultiGet()
                .add(article, content, "526")
                .add(article, content, "572", "582", "613")
                .get();
        for (MultiGetItemResponse itemResponse : multiGetItemResponses) {
            GetResponse response = itemResponse.getResponse();
            if (response.isExists()) {
                String json = response.getSourceAsString();
                System.out.println(json);
            }
        }
    }

    /**
     * +包含 -除外
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-full-text-queries.html#java-query-dsl-simple-query-string-query'>
     * @throws Exception
     */
    @Test
    public void queryStringQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.queryStringQuery("*:*");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * +包含 -除外
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-full-text-queries.html#java-query-dsl-simple-query-string-query'>
     * @throws Exception
     */
    @Test
    public void simpleQueryStringQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.simpleQueryStringQuery("+id:1");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


     /**
     * existsQuery
     * 匹配含有id字段的记录
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public void existsQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.existsQuery("id");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


     /**
     * prefixQuery  匹配包含具有指定前缀的术语的文档的查询
     * 匹配title中前缀为JAVA的记录
     * 匹配分词前缀 如果字段没分词，就匹配整个字段前缀
     * 前缀匹配（比如我要查询的是192.168.1.12，但是当输入192.168、192.168.1、192.168.1.1等的情况都会有相应结果返回，只不过是个范围)
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public void prefixQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.prefixQuery(
                "title",
                "192.138"
            );
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * MatchPhrasePrefixQueryBuilder  为提供的字段名称和文本创建一个类型为“PHRASE_PREFIX”的匹配查询。
     * @throws Exception
     */
    @Test
    public void MatchPhrasePrefixQueryBuilder() throws Exception {
        String key = "C++";
        MatchPhrasePrefixQueryBuilder matchPhrasePrefixQueryBuilder = QueryBuilders.matchPhrasePrefixQuery("title",key);

        matchPhrasePrefixQueryBuilder.boost(10);
        matchPhrasePrefixQueryBuilder.analyzer("standard");
        matchPhrasePrefixQueryBuilder.slop(2);
        matchPhrasePrefixQueryBuilder.maxExpansions(100);

        SearchResponse searchResponse = client.prepareSearch()
                .setIndices(article)
                .setTypes(content)
                .setQuery(matchPhrasePrefixQueryBuilder)
                .execute()
                .actionGet();
        for (SearchHit  searchHit: searchResponse.getHits()) {
            println(searchHit);
        }
    }


    /**
     * wildcardQuery
     * 通配符
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public void wildcardQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("author", "*e");//J?V*
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * fuzzyQuery  使用模糊查询匹配文档的查询
     * @throws Exception
     */
    @Test
    public  void fuzzyQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.fuzzyQuery(
                "author",
                "e"
            );
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * boolQuery 匹配与其他查询的布尔组合匹配的文档的查询。
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-compound-queries.html'>
     * @throws Exception
     */
    @Test
    public void BoostQuery() throws Exception{
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery()
                .should(QueryBuilders.termQuery("author","eeee")).boost(100) //设置此查询的权重。 匹配此查询的文件（除正常权重之外）的得分乘以提供的提升。
                .should(QueryBuilders.termQuery("id","AV5NF_Dbhqf-jFOFkksT").boost(1));

        SearchResponse response=client.prepareSearch("article").setQuery(boolQueryBuilder).execute().get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }

    }


    /**
     * boolQuery
     * @throws Exception
     */
    @Test
    public void boolQuery() throws Exception {
        QueryBuilder qb = QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("author", "eeee"))
                .must(QueryBuilders.termQuery("title", "JAVA思想"))
                .mustNot(QueryBuilders.termQuery("content", "C++")) //添加不得出现在匹配文档中的查询。
                .should(QueryBuilders.termQuery("id", "AV5NF_Dbhqf-jFOFkksT"))//添加应该与返回的文档匹配的子句。 对于具有no的布尔查询,子句必须一个或多个SHOULD子句且必须与文档匹配,用于布尔值查询匹配。 不允许null值。
                .filter(QueryBuilders.termQuery("price", "30.3"));//添加一个查询，必须出现在匹配的文档中，但会不贡献得分。 不允许null值。
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();

        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * boostingQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-compound-queries.html'>
     * @throws Exception
     */
    @Test
    public void boostingQuery() throws Exception {
        QueryBuilder qb = QueryBuilders.boostingQuery(
                QueryBuilders.termQuery("id","AV5NF_Dbhqf-jFOFkksR"),
                QueryBuilders.termQuery("title","C"))
                .negativeBoost(0.2f);//设置负增强因子。
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();

        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }



    /**
     * constantScoreQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-compound-queries.html'>
     * @throws Exception
     */
    @Test
    public void constantScoreQuery() throws Exception {
        QueryBuilder qb = QueryBuilders.constantScoreQuery(
                QueryBuilders.termQuery("title","C")
        ).boost(2.0f);
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * disMaxQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-compound-queries.html'>
     * @throws Exception
     */
    @Test
    public void disMaxQuery() throws Exception {
        QueryBuilder qb = QueryBuilders.disMaxQuery()
                .add(QueryBuilders.termQuery("id", "512"))
                .add(QueryBuilders.termQuery("author", "ckse"))
                .boost(1.2f)
                .tieBreaker(0.7f);
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * functionScoreQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-compound-queries.html'>
     * @throws Exception
     */
    @Test
    public void functionScoreQuery() throws Exception {
        FunctionScoreQueryBuilder.FilterFunctionBuilder[] functions = {
                new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                        QueryBuilders.matchQuery("id", "512"),
                        ScoreFunctionBuilders.randomFunction("ABCDEF")),
                new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                        ScoreFunctionBuilders.exponentialDecayFunction("age", 0L, 1L))
        };
        QueryBuilder qb = QueryBuilders.functionScoreQuery(functions);
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }


    /**
     * regexpQuery 匹配包含具有指定正则表达式的术语的文档的查询。
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public void regexpQuery() throws Exception {
        QueryBuilder qb = QueryBuilders.regexpQuery(
                "title",
                "*J");
        SearchResponse response=client.prepareSearch().setQuery(qb).execute().actionGet();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * typeQuery
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public  void typeQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.typeQuery("data");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * idsQuery
     * 类型是可选的
     * 指定type和id进行查询。
     * <a href='https://www.elastic.co/guide/en/elasticsearch/client/java-api/5.5/java-term-level-queries.html'>
     * @throws Exception
     */
    @Test
    public  void idsQuery() throws Exception{
        QueryBuilder queryBuilder = QueryBuilders.idsQuery(content)
                .addIds("512", "520", "531");
        SearchResponse response = client.prepareSearch(article).setQuery(queryBuilder).get();
        for (SearchHit  searchHit: response.getHits()) {
            println(searchHit);
        }
    }

    /**
     * group 分组查询
     */
    @Test
    public void group(){


    }

    /**
     * Aggregation
     */
    @Test
    public void Aggregation()
    {

        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        //添加时间范围过滤
        boolQueryBuilder.must(QueryBuilders.rangeQuery("@timestamp").format("yyyy-MM-dd HH:mm:ss").gte("").lte(""));
        AggregationBuilder aggregationBuilder = AggregationBuilders
                //terms(查询字段别名).field(分组字段)
                .terms("").field("")
                .order(Terms.Order.aggregation("", false))
                .size(10)
                .subAggregation(AggregationBuilders.count("").field(""));
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch("article").setTypes("articledate")
                .setQuery(boolQueryBuilder)
                .addAggregation(aggregationBuilder)
                .setSize(0);

        SearchResponse sr = searchRequestBuilder.execute().actionGet();
        Terms genders = sr.getAggregations().get("");//统计字段别名
        for (Terms.Bucket entry : genders.getBuckets())
        {
          System.out.println((String) entry.getKey()+"-("+entry.getDocCount()+")");
        }


        //如想group by 时间，并且按天来进行分组
        AggregationBuilder aggregation = AggregationBuilders
                .dateHistogram("agg")
                .field("@timestamp")
                .format("yyyy-MM-dd")
                .dateHistogramInterval(DateHistogramInterval.DAY);
        //可能有新需求，group by 时间，姓名
        //AggregationBuilder nameAgg = AggregationBuilders.terms(姓名别名).field(姓名).size(10);
        //aggregation.subAggregation(nameAgg);

        //可以能需要进行名称统计，但是需要distinct
        //aggregation.subAggregation(AggregationBuilders.cardinality(别名).field(姓名))

        //其他如下
//        （1）统计某个字段的数量
//        ValueCountBuilder vcb=  AggregationBuilders.count("count_uid").field("uid");
//      （2）去重统计某个字段的数量（有少量误差）
//       CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
//      （3）聚合过滤
//      FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
//      （4）按某个字段分组
//      TermsBuilder tb=  AggregationBuilders.terms("group_name").field("name");
//      （5）求和
//      SumBuilder  sumBuilder= AggregationBuilders.sum("sum_price").field("price");
//      （6）求平均
//      AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
//      （7）求最大值
//      MaxBuilder mb= AggregationBuilders.max("max_price").field("price");
//      （8）求最小值
//      MinBuilder min= AggregationBuilders.min("min_price").field("price");
//      （9）按日期间隔分组
//      DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
//      （10）获取聚合里面的结果
//      TopHitsBuilder thb=  AggregationBuilders.topHits("top_result");
//      （11）嵌套的聚合
//      NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
//      （12）反转嵌套
//      AggregationBuilders.reverseNested("res_negsted").path("kps ");


    }


    /**
     * MultiSearchResponse 多字段检索
     */
    @Test
    public void MultiSearchResponse(){


        SearchRequestBuilder srb1 = client.prepareSearch().setQuery(QueryBuilders.queryStringQuery("JAVA"));
        SearchRequestBuilder srb2 = client.prepareSearch().setQuery(QueryBuilders.matchQuery("title", "C"));

        MultiSearchResponse sr = client.prepareMultiSearch().add(srb1).add(srb2).get();

        for (MultiSearchResponse.Item item : sr.getResponses()) {
            SearchResponse response = item.getResponse();
            for (SearchHit searchHit : response.getHits()) {
                println(searchHit);
            }
        }
    }




    /**
     * 复杂查询
     */
    @Test
    public void complexSearch1(){
        int page=1;
        int pageSize=10;
        String keyword="";

        BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();

        if(keyword!=null&&!keyword.equals("")){
           QueryBuilder nameBuilder=QueryBuilders.matchQuery("zuName", keyword).analyzer("ik_max_word").boost(10);
           QueryBuilder labelBuilder=QueryBuilders.matchQuery("zuLabelName", keyword).analyzer("ik_max_word").boost(10);
           QueryBuilder categoryBuilder=QueryBuilders.matchQuery("categoryName", keyword).analyzer("ik_max_word").boost(10);
           boolQueryBuilder.should(nameBuilder).should(labelBuilder).should(categoryBuilder);
        }else{
           boolQueryBuilder.must(QueryBuilders.matchAllQuery());
        }
        SearchResponse response=client.prepareSearch("article").setTypes("articledate")
              .setQuery(boolQueryBuilder)
              .setFrom((page-1)*pageSize).setSize(pageSize)
              .setExplain(true)
              .get();

        SearchHits hits=response.getHits();
    }

    /**
     * 复杂查询2
     */
    @Test
    public void complexSearch2(){

        String relatedValue="fendo";
        String userId="1234";
        int page=1;
        int pageSize=10;

        BoolQueryBuilder builders=new BoolQueryBuilder();
        //加上条件
        builders.must(QueryBuilders.termQuery("userId", userId));
        if(relatedValue=="fendo"){
           builders.must(QueryBuilders.nestedQuery("related4ZuValue",
                 QueryBuilders.boolQuery()
                          .must(QueryBuilders.termQuery("related4ZuValue.nameValue", ""))
                          //.must(QueryBuilders.rangeQuery("endTime").lte(LongformStringDate(System.currentTimeMillis())))
                 ,ScoreMode.None));
        }else{
           builders.must(QueryBuilders.nestedQuery("related4ZuValue", QueryBuilders.termQuery("related4ZuValue.nameValue", ""),
                 ScoreMode.None));
        }
        SearchResponse response=client.prepareSearch("article").setTypes("articledate")
              .setQuery(builders).setFrom((page-1)*pageSize)
              .setSize(pageSize)
              .get();
        SearchHits hits=response.getHits();
    }


    /**
     * 取查询结果总和count
     */
    @Test
    public void countSum() {

           int relatedValue=1;
           String userId="111";
           BoolQueryBuilder builders=new BoolQueryBuilder();
           builders.must(QueryBuilders.termQuery("userId", userId));
           if(relatedValue==1){
               builders.must(QueryBuilders.nestedQuery("related4ZuValue",QueryBuilders.boolQuery()
                         .must(QueryBuilders.termQuery("related4ZuValue.nameValue", "123"))
                         .must(QueryBuilders.rangeQuery("endTime").lte(""))
                ,ScoreMode.None));

           }else{
              builders.must(QueryBuilders.nestedQuery("related4ZuValue", QueryBuilders.termQuery("related4ZuValue.nameValue", "111"),
                    ScoreMode.None));
           }
           SearchResponse response=client.prepareSearch("article").setTypes("articledate")
                 .setQuery(builders)
                 .setSize(1)
                 .get();
           SearchHits hits=response.getHits();
           System.out.println(hits.getTotalHits());
        }



    /**
     * 聚合求和sum
     * @param keyword
     * @param startTime
     * @param endTime
     */
    @Test
    public void getPlatformZuOrdersTotalAmount() {

           String keyword="";
           String startTime="";
           String endTime="";

           BoolQueryBuilder boolQueryBuilder=QueryBuilders.boolQuery();
           if(keyword==null||keyword.equals("")){
              QueryBuilder queryBuilder=QueryBuilders.matchAllQuery();
              boolQueryBuilder.must(queryBuilder);
           }else{
              QueryBuilder zuNameBuilder=QueryBuilders.matchQuery("zuName", keyword);
              QueryBuilder buyerNameBuilder=QueryBuilders.matchQuery("buyerName", keyword);
              QueryBuilder sellerNameBuilder=QueryBuilders.matchQuery("sellerName", keyword);
              boolQueryBuilder.should(zuNameBuilder).should(buyerNameBuilder).should(sellerNameBuilder);

           }
           if(!startTime.equals("")){
              QueryBuilder addTimeBuilder=QueryBuilders.rangeQuery("addTime").from(startTime).to(endTime);
              boolQueryBuilder.must(addTimeBuilder);
           }
           SearchResponse response=client.prepareSearch("article").setTypes("articledate")
                 .setQuery(boolQueryBuilder)
                 .addAggregation(AggregationBuilders.sum("price").field("price"))
                 .get();
           Sum sum=response.getAggregations().get("price");
           System.out.println(sum.getValue());
        }


    /**
     * ---------------------------分页
     */


    /**
     * 使用Scroll方法分页
     */
    @Test
    public void queryPageScroll(){

        QueryBuilder qb = QueryBuilders.termQuery("id", "1");

        SearchResponse scrollResp = client.prepareSearch("article")
                .addSort(FieldSortBuilder.DOC_FIELD_NAME, SortOrder.ASC)
                .setScroll(new TimeValue(60000))
                .setQuery(qb)
                .setSize(1).get();
        do {
            for (SearchHit hit : scrollResp.getHits().getHits()) {
                println(hit);
            }
            scrollResp = client.prepareSearchScroll(scrollResp.getScrollId()).setScroll(new TimeValue(60000)).execute().actionGet();
        } while(scrollResp.getHits().getHits().length != 0);
    }


    /**
     * 分页
     * @throws Exception
     */
    @Test
    public void fenye() throws Exception {

        SearchResponse response = client.prepareSearch("article")
                .setQuery(QueryBuilders.matchAllQuery())
                .setFrom(10)
                .setSize(20)
                .execute().actionGet();
        for (SearchHit searchHit : response.getHits()) {
            println(searchHit);
        }

    }


    /**
     * 高亮
     * @throws Exception
     */
    @Test
    public void highlighter() throws Exception{


         QueryBuilder matchQuery = QueryBuilders.matchQuery("author", "fendo");
            HighlightBuilder hiBuilder=new HighlightBuilder();
            hiBuilder.preTags("<h2>");
            hiBuilder.postTags("</h2>");
            hiBuilder.field("author");
            // 搜索数据
            SearchResponse response = client.prepareSearch("article")
                    .setQuery(matchQuery)
                    .highlighter(hiBuilder)
                    .execute().actionGet();
            for (SearchHit searchHit : response.getHits()) {
                println(searchHit);
            }
    }





    /**
     * ---------------------------分词器
     */

    /**
     * AnalyzeRequest 分词器
     * <a href='https://www.elastic.co/guide/cn/elasticsearch/guide/current/standard-tokenizer.html'>
     * @throws Exception
     */
    @Test
    public void AnalyzeRequest() throws Exception {
        AnalyzeRequest analyzeRequest = new AnalyzeRequest();
        analyzeRequest.text("My œsophagus caused a débâcle");
        /**
         * whitespace （空白字符）分词器按空白字符 —— 空格、tabs、换行符等等进行简单拆分
         * letter 分词器 ，采用另外一种策略，按照任何非字符进行拆分
         * standard 分词器使用 Unicode 文本分割算法
         */
        analyzeRequest.addTokenFilter("standard");
        analyzeRequest.addCharFilter("asciifolding");
        ActionFuture<AnalyzeResponse> analyzeResponseActionFuture =  client.admin().indices().analyze(analyzeRequest);
        List<AnalyzeResponse.AnalyzeToken> analyzeTokens =  analyzeResponseActionFuture.actionGet().getTokens();
        for (AnalyzeResponse.AnalyzeToken analyzeToken : analyzeTokens){
            System.out.println(analyzeToken.getTerm());
        }
    }

    /**
     * IK分词器
     * @param args
     * @throws IOException
     */
    public  void IKAnalyzer(String []args) throws IOException {
        Settings settings  = Settings.EMPTY;
        IKAnalyzer analyzer = new IKAnalyzer();
        String text = "中华人民共和国国歌";
        StringReader stringReader = new StringReader(text);
        TokenStream tokenStream = analyzer.tokenStream("",stringReader);
        tokenStream.reset();
        CharTermAttribute term=tokenStream.getAttribute(CharTermAttribute.class);
        while(tokenStream.incrementToken()){
            System.out.print(term.toString()+"—");
        }
        stringReader.close();
        tokenStream.close();
    }

    /**
     * 输出结果SearchResponse
     * @param response
     */
    public static void println(SearchResponse response){
        System.err.println("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-");
        System.err.println(
                "getFailedShards : " + response.getFailedShards() + "
" +
                "getNumReducePhases : " + response.getNumReducePhases() + "
" +
                "getScrollId : " + response.getScrollId() +  "
" +
                "getTookInMillis : " + response.getTookInMillis() + "
" +
                "getTotalShards : " + response.getTotalShards() +  "
" +
                "getAggregations : " + response.getAggregations() + "
" +
                "getProfileResults : " + response.getProfileResults() + "
" +
                "getShardFailures : " + response.getShardFailures() + "
" +
                "getSuggest : " + response.getSuggest() + "
" +
                "getTook : " + response.getTook() + "
" +
                "isTerminatedEarly : " + response.isTerminatedEarly() + "
" +
                "isTimedOut : " + response.isTimedOut() + "
" +
                "remoteAddress : " + response.remoteAddress() + "
" +
                "status : " + response.status() + "
" +
                "getHits : " + response.getHits()
                );
    }

    /**
     * 输出结果SearchResponse
     * @param response
     */
    public static void println(SearchHit searchHit){
        System.err.println("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-");
        System.err.println(
                "docId : " + searchHit.docId() + "
" +
                "getId : " + searchHit.getId() + "
" +
                "getIndex : " + searchHit.getIndex()+ "
" +
                "getScore : " + searchHit.getScore() + "
" +
                "getSourceAsString : " + searchHit.getSourceAsString() + "
" +
                "getType : " + searchHit.getType() + "
" +
                "getVersion : " + searchHit.getVersion() + "
" +
                "fieldsOrNull : " + searchHit.fieldsOrNull() + "
" +
                "getExplanation : " + searchHit.getExplanation() + "
" +
                "getFields : " + searchHit.getFields() + "
" +
                "highlightFields : " + searchHit.highlightFields() + "
" +
                "hasSource : " + searchHit.hasSource()
                );
    }


}

完整项目如下:http://download.csdn.net/download/u011781521/9964499