对ElasticSearch读写操作的封装

最新推荐文章于 2024-08-15 14:15:34 发布
最新推荐文章于 2024-08-15 14:15:34 发布
阅读量386 收藏
点赞数
文章标签： 大数据 json 数据库
原文链接：https://my.oschina.net/HuQingmiao/blog/703292
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1 依赖的jar包：

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>1.7.1</version>
        </dependency>

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

2 Es环境配置：elasticsearch.yml

cluster.name: ${es.cluster.name}
node.name: "${es.node.name}"

client.transport.ip: ${es.client.transport.ip}
client.transport.port: ${es.client.transport.port}

3 封装的客户端工具类 ESClient

import com.alibaba.fastjson.JSONObject;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetResponse;
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.client.transport.TransportClient;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

public class ESClient {

    private static final Logger log = LoggerFactory.getLogger(ESClient.class);

    private TransportClient client;

    public ESClient() {
        this.init();
    }


    private void close() {
        if (this.client != null) {
            this.client.close();
        }
    }

    @Override
    public void finalize() throws Throwable {
        this.close();
        super.finalize();
    }

    private void init() {
        try {
            Settings settings = ImmutableSettings.settingsBuilder().loadFromClasspath("elasticsearch.yml")
                    .put("client.transport.sniff", true).build();
            this.client = new TransportClient(settings);

            int port = settings.getAsInt("client.transport.port", 9900);
            String[] ips = settings.getAsArray("client.transport.ip");

            for (String ip : ips) {
                log.info("the ip is:" + ip);
                client.addTransportAddress(new InetSocketTransportAddress(ip, port));
            }
            log.info("es连接成功:{},{}", client, JSONObject.toJSONString(client.listedNodes()));

        } catch (Exception e) {
            if (client != null) {
                client.close();
            }
            log.error("连接es失败!", e);
        }
    }

    /**
     * 为一份文档建立索引
     *
     * @param index 索引名，相当于关系型数据库的库名
     * @param type  文档类型，相当于关系型数据库的表名
     * @param json  json格式的数据集，必须含有属性"id"
     * @return
     */
    public IndexResponse indexDoc(String index, String type, String json) throws Exception {
        JSONObject kvMap = JSONObject.parseObject(json);
        return this.indexDoc(index, type, kvMap);
    }


    /**
     * 为一份文档建立索引
     *
     * @param index 索引名，相当于关系型数据库的库名
     * @param type  文档类型，相当于关系型数据库的表名
     * @param kvMap 键值对形式的数据集，map中必须有属性key: "id"
     * @return
     */
    public IndexResponse indexDoc(String index, String type, Map<String, Object> kvMap)
            throws Exception {
        if (!kvMap.containsKey("id")) {
            throw new Exception("创建索引时，传入的map或json串中没有属性'id'! ");
        }
        String id = (String) kvMap.get("id");
        if (id == null) {
            throw new Exception("创建索引时，传入的map或json的属性'id'的值为null! ");
        }

        IndexRequestBuilder builder = client.prepareIndex(index, type, id);
        IndexResponse response = builder.setSource(kvMap)
                .execute()
                .actionGet();
        return response;
    }


    /**
     * 为多份文档建立索引
     *
     * @param index 索引名，相当于关系型数据库的库名
     * @param type  文档类型，相当于关系型数据库的表名
     * @param jsons json格式的数据集，其下json串必须有属性"id"
     * @return
     */
    public BulkResponse batchIndexDocsForJson(String index, String type, List<String> jsons)
            throws Exception {
        if (jsons.isEmpty()) {
            throw new Exception("批量创建索引时，传入的参数'jsons'为空！");
        }

        List<Map<String, Object>> kvList = new ArrayList<Map<String, Object>>(jsons.size());
        for (String json : jsons) {
            JSONObject kvMap = JSONObject.parseObject(json);
            kvList.add(kvMap);
        }

        BulkResponse response = this.batchIndexDocsForMap(index, type, kvList);
        kvList.clear();
        return response;
    }


    /**
     * 为多份文档建立索引
     *
     * @param index  索引名，相当于关系型数据库的库名
     * @param type   文档类型，相当于关系型数据库的表名
     * @param kvList 键值对形式的数据集，其下map中必须有属性key: "id"
     * @return
     */
    public BulkResponse batchIndexDocsForMap(String index, String type, List<Map<String, Object>> kvList)
            throws Exception {
        if (kvList.isEmpty()) {
            throw new Exception("批量创建索引时，传入的参数'kvList'为空！");
        }

        List<IndexRequest> requestList = new ArrayList<IndexRequest>(kvList.size());

        for (Map<String, Object> kvMap : kvList) {
            if (!kvMap.containsKey("id")) {
                throw new Exception("批量创建索引时，传入的map或json串中没有属性'id'! ");
            }
            String id = (String) kvMap.get("id");
            if (id == null) {
                throw new Exception("批量创建索引时，传入的map或json的属性'id'的值为null! ");
            }

            IndexRequest request = client
                    .prepareIndex(index, type, id).setSource(kvMap)
                    .request();
            requestList.add(request);
        }

        BulkRequestBuilder bulkRequest = client.prepareBulk();
        for (IndexRequest request : requestList) {
            bulkRequest.add(request);
        }

        BulkResponse response = bulkRequest
                .execute()
                .actionGet();

        return response;
    }


    /**
     * 删除一个文档
     *
     * @param index 索引名，相当于关系型数据库的库名
     * @param type  文档类型，相当于关系型数据库的表名
     * @param id    键值对形式的数据集
     * @return
     */
    public DeleteResponse deleteDoc(String index, String type, String id) throws InterruptedException {
        DeleteRequestBuilder builder = client.prepareDelete(index, type, id);
        DeleteResponse response = builder
                .execute()
                .actionGet();
        return response;
    }

    /**
     * 根据条件删除多个文档
     *
     * @param index        索引名，相当于关系型数据库的库名
     * @param type         文档类型，相当于关系型数据库的表名
     * @param queryBuilder 查询器
     * @return
     */
    public void deleteDocsByQuery(String index, String type, QueryBuilder queryBuilder) {
        client.prepareDeleteByQuery(index).setTypes(type).setQuery(queryBuilder)
                .execute()
                .actionGet();
    }


    /**
     * 指定id获取文档
     *
     * @param index 索引名，相当于关系型数据库的库名
     * @param type  文档类型，相当于关系型数据库的表名
     * @param id    文档id
     * @return
     */
    public Map<String, Object> getDoc(String index, String type, String id) {
        GetResponse response = client.prepareGet(index, type, id)
                .execute()
                .actionGet();

        Map<String, Object> retMap = response.getSourceAsMap();
        return retMap;
    }


    public List<Map<String, Object>> search(String index, String type, QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
        SearchRequestBuilder builder = client.prepareSearch(index).setTypes(type);
        if (queryBuilder != null) {
            builder = builder.setQuery(queryBuilder);
        }
        if (filterBuilder != null) {
            builder = builder.setPostFilter(filterBuilder);
        }

        SearchResponse searchResponse = builder.execute().actionGet();

        SearchHits hits = searchResponse.getHits();
        log.info("Es Hits count: " + hits.getTotalHits());

        List<Map<String, Object>> kvList = new ArrayList<Map<String, Object>>();

        SearchHit[] hitArray = hits.getHits();
        if (hitArray.length > 0) {
            for (SearchHit hit : hitArray) {
                Map<String, Object> kvMap = hit.getSource();
                kvMap.put("id", hit.getId());
                kvList.add(kvMap);
            }
        }
        return kvList;
    }
}

4 测试类 ESClientTest

import com.alibaba.fastjson.JSONObject;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.FilterBuilders;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class ESClientTest {

    private static final Logger log = LoggerFactory.getLogger(ESClientTest.class);

    @Test
    public void testIndexDoc() {
        ESClient client = new ESClient();
        try {
            // 创建索引
            Map<String, Object> kvMap = new HashMap<String, Object>();
            kvMap.put("name", "hu");
            kvMap.put("age", "30");
            kvMap.put("gender", "f");
            kvMap.put("id", "33sdfa");
            client.indexDoc("test", "test_user", kvMap);

            // 创建索引
            String json = "{\"id\":\"55\",\"bb\":\"bbs\"}";
            client.indexDoc("test", "test_user", json);


            Thread.sleep(3000);

            // 查询结果
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            List<Map<String, Object>> kvList = client.search("test", "test_user", queryBuilder, null);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testBatchIndexDocsForJson() {
        String json1 = "{\"id\":\"1\",\"ak\":\"av\",\"bk\":\"bv\"}";
        String json2 = "{\"id\":\"2\",\"ak\":\"av2\",\"bk\":\"bv2\"}";
        String json3 = "{\"id\":\"3\",\"ak\":\"av3\",\"bk\":\"bv3\"}";

        List<String> jsonList = new ArrayList<String>();
        jsonList.add(json1);
        jsonList.add(json2);
        jsonList.add(json3);

        ESClient client = new ESClient();
        try {
            // 创建索引
            client.batchIndexDocsForJson("test", "test_hw", jsonList);

            Thread.sleep(3000);

            // 查询结果
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            List<Map<String, Object>> kvList = client.search("test", "test_hw", queryBuilder, null);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testBatchIndexDocsForMap() {
        Map<String, Object> kvMap = new HashMap<String, Object>();
        kvMap.put("id", "3");
        kvMap.put("name", "hu");
        kvMap.put("age", "30");
        kvMap.put("gender", "f");
        kvMap.put("asdf", "33");

        Map<String, Object> kvMap2 = new HashMap<String, Object>();
        kvMap2.put("id", "2");
        kvMap2.put("name", "wang");
        kvMap2.put("age", "35");
        kvMap2.put("gender", "f");

        List<Map<String, Object>> kvList = new ArrayList<Map<String, Object>>();
        kvList.add(kvMap);
        kvList.add(kvMap2);


        ESClient client = new ESClient();
        try {
            // 创建索引
            client.batchIndexDocsForMap("test", "test_user", kvList);

            Thread.sleep(3000);

            // 查询结果
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            kvList = client.search("test", "test_user", queryBuilder, null);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testSearch() {
        ESClient client = new ESClient();
        try {

            QueryBuilder queryBuilder = QueryBuilders.termQuery("gender", "f");
            FilterBuilder filterBuilder = FilterBuilders.rangeFilter("age").from(32);

            List<Map<String, Object>> kvList = client.search("test", "test_user", queryBuilder, filterBuilder);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testDeleteDoc() {
        ESClient client = new ESClient();
        try {

            client.deleteDoc("test", "test_user", "1");

            Thread.sleep(3000);

            // 查询结果
            QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
            List<Map<String, Object>> kvList = client.search("test", "test_hw", queryBuilder, null);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testDeleteDocs() {
        ESClient client = new ESClient();
        try {
            // 删除文档
            QueryBuilder queryBuilder = QueryBuilders.termQuery("ak", "av2");
            client.deleteDocsByQuery("test", "test_user", queryBuilder);

            // 查询结果
            queryBuilder = QueryBuilders.matchAllQuery();
            List<Map<String, Object>> kvList = client.search("test", "test_user", queryBuilder, null);
            for (Map<String, Object> kv : kvList) {
                System.out.println(JSONObject.toJSONString(kv));
            }

            queryBuilder = QueryBuilders.matchAllQuery();
            client.deleteDocsByQuery("test", "test_user", queryBuilder);

            queryBuilder = QueryBuilders.matchAllQuery();
            client.deleteDocsByQuery("test", "test_hw", queryBuilder);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

转载于:https://my.oschina.net/HuQingmiao/blog/703292

weixin_34237596
关注
ElasticSearch工具类封装
专注基础架构领域
01-10 2474
最近在项目中有看到一种比较实用的ElasticSearch工具类封装方式，特此记录便于日后查阅。 1、controller层 @RequestMapping(value = "/uri/page", method = RequestMethod.GET) public DataResult page( @RequestParam(name = "pageIndex") Integer pageIndex, @RequestParam(name = "pa...
ElasticSearch 数据读写
weixin_48922154的博客
12-23 1769
Master 节点会维护一个 in-sync group，里面包含所有同步了最新数据的副本，每个分片有一个唯一标识 Allocation ID，如果某分片主副本异常，会从这些分片中选取新的主副本，来保障主副本有最新的数据。数据节点则执行真正的数据读取。通过 Primary Terms 和 Squence Numbers 来校验分布式场景的数据的一致性，以及进行数据的矫正，类似 Raft 的 terms 和 index。ES 一个索引会拆成多个分片，每个分片又有多个副本，对于文档的添加删除都是同步写的。
ElasticSearch连接池全套封装
12-28
ElasticSearch连接池全套封装
ElasticSearch读写性能调优
最新发布
qq_44027353的博客
08-15 1200
深层次理解，虽然是每隔一秒就会将内存中的segment数据刷新到segment file中，但实际上这里并没有直接到磁盘文件，而是先写入到OS Cache中。以refresh_interval为间隔时间，将保存在ES 内存缓存区中的数据 刷新到 os的文件系统缓存中，定期清空es的buffer，生成segment。注意：ES 的默认设置，已经综合考虑了数据可靠性，搜索的实时性，写入速度，一般不要盲目修改。将segment刷新到os cache中，并开放了查询权限，以提升搜索的实时性。
ElasticSearch封装啊javaAPI
weixin_34304013的博客
12-04 193
2019独角兽企业重金招聘Python工程师标准>>> ...
ElasticSearch 通用化批量数据同步器封装设计
乐之终曲
06-21 698
ES 分页分片通用功能设计与封装
基于elasticsearch的CRUD简单封装java版
06-23
简化elasticsearch API的使用方式 使用示例 ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class); ESBasicService service = context.getBean(ESBasicService.class); /*service.createIndexAndMapping(UserM.class); // 插入数据 List users = new ArrayList(); UserM user = new UserM("张先生", 25); users.add(user); UserM user2 = new UserM("王大姐", 30); users.add(user2); UserM user3 = new UserM("王小二", 25); users.add(user3); int count = service.saveDatas(users); System.out.println(count);*/ QueryRule rule = new QueryRule(); rule.add(Restrictions.ge("age", 20)).add(Restrictions.like("name", "*王*")); System.out.println(JSON.toJSONString(service.list(UserM.class, rule))); 源码链接：https://blog.csdn.net/u010825190/article/details/106838796
ElasticSearch从入门到精通，史上最全（持续更新，未完待续，每天一点点）
热门推荐
Null的博客
07-30 13万+
目录 1.ElasticSearch的简介 2.用数据库实现搜素的功能 3.ES的核心概念 3.1 NRT(Near Realtime)近实时 3.2 cluster集群，ES是一个分布式的系统 3.3 Node节点，就是集群中的一台服务器 3.4 index 索引（索引库） 3.5 type类型 3.6 document：文档 3.7 Field 字段 3.8 sha...
【原创】ES5高效封装WIN10系统教程2020系列（二）准备封装环境
weixin_43707156的博客
04-05 4345
本教程共有7个系列 1. 母盘定制 2. 准备封装环境 3. 母盘安装及系统调整 4. 使用工具优化与清理 5. 常用软件安装及设置 6. ES5封装 7. 测试效果 磨刀不误砍柴工，预先准备一个良好的封装环境，准备好封装系统要用的东西，可以有效的提高封装效率，那么今天就来讲一下封装前的各种准备。封装系统一般耗时比较长，所以，能够合理的利用自己的空余时间和办公场所，也能有效的提高封装效率，那么...
1.ELK之Elasticsearch&Kibana一篇入门(安装/分片/操作流程/常用语句/分词)
mijichui2153的博客
08-05 7399
elasticsearch安装
Elasticsearch写入流程源码解析
qq_27639777的博客
03-28 835
文章目录前言协调节点流程数据预处理pipeline请求自动创建索引检测索引的mapping、routing、id信息内容路由，构建基于shard的请求将请求转发给primary shard并等待响应主分片节点流程检查写一致性写Lucene写Translog写副分片副分片节点流程 前言 新建、索引和删除请求都是写操作，写单个文档的流程如下： 客户端向协调节点发送写请求，ES的任意节点都可以作为协调节点(coordinating node)接受请求。 协调节点使用_routing（默认是文档ID）字段来确定文
Elasticsearch的JAVA操作工具类，包括增删改查的封装
09-13
Elasticsearch的JAVA操作工具类，包括增删改查的封装，Elasticsearch的JAVA操作工具类，包括增删改查的封装
基于transportClient+spring MVC的elasticsearch封装
09-21
在网上找了很久没有找到es6.2以上在spring MVC中的整合，暂时自己先写了一个
rest client全套封装好的java调用elasticsearch功能的工程demo,亲测可用
11-18
rest client全套封装好的java调用elasticsearch功能的工程demo,亲测可用。我安装的es是elasticsearch-7.10.0版本，测试好用。直接用idea打开工程就可以使用，并且有写好的junit测试类，可供测试。可以直接拿来做应用内搜索。
深入分析Elastic Search的写入过程
weixin_30372371的博客
07-27 158
摘要 之前写过一篇ElasticSearch初识之吐槽,不知觉竟然过去了两年了。哎，时光催人老啊。最近又用到了ES，想找找过去的总结文档，居然只有一篇，搞了半年的ES，遇到那么多的问题，产出只有这么点，真是说不过去啊。只好又重新捡起ES，发现ES槽点依然很多，不兼容的更新太多了，各个版本之间的差异不小，感觉ES就是偏理论算法的人设计出来的，而不是工程学家写的。非常像公司里面，算法工程师吐槽后端应用...
Elasticsearch 无阻碍查询，泛型封装，反射实现。让你ES查询只需要一个实现
weishui21的博客
07-05 388
ES好处和作用就不多说了，但是查询让人烦躁，看了无数大佬作品，几乎没有封装的方法。一个表一个查询方法，让人苦不堪言 更具自己需要的类型随意封装查询，可以可以根据java的设计模式来实现case过程...
ElasticSearch6.3.1工具封装
Romantic_sir的博客
11-07 553
package com.es; import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; import org.elasticsearch.action.admin.indices.create.CreateIndexResponse; import org.elasticsearch.act...
ElasticSearch 封装工具
发呆的比目鱼的博客
09-16 436
ElasticSearch 工具 # -*- coding:UTF-8 -*- # author:user # contact: test@test.com # datetime:2021/8/16 14:30 # software: PyCharm """ 文件说明： ES工具 """ import pandas as pd from elasticsearch import Elasticsearch from elasticsearch import helpers class Es
elasticsearch简单操作封装
u010825190的博客
06-22 795
接口 public interface ESBasicService { boolean indexExists(Class<?> clazz); boolean deleteIndex(Class<?> clazz); boolean createIndexAndMapping(Class<?> clazz); <T> boolean saveData(T data); <T> Integer saveDatas(Co
Win7封装教程：磁盘碎片清理与摄像头CMOS驱动调试
然后通过特定工具，如"ES3.1系统封装部署利器"，进行封装，确保系统在安装后能够快速启动和运行。 在教程的其他章节中，作者还提到了安装软件、打补丁、防止封装错误、Ghost备份等步骤，这些都是系统封装过程中不可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值