Elasticsearch-37-Java API document 增删改查

前文都是讲的理论知识,用restful API来做的测试. 本文将使用java API来操作索引,document.

添加依赖

<!-- es依赖 -->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>transport</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>${elasticsearch.version}</version>
</dependency>

yml配置

elasticsearch:
  ip: 127.0.0.1
  port: 9300
  pool: 5
# 集群名称
  cluster:
    name: elasticsearch

配置client

@Configuration
@Slf4j
public class ElasticsearchConfig {

    /**
     * ip地址
     */
    @Value("${elasticsearch.ip}")
    private String hostName;

    @Value("${elasticsearch.port}")
    private int port;

    @Value("${elasticsearch.pool}")
    private int poolSize;

    @Value("${elasticsearch.cluster.name}")
    private String clusterName;

    @Bean
    public TransportClient init(){
        TransportClient transportClient = null;
        try {
            // 配置
            Settings settings = Settings.builder()
                    .put("cluster.name", clusterName)
                    // 集群嗅探机制,找到es集群
                    .put("client.transport.sniff", true)
                    // 增加线程池个数
                    .put("thread_pool.search.size", poolSize)
                    .build();

            transportClient = new PreBuiltTransportClient(settings)
                    // 设置地址端口号
                    .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(hostName), port));

        } catch (Exception e){
            log.error("elasticsearch TransportClient init error,{}", e);
        }

        return transportClient;
    }
}

基础的配置已经完成了,接下来就是具体的方法

增删改查节点和索引

Util工具类

@Component
@Slf4j
public class ElasticsearchUtils {

    @Autowired
    private TransportClient transportClient;

    private static TransportClient client;

    @PostConstruct
    public void init(){
        client = this.transportClient;
    }

    /**
     * 判断索引是否存在
     * @param indexName 索引名称
     * @return true/false
     */
    public static boolean indexExist(String indexName){
        IndicesExistsResponse indicesExistsResponse = client.admin()
                .indices()
                .exists(new IndicesExistsRequest(indexName))
                .actionGet();

        if (indicesExistsResponse.isExists()){
            log.info("Index ['{}'] is exists", indexName);
        } else {
            log.info("Index ['{}'] is not exists", indexName);
        }

        return indicesExistsResponse.isExists();
    }

    /**
     * 创建索引
     * @param indexName 索引名称
     * @return isAcknowledged
     */
    public static boolean createIndex(String indexName){

        if (!indexExist(indexName)){
            log.info("Index is not exist");
        }

        CreateIndexResponse response = client.admin()
                .indices()
                .prepareCreate(indexName)
                .execute()
                .actionGet();

        return response.isAcknowledged();

    }

    /**
     * 删除索引
     * @param indexName 索引名称
     * @return isAcknowledged
     */
    public static boolean deleteIndex(String indexName){

        if (!indexExist(indexName)){
            log.info("Index is not exist");
        }

        DeleteIndexResponse response = client.admin()
                .indices()
                .prepareDelete(indexName)
                .execute()
                .actionGet();

        return response.isAcknowledged();
    }

    /**
     * 创建一个document,需要手动指定id
     * @param indexName 索引名称
     * @param typeName 类型名称
     * @param id id
     * @param xContentBuilder 数据(fields)
     * @return id
     */
    public static String createDocument(String indexName, String typeName, String id, XContentBuilder xContentBuilder){

        IndexResponse response = client
                .prepareIndex(indexName, typeName, id)
                .setSource(xContentBuilder)
                .get();

        log.info("add document response:{}", response.toString());

        return response.getId();
    }

    /**
     * 创建一个document,不需要手动指定id
     * @param indexName 索引名称
     * @param typeName 类型名称
     * @param xContentBuilder 数据(fields)
     * @return id
     */
    public static String createDocumentWithNoId(String indexName, String typeName, XContentBuilder xContentBuilder){

        IndexResponse response = client
                .prepareIndex(indexName, typeName)
                .setSource(xContentBuilder)
                .get();

        log.info("add document response:{}", response.toString());

        return response.getId();
    }

    /**
     * 更新document,partial update
     * @param indexName 索引名称
     * @param typeName 类型名称
     * @param id id
     * @param xContentBuilder 数据
     * @return id
     */
    public static String updateDocument(String indexName, String typeName, String id, XContentBuilder xContentBuilder){

        UpdateResponse updateResponse = client
                .prepareUpdate(indexName, typeName, id)
                .setDoc(xContentBuilder)
                .get();

        log.info("update response:{}", updateResponse.toString());

        return updateResponse.getId();
    }

    /**
     * 删除document
     * @param indexName 索引名称
     * @param typeName 类型名称
     * @param id id
     * @return id
     */
    public static String deleteDocument(String indexName, String typeName, String id){

        DeleteResponse response = client
                .prepareDelete(indexName, typeName, id)
                .get();

        log.info("delete response:{}", response.toString());

        return response.getId();
    }

    /**
     * 根据id获取document
     * @param indexName 索引名称
     * @param typeName 类型名称
     * @param id id
     * @return _source数据
     */
    public static String getDocumentById(String indexName, String typeName, String id){

        GetResponse response = client
                .prepareGet(indexName, typeName, id)
                .get();

        log.info("get response");

        return response.getSourceAsString();
    }

    /**
     * 只做查询,没有排序
     * @param indexes 索引
     * @param types 类型
     * @param matchMap 搜索条件
     * @param fields 要显示的fields,不传返回全部
     * @return 结果集
     */
    public static List<Map<String,Object>> searchDocument(String indexes, String types, Map<String,String> matchMap, String fields){
        return searchDocument(indexes, types, 0, 0, matchMap, false, null, fields, null, null, null);
    }


    /**
     * 查询/精准匹配,可以排序
     * @param indexes 索引
     * @param types 类型
     * @param matchMap 查询条件
     * @param fields 要显示的fields,不传返回全部
     * @param matchPhrase true 使用短语精准匹配
     * @param sortField 排序field
     * @param sortOrder 正序倒序(正序的话需要字段有正排索引)
     * @return 结果集
     */
    public static List<Map<String,Object>> searchDocument(String indexes, String types, Map<String,String> matchMap, String fields, boolean matchPhrase, String sortField, SortOrder sortOrder){
        return searchDocument(indexes, types, 0, 0, matchMap, matchPhrase, null, fields, sortField, sortOrder, null);
    }

    /**
     * 查询/精准匹配,可以排序,高亮,文档大小限制
     * @param indexes 索引
     * @param types 类型
     * @param matchMap 查询条件
     * @param fields 要显示的fields,不传返回全部
     * @param matchPhrase true 使用短语精准匹配
     * @param sortField  排序field
     * @param sortOrder 正序倒序(正序的话需要字段有正排索引)
     * @param highlightField 高亮字段
     * @param size 文档大小限制
     * @return 结果集
     */
    public static List<Map<String,Object>> searchDocument(String indexes, String types, Map<String,String> matchMap, String fields, boolean matchPhrase, String sortField,
                                                          SortOrder sortOrder, String highlightField, Integer size){
        return searchDocument(indexes, types, 0, 0, matchMap, matchPhrase, highlightField, fields, sortField, sortOrder, size);
    }

    /**
     * 搜索document
     * @param indexes 索引名
     * @param types 类型
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param matchMap 查询条件(filed:value)
     * @param matchPhrase true 使用短语精准匹配
     * @param highlightField 高亮显示的field
     * @param fields 要显示的fields,不传返回全部
     * @param sortField 排序field
     * @param sortOrder 正序倒序(正序的话需要字段有正排索引)
     * @param size 文档大小限制
     * @return 结果集
     */
    public static List<Map<String, Object>> searchDocument(String indexes, String types, long startTime, long endTime, Map<String,String> matchMap, boolean matchPhrase,
                                                           String highlightField, String fields, String sortField, SortOrder sortOrder, Integer size){
        if (StringUtils.isEmpty(indexes)){
            return null;
        }

        // 构建查询的request body
        SearchRequestBuilder searchRequestBuilder = client.prepareSearch(indexes.split(","));

        // 拆分type
        if (StringUtils.isNotEmpty(types)){
            searchRequestBuilder.setTypes(types.split(","));
        }

        // 组合查询 bool
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        // 组装查询条件
        boolQueryBuilder = boolQuery(boolQueryBuilder, startTime, endTime, matchMap, matchPhrase);

        // 设置高亮字段
        searchRequestBuilder = setHighlightField(searchRequestBuilder, highlightField);

        // 搜索条件加到request中
        searchRequestBuilder.setQuery(boolQueryBuilder);

        // 定制返回的fields
        if (StringUtils.isNotEmpty(fields)){
            searchRequestBuilder.setFetchSource(fields.split(","), null);
        }

        searchRequestBuilder.setFetchSource(true);

        // 设置排序
        if (StringUtils.isNotEmpty(sortField)){
            searchRequestBuilder.addSort(sortField, sortOrder);
        }

        // 设置文档大小限制
        if (size != null && size > 0){
            searchRequestBuilder.setSize(size);
        }

        // 把请求体打印出来
        log.info("查询请求体:{}", searchRequestBuilder);

        // 发送请求,执行查询
        SearchResponse response = searchRequestBuilder
                .execute()
                .actionGet();

        long totalHits = response.getHits().totalHits();
        long length = response.getHits().getHits().length;

        log.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

        if (response.status().getStatus() == 200){
            return setSearchResponse(response, highlightField);
        }

        return null;
    }

    /**
     * 分页查询
     * @param indexes 索引
     * @param types 类型
     * @param pageNum 页码
     * @param pageSize 每页显示数量
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param fields 要显示的字段
     * @param sortField 排序字段
     * @param sortOrder 正序倒序(正序需要排序的字段有正排索引)
     * @param matchPhrase true 精准匹配
     * @param highlightField 高亮子弹
     * @param matchMap 查询条件
     * @return PageVO
     */
    public static PageVO searchDocumentPage(String indexes, String types, int pageNum, int pageSize, long startTime, long endTime, String fields, String sortField,
                                            SortOrder sortOrder, boolean matchPhrase, String highlightField, Map<String,String> matchMap){
        if (StringUtils.isEmpty(indexes)){
            return null;
        }

        SearchRequestBuilder searchRequestBuilder = client.prepareSearch(indexes.split(","));

        if (StringUtils.isNotEmpty(types)){
            searchRequestBuilder.setTypes(types.split(","));
        }
        searchRequestBuilder.setSearchType(SearchType.QUERY_THEN_FETCH);

        // 设置需要显示的字段
        if (StringUtils.isNotEmpty(fields)){
            searchRequestBuilder.setFetchSource(fields.split(","), null);
        }

        // 设置排序字段
        if (StringUtils.isNotEmpty(sortField)){
            searchRequestBuilder.addSort(sortField, sortOrder);
        }

        // 组合查询 bool
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        // 组装查询条件
        boolQueryBuilder = boolQuery(boolQueryBuilder, startTime, endTime, matchMap, matchPhrase);

        // 设置高亮字段
        searchRequestBuilder = setHighlightField(searchRequestBuilder, highlightField);

        // 搜索条件加到request中
        searchRequestBuilder.setQuery(boolQueryBuilder);
        searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());

        // 设置分页
        searchRequestBuilder.setFrom(pageNum).setSize(pageSize);

        // 设置按照匹配度排序
        searchRequestBuilder.setExplain(true);

        // 打印请求体
        log.info("请求体:{}", searchRequestBuilder);

        // 发送请求,执行查询
        SearchResponse response = searchRequestBuilder
                .execute()
                .actionGet();

        long totalHits = response.getHits().totalHits();
        long length = response.getHits().getHits().length;

        log.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);

        if (response.status().getStatus() == 200){
            // 解析查询对象
            List<Map<String,Object>> rList = setSearchResponse(response, highlightField);

            return new PageVO(pageNum, pageSize, (int) totalHits, rList);
        }

        return null;
    }

    /**
     * 高亮结果集 特殊处理
     * @param searchResponse 查询返回结果
     * @param highlightField 高亮字段
     * @return 结果
     */
    public static List<Map<String,Object>> setSearchResponse(SearchResponse searchResponse, String highlightField){
        List<Map<String,Object>> sourceList = new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();

        // 循环查询结果
        for (SearchHit searchHitFields : searchResponse.getHits().getHits()) {
            // 把id放到_source里面去
            searchHitFields.getSource().put("id", searchHitFields.getId());

            // 有高亮字段的话做处理
            if (StringUtils.isNotEmpty(highlightField)){
                log.info("遍历高亮结果集,覆盖正常结果集...{}", searchHitFields.getSource());

                Text[] texts = searchHitFields.getHighlightFields().get(highlightField).getFragments();

                if (texts != null){
                    for (Text text : texts) {
                        stringBuilder.append(text.toString());
                    }
                    // 遍历高亮结果集,覆盖正常结果集
                    searchHitFields.getSource().put(highlightField, stringBuilder.toString());
                }
            }

            sourceList.add(searchHitFields.getSource());
        }

        return sourceList;
    }

    /**
     * 封装
     * @param boolQueryBuilder boolQueryBuilder
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param matchMap 查询条件
     * @param matchPhrase true 使用精准匹配
     * @return boolQueryBuilder
     */
    public static BoolQueryBuilder boolQuery(BoolQueryBuilder boolQueryBuilder, long startTime, long endTime, Map<String, String> matchMap, boolean matchPhrase){
        // TODO 不清楚是做什么
        if (startTime > 0 && endTime > 0){
            boolQueryBuilder.must(QueryBuilders.rangeQuery("processTime")
                    .format("epoch_millis")
                    .from(startTime)
                    .to(endTime)
                    .includeLower(true)
                    .includeUpper(true)
            );
        }

        // 搜索条件
        if (!matchMap.isEmpty()){
            for (Map.Entry<String,String> entry : matchMap.entrySet()) {
                if (StringUtils.isNoneBlank(entry.getKey(),entry.getValue())){
                    if (matchPhrase == Boolean.TRUE){
                        // 精准匹配
                        boolQueryBuilder.must(QueryBuilders.matchPhraseQuery(entry.getKey(), entry.getValue()));
                    } else {
                        boolQueryBuilder.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
                    }
                }
            }
        }

        return boolQueryBuilder;
    }

    /**
     * 封装设置高亮字段
     * @param searchRequestBuilder searchRequestBuilder
     * @param highlightField 高亮字段
     * @return searchRequestBuilder
     */
    public static SearchRequestBuilder setHighlightField(SearchRequestBuilder searchRequestBuilder, String highlightField){
        // 高亮字段
        if (StringUtils.isNotEmpty(highlightField)){
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            // 设置前缀
//            highlightBuilder.preTags("<span style='color:red'>");
            // 设置后缀
//            highlightBuilder.postTags("</span>");
            // 设置高亮字段
            highlightBuilder.field(highlightField);
            searchRequestBuilder.highlighter(highlightBuilder);
        }

        return searchRequestBuilder;
    }
}

分页model

/**
 * @author 周泽
 * @date Create in 10:38 2018/11/29
 * @Description 分页结果集
 */
@Getter
@Setter
public class PageVO {
    /**
     * 当前页码
     */
    private Integer pageNum;

    /**
     * 一页显示数量
     */
    private Integer pageSize;

    /**
     * 总数量
     */
    private Integer total;

    /**
     * 结果集合
     */
    private List<Map<String,Object>> rList;

    /**
     * 共有多少页
     */
    private Integer pageCount;

    /**
     * 页码列表的开始索引(包含)
     */
    private Integer beginPageIndex;

    /**
     * 码列表的结束索引(包含)
     */
    private Integer endPageIndex;

    /**
     * 只接受前4个必要的属性，会自动的计算出其他3个属性的值
     * @param pageNum 当前页码
     * @param pageSize 每页显示条数
     * @param total 总条数
     * @param rList 结果集合
     */
    public PageVO(int pageNum, int pageSize, int total, List<Map<String, Object>> rList) {
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.total = total;
        this.rList = rList;

        // 计算总页码
        pageCount = (total + pageSize - 1) / pageSize;

        // 计算 beginPageIndex 和 endPageIndex
        // >> 总页数不多于10页，则全部显示
        if (pageCount <= 10) {
            beginPageIndex = 1;
            endPageIndex = pageCount;
        } else {
            // >> 总页数多于10页，则显示当前页附近的共10个页码
            // 当前页附近的共10个页码（前4个 + 当前页 + 后5个）
            beginPageIndex = pageNum - 4;
            endPageIndex = pageNum + 5;

            // 当前面的页码不足4个时，则显示前10个页码
            if (beginPageIndex < 1) {
                beginPageIndex = 1;
                endPageIndex = 10;
            }

            // 当后面的页码不足5个时，则显示后10个页码
            if (endPageIndex > pageCount) {
                endPageIndex = pageCount;
                beginPageIndex = pageCount - 10 + 1;
            }
        }
    }

}

单元测试代码在源码里.
源码地址