SpringBoot基于ElasticSearch7.9.2和ElasticsearchRestTemplate的一些通用接口（可复用）

最新推荐文章于 2024-09-26 10:51:36 发布
最新推荐文章于 2024-09-26 10:51:36 发布
阅读量4.2k 收藏 8
点赞数
分类专栏： elasticsearch springboot 文章标签： java intellij idea elasticsearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43753812/article/details/123634686
版权

之前写过一篇SpringBoot集成ElasticSearch 7.9.2 教程和简单增删改查案例icon-default.png?t=M276https://blog.csdn.net/weixin_43753812/article/details/117733551

这里提供一个通用的操作接口和文档的方法类，大多数的使用场景都已经覆盖，话不多说，开整：

  1. 首先，创建一个自定义注解，结合elasticsearch提供的注解一起，配合实体类操作文档和索引。
package com.cqvip.innocence.common.annotation;

import java.lang.annotation.*;

/**
 * @ClassName DocumentId
 * @Description es文档数据的id标识
 * @Author Innocence
 * @Date 2021/6/16 11:34
 * @Version 1.0
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DocumentId {
}

2.写一个与文档对应的DTO（这里只是示例，具体的实体根据对应需求建立）

package com.cqvip.innocence.project.model.entity;

import com.cqvip.innocence.common.annotation.DocumentId;
import lombok.Data;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

import java.io.Serializable;

/**
 * @ClassName EsTestInfo
 * @Description es测试数据
 * @Author Innocence
 * @Date 2021/6/16 13:57
 * @Version 1.0
 */
@Data
@Document(indexName = "test_info")
public class EsTestInfo implements Serializable {
    private static final long serialVersionUID = 6735913456541605819L;

    @DocumentId
    @Field(type = FieldType.Keyword)
    private String infoId;

    private String name;

    @Field(type = FieldType.Integer)
    private Integer age;

    @Field(type = FieldType.Keyword)
    private String sex;

    @Field(type = FieldType.Keyword)
    private String[] roles;
}

 3.索引操作的接口和实现

package com.cqvip.innocence.project.esservice;

/**
 * @ClassName IndexService
 * @Description 索引的增删改查
 * @Author Innocence
 * @Date 2021/3/1 14:06
 * @Version 1.0
 */
public interface IndexService<T>{

    /**
     * 根据类创建索引
     * @author Innocence
     * @date 2021/6/16
     * @param clazz
     * @return java.lang.Boolean
     */
    Boolean createIndexByClass(Class<T> clazz);

    /**
     * 根据名称创建索引
     * 不建议使用，因为很多设置需要自己写配置文件
     * @author Innocence
     * @date 2021/3/1
     * @param indexName
     * @return java.lang.Boolean
     */
    Boolean createIndexByName(String indexName);

    /**
     * 根据索引名判断索引是否存在
     * @author Innocence
     * @date 2021/6/16
     * @param indexName 索引名
     * @return java.lang.Boolean
     */
    Boolean isIndexExist(String indexName);

    /**
     * 根据索引名删除索引
     * @author Innocence
     * @date 2021/6/16
     * @param indexName 索引名
     * @return java.lang.Boolean
     */
    Boolean deleteIndexByName(String indexName);

    /**
     * 获取被标记的索引名
     * @author Innocence
     * @date 2021/6/16
     * @param clazz
     * @return java.lang.String
     */
    String getIndexName(Class<T> clazz);
}

package com.cqvip.innocence.project.esservice.impl;

import cn.hutool.core.util.StrUtil;
import com.cqvip.innocence.project.esservice.IndexService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.stereotype.Service;

import java.lang.annotation.Annotation;

/**
 * @ClassName IndexServiceImpl
 * @Description  抽象
 * @Author Innocence
 * @Date 2021/3/1 14:24
 * @Version 1.0
 */
@Service
public class IndexServiceImpl<T> implements IndexService<T> {

    @Autowired
    private ElasticsearchRestTemplate restTemplate;

    @Override
    public String getIndexName(Class<T> clazz){
        Annotation documentAnnotation = clazz.getDeclaredAnnotation(Document.class);
        if(documentAnnotation==null){
            return null;
        }
        String indexName = ((Document) documentAnnotation).indexName();
        if (StrUtil.isNotBlank(indexName)){
            return indexName;
        }
        return null;
    }

    @Override
    public Boolean createIndexByClass(Class<T> clazz) {
        Boolean indexExist = isIndexExist(getIndexName(clazz));
        if (indexExist){
            return false;
        }
        IndexOperations indexOps = restTemplate.indexOps(clazz);
        boolean result1 = indexOps.create();
        boolean result2 = indexOps.putMapping(indexOps.createMapping(clazz));
        return result1&result2;
    }

    @Override
    public Boolean createIndexByName(String indexName) {
        Boolean indexExist = isIndexExist(indexName);
        if (indexExist){
            return false;
        }
        IndexOperations indexOps = restTemplate.indexOps(IndexCoordinates.of(indexName));
        return indexOps.create();

    }

    @Override
    public Boolean isIndexExist(String indexName) {
        IndexOperations indexOps = restTemplate.indexOps(IndexCoordinates.of(indexName));
        return indexOps.exists();
    }

    @Override
    public Boolean deleteIndexByName(String indexName) {
        IndexOperations indexOps = restTemplate.indexOps(IndexCoordinates.of(indexName));
        return indexOps.delete();

    }
}

4.文档操作的接口和实现类

package com.cqvip.innocence.project.esservice;

import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.query.Query;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @ClassName DocumentService
 * @Description 适用于本项目的数据的增删改查
 * @Author Innocence
 * @Date 2021/3/1 15:43
 * @Version 1.0
 */
public interface DocumentService<T> {

    /**
     * 设置高亮字段
     * @author Innocence
     * @date 2021/3/2
     * @param fields 需要设置的高亮字段
     * @return org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder
     */
    HighlightBuilder getHighlightBuilder(String[] fields);

    /**
     * 根据id判断文档是否存在于指定索引中
     * @author Innocence
     * @date 2021/3/1
     * @param id
     * @param clazz
     * @return java.lang.Boolean
     */
    Boolean isExist(String id, Class<T> clazz);

    /**
     *  单条数据插入
     * @author Innocence
     * @date 2021/3/1
     * @param t 需插入的数据
     * @return java.lang.String 返回文档id
     */
    String saveByEntity(T t);

    /**
     * 批量插入
     * @author Innocence
     * @date 2021/3/1
     * @param entities 待插入的数据实体集合
     * @return java.util.List<java.lang.String> 返回idList
     */
    List<String> saveBatchByEntities(List<T> entities) throws Exception;

    /**
     * 单条数据更新
     * @author Innocence
     * @date 2021/3/1
     * @param t 需要更新的实体数据
     * @return void
     */
    void updateByEntity(T t);

    /**
     * 批量更新
     * @author Innocence
     * @date 2021/3/1
     * @param entities 待更新的数据实体集合
     * @return void
     */
    void updateByEntities(List<T> entities);

    /**
     * 根据id删除数据
     * @author Innocence
     * @date 2021/3/1
     * @param id
     * @param clazz
     * @return java.lang.String 被删除的id
     */
    String deleteById(String id, Class<T> clazz);

    /**
     * 根据id批量删除数据
     * @author Innocence
     * @date 2021/3/12
     * @param ids
     * @param clazz
     * @return void
     */
    void deleteByIds(List<String> ids, Class<T> clazz);

    /**
     * 根据条件删除数据
     * @author Innocence
     * @date 2021/3/1
     * @param query 条件构造器
     * @param clazz
     * @return void
     */
    void deleteByQuery(Query query, Class<T> clazz);

    /**
     * 根据id查询数据 (基于注解形式设置了索引mapping)
     * @author Innocence
     * @date 2021/3/1
     * @param clazz
     * @return T
     */
    T getEntityById(String id,Class<T> clazz);

    /**
     * 根据id批量查询数据 (基于注解形式设置了索引mapping)
     * @author Innocence
     * @date 2021/8/24
     * @return java.util.List<T>
     */
    List<T> getEntityByIds(List<String> ids, Class<T> clazz);

    /**
     * 查询符合条件的总条数
     * @author Innocence
     * @date 2021/3/2
     * @return java.lang.Long
     */
    Long getCount(Query query,Class<T> clazz);

    /**
     * 查询符合条件的实体list
     * @author Innocence
     * @date 2021/3/2
     * @param query 构建的查询条件 主要使用NativeSearchQuery 来进行构造
     * @param isHighLight 是否映射高亮（true映射高亮，否则不映射）
     * @return java.util.List<T>
     */
    List<T> getInfoList(Query query, Class<T> clazz,Boolean isHighLight);

    /**
     * 查询符合条件的分页
     * @author Innocence
     * @date 2021/3/2
     * @param query 构建的查询条件 主要使用NativeSearchQuery 来进行构造
     * @return org.springframework.data.domain.Page<T>
     */
    Map<String,Object> getPageList(Query query, PageRequest pageRequest,Class<T> clazz);

    /**
     * 根据条件获取聚类信息
     * springboot-data 封装的聚类查询速度很慢，这里直接用client操作
     * @author Innocence
     * @date 2021/3/19
     * @param query, clazz
     * @return java.util.Map<java.lang.String,java.util.List<? extends org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket>>
     */
    Map<String, List<? extends Terms.Bucket>> getFacetByQuery(SearchSourceBuilder query, Class<T> clazz) throws IOException;
}

 

package com.cqvip.innocence.project.esservice.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.cqvip.innocence.common.annotation.DocumentId;
import com.cqvip.innocence.common.exception.ElasticServiceException;
import com.cqvip.innocence.project.esservice.DocumentService;
import com.cqvip.innocence.project.esservice.IndexService;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.lucene.search.IndexSearcher;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.*;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.*;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.lang.reflect.*;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * @ClassName DocumentServiceImpl
 * @Description TODO
 * @Author Innocence
 * @Date 2021/3/1 16:27
 * @Version 1.0
 */
@Service
public class DocumentServiceImpl<T> implements DocumentService<T> {

    @Autowired
    private ElasticsearchRestTemplate restTemplate;

    @Qualifier("highLevelClient")
    @Autowired
    private RestHighLevelClient highLevelClient;

    @Autowired
    private IndexService<T> indexService;

    /**
     * 反射获取es实体代表id的字段名
     * @author Innocence
     * @date 2021/6/17
     * @param clazz
     * @return java.lang.String
     */
    private String getPrimaryNameByClass(Class<T> clazz){
        Field[] fields = clazz.getDeclaredFields();
        for (Field f:fields) {
            DocumentId id = f.getAnnotation(DocumentId.class);
            if (id != null){
                return f.getName();
            }
        }
        return null;
    }

    /**
     * 根据注解获取实体类关联es属性的id值
     * @author Innocence
     * @date 2021/6/16
     * @return java.lang.String
     */
    private String getPrimaryValueByEntity(T t){
        Class<T> clazz = (Class<T>) t.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field f:fields) {
            Class<?> type = f.getType();
            if (type.getTypeName().equals(String.class.getTypeName())){
                DocumentId id = f.getAnnotation(DocumentId.class);
                if (id != null){
                    try {
                        String replace = f.getName()
                                .replace(f.getName().substring(0, 1), f.getName().substring(0, 1).toUpperCase());
                        Method method = clazz.getMethod("get" + replace);
                        String invoke = (String) method.invoke(t);
                        if (StrUtil.isNotBlank(invoke)){
                            return invoke;
                        }else {
                            return null;
                        }
                    } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return null;
    }

    /**
     * 类上无索引名的统一异常处理
     * @author Innocence
     * @date 2021/8/6
     * @param clazz
     * @return void
     */
    private String indexNameExceptionHandler(Class<T> clazz){
        String indexName = indexService.getIndexName(clazz);
        if (StrUtil.isBlank(indexName)){
            throw new ElasticServiceException("The index name on the current class does not exist！");
        }else {
            return indexName;
        }
    }

    /**
     * 映射高亮字段到原生属性
     * @author Innocence
     * @date 2021/3/2
     * @param searchHits
     * @return java.util.List<T>
     */
    private <T> List<T> mappingHighlight(List<SearchHit<T>> searchHits){
        List<T> infoList = new ArrayList<>();
        for (SearchHit<T> searchHit : searchHits) {
            T content = searchHit.getContent();
            Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
            for (Map.Entry<String, List<String>> entry : highlightFields.entrySet()) {
                try {
                    PropertyUtils.setProperty(content,entry.getKey(),entry.getValue().get(0));
                } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }
            infoList.add(content);
        }
        return infoList;
    }

    @Override
    public HighlightBuilder getHighlightBuilder(String[] fields) {
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        for (String field : fields) {
            highlightBuilder.field(field);
        }
        highlightBuilder.requireFieldMatch(false);     //如果要多个字段高亮,这项要为false
        highlightBuilder.preTags("<span style=\"color:red\">");
        highlightBuilder.postTags("</span>");
        //下面这两项,如果你要高亮如文字内容等有很多字的字段,必须配置,不然会导致高亮不全,文章内容缺失等
        highlightBuilder.fragmentSize(800000); //最大高亮分片数
        highlightBuilder.numOfFragments(0); //从第一个分片获取高亮片段

        return highlightBuilder;
    }


    @Override
    public Boolean isExist(String id,Class<T> clazz) {
        String name = indexNameExceptionHandler(clazz);
        return restTemplate.exists(id, IndexCoordinates.of(name));
    }

    @Override
    public  String saveByEntity(T t) {
        String id = getPrimaryValueByEntity(t);
        String indexName = indexNameExceptionHandler((Class<T>) t.getClass());
        if (StrUtil.isBlank(id)){
            throw new ElasticServiceException("Document id cannot be empty！");
        }
        IndexQuery build = new IndexQueryBuilder().withId(id).withObject(t).build();
        String index = restTemplate.index(build, IndexCoordinates.of(indexName));
        //业务需要，新增后马上刷新，ElasticsearchRestTemplate是默认不立即刷新（立即刷新会影响性能）
        restTemplate.indexOps(t.getClass()).refresh();
        return index;
    }

    @Override
    public List<String> saveBatchByEntities(List<T> entities){
        Class<T> clazz =(Class<T>) entities.get(0).getClass();
        String indexName = indexNameExceptionHandler(clazz);
        List<IndexQuery> queryList = new ArrayList<>();
        for (T item:entities){
            String id = getPrimaryValueByEntity(item);
            if (StrUtil.isBlank(id)){
                throw new ElasticServiceException("Document id cannot be empty！");
            }
            IndexQuery build = new IndexQueryBuilder().withId(id).withObject(item).build();
            queryList.add(build);
        }
        List<String> idList = restTemplate.bulkIndex(queryList, IndexCoordinates.of(indexName));
        restTemplate.indexOps(IndexCoordinates.of(indexName)).refresh();
        return idList;
    }

    @Override
    public void updateByEntity(T t) {
        String indexName = indexNameExceptionHandler((Class<T>) t.getClass());
        Document document = Document.parse(JSON.toJSONString(t));
        document.setId(getPrimaryValueByEntity(t));
        UpdateQuery build = UpdateQuery.builder(document.getId())
                .withRefresh(UpdateQuery.Refresh.Wait_For) //更新后立即刷新可见（影响性能，按需注释或使用）
                .withDocument(document)
                .build();
        restTemplate.update(build, IndexCoordinates.of(indexName));
    }

    @Override
    public void updateByEntities(List<T> entities) {
        Class<T> clazz =(Class<T>) entities.get(0).getClass();
        String indexName = indexNameExceptionHandler(clazz);
        List<UpdateQuery> updateQueries = new ArrayList<>();
        entities.forEach(item->{
            Document document = Document.parse(JSON.toJSONString(item));
            document.setId(getPrimaryValueByEntity(item));
            UpdateQuery build = UpdateQuery.builder(document.getId())
                    .withRefresh(UpdateQuery.Refresh.Wait_For)
//                    .withDocAsUpsert(true) //不加默认false。true表示更新时不存在就插入
                    .withDocument(document)
                    .build();
            updateQueries.add(build);
        });
        restTemplate.bulkUpdate(updateQueries,IndexCoordinates.of(indexName));
    }

    @Override
    public String deleteById(String id, Class<T> clazz) {
        String indexName = indexNameExceptionHandler(clazz);
        return restTemplate.delete(id,IndexCoordinates.of(indexName));
    }

    @Override
    public void deleteByIds(List<String> ids, Class<T> clazz) {
        String indexName = indexNameExceptionHandler(clazz);
        StringQuery query = new StringQuery(QueryBuilders.termsQuery(getPrimaryNameByClass(clazz), ids).toString());
        restTemplate.delete(query,clazz,IndexCoordinates.of(indexName));
    }

    @Override
    public void deleteByQuery(Query query,Class<T> clazz) {
        String indexName = indexNameExceptionHandler(clazz);
        restTemplate.delete(query,clazz,IndexCoordinates.of(indexName));
    }

    @Override
    public T getEntityById(String id,Class<T> clazz) {
        return restTemplate.get(id,clazz);
    }

    @Override
    public List<T> getEntityByIds(List<String> ids, Class<T> clazz) {
        String indexName = indexNameExceptionHandler(clazz);
        NativeSearchQuery build = new NativeSearchQueryBuilder().withIds(ids).build();
        return restTemplate.multiGet(build, clazz, IndexCoordinates.of(indexName));
    }

    @Override
    public Long getCount(Query query,Class<T> clazz) {
        return restTemplate.count(query,clazz);
    }

    @Override
    public List<T> getInfoList(Query query,Class<T> clazz,Boolean isHighLight) {
        query.setTrackTotalHits(true);
        SearchHits<T> search = restTemplate.search(query,clazz);
        if (isHighLight){
            return mappingHighlight(search.getSearchHits());
        }
        List<T> infoList = new ArrayList<>();
        for (SearchHit<T> searchHit : search){
            infoList.add(searchHit.getContent());
        }
        return infoList;
    }

    @Override
    public Map<String, Object> getPageList(Query query, PageRequest pageRequest,Class<T> clazz) {
        query.setTrackTotalHits(true);
        query.setPageable(pageRequest);
        SearchHits<T> search = restTemplate.search(query,clazz);
        Aggregations aggregations = search.getAggregations();
        List<SearchHit<T>> searchHits = search.getSearchHits();
        List<T> esSourceInfos = mappingHighlight(searchHits);
        Page infos = new PageImpl(
                esSourceInfos,
                pageRequest,
                search.getTotalHits());
        Map<String, Object> map = new HashMap<>();
        map.put("page",infos);
        map.put("ag",formatFacet(aggregations));
        return map;
    }

    @Override
    public Map<String, List<? extends Terms.Bucket>> getFacetByQuery(SearchSourceBuilder query, Class<T> clazz) throws IOException {
        String indexName = indexNameExceptionHandler(clazz);
        SearchRequest request = new SearchRequest(indexName);
        SearchSourceBuilder builder = query;
        request.source(builder);
        SearchResponse response = highLevelClient.search(request, RequestOptions.DEFAULT);
        Aggregations aggregations = response.getAggregations();
        return formatFacet(aggregations);
    }


    /**
     * 格式化聚类数据
     * @author Innocence
     * @date 2021/3/18
     * @param aggregations
     * @return java.util.Map<java.lang.String,java.util.List<java.util.Map<java.lang.String,java.lang.Object>>>
     */
    private Map<String, List<? extends Terms.Bucket>> formatFacet(Aggregations aggregations){
        if (aggregations == null){
            return null;
        }
        Map<String, List<? extends Terms.Bucket>> map = new HashMap<>();
        List<Aggregation> list = aggregations.asList();
        list.forEach(item->{
            ParsedStringTerms newItem = (ParsedStringTerms) item;
            String name = newItem.getName();
            List<? extends Terms.Bucket> buckets = newItem.getBuckets();
            map.put(name,buckets);
        });
        return map;
    }
}

 5.使用示例，使用@Autowired自动注入，并且带上泛型类

package com.cqvip.innocence.tests;

import com.cqvip.innocence.project.esservice.DocumentService;
import com.cqvip.innocence.project.esservice.IndexService;
import com.cqvip.innocence.project.model.entity.EsTestInfo;
import org.apache.commons.lang3.builder.ToStringExclude;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName EsTest
 * @Description TODO
 * @Author Innocence
 * @Date 2021/6/16 14:05
 * @Version 1.0
 */
@SpringBootTest
public class EsTest {

    @Autowired
    private IndexService<EsTestInfo> indexService;

    @Autowired
    private DocumentService<EsTestInfo> documentService;

    @Test
    public void indexOperation(){
        Boolean index = indexService.createIndexByClass(EsTestInfo.class);
        System.out.println("index = " + index);
    }

    @Test
    public void saveByEntity(){
        EsTestInfo esTestInfo = new EsTestInfo();
        esTestInfo.setAge(20);
        esTestInfo.setInfoId("test_02");
        esTestInfo.setName("一库一库");
        esTestInfo.setSex("男");
        String entity = null;
        try {
            entity = documentService.saveByEntity(esTestInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("entity = " + entity);
    }

    @Test
    public void isExist(){
        Boolean test_01 = documentService.isExist("test_01", EsTestInfo.class);
        System.out.println("test_01 = " + test_01);
    }

    @Test
    public void updateByEntity(){
        EsTestInfo info = documentService.getEntityById("test_01", EsTestInfo.class);
        info.setName(info.getName()+"_update");
        documentService.updateByEntity(info);
    }

    @Test
    public void deleteById(){
        String deleteById = documentService.deleteById("test_01", EsTestInfo.class);
        System.out.println("deleteById = " + deleteById);
    }

    @Test
    public void saveBatchByEntities(){
        List<EsTestInfo> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            EsTestInfo info = new EsTestInfo();
            info.setInfoId("test_batch_"+(i+1)+"");
            info.setName("name_batch_"+(i+1)+"");
            info.setSex("N");
            info.setAge((i+1)*10);
            info.setRoles(new String[]{"管理员","超级管理员"});
            list.add(info);
        }
        try {
            documentService.saveBatchByEntities(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void getInfoList(){
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.wildcardQuery("infoId","test_batch_*"));
        NativeSearchQuery build = queryBuilder.withQuery(boolQuery).build();
        List<EsTestInfo> infoList = documentService.getInfoList(build,EsTestInfo.class,true);
    }

    @Test
    public void count(){
        Long count = documentService.getCount(new NativeSearchQueryBuilder().build(),EsTestInfo.class);
        System.out.println("count = " + count);
    }

    @Test
    public void deleteByIds(){
        ArrayList<String> strings = new ArrayList<>();
        strings.add("test_01");
        strings.add("test_02");
        Class<EsTestInfo> clazz = EsTestInfo.class;
        documentService.deleteByIds(strings, clazz);
    }

    @Test
    public void update() {
        EsTestInfo info = new EsTestInfo();
        info.setName("wait_for");
        info.setInfoId("test_batch_wait_for_2");
        documentService.saveByEntity(info);
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
                .must(QueryBuilders.wildcardQuery("infoId","test_batch_*"));
        NativeSearchQuery build = queryBuilder.withQuery(boolQuery).build();
        List<EsTestInfo> infoList = documentService.getInfoList(build,EsTestInfo.class);
        System.out.println("infoList = " + infoList);
    }
}

 

菜菜的小咸鱼
关注
专栏目录
SpringBoot集成ElasticsearchRestTemplate
abaibai12的博客
03-02 2565
SpringBoot集成ElasticsearchRestTemplate 具体使用操作
Springboot 集成 ElasticSearch 7.14.1 ，ElasticsearchRestTemplate是个啥？
HeartException的博客
09-24 1210
ElasticSearch 7.14.1 基操pomapplicantion.ymlpojoDocument 注解映射注释概述（摘自官网）索引设置（摘自官网） pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schema
【Java】SpringBoot快速整合ElasticSearch
m0_64210833的博客
12-29 9044
SpringBoot快速整合ElasticSearch
Elasticsearch 批量删除操作示例
Leon_Jinhai_Sun的博客
09-26 366
Elasticsearch 批量删除操作示例
SpringBoot集成ES之ElasticsearchRestTemplate
weixin_42619846的博客
05-08 2752
之前写的那边那篇SpringBoot集成ES，现在已经不推荐使用的。 建议使用RestHighLevelClient也是官网推荐的。 简单操作使用ElasticsearchRestTemplate就好了，它只是Spring对RestHighLevelClient进行了封装 pom.xml <dependency> <groupId>org.springframework.boot</groupId>
SpringBoot 使用ElasticsearchRestTemplate
hbzslb的博客
09-05 2402
SpringBoot 使用ElasticsearchRestTemplate 简单使用
springboot集成es7.9.1及实现es用户登录
09-29
springboot集成es7.9.1，实现索引的创建删除查看；文档的增删改查等基本方法； 实现es用户登录
springboot整合es-springboot-elasticsearch.zip
11-07
SpringBoot整合Elasticsearch是现代Java开发中常见的一项任务，因为SpringBoot的便捷性和Elasticsearch的高效搜索能力，使得这种结合在数据检索、分析和日志存储等领域广泛应用。本项目"springboot-elasticsearch-...
最新版本springboot集成elasticsearch
05-25
一般来说我们开发Elasticsearch会选择使用集成springboot，在网上找的springboot集成elasticsearch文章几乎都是extends ElasticsearchRepository的方式来实现。但是新版本ElasticsearchRepository里的方法基本上已经...
基于SpringBoot的Elasticsearch客户端调用封装工具设计源码
03-29
EsClientRHL是一个可基于springboot的elasticsearch客户端调用封装工具，通过elasticsearch官网推荐的RestHighLevelClient实现，内置了es索引结构工具、es索引数据增删改工具、es查询工具、es数据分析工具或者es。...
基于SpringBoot和Elasticsearch的Java在线题库系统设计源码
最新发布
10-03
本项目是一款基于SpringBoot和Elasticsearch技术的Java在线题库系统源码，包含511个文件，其中Java源文件191个，HTML文件83个，JavaScript文件79个，CSS文件42个，XML配置文件35个，以及各类图片、字体文件等资源。...
SpringBoot之ElasticsearchRestTemplate常用示例.rar
12-31
SpringBoot之ElasticsearchRestTemplate常用示例
Elasticsearch 7.X SpringBoot 使用 ElasticsearchRestTemplate 操作 ES
热门推荐
小毕超博客
01-03 1万+
一、ElasticsearchRestTemplate 前面学习了es rest接口对es进行操作的方式，并且还学习了es的分片及扩容，有讲解了几种常见的分词器，喜欢的小伙伴可以看下本专栏的其他文章，本篇主要将 在 SpringBoot 中使用ElasticsearchRestTemplate 对ES进行操作。 对于SpringBoot对ES的操作早在以前我就写过一篇文章，但那时基于ES 6.X 的，在新版本的ES中都已经不建议使用了。 注意: 在网上还有些教程是使用TransportClient进行操作的
SpringBoot整合 ElasticSearchRestTemplate使用
smile_boyyy的博客
03-28 3949
ElasticSearch ElasticRestTemplate使用 环境准备 SpringBoot 2.4.3 es版本 7.11.1 jdk 1.8 application.yml #因为本机9200是默认链接地址，未设置用户名密码，唯一未配，如需配置，以下地址配置 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-omRDYdeP-1616901668266)(C:\Users\huyonghao\AppData\Roaming\Typora\typora-us
Springboot项目中使用Elasticsearch的RestClient
程序员半支烟，wechat：yclxiao
04-27 1559
选择RestHighLevelClient作为ES的RestClient。核心步骤：增加properties配置、引入pom、配置conf类。调用API、使用DSL语法。本篇完结！！！Springboot项目中使用Elasticsearch的RestClient - 不焦躁的程序员Springboot项目中使用Elasticsearch的RestClient。
比较详细的Springboot整合Elasticsearch使用ElasticsearchRestTemplate处理搜索结果的分段显示、高光显示
BigCanda的博客
04-13 1940
使用ElasticsearchRestTemplate实现高光、分段的中文关键词搜索结果获取。
springboot结合es，使用ElasticsearchRestTemplate
qq_40293993的博客
05-21 1753
首先说一下，es的版本号很重要，版本号不对，各种失败。我是先装的es，kibana,后新建的项目，结果启动报错，日志写着用高版本es，直接重装了又。 我的spring-boot-starter-parent是2.4.5版本，对应的es是7.9.3,启动的时候会有日志显示。 pom中添加es依赖 <dependency> <groupId>org.springframework.boot</groupId> &.
基于spring-boot整合data-elasticsearch(4.0.3)使用ElasticsearchRestTemplate的相关操作
YINJOER的博客
09-17 2032
ElasticsearchRestTemplate操作方法 本次从以下几个内容分享: 导入依赖 配置连接ES的属性 编码实现 导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> </depend
SpringBoot之ElasticsearchRestTemplate常用示例
m0_67392126的博客
06-12 4029
2.application 配置 3.JavaBean配置以及ES相关注解 3.1 Student实体类 3.2 Teacher实体类 3.3 Headmaster 实体类 4. 启动类配置 5.elasticsearchRestTemplate 新增 5.1 createIndex && putMapping 创建索引及映射 createIndex && putMapping 创建索引及映射测试import com.it.mhh.elasticsearch.servi
基于SpringBoot和Elasticsearch的博客系统开发项目
资源摘要信息:"该项目为一个基于Spring Boot技术栈构建的博客系统，同时也结合了Vue前端框架和MySQL数据库。系统采用了前后端分离的开发模式，旨在提供一个高效、稳定且易用的博客平台。通过使用Spring Boot框架，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值