[elasticsearch]通用CURD

冷不防 2023-06-06 03:43 24阅读 0赞

### 保存 ###

public int save(T t) throws Exception {
            try {
                Map<String, Object> params = convert2Map(t);
                if (MapUtils.isEmpty(params)) {
                    throw new CustomException(ExceptionEnum.PARAMS_ERROR);
                }
                //构造请求数据json
                XContentBuilder xcb = null;
                xcb = XContentFactory.jsonBuilder().startObject();
                for (String key : params.keySet()) {
                    xcb.field(key, params.get(key));
                }
                xcb.endObject();
    			// 获取es客户端连接,由于包装加密等,无参考性,所以不再贴此处代码
                TransportClient client = getInstance();
                IndexRequestBuilder builder = client.prepareIndex(indexName, typeName);
    
                IndexRequestBuilder indexRequestBuilder = builder.setSource(xcb);
                IndexResponse response = indexRequestBuilder.get();
                return response.getVersion() > 0 ? 1 : 0;
            } catch (Throwable e) {
                logger.error("ES保存异常", e);
                throw e;
            } 
        }

### 浅分页 ###

/**
         * from,size查询
         *
         */
        public List<T> selectList(EsSearchBean esSearchBean) throws Exception {
            if (null == esSearchBean) {
                throw new CustomException(ExceptionEnum.PARAMS_ERROR);
            }
            List<T> result = null;
            try {
                result = new ArrayList<T>();
    
                SearchRequestBuilder srb = getInstance().prepareSearch(indexName);
                // 判断分页
                if (null != esSearchBean.getPageSize() && null != esSearchBean.getPageNum()) {
                    esSearchBean.initPage();
                    int offsetPage = getOffsetPage(esSearchBean.getPageNum(), esSearchBean.getPageSize());
                    srb.setFrom(offsetPage).setSize(esSearchBean.getPageSize());
                }
                // 查询条件
                buildCondition(esSearchBean, srb);
    
                MultiSearchResponse sr = getInstance().prepareMultiSearch().add(srb).get();
                for (MultiSearchResponse.Item item : sr.getResponses()) {
                    for (SearchHit hit : item.getResponse().getHits().getHits()) {
                        Class<?> tClass = (Class<?>) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
                        result.add((T) JSON.parseObject(hit.getSourceAsString(), tClass));
                    }
                }
            } catch (Throwable e) {
                logger.error("ES浅查询分页异常", e);
                throw e;
            } 
            return result;
        }
    	/**
         * 根据页号，页数据大小，初始化查数据库页信息
         */
        public int getOffsetPage(Integer pageNum, Integer pageSize) {
            if (pageNum <= 0) {
                pageNum = 1;
            }
            return pageSize * (pageNum - 1);
        }
    	/**
         * EsSearchBean:根据页号，页数据大小，初始化查数据库页信息
         */
        public void initPage() {
            if (null != this.pageSize && null != this.pageNum) {
                if (this.pageSize == 0) {
                    this.pageSize = 10;
                }
                if (pageNum <= 0) {
                    pageNum = 1;
                }
            }
        }

查询条件构造

private void buildCondition(EsSearchBean esSearchBean, SearchRequestBuilder searchRequestBuilder) {
            // 构建查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            // 查询and条件
            if (MapUtils.isNotEmpty(esSearchBean.getMustConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getMustConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()).operator(Operator.AND));//默认关联是or,所以如果用and,需要显示调用
                    }
                }
            }
            // 查询or条件
            if (MapUtils.isNotEmpty(esSearchBean.getShouldConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getShouldConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
                    }
                }
            }
            // 查询模糊and条件
            if (MapUtils.isNotEmpty(esSearchBean.getWildMustConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getWildMustConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.wildcardQuery(entry.getKey(), entry.getValue().toString()));
                    }
                }
            }
            // 查询模糊or条件
            if (MapUtils.isNotEmpty(esSearchBean.getWildShouldConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getWildShouldConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.wildcardQuery(entry.getKey(), entry.getValue().toString()));
                    }
                }
            }
            //时间范围
            if (MapUtils.isNotEmpty(esSearchBean.getDataConditionMap())) {
                for (Map.Entry<String, DateRangeSearchBean> entry : esSearchBean.getDataConditionMap().entrySet()) {
                    if (null != entry.getValue()) {
                        boolQueryBuilder.must(QueryBuilders.rangeQuery(entry.getKey()).from(entry.getValue().getStartTime())
                                .to(entry.getValue().getEndTime()));
                    }
                }
            }
    
            searchRequestBuilder.setQuery(boolQueryBuilder);
            // 排序条件
            if (CollectionUtils.isNotEmpty(esSearchBean.getAscSortOrderConditionList())) {
                for (String ascSortOrderCondition : esSearchBean.getAscSortOrderConditionList()) {
                    if (StringUtils.isNotBlank(ascSortOrderCondition)) {
                        searchRequestBuilder.addSort(ascSortOrderCondition, ASC);
                    }
                }
            }
            if (CollectionUtils.isNotEmpty(esSearchBean.getDescSortOrderConditionList())) {
                for (String descSortOrderCondition : esSearchBean.getDescSortOrderConditionList()) {
                    if (StringUtils.isNotBlank(descSortOrderCondition)) {
                        searchRequestBuilder.addSort(descSortOrderCondition, SortOrder.DESC);
                    }
                }
            }
        }

### 深分页 ###

/**
         * scroll查询
         *
         * @param t
         * @return
         */
        public List<T> selectListByScroll(T t, EsSearchBean esSearchBean) throws Exception {
            if (null == esSearchBean) {
                throw new CustomException(ExceptionEnum.PARAMS_ERROR);
            }
    
            List<T> result = null;
            try {
                SearchRequestBuilder searchRequestBuilder = getInstance().prepareSearch(indexName).setTypes(typeName);
                // 构建查询,排序条件
                buildCondition(esSearchBean, searchRequestBuilder);
    
                TimeValue timeValue = new TimeValue(scrollTimeValue);
                searchRequestBuilder.setScroll(timeValue).setSize(scrollSize);
                SearchResponse response = searchRequestBuilder.get();
                result = new ArrayList<>();
                //分页取数
                while (response.getHits().getHits().length != 0) {
                    for (SearchHit sh : response.getHits().getHits()) {
                        Map<String, Object> tempMap = sh.getSourceAsMap();
                        result.add(ConvertUtils.convert2Object(tempMap, t));
                    }
                    response = getInstance().prepareSearchScroll(response.getScrollId())
                            .setScroll(timeValue)
                            .execute()
                            .actionGet();
                }
                //清除scroll
                ClearScrollRequestBuilder clearScroll = getInstance().prepareClearScroll();
                clearScroll.addScrollId(response.getScrollId());
                clearScroll.get();
            } catch (Throwable e) {
                logger.error("ES的scroll异常", e);
                throw e;
            } 
            return result;
        }
    
    
    	/**
         * map转化class
         */
        public static <T> T convert2Object(Map<String, Object> map, T classModel) throws Exception {
            if (MapUtils.isEmpty(map)) {
                return null;
            }
            T tempClass = classModel;
            Class<?> clazz = tempClass.getClass();
            Object obj = clazz.newInstance();
    
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
                for (PropertyDescriptor property : propertyDescriptors) {
                    Method setter = property.getWriteMethod();
                    if (setter == null) {
                        continue;
                    }
                    if (null == map.get(property.getName())) {
                        continue;
                    }
                    String value = map.get(property.getName()).toString();
                    setter.invoke(obj, value);
                }
            }
            return (T)obj;
        }

### 更新 ###

public int updateById(T t) throws Exception {
            UpdateResponse response = null;
            try {
                Map<String, Object> param = convert2Map(t);
                if (StringUtils.isBlank(String.valueOf(param.get("id")))) {
                    throw new CustomException(ExceptionEnum.PARAMS_ERROR);
                }
                UpdateRequest updateRequest = new UpdateRequest();
                updateRequest.index(indexName);
                updateRequest.type(typeName);
                updateRequest.id(String.valueOf(param.get("id")));
                updateRequest.doc(jsonBuilder(param));
                response = getInstance().update(updateRequest).get();
            } catch (Throwable e) {
                logger.error("ES更新异常", e);
                throw e;
            } 
            return response.getVersion() > 0 ? 1 : 0;
        }
    
    
    private Map<String, Object> convert2Map(T t) throws Exception {
            Map<String, Object> result = new HashMap<String, Object>();
            if (null == t) {
                return result;
            }
            try {
                Class<? extends Object> clazz = t.getClass();
                //向上循环  遍历父类
                for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
                    for (Field field : clazz.getDeclaredFields()) {
                        PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                        Object obj = pd.getReadMethod().invoke(t);
                        if (obj == null) {
                            continue;
                        }
                        if (obj instanceof Date) {
                            result.put(field.getName(), DateUtils.stringToDate(obj.toString()));
                        } else {
                            result.put(field.getName(), obj);
                        }
                    }
                }
            } catch (Throwable e) {
                throw e;
            }
            return result;
        }
    
    	/**
         * map转化XContentBuilder
         *
         * @param param
         * @return
         */
        private XContentBuilder jsonBuilder(Map<String, Object> param) throws Exception {
            if (MapUtils.isEmpty(param)) {
                return null;
            }
            XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject();
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                xContentBuilder = xContentBuilder.field(entry.getKey(), entry.getValue());
            }
            return xContentBuilder.endObject();
        }

### 删除 ###

/**
         * 删除
         *
         * @return
         */
        public long delete(EsSearchBean searchBean) throws Exception {
            long result = 0;
            try {
                String id = String.valueOf(searchBean.getMustConditionMap().get("id"));
                if (MapUtils.isNotEmpty(searchBean.getMustConditionMap()) && StringUtils.isNotBlank(id)) {
                    int status = getInstance().prepareDelete(indexName,typeName,id).get().status().getStatus();
                    result = status > 0 ? 1 : 0;
                } else {
                    DeleteByQueryRequestBuilder builder = DeleteByQueryAction.INSTANCE.newRequestBuilder(getInstance());
                    BulkByScrollResponse scrollResponse = buildDeleteCondition(searchBean, builder);
                    result = scrollResponse.getDeleted();
                }
            } catch (Exception e) {
                logger.error("ES删除异常", e);
                throw e;
            } 
            return result;
        }
    
    
        private BulkByScrollResponse buildDeleteCondition(EsSearchBean esSearchBean, DeleteByQueryRequestBuilder builder) {
            // 构建查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            // 查询and条件
            if (MapUtils.isNotEmpty(esSearchBean.getMustConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getMustConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.must(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
                    }
                }
            }
            // 查询or条件
            if (MapUtils.isNotEmpty(esSearchBean.getShouldConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getShouldConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.matchQuery(entry.getKey(), entry.getValue()));
                    }
                }
            }
            // 查询模糊and条件
            if (MapUtils.isNotEmpty(esSearchBean.getWildMustConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getWildMustConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.wildcardQuery(entry.getKey(), entry.getValue().toString()));
                    }
                }
            }
            // 查询模糊or条件
            if (MapUtils.isNotEmpty(esSearchBean.getWildShouldConditionMap())) {
                for (Map.Entry<String, Object> entry : esSearchBean.getWildShouldConditionMap().entrySet()) {
                    if (null != entry.getValue() && StringUtils.isNotBlank(String.valueOf(entry.getValue()))) {
                        boolQueryBuilder.should(QueryBuilders.wildcardQuery(entry.getKey(), entry.getValue().toString()));
                    }
                }
            }
            //时间范围
            if (MapUtils.isNotEmpty(esSearchBean.getDataConditionMap())) {
                for (Map.Entry<String, DateRangeSearchBean> entry : esSearchBean.getDataConditionMap().entrySet()) {
                    if (null != entry.getValue()) {
                        boolQueryBuilder.must(QueryBuilders.rangeQuery(entry.getKey()).from(entry.getValue().getStartTime())
                                .to(entry.getValue().getEndTime()));
                    }
                }
            }
            return builder.filter(boolQueryBuilder).source(indexName).get();
        }