ElasticSearch 增删改查 基本使用

import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.get.GetRequestBuilder;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequestBuilder;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.Test;

import java.net.InetAddress;
import java.util.HashMap;
import java.util.List;

public class elasticsearch {

    private TransportClient getTransportClient(String ip, Integer port) throws Exception {

        //返回一个PreBuiltTransportClient的建造客户端的对象
        PreBuiltTransportClient preBuiltTransportClient = new PreBuiltTransportClient(Settings.EMPTY);

        //新建一个传输客户端，传入ip和端口号
        TransportClient transportClient = preBuiltTransportClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(ip), port));

        //返回一个TransportClient客户端的对象
        return transportClient;
    }

    //增加
    @Test
    public void testAdd() throws Exception {

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient transportClient = getTransportClient("localhost", 9300);

        //调用准备增加索引的方法，传入参数是（索引库，对象，ID），返回一个请求构建索引的构造器
        IndexRequestBuilder indexRequestBuilder = transportClient.prepareIndex("crm", "employee", "1");

        //准备一个map，传入进去参数。
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("id", 1);
        map.put("name", "cc");
        map.put("age", "12");
        map.put("desc", "努力努力再努力");

        //设置参数进去，这里我们用的是参数是Map的。然后返回结果。
        IndexResponse indexResponse = indexRequestBuilder.setSource(map).get();

        System.out.println(indexResponse);
        transportClient.close();
    }

    //修改
    @Test
    public void testUpdate() throws Exception {

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient transportClient = getTransportClient("localhost", 9300);

        //调用修改索引的方法，传入参数是（索引库，对象，ID），返回一个请求修改索引的构造器
        //索引库，对象，id必须在库里存在，不然修改会报错
        UpdateRequestBuilder updateRequestBuilder = transportClient.prepareUpdate("crm", "employee", "1");

        //准备一个map，传入进去参数。
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("id", 1);
        map.put("name", "xx");
        map.put("age", "18");
        map.put("desc", "P城霸主");

        //调用的是参数为map的方法，返回结果
        System.out.println(updateRequestBuilder.setDoc(map).get());
        transportClient.close();
    }

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

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient transportClient = getTransportClient("localhost", 9300);

        //获得准备查询的索引构造器
        GetRequestBuilder getRequestBuilder = transportClient.prepareGet("crm", "employee", "1");

        //从结果中获得_source，也就是调用getSource方法
        System.out.println(getRequestBuilder.get().getSource());

        transportClient.close();
    }

    //删除
    @Test
    public void testDelete() throws Exception {

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient transportClient = getTransportClient("localhost", 9300);

        //获得删除索引的构造器
        DeleteRequestBuilder deleteRequestBuilder = transportClient.prepareDelete("crm", "employee", "1");

        System.out.println(deleteRequestBuilder.get());

        transportClient.close();
    }


    //多个增加
    @Test
    public void testMoreAdd() throws Exception {

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient transportClient = getTransportClient("localhost", 9300);

        //获得多个操作索引的构造器(可以多个操作CRUD索引的步骤)
        BulkRequestBuilder bulkRequestBuilder = transportClient.prepareBulk();

        for (int i = 0; i < 10; i++) {
            HashMap<String, Object> map = new HashMap<String, Object>();
            map.put("id", 1 + i);
            map.put("name", "cc");
            map.put("age", 20 + i);
            map.put("desc", "努力努力再努力" + i);
            //返回一个准备增加索引的构造器
            IndexRequestBuilder indexRequestBuilder = transportClient.prepareIndex("crm", "user", "" + i);
            //将map传入增加的构造器中，再放入多个操作的构造器中
            bulkRequestBuilder.add(indexRequestBuilder.setSource(map));
        }

        //提交请求
        BulkResponse bulkResponse = bulkRequestBuilder.execute().actionGet();

        //获得一个迭代器
         /*Iterator<BulkItemResponse> iterator = bulkResponse.iterator();
            if(iterator.hasNext()){
            System.out.println(iterator.next().getItemId());
         }*/


        //因为是异步的，出错可以打印一下
        if (bulkResponse.hasFailures()) {
            System.out.println("出错啦！出错啦！出错啦！");
        }

        transportClient.close();
    }



    //条件查询
    @Test
    public void testQuerySource() throws Exception {

        //调用上面的工具方法，建立一个本地的对应端口的客户端对象
        TransportClient client= getTransportClient("localhost", 9300);

        //调用查询构造器的方法，返回一个构造器多种查询的对象
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

        //返回构造器中must的对象（必须有的传入即可）
        List<QueryBuilder> must = boolQuery.must();
        //在must中增加  单词查询  的对象，然后传入属性和值
        must.add(QueryBuilders.termQuery("name","cc"));

        //过滤的操作传入参数
        List<QueryBuilder> filter = boolQuery.filter();
        //范围查询
        filter.add(QueryBuilders.rangeQuery("age").lte(28).gte(23));

        // 设置需要查询的索引库，分页，查询对象的类型，排序，然后提交
        SearchResponse searchResponse = client.prepareSearch("crm")
                        .setFrom(0).setSize(5)
                        .setQuery(boolQuery)
                        .addSort("id", SortOrder.DESC)
                        .get();

        //获得查询的总数量
        System.out.println(searchResponse.getHits().getTotalHits());
        //获得查询的总数据对象数组
        SearchHit[] hits = searchResponse.getHits().getHits();
        //打印每一个对象的内容
        for (SearchHit hit : hits) {
            System.out.println(hit.getSource());
        }


        client.close();
    }
}

转载于:https://my.oschina.net/u/4083694/blog/3076810