ElasticSearch Java API

<dependencies>
        <!-- es的客户端-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>6.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <!-- 依赖2.x的log4j -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

一、基础 CRUD（增删改查）

1、TransportClient  client进行crud

package com.xin;

import com.alibaba.fastjson.JSONObject;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ElasticSearchDemo1 {
    private final static String host1 = "hdp-1";
    private final static String host2 = "hdp-2";
    private final static String host3 = "hdp-3";
    private final static int PORT = 9300;
    private static TransportClient client;


    //初始化创建连接
    @Before
    public void init(){
        //设置集群名称
        Settings settings = Settings.builder().put("cluster.name", "my-application").build();

        try {
            client = new PreBuiltTransportClient(settings).addTransportAddresses(
                    new TransportAddress(InetAddress.getByName(host1),PORT),
                    new TransportAddress(InetAddress.getByName(host2),PORT),
                    new TransportAddress(InetAddress.getByName(host3),PORT)
            );
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }


    //关闭资源
    @After
    public void destory(){
        if(client != null){
            client.close();
        }
    }

    /**
     * testIndex:(创建索引).
     */
    @Test
    public void testCreateIndex() throws IOException {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("orderNo", new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + "001");
        jsonObject.put("orderName", "购买元宝");
        jsonObject.put("orderTime", new Date());
        jsonObject.put("price", 1.5);
        jsonObject.put("ip", "192.168.1.111");

        IndexResponse response = client.prepareIndex("rxpay", "order").setSource(jsonObject.toString(), XContentType.JSON).get();
        System.out.println("索引名称：" + response.getIndex());
        System.out.println("类型：" + response.getType());
        System.out.println("文档ID：" + response.getId()); // 没有设置会默认一串字符
        System.out.println("当前实例状态：" + response.status());
    }

    /**
     * testQuery:(查询).
     */
    @Test
    public void testQuery() {
        try {
            GetResponse response = client.prepareGet("rxpay", "order", "WDg5P24BNuS3PnMJEbV_").execute().actionGet();
            System.out.println(response.getSourceAsString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * testUpdate:(更新).
     */
    @Test
    public void testUpdate() {
        JSONObject json = new JSONObject();
//        json.put("user", "Joe");
//        json.put("age", "22");
//        json.put("sex", "男");
//        json.put("orderTime", "6666666");
        //原有字段会覆盖。没有的会追加在原来数据上
        json.put("orderName","元宝");
        UpdateResponse response = client.prepareUpdate("rxpay", "order", "WDg5P24BNuS3PnMJEbV_")
                .setDoc(json.toJSONString(), XContentType.JSON).get();

        System.out.println("索引名称：" + response.getIndex());
        System.out.println("类型：" + response.getType());
        System.out.println("文档ID：" + response.getId());
        System.out.println("当前实例状态：" + response.status());
    }

    /**
     * testDelete:(删除).
     */
    @Test
    public void testDelete() {
        DeleteResponse response = client.prepareDelete("rxpay", "order", "6W2QKmMBhrIcTC9dgt7A").get();
        System.out.println("索引名称：" + response.getIndex());
        System.out.println("类型：" + response.getType());
        System.out.println("文档ID：" + response.getId());
        System.out.println("当前实例状态：" + response.status());
    }
}

2、TransportClient  client.admin().indices 方法进行crud

package com.xin;

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.client.AdminClient;
import org.elasticsearch.client.IndicesAdminClient;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.net.InetAddress;
import java.util.HashMap;

public class AdminAPI {

    private TransportClient client = null;

    //在所有的测试方法之前执行
    @Before
    public void init() throws Exception {
        //设置集群名称
        Settings settings = Settings.builder().put("cluster.name", "my-application").build();
        //创建client
        client = new PreBuiltTransportClient(settings).addTransportAddresses(
                new TransportAddress(InetAddress.getByName("hdp-1"), 9300),
                new TransportAddress(InetAddress.getByName("hdp-2"), 9300),
                new TransportAddress(InetAddress.getByName("hdp-3"), 9300));
    }

    //创建索引，并配置一些参数
    @Test
    public void createIndexWithSettings() {
        //获取Admin的API
        AdminClient admin = client.admin();
        //使用Admin API对索引进行操作
        IndicesAdminClient indices = admin.indices();
        //准备创建索引
        indices.prepareCreate("adminindex")
                //配置索引参数
                .setSettings(
                        //参数配置器
                        Settings.builder()//指定索引分区的数量
                        .put("index.number_of_shards", 4)
                                //指定索引副本的数量（注意：不包括本身，如果设置数据存储副本为2，实际上数据存储了3份）
                        .put("index.number_of_replicas", 2)
                )
                //真正执行
                .get();
    }

    //跟索引添加mapping信息（给表添加schema信息）
    @Test
    public void putMapping() {
        //创建索引
        client.admin().indices().prepareCreate("twitter")
                //创建一个type，并指定type中属性的名字和类型
                .addMapping("tweet",
                        "{\n" +
                                "    \"tweet\": {\n" +
                                "      \"properties\": {\n" +
                                "        \"message\": {\n" +
                                "          \"type\": \"string\"\n" +
                                "        }\n" +
                                "      }\n" +
                                "    }\n" +
                                "  }")
                .get();
    }

    /**
     * 你可以通过dynamic设置来控制这一行为，它能够接受以下的选项：
     * true：默认值。动态添加字段
     * false：忽略新字段
     * strict：如果碰到陌生字段，抛出异常
     * @throws IOException
     */
    @Test
    public void testSettingsMappings() throws IOException {
        //1:settings
        HashMap<String, Object> settings_map = new HashMap<String, Object>(2);
        settings_map.put("number_of_shards", 3);
        settings_map.put("number_of_replicas", 2);

        //2:mappings（映射、schema）
        XContentBuilder builder = XContentFactory.jsonBuilder()
                .startObject()
                    .field("dynamic", "true")
                    //设置type中的属性
                    .startObject("properties")
                        //id属性
                        .startObject("num")
                            //类型是integer
                            .field("type", "integer")
                            //不分词，但是建索引
                            .field("index", "not_analyzed")
                            //在文档中存储
                            .field("store", "yes")
                        .endObject()
                        //name属性
                        .startObject("name")
                            //string类型
                            .field("type", "string")
                            //在文档中存储
                            .field("store", "yes")
                            //建立索引
                            .field("index", "analyzed")
                            //使用ik_smart进行分词
                            .field("analyzer", "ik_smart")
                        .endObject()
                    .endObject()
                .endObject();

        CreateIndexRequestBuilder prepareCreate = client.admin().indices().prepareCreate("user_info");
        //管理索引（user_info）然后关联type（user）
        prepareCreate.setSettings(settings_map).addMapping("user", builder).get();
    }

    /**
     * XContentBuilder mapping = jsonBuilder()
     .startObject()
     .startObject("productIndex")
     .startObject("properties")
     .startObject("title").field("type", "string").field("store", "yes").endObject()
     .startObject("description").field("type", "string").field("index", "not_analyzed").endObject()
     .startObject("price").field("type", "double").endObject()
     .startObject("onSale").field("type", "boolean").endObject()
     .startObject("type").field("type", "integer").endObject()
     .startObject("createDate").field("type", "date").endObject()
     .endObject()
     .endObject()
     .endObject();
     PutMappingRequest mappingRequest = Requests.putMappingRequest("productIndex").type("productIndex").source(mapping);
     client.admin().indices().putMapping(mappingRequest).actionGet();
     */


    /**
     * index这个属性，no代表不建索引
     * not_analyzed，建索引不分词
     * analyzed 即分词，又建立索引
     * expected [no], [not_analyzed] or [analyzed]
     * @throws IOException
     */

    @Test
    public void testSettingsPlayerMappings() throws IOException {
        //1:settings
        HashMap<String, Object> settings_map = new HashMap<String, Object>(2);
        settings_map.put("number_of_shards", 3);
        settings_map.put("number_of_replicas", 1);

        //2:mappings
        XContentBuilder builder = XContentFactory.jsonBuilder()
                .startObject()//
                    .field("dynamic", "true")
                    .startObject("properties")
                        .startObject("id")
                            .field("type", "integer")
                            .field("store", "yes")
                        .endObject()
                        .startObject("name")
                            .field("type", "string")
                            .field("index", "not_analyzed")
                        .endObject()
                        .startObject("age")
                            .field("type", "integer")
                        .endObject()
                        .startObject("salary")
                            .field("type", "integer")
                        .endObject()
                        .startObject("team")
                            .field("type", "string")
                            .field("index", "not_analyzed")
                        .endObject()
                        .startObject("position")
                            .field("type", "string")
                            .field("index", "not_analyzed")
                        .endObject()
                        .startObject("description")
                            .field("type", "string")
                            .field("store", "no")
                            .field("index", "analyzed")
                            .field("analyzer", "ik_smart")
                        .endObject()
                        .startObject("addr")
                            .field("type", "string")
                            .field("store", "yes")
                            .field("index", "analyzed")
                            .field("analyzer", "ik_smart")
                        .endObject()
                    .endObject()
                .endObject();

        CreateIndexRequestBuilder prepareCreate = client.admin().indices().prepareCreate("player_info");
        prepareCreate.setSettings(settings_map).addMapping("player", builder).get();

    }
}

二、封装工具类

 
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.client.IndicesAdminClient;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import java.net.InetAddress;
import java.net.UnknownHostException;
 
public class ESUtil {
    //集群名,默认值elasticsearch
    private static final String CLUSTER_NAME = "elasticsearch";
    //ES集群中某个节点
    private static final String HOSTNAME = "node1";
    //连接端口号
    private static final int TCP_PORT = 9300;
    //构建Settings对象
    private static Settings settings = Settings.builder().put("cluster.name", CLUSTER_NAME).build();
    //TransportClient对象，用于连接ES集群
    private static volatile TransportClient client;
 
    /**
     * 同步synchronized(*.class)代码块的作用和synchronized static方法作用一样,
     * 对当前对应的*.class进行持锁,static方法和.class一样都是锁的该类本身,同一个监听器
     * @return
     * @throws UnknownHostException
     */
    public static TransportClient getClient(){
        if(client==null){
            synchronized (TransportClient.class){
                try {
                    client=new PreBuiltTransportClient(settings)
                        .addTransportAddress(new TransportAddress(InetAddress.getByName(HOSTNAME), TCP_PORT));
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                }
            }
        }
        return client;
    }
 
    /**
     * 获取索引管理的IndicesAdminClient
     */
    public static IndicesAdminClient getAdminClient() {
        return getClient().admin().indices();
    }
 
    /**
     * 判定索引是否存在
     * @param indexName
     * @return
     */
    public static boolean isExists(String indexName){
        IndicesExistsResponse response=getAdminClient().prepareExists(indexName).get();
        return response.isExists()?true:false;
    }
    /**
     * 创建索引
     * @param indexName
     * @return
     */
    public static boolean createIndex(String indexName){
        CreateIndexResponse createIndexResponse = getAdminClient()
                .prepareCreate(indexName.toLowerCase())
                .get();
        return createIndexResponse.isAcknowledged()?true:false;
    }
 
    /**
     * 创建索引
     * @param indexName 索引名
     * @param shards   分片数
     * @param replicas  副本数
     * @return
     */
    public static boolean createIndex(String indexName, int shards, int replicas) {
        Settings settings = Settings.builder()
                .put("index.number_of_shards", shards)
                .put("index.number_of_replicas", replicas)
                .build();
        CreateIndexResponse createIndexResponse = getAdminClient()
                .prepareCreate(indexName.toLowerCase())
                .setSettings(settings)
                .execute().actionGet();
        return createIndexResponse.isAcknowledged()?true:false;
    }
 
    /**
     * 位索引indexName设置mapping
     * @param indexName
     * @param typeName
     * @param mapping
     */
    public static void setMapping(String indexName, String typeName, String mapping) {
        getAdminClient().preparePutMapping(indexName)
                .setType(typeName)
                .setSource(mapping, XContentType.JSON)
                .get();
    }
 
    /**
     * 删除索引
     * @param indexName
     * @return
     */
    public static boolean deleteIndex(String indexName) {
        DeleteIndexResponse deleteResponse = getAdminClient()
                .prepareDelete(indexName.toLowerCase())
                .execute()
                .actionGet();
        return deleteResponse.isAcknowledged()?true:false;
    }
}

测试类

 
import cn.hadron.es.*;
import org.elasticsearch.common.xcontent.XContentBuilder;
 
import java.io.IOException;
 
import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
public class ESUtilDemo {
    public static void main(String[] args) {
        //1.判定索引是否存在
        boolean flag=ESUtil.isExists("index1");
        System.out.println("isExists:"+flag);
        //2.创建索引
        flag=ESUtil.createIndex("index1", 3, 0);
        System.out.println("createIndex:"+flag);
        //3.设置Mapping
        try {
            XContentBuilder builder = jsonBuilder()
                    .startObject()
                    .startObject("properties")
                    .startObject("id")
                    .field("type", "long")
                    .endObject()
                    .startObject("title")
                    .field("type", "text")
                    .field("analyzer", "ik_max_word")
                    .field("search_analyzer", "ik_max_word")
                    .field("boost", 2)
                    .endObject()
                    .startObject("content")
                    .field("type", "text")
                    .field("analyzer", "ik_max_word")
                    .field("search_analyzer", "ik_max_word")
                    .endObject()
                    .startObject("postdate")
                    .field("type", "date")
                    .field("format", "yyyy-MM-dd HH:mm:ss")
                    .endObject()
                    .startObject("url")
                    .field("type", "keyword")
                    .endObject()
                    .endObject()
                    .endObject();
            System.out.println(builder.string());
            ESUtil.setMapping("index1", "blog", builder.string());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

三、批量处理

package com.xin.own;

import org.elasticsearch.action.bulk.*;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Iterator;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

/**
 *批量操作
 */
public class MyEScrud {
    private final static String host1 = "hdp-1";
    private final static String host2 = "hdp-2";
    private final static String host3 = "hdp-3";
    private final static int PORT = 9300;
    private static TransportClient client = null;
    private static Settings settings = Settings.builder().put("cluster.name", "my-application").build();

    @Before
    public void init(){
        try {
            client = new PreBuiltTransportClient(settings).addTransportAddresses(
                    new TransportAddress(InetAddress.getByName(host1), PORT),
                    new TransportAddress(InetAddress.getByName(host2), PORT),
                    new TransportAddress(InetAddress.getByName(host3), PORT)
            );
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

    /**
     * 批量查询
     */
    @Test
    public void multiSearch(){
        MultiGetResponse response = client.prepareMultiGet()
                .add("poem", "text", "2")                       //要查询的第一个索引/类型/id
                .add("my-index", "persion", "2", "3", "4")    //id可以传递多个
                .get();                                                       //执行
//        for(MultiGetItemResponse res : response){      //注意MultiGetItemResponse与MultiGetResponse不同
//            GetResponse rs = res.getResponse();
//            if(rs !=null && rs.isExists()){
//                System.out.println(rs.getSourceAsString());
//            }
//        }
        //iterator遍历器
        Iterator<MultiGetItemResponse> iterator = response.iterator();
        while(iterator.hasNext()){
            MultiGetItemResponse next = iterator.next();
            GetResponse rs = next.getResponse();
            System.out.println(rs.getSourceAsString());    //rs.toString()
        }
    }

    /**
     * 批量添加一
     */
    @Test
    public void multiPut() throws IOException {

        BulkRequestBuilder bulk = client.prepareBulk();
        bulk.add(client.prepareIndex("poem","text","5")
                .setSource(jsonBuilder()         //注意是jsonBuilder()，直接调用，不是new对象
                        .startObject()
                        .field("title","行路难")
                        .field("num","5")
                        .field("author","libai")
                        .endObject()
                ));
        bulk.add(client.prepareIndex("poem","text","6")
                .setSource(jsonBuilder()
                        .startObject()
                        .field("title","蜀道难")
                        .field("num","5")
                        .field("author","libai2")
                        .endObject()
                ));

        //批量执行
        BulkResponse bulkItemResponses = bulk.get();
        System.out.println(bulkItemResponses.status());
        if(bulkItemResponses.hasFailures()){
            System.out.println("部分节点插入失败");
        }
    }

    /**
     * 批量添加方法二
     */
    @Test
    public void testBulk() throws IOException {
        //数据1
        XContentBuilder xContentBuilder = XContentFactory.jsonBuilder();
        XContentBuilder xcb = xContentBuilder.startObject();
        xcb.field("title", "梅花");
        xcb.field("num", "30");
        xcb.field("author", "nan");
        xContentBuilder.endObject();
        IndexRequestBuilder indexRequestBuilder = client.prepareIndex("poem", "text", "7");
        IndexRequestBuilder source1 = indexRequestBuilder.setSource(xcb);

        //数据2
        XContentBuilder xContentBuilder2 = XContentFactory.jsonBuilder();
        XContentBuilder xcb2 = xContentBuilder2.startObject();
        xcb2.field("title", "梅花2");
        xcb2.field("num", "32");
        xcb2.field("author", "nan2");
        xContentBuilder2.endObject();
        IndexRequestBuilder indexRequestBuilder2 = client.prepareIndex("poem", "text", "8");
        IndexRequestBuilder source2 = indexRequestBuilder2.setSource(xcb2);


//        System.out.println(source);

        BulkRequestBuilder bulkRequestBuilder = client.prepareBulk();

        bulkRequestBuilder.add(source1);
        bulkRequestBuilder.add(source2);

        BulkResponse bulkItemResponses = bulkRequestBuilder.get();
    }

    /**
     * Bulk Processor（批量处理器）
BulkProcessor类提供了一个简单接口，可以根据请求的数量或大小自动刷新批量操作，也可以在给定的时间段之后自动刷新批量操作。
     */
    @Test
    public void testBulkProcessor() {
        BulkProcessor bulkProcessor = BulkProcessor.builder(
                client,
                new BulkProcessor.Listener() {
                    public void beforeBulk(long executionId, BulkRequest request) {
                        //设置bulk批处理的预备工作
                        System.out.println("请求数:" + request.numberOfActions());
                    }

                    public void afterBulk(long executionId, BulkRequest request, BulkResponse response) {
                        //设置bulk批处理的善后工作
                        if (!response.hasFailures()) {
                            System.out.println("执行成功！");
                        } else {
                            System.out.println("执行失败！");
                        }
                    }

                    public void afterBulk(long executionId, BulkRequest request, Throwable failure) {
                        //设置bulk批处理的异常处理工作
                        System.out.println(failure);
                    }
                })
                .setBulkActions(1000)//设置提交批处理操作的请求阀值数
                .setBulkSize(new ByteSizeValue(5, ByteSizeUnit.MB))//设置提交批处理操作的请求大小阀值
                .setFlushInterval(TimeValue.timeValueSeconds(5))//设置刷新索引时间间隔
                .setConcurrentRequests(1)//设置并发处理线程个数
                //设置回滚策略，等待时间100ms,retry次数为3次
                .setBackoffPolicy(BackoffPolicy.exponentialBackoff(TimeValue.timeValueMillis(100), 3))
                .build();
        // 添加你的请求  删除id 2 4的文档
        bulkProcessor.add(new DeleteRequest("poem", "text", "2"));
        bulkProcessor.add(new DeleteRequest("poem", "text", "4"));
        // 刷新所有请求
        bulkProcessor.flush();
        // 关闭bulkProcessor
        bulkProcessor.close();
        // 刷新索引
        client.admin().indices().prepareRefresh().get();
        // Now you can start searching!
        client.prepareSearch().get();
    }
    /**
     * 查询删除
     */
    @Test
    public void testDeleteByQuery() {
        BulkByScrollResponse response = DeleteByQueryAction.INSTANCE
                .newRequestBuilder(client)
                .filter(QueryBuilders.matchQuery("title", "静夜"))  //只要包含 静夜都会删除                .source("poem")//设置索引名称
                .get();
        //被删除文档数目
        long deleted = response.getDeleted();
        System.out.println(deleted);
    }

    @After
    public void destory(){
        if(client != null){
            client.close();
        }
    }
}

四、Match All 全文检索（封装）

Elasticsearch以类似于REST Query DSL的方式提供完整的Java查询dsl。 查询构建器的工厂是QueryBuilders。 一旦您的查询准备就绪，您可以使用搜索API

   /**
     * matchAll
     */
    @Test
    public void testMatchAll(){
        //构造查询对象
        QueryBuilder query= QueryBuilders.matchAllQuery();
        //搜索结果存入SearchResponse
        SearchResponse response=client.prepareSearch("poem"，"my-index")  //可查多个索引
                .setQuery(query) //设置查询器
                .setSize(3)      //一次查询文档数
                .get();
        SearchHits hits=response.getHits();     //hit匹配记录，即满足条件的数据
        for(SearchHit hit:hits){
            System.out.println("source:"+hit.getSourceAsString());
            System.out.println("index:"+hit.getIndex());
            System.out.println("type:"+hit.getType());
            System.out.println("id:"+hit.getId());
            //遍历文档的每个字段
            Map<String,Object> map=hit.getSourceAsMap();
            for(String key:map.keySet()){
                System.out.println(key+"="+map.get(key));
            }
            System.out.println("--------------------");
        }
    }

2 全文检索

公共查询类

import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;

import java.util.Map;

public class QueryUtil {
    private String index="my-index";
    private int size=3;
    private SearchHits hits;
    private TransportClient client = ESUtil.getClient();

    public QueryUtil(String index,int size){
        this.index=index;
        this.size=size;
    }

    public QueryUtil query(QueryBuilder query){
        //搜索结果存入SearchResponse
        SearchResponse response=client.prepareSearch(index)
                .setQuery(query) //设置查询器
                .setSize(size)      //一次查询文档数
                .get();
        this.hits=response.getHits();
        return this;
    }

    public void print(){
        if(hits==null){
            return ;
        }
        for(SearchHit hit:hits){
            System.out.println("source:"+hit.getSourceAsString()); //包括index,id,type
            System.out.println("index:"+hit.getIndex());
            System.out.println("type:"+hit.getType());
            System.out.println("id:"+hit.getId());
            //遍历文档的每个字段
            Map<String,Object> map=hit.getSourceAsMap();   //不用指定字段名字，全部遍历
            for(String key:map.keySet()){
                System.out.println(key+"="+map.get(key));
            }
        }
    }
}

查询实例    只要包含 查询条件 中任意一个字（分词器具体定）就被选中

 @Test
    public void testFullTestQuery(){
        QueryUtil util=new QueryUtil("my-index",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.matchQuery(
                "gender",
                "nv女仙子");    //只要包含 nv女仙子 中任意一个就被选中
        util.query(qb).print();
    }

Operator    and必须满足条件

@Test
    public void testOperator() {
        QueryUtil util = new QueryUtil("website", 5);
        //构造查询对象
        QueryBuilder qb = QueryBuilders
                .matchQuery("title", "蜀道难")
                .operator(Operator.AND);             //and必须满足条件   
        util.query(qb).print();

    }

multiMatchQuery   

@Test
    public void testMultiMatchQuery() {
        QueryUtil util = new QueryUtil("website", 5);
        //multiMatchQuery 参数 1、查询内容 后接可变参数，指定哪个字段包含查询内容
        QueryBuilder qb = QueryBuilders.multiMatchQuery("蜀道nan", "title", "num");
        util.query(qb).print();
    }

五、词项查询

1、term terms查询  用于指定字段包含指定分词，所以“蜀道难”不满足（ik分词器没有自定义），与matchquery不同

    @Test
    public void testCI(){
        QueryUtil util=new QueryUtil("poem",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.termQuery("title","蜀");
        util.query(qb).print();

        QueryUtil util=new QueryUtil("website",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.termsQuery("title","centos","yum");
        util.query(qb).print();
    }

2、range查询   范围查询

        QueryUtil util=new QueryUtil("website",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.rangeQuery("postdate").from("2017-01-01").to("2017-12-31").format("yyyy-MM-dd");
        util.query(qb).print();

3、prefix

        QueryUtil util=new QueryUtil("my-index",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.prefixQuery("name","小");
        util.query(qb).print()

4、wildcard查询 通配符

        QueryUtil util=new QueryUtil("website",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.wildcardQuery("title","*yum*");
        util.query(qb).print();

5、regexp查询

        QueryUtil util=new QueryUtil("website",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.regexpQuery("title","gc.*");
        util.query(qb).print();

6、fuzzy查询

        QueryUtil util=new QueryUtil("website",5);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.fuzzyQuery("title","vmwere");
        util.query(qb).print();

7、type查询

        QueryUtil util=new QueryUtil("website",2);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.typeQuery("blog");
        util.query(qb).print();

8、ids查询

        QueryUtil util=new QueryUtil("website",2);
        //构造查询对象
        QueryBuilder qb=QueryBuilders.idsQuery().addIds("1","3");
        util.query(qb).print();

 

待续。。。