es工具类AbstractElasticSearch

最新推荐文章于 2024-03-08 15:48:41 发布
最新推荐文章于 2024-03-08 15:48:41 发布
阅读量1.6k 收藏
点赞数
分类专栏： ElasticSearch 文章标签： es工具类AbstractElasticSearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34412985/article/details/98457470
版权

 
import com.alibaba.fastjson.JSON;
 
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetRequestBuilder;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.Client;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.collect.ImmutableOpenMap;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.sort.SortBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;

/**
 * ES搜索服务的抽象类
 *
 
 *
 * @param <T>
 */
public abstract class AbstractElasticSearch<T> {
    /** 日志记录 */
    public static final Logger logger = LoggerFactory.getLogger(AbstractElasticSearch.class);

    // 创建访问ES服务器的客户端

    protected Client client = ElasticSearchClientHelper.getInstance().getClient();

    /**
     * 索引名称 相当于数据库的数据名称
     *
     * @return
     */
    protected abstract String getIndex();

    /**
     * 类型名称 相当于数据库的表名
     *
     * @return
     */
    protected abstract String getType();

    /**
     * 获取集成类的类对象
     *
     * @return
     */
    protected abstract Class<T> getBeanClass();

//    /**
//     * 自定义的查询条件 HashMap<查询的字段, 查询的内容>
//     *
//     * @param map
//     * @return
//     */
//    public abstract List<T> query(HashMap<String, Object> map);

//    /**
//     * 将数据重新加载到ES到服务器中
//     */
//    public abstract void reLoad();

    /**
     * 将list集合转换为key为id和value为对象的map
     *
     * @param list
     * @return
     */
    protected  HashMap<String, T> listToMap(List<T> list){
        if (list == null || list.size() <= 0) {
            return null;
        }

        HashMap<String, T> map = new HashMap<>();
        for (T obj : list) {
            if (obj != null) {
                try {
                    map.put(obj.getClass().getDeclaredField("id").get(obj).toString(), obj);
                } catch (IllegalAccessException e) {
                    logger.error("list to map error",e);
                } catch (NoSuchFieldException e) {
                    logger.error("list to map error no such field Exception",e);
                }
            }
        }

        return map;
    }

//    /**
//     * 将map转换为对象，主要用于返回数据转换为正常对象
//     *
//     * @param map
//     * @return
//     */
//    protected abstract T mapToBean(Map<String, Object> map);

    /**
     * 指定id批量添加
     *
     * map中的 String是id T是对象
     *
     * @param map
     * @return
     */
    public BulkResponse addDocByBulk(Map<String, T> map) {
        BulkRequestBuilder builder = client.prepareBulk();
        // 批量添加
        int count = 0;
        for (Entry<String, T> entry : map.entrySet()) {
            if (entry.getKey() == null || entry.getKey().length() <= 0 || entry.getValue() == null) {
                continue;
            }
            try {
                String json = JSON.toJSONString(entry.getValue());
                builder.add(
                        client.prepareIndex(getIndex(), getType(), entry.getKey()).setSource(json, XContentType.JSON));
                // 每1000条刷新提交一次
                if (count % 1000 == 0) {
                    builder.execute().actionGet();
                    logger.debug("addDocByBulk index[{}] type[{}] num[{}]", getIndex(), getType(), count);
                }
                count++;
            } catch (Exception e) {
                logger.error("{}", e);
                continue;
            }

        }
        BulkResponse response = builder.execute().actionGet();
        logger.debug("addDocByBulk index[{}] type[{}] num[{}] status[{}]", getIndex(), getType(), count,
                response.status());
        return response;
    }

    /**
     * 批量添加，id由es自动生成
     *
     * @param list
     * @return
     */
    public BulkResponse addDocByBulk(List<T> list) {
        // List<T> list
        BulkRequestBuilder builder = client.prepareBulk();
        // 批量添加
        int count = 0;
        for (T t : list) {
            if (t == null) {
                continue;
            }
            try {
                builder.add(client.prepareIndex(getIndex(), getType()).setSource(JSON.toJSONString(t),
                        XContentType.JSON));
                // 每1000条刷新提交一次
                if (count % 1000 == 0) {
                    builder.execute().actionGet();
                    logger.info("提交了：" + count);
                }
                count++;
            } catch (Exception e) {
                logger.error("{}", e);
                continue;
            }
        }
        BulkResponse response = builder.execute().actionGet();
        logger.info("addDocByBulk response status {}",response.status());
        // 查看是否有失败情况
        if (response.hasFailures()) {
            logger.info("addDocByBulk 存在错误");
            logger.error("addDocByBulk ByList index[{}] type[{}] num[{}] status[{}] hasFailures[{}]", getIndex(),
                    getType(), count, response.status(), response.hasFailures());
        }
        logger.debug("addDocByBulk ByList index[{}] type[{}] num[{}] status[{}] hasFailures[{}]", getIndex(), getType(),
                count, response.status(), response.hasFailures());
        return response;
    }

    /**
     * 添加 单个
     *
     * @param id
     * @param bean
     * @throws Exception
     */
    public void addDoc(Object id, T bean) throws Exception {
        if (id == null && bean == null) {
            return;
        }
        logger.debug("addDoc index[{}] type[{}] id[{}]", getIndex(), getType(), id);

        client.prepareIndex(getIndex(), getType(), id.toString())
                .setSource(JSON.toJSONString(bean), XContentType.JSON).get();
    }

    /**
     * 更新文档 单个 保证ES搜索库中没有否则用upsert方式
     *
     * @param id
     * @param bean
     * @throws Exception
     */
    public void updateDoc(Object id, T bean) throws Exception {
        if (id == null && bean == null) {
            return;
        }
        logger.debug("updateDoc upsert index[{}] type[{}] id[{}]", getIndex(), getType(), id);
        client.prepareUpdate(getIndex(), getType(), id.toString()).setDoc(JSON.toJSONString(bean), XContentType.JSON)
                .get();
    }

    /**
     * 通过upsert进行更新，如果没有就插入
     *
     * @param id
     * @param bean
     * @throws Exception
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public void updateDocByUpsert(Object id, T bean) throws Exception, InterruptedException, ExecutionException {
        if (id == null && bean == null) {
            return;
        }
        String json = JSON.toJSONString(bean);
        // 1. 先定义好要添加的数据 (如果没更新成功就添加的数据)
        IndexRequest indexRequest = new IndexRequest(getIndex(), getType(), id.toString()).source(json,
                XContentType.JSON);
        // 2. 定义好要修改的的数据，如果修改不成功，则进行upsert操作 进行插入
        UpdateRequest updateRequest = new UpdateRequest(getIndex(), getType(), id.toString())
                .doc(JSON.toJSONString(bean), XContentType.JSON).upsert(indexRequest);
        // 3. 提交update请求 操作成功返回OK，否则返回NOT_FOUND
        UpdateResponse response = client.update(updateRequest).get();

        logger.debug("updateDoc index[{}] type[{}] id[{}] status[{}] ", getIndex(), getType(), id, response.status());
        // 4. 查看添加文档是否成功
        // logger.info(response.status());
    }

    /**
     * 通过Bulk 批量更新
     *
     * @param map
     * @return
     * @throws Exception
     */
    public BulkResponse updateByBulk(Map<String, T> map) throws Exception {
        if (map == null || map.isEmpty()) {
            return null;
        }
        BulkRequestBuilder builder = client.prepareBulk();
        // 批量添加
        int count = 0;
        for (Entry<String, T> entry : map.entrySet()) {
            if (entry.getKey() == null || entry.getKey().length() <= 0 || entry.getValue() == null) {
                continue;
            }
            try {
                String json = JSON.toJSONString(entry.getValue());
                builder.add(
                        client.prepareUpdate(getIndex(), getType(), entry.getKey()).setDoc(json, XContentType.JSON));
                // 每1000条刷新提交一次
                if (count % 1000 == 0) {
                    builder.execute().actionGet();
                    logger.debug("addDocByBulk index[{}] type[{}] num[{}]", getIndex(), getType(), count);
                }
                count++;
            } catch (Exception e) {
                logger.error("{}", e);
                continue;
            }

        }
        BulkResponse response = builder.execute().actionGet();
        logger.debug("updateByBulk index[{}] type[{}] num[{}] status[{}]", getIndex(), getType(), count,
                response.status());
        logger.info("updateByBulk response status {}",response.status());
        return response;

    }

    // 按id删除
    public void delDoc(Object id) {
        if (id == null) {
            return;
        }
        logger.debug("delDoc  index[{}] type[{}] id[{}]", getIndex(), getType(), id);
        // 3. 指定要删除的文档
        client.prepareDelete(getIndex(), getType(), id.toString()).get();
    }

    /**
     * 按id批量删除 调用bulk
     *
     * @param ids
     */
    public void delDocByBulk(Object[] ids) {

        if (ids == null || ids.length <= 0) {
            return;
        }
        BulkRequestBuilder builder = client.prepareBulk();
        // 批量添加
        int count = 0;
        for (Object id : ids) {
            if (id == null || "".equals(id.toString())) {
                continue;
            }
            builder.add(client.prepareDelete(getIndex(), getType(), id.toString()));
            // 每1000条刷新提交一次
            if (count % 1000 == 0) {
                builder.execute().actionGet();
                logger.info("delDocByBulk ids index[{}] type[{}] num[{}]", getIndex(), getType(), count);
            }
            count++;
        }
        BulkResponse response = builder.execute().actionGet();
        logger.debug("delDocByBulk ByList index[{}] type[{}] num[{}] status[{}] hasFailures[{}]", getIndex(), getType(),
                count, response.status(), response.hasFailures());
        // 查看是否有失败情况
        if (response.hasFailures()) {
            logger.info("delDocByBulk 存在错误");
            logger.error("delDocByBulk ByList index[{}] type[{}] num[{}] status[{}] hasFailures[{}]", getIndex(),
                    getType(), count, response.status(), response.hasFailures());
        }
    }

    // 查询 按id查询

    /**
     * 获取单个对象
     *
     * @param id
     * @return
     * @throws Exception
     */
    public T get(Object id) throws Exception {
        if (id == null || id.toString().trim().length() <= 0) {
            return null;
        }
        // 3. 数据查询展示
        GetResponse response = client.prepareGet(getIndex(), getType(), id.toString()).execute().actionGet();
        String sourceAsString = response.getSourceAsString();
        return JSON.parseObject(sourceAsString,getBeanClass());

    }

    public List<T> multiGet(Object[] ids) throws Exception {
        // 如果id为空 就返回null
        if (ids == null || ids.length <= 0) {
            return null;
        }

        // 数据查询展示
        MultiGetRequestBuilder prepareMultiGet = client.prepareMultiGet();
        for (Object id : ids) {
            if (StringUtils.isNotBlank(id.toString())) {
                prepareMultiGet.add(getIndex(), getType(), id.toString());
            }
        }
        MultiGetResponse multiGetResponse = prepareMultiGet.get();
        // 遍历输出一下
        List<T> list = new ArrayList<>();
        for (MultiGetItemResponse response : multiGetResponse) {
            GetResponse gr = response.getResponse();
            if (gr != null && gr.isExists() && StringUtils.isNotBlank(gr.getSourceAsString())) {
                list.add(JSON.parseObject(gr.getSourceAsString(), getBeanClass()));
                logger.info("multiGet responseAsString {}",gr.getSourceAsString());
            }
        }

        return list;
    }

    /**
     * 按条件查询
     *
     * @param queryBuilder
     *            查询器
     * @param from
     *            分页 从那个开始 默认为0
     * @param size
     *            分页 每页几条 默认为10
     * @return
     * @throws Exception
     */
    public List<T> query(QueryBuilder queryBuilder, int from, int size, List<SortBuilder> sortBuilders, Page<T> page) {
        // 查询器没有的话就返回null
        if (queryBuilder == null) {
            return null;
        }
        // 输入条件重置
        if (from < 0) {
            from = 0;
        }
        if (size <= 1) {
            size = 20;
        }
        // 按照size大小创建list集合，节省内存
        List<T> list = new ArrayList<>(size);

        SearchRequestBuilder searchRequestBuilder = client.prepareSearch(getIndex()).setTypes(getType()).setQuery(queryBuilder).setFrom(from).setSize(size);
        //排序
        if (CollectionUtils.isNotEmpty(sortBuilders)){
            for (SortBuilder sortBuilder :sortBuilders){
                searchRequestBuilder.addSort(sortBuilder);
            }
        }
        //设置返回排除字段
        if (CollectionUtils.isNotEmpty(page.getExclude())){
            List<String> stringList = page.getExclude();
            String[] excludeArray =stringList.toArray(new String[stringList.size()]);
            searchRequestBuilder.setFetchSource(null,excludeArray);
        }
        //设置返回指定字段
        if (CollectionUtils.isNotEmpty(page.getInclude())){
            List<String> stringList = page.getInclude();
            String[] includeArray =stringList.toArray(new String[stringList.size()]);
            searchRequestBuilder.setFetchSource(includeArray,null);
        }
        //搜索
        long startTime = System.currentTimeMillis();
         SearchResponse response = searchRequestBuilder.get();
         long endTime = System.currentTimeMillis();
        logger.info(searchRequestBuilder.toString());
        logger.info("es query hit total {} ,hits cost time [{} ms] ",response.getHits().getTotalHits(),endTime-startTime);
        page.setCount( (int)response.getHits().getTotalHits()) ;
        for (SearchHit hit : response.getHits()) {
//            logger.info("es query hit getSourceAsString {}",hit.getSourceAsString());
            try {
                list.add(JSON.parseObject(hit.getSourceAsString(), getBeanClass()));
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("{},{}", hit.getSourceAsString(), e);
            }
        }
        return list;
    }

//    public List<T> query(String fieldName, Object value, int from, int size) {
//        if (StringUtils.isBlank(fieldName)) {
//            return null;
//        }
//        if (value == null) {
//            return null;
//        }
//        return query(QueryBuilders.matchQuery(fieldName, value), from, size);
//    }

    /**
     * 联合查询
     *
     * @param must
     *            必须成立
     * @param mustNot
     *            必须不
     * @param should
     *            或者
     * @param filter
     *            过滤
     * @param from
     * @param size
     * @return
     */
//    public List<T> boolQuery(QueryBuilder must, QueryBuilder mustNot, QueryBuilder should, QueryBuilder filter,
//            int from, int size) {
//        if (must == null && mustNot == null && should == null) {
//            return null;
//        }
//        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//        // 必须 且
//        if (must != null) {
//            boolQuery.must(must);
//        }
//        // 必须不 否
//        if (mustNot != null) {
//            boolQuery.mustNot(mustNot);
//        }
//        // 或者
//        if (should != null) {
//            boolQuery.should(should);
//        }
//        // 过滤条件
//        if (filter != null) {
//            boolQuery.filter(filter);
//        }
//        return query(boolQuery, from, size);
//    }

    /**
     * 按照关键字查询，查询内容不分词
     *
     * @param fieldName
     *            查询范围
     * @param value
     *            查询值
     * @param from
     *            分页 开始行数
     * @param size
     *            每页多少行
     * @return
     */
//    public List<T> termQuery(String fieldName, Object value, int from, int size) {
//        return query(QueryBuilders.termQuery(fieldName, value), from, size);
//    }

    /**
     * 按关键字查询，查询内容不分词，一个
     *
     * @param fieldName
     * @param value
     * @param from
     * @param size
     * @return
     */
//    public List<T> termsQuery(String fieldName, Object[] value, int from, int size) {
//        return query(QueryBuilders.termsQuery(fieldName, value), from, size);
//    }

    /**
     * 多个字段查询一个查询词
     *
     * @param fieldName
     * @param value
     * @param from
     * @param size
     * @return
     */
//    public List<T> multiMatchQuery(String[] fieldName, Object value, int from, int size) {
//        return query(QueryBuilders.multiMatchQuery(value, fieldName), from, size);
//    }

    /**
     * 获取索引mapping的Json字符串 如果自定义的mapping最好重写
     *
     * @return
     */
    public String getMapping() {
        ImmutableOpenMap<String, MappingMetaData> mappings = client.admin().cluster().prepareState().execute()
                .actionGet().getState().getMetaData().getIndices().get(getIndex()).getMappings();
        if (mappings == null || mappings.isEmpty()) {
            return null;
        }
        return mappings.get(getType()).source().toString();
    }

    /**
     *
     * @Description: 重构索引(更新词库之后)
     */
    public void reindex() {
        SearchResponse scrollResp = client.prepareSearch(getIndex())//
                .setScroll(new TimeValue(60000))//
                .setQuery(QueryBuilders.matchAllQuery())//
                .setSize(100).get(); // max of 100 hits will be returned for
        // Scroll until no hits are returned
        do {
            for (SearchHit hit : scrollResp.getHits().getHits()) {
                client.prepareIndex(getIndex(), hit.getType(), hit.getId())
                        .setSource(hit.getSourceAsString(), XContentType.JSON).execute().actionGet();
            }
            scrollResp = client.prepareSearchScroll(scrollResp.getScrollId()).setScroll(new TimeValue(60000)).execute()
                    .actionGet();
        } while (scrollResp.getHits().getHits().length != 0);
    }

 

 

}

 

qq_34412985
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
es-abstract-refs:ECMAScript 的抽象参考提案
06-22
ECMAScript 的抽象参考 该提案已被以下两项提案取代： 概述和动机 尽管具有函数式编程设施，但 ECMAScript 表现出对使用实例方法的面向对象的“从左到右”组合的强烈偏好。 不幸的是，通过实例方法的组合需要通过向对象或对象的原型祖先添加函数值属性来实现可扩展性。 这会导致以下困难： 抽象的 API 负担直接或通过继承层次结构的引入置于抽象本身上。 这会导致 API 表面不希望的集中。 将 API 表面添加到现有抽象会引入难以预测的破坏可能性。 通过将 API 表面直接添加到对象或其原​​型祖先之一，不可能将对象和 API 视为不同的能力。 如果用户有权访问该对象，则该用户必须有权访问完整的 API（我们可能希望隐藏其中的一部分）。 该提案使用新的二元运算符增加了对“从左到右”语法组合的支持，这不需要向对象本身添加属性和方法。 它通过引入“抽象引用”的概念来实现这一点。
【Android】使用ContentProvider实现跨进程通讯
little_fat_sheep
11-22 3094
1 前言 ContentProvider 即内容提供器，是 Android 四大组件之一，为 App 存取数据提供统一的对外接口，让不同的应用之间可以共享数据。 如图，Server 端通过 ContentProvider 对外提供操作 SQLite 的接口，Client 端通过 ContentResolver 与 ContentProvider 通讯，从而实现跨进程操作 Sqlite。 （1）ContentProvider 接口 ContentProvider 是一个抽象类，用户需要实现如下抽.
【elasticsearch】ES的JAVA工具类完整版（已完成，已测试）
最新发布
Timeguys的专栏
03-08 568
当你制作好一个java类，并且把属性的类型都规范好，这时候可直接通过该方法创建索引，如果该类中有数组类型的属性，则需要指定 nestedFields 参数的属性名，否则在插入数据后悔发现，该数组类型的es中的type不是 nested类型。solution 便是数组类型，无论List的泛型是基本类型，还是包装类型，在es中都需要指定该字段是【nested】。通过es控制台或者postman都可以进行索引操作，类型mysql可视化工具对mysql数据库表结构操作类型，只不过，不解释了，没啥好说的。
关于通过spring-web的ServletRequestUtils工具类对获取getParameter传参的默认转换基本数据类型的学习...
weixin_30325793的博客
05-06 1299
基于spring-web(4.1.4)包的org.springframework.web.bind.ServletRequestUtils工具类对HttpServletRequest获取的传递入参获取request.getParameter进行常见默认数据类型（整型IntParser、长整型LongParser、浮点数类型FloatParser、双精度浮点数、布尔型类型DoubleParser、字...
Spring深入学习笔记
waooi的博客
03-16 567
自己的学习笔记 2.Bean定义,注册,获取 BeanFactory代表了bean工厂 该接口里面有getBean(String name)方法，用来返回bean对象 BeanDefinition，用于定义 Bean 实例化信信息 首先非常重要的一点是在 Bean 注册的时候只注册一个类信息，而不会直接把实例化信息 注册到 Spring 容器中。那么就需要修改 BeanDefinition 中的属性Class，接下来在需要做的就是在获取 Bean 对象时需要处理 B
记录开发中更新vue element-ui时遇到的问题
weixin_44096821的博客
03-14 2117
首先更新element-ui 1.先卸载element-ui 使用命令：npm uninstall element-ui 或cnpm uninstall element-ui 2.再次安装element-ui 使用命令：npm install element-ui -S 或 cnpm install element-ui -S //安装最新版本的element-ui 如果安装指定版本的element-ui，则是 命令： npm install element-ui @2.12.0 -S 或
reify:webpack: timing reifyNode:node_modules/eslint Completed in 896ms卡住
zoxm
12-11 1179
我当时版本是node-v16.18.0-win-x64，试过很多方法还是卡住。切换node-v18.19.0-win-x86版本。直接安装nrm对镜像源进行管理。
Java抽象类
一只小菜鸡
04-21 246
1.什么是抽象类？ 类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。 类本身是不存在的，所以抽象类无法创建对象《无法实例化》。 2.抽象类属于什么类型？ 抽象类也属于 引用数据 类型。 3.抽象类怎么定义？ 语法： [修饰符列表] abstract class 类名{ 类体; } 一些结论 4.抽象类是 无法实例化 的，无法创建对象 的，所以抽象类是用来被子类继承的。 5.final和abstract不能联合使用，这两个关键字是对立的。 6.抽象类的子类可以是抽象类。也可以是非抽象类。
es-abstract:ECMAScript规范摘要操作
05-01
抽象 ECMAScript规范摘要操作。 每个操作都可以按版本/年份和名称进行使用-例如， es-abstract/2020/Call提供ES2020中的Call操作， es-abstract/5/Type提供ES5中的Type操作。 es5 / es5 / es2015 / es2016 / es2017 / es2018 / es2019 / es2020入口点下也可以使用所有抽象操作，并且作为main出口的属性，但是出于捆绑规模和性能原因，强烈建议使用深度导入。 非深度入口点将在下一个主要版本中删除。 例子 var ES = require ( 'es-abstract' ) ; var assert = require ( 'assert' ) ; assert ( ES . isCallable ( function ( ) { } ) ) ; assert ( ! ES
ES常见启动报错解决办法
09-16
ES常见启动报错解决办法汇总
Elasticsearch工具类
04-08
Elasticsearch工具类，支持通过标签注释实体类并通过工具类实现对es的映射（把po的结构导入es），和对es的增删查改，包括分页，scroll读取，关联查询等。
ElasticSearchPoolUtil.java(es连接池工具类)
09-11
使用过Elasticsearch RestFul API的都知道，在Java端使用是ES服务需要创建Java Client，但是每一次连接都实例化一个client，对系统的消耗很大，而且最令人头疼的是它的连接非常慢。所以为了解决上述问题并提高client...
Elasticsearch Java api 工具类
12-15
Elasticsearch Java api 工具类，包括增删改查索引，增删改查数据等代码，欢迎下载
ElasticSearchUtll工具类
06-24
ElasticSearch的综合运用：包括：查询数据 开出去的公用方法需要添加index存储转换策略，创建索引，判断index是否存在，创建基于指定时间字段自动生成索引名称的处理器，默认创建得事件索引模板，默认创建的属性索引...
Elasticsearch java工具类
01-18
使用springboot集成了elasticsearch，封装了常用api，并使用自定义注解创建mapping，简化开发，开箱即用。注：使用的是elasticsearch 5.x版本
ES与Solr的区别
热门推荐
qq_34412985的博客
07-28 1万+
背景：它们都是基于Lucene搜索服务器基础之上开发，一款优秀的，高性能的企业级搜索服务器。【是因为他们都是基于分词技术构建的倒排索引的方式进行查询】 开发语言：Java语言开发 诞生时间：Solr ：2004年诞生。ES：2010年诞生。ES 更新【功能越强大】 区别： 1.当实时建立索引的时候，solr会产生io阻塞，而es则不会，es查询性能要高于solr。 2.在不断动态添加数据...
logstash集成elasticsearch报Attempted to resurrect connection to dead ES instance
qq_34412985的博客
10-15 1万+
Attempted to resurrect connection to dead ES instance, but got an error. {:url=>"http://192.168.1.100:9200/", :error_type=>LogStash::Outputs::ElasticSearch::HttpClient::Pool::HostUnreachableErro...
python Elasticsearch 工具类
11-22
以下是Python Elasticsearch工具类的示例代码，它包括了连接Elasticsearch、创建索引、插入数据、查询数据等常用操作： ```python from elasticsearch import Elasticsearch class ES: def __init__(self, host='...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值