Elasticsearch8搭建及Springboot中集成使用_elasticsearch8安装配置

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注运维）

正文

private List<T> getResult(Class<T> target, List<T> result, SearchResponse<HashMap> search) {
    List<Hit<HashMap>> hits = search.hits().hits();
    Iterator<Hit<HashMap>> iterator = hits.iterator();
    while (iterator.hasNext()) {
        Hit<HashMap> decodeBeanHit = iterator.next();
        Map<String, Object> docMap = decodeBeanHit.source();
        docMap.put("id", decodeBeanHit.id());
        String json = JSON.toJSONString(docMap);
        T obj = JSON.parseObject(json, target);
        result.add(obj);
    }
    return result;
}

/**
 * @param
 * @param client
 * @param dto
 * @return long
 * @author liuch
 * @description 根据关键字查询总条数
 * @date 2022/4/2 17:15
 */
public static long queryCountByFiled(ElasticsearchClient client, EsQueryDTO dto) throws Exception {
    CountResponse count = client.count(c -> c.index(dto.getIndexName()).query(q -> q.term(t -> t
            .field(dto.getField())
            .value(dto.getWord())
    )));
    long total = count.count();
    return total;
}

/**
 * @param
 * @param client
 * @param dto
 * @return long
 * @author liuch
 * @description 根据关键字查询总条数-复合查询
 * @date 2022/4/2 17:15
 */
public static long queryCountByFileds(ElasticsearchClient client, List<Query> queries, EsQueryDTO dto) throws Exception {
    getFieldValues(dto, queries);
    CountResponse count = client.count(c -> c.index(dto.getIndexName()).query(q -> q.bool(b -> b.must(queries))));
    long total = count.count();
    return total;
}


/**
 * @param client
 * @param dto
 * @param target
 * @return java.util.List<T>
 * @author liuch
 * @description 根据关键字分页查询- 复合查询  must
 * @date 2022/4/2 17:15
 */
public List<T> queryMustByFiledsWithPage(ElasticsearchClient client, EsQueryDTO dto, List<Query> queries, Class<T> target) throws Exception {
    List<T> result = new ArrayList<>();
    List<SortOptions> sorts = new ArrayList<>();
    if (StringUtils.isNotBlank(dto.getOrder())) {
        SortOptions sortOptions = SortOptions.of(s -> s
                .field(f -> f.field(dto.getOrder()).order(SortOrder.valueOf(dto.getOrderType()))));
        sorts.add(sortOptions);
    }
    SearchResponse<HashMap> search = client.search(s -> s
                    .index(dto.getIndexName())
                    .query(q -> q.bool(b -> b.must(queries)))
                    .sort(sorts).from(dto.getFrom()).size(dto.getSize()),
            HashMap.class);
    return getResult(target, result, search);
}

/**
* @param client
* @param dto
* @param target
* @return java.util.List
* @author liuch
* @description 根据关键字分页查询- 复合查询 must 过滤
* @date 2022/4/2 17:15
*/
public List queryMustByFiledsWithPage(ElasticsearchClient client, EsQueryDTO dto, List queries, List filters, Class target) throws Exception {
List result = new ArrayList<>();
List sorts = new ArrayList<>();
if (StringUtils.isNotBlank(dto.getOrder())) {
SortOptions sortOptions = SortOptions.of(s -> s
.field(f -> f.field(dto.getOrder()).order(SortOrder.valueOf(dto.getOrderType()))));
sorts.add(sortOptions);
}
SearchResponse search = client.search(s -> s
.index(dto.getIndexName())
.query(q -> q.bool(b -> b.must(queries).filter(filters)))
.sort(sorts).from(dto.getFrom()).size(dto.getSize()),
HashMap.class);
return getResult(target, result, search);
}

/**
 * @param client
 * @param dto
 * @param target
 * @return java.util.List<T>
 * @author liuch
 * @description 根据关键字分页查询- 复合查询  should
 * @date 2022/4/2 17:15
 */
public List<T> queryShouldByFiledsWithPage(ElasticsearchClient client, EsQueryDTO dto, List<Query> queries, Class<T> target) throws Exception {
    List<T> result = new ArrayList<>();
    List<SortOptions> sorts = new ArrayList<>();
    if (StringUtils.isNotBlank(dto.getOrder())) {
        SortOptions sortOptions = SortOptions.of(s -> s
                .field(f -> f.field(dto.getOrder()).order(SortOrder.valueOf(dto.getOrderType()))));
        sorts.add(sortOptions);
    }
    SearchResponse<HashMap> search = client.search(s -> s
                    .index(dto.getIndexName())
                    .query(q -> q.bool(b -> b.should(queries)))
                    .sort(sorts).from(dto.getFrom()).size(dto.getSize()),
            HashMap.class);
    return getResult(target, result, search);
}

/**
 * 构件复合查询条件
 *
 * @param dto
 * @param queries
 */
private static void getFieldValues(EsQueryDTO dto, List<Query> queries) {
    List<FieldValue> fieldValues = new ArrayList<>();
    //根据关键字列表构件复合查询的值
    dto.getWords().stream().forEach(word -> fieldValues.add(FieldValue.of(word)));
    //查询条件列表
    queries.add(Query.of(q -> q.terms(t -> t.field(dto.getField()).terms(v -> v.value(fieldValues)))));
}


/**
 * @param
 * @param client
 * @param dto
 * @param target
 * @return java.lang.Object
 * @author liuch
 * @description 根据文档id查询
 * @date 2022/4/2 17:16
 */
public Object queryByDocumentId(ElasticsearchClient client, EsQueryDTO dto, Class<T> target) throws Exception {
    GetResponse<HashMap> getResponse = client.get(s -> s
                    .index(dto.getIndexName()).id(dto.getWord()),
            HashMap.class);
    getResponse.source();
    Map<String, Object> docMap = getResponse.source();
    String json = JSON.toJSONString(docMap);
    T obj = JSON.parseObject(json, target);
    return obj;
}

}

#### 2.4.4.基础操作接口

/**
 * 基础操作—接口
 */
public interface IElasticSearchIRepository<T, V> {

int delete(V id);

int update(T entity);

T getById(V id);

List<T> getAll();

long count();

PageInfo<T> getListByPage(int pageIndex, int pageSize);

/**
 * 新增一个文档
 *
 * @param entity 实体类
 * @return
 */
IndexResponse createByFluentDSL(T entity);

/**
 * 新增一个文档
 *
 * @param entity 实体类
 * @return
 */
IndexResponse createByBuilderPattern(T entity);

/**
 * 批量增加文档
 *
 * @param list 对象集合
 * @return 批量操作的结果
 */
BulkResponse bulkCreate(List<T> list);

/**
* 根据文档id查找文档，返回类型是ObjectNode
*
* @param id 文档id
* @return ObjectNode类型的查找结果
*/
ObjectNode getObjectNodeById(V id);

/**
 * 批量删除文档
 *
 * @param docIds  要删除的文档id集合
 * @return
 * @throws Exception
 */
BulkResponse bulkDeleteByIds(List<V> docIds);

/**
 * 根据文档id删除文档
 *
 * @param idxName 索引名
 * @param docId   文档id
 * @return Object类型的查找结果
 * @throws Exception
 */
Boolean deleteById(String idxName, String docId) throws IOException;


/**

* 新建索引，指定索引名称
     *
     */
    Boolean createIndex();

/**
     * 创建索引，指定索引名称和setting和mapping
     *
     * @param settingFn - 索引参数
     * @param mappingFn - 索引结构
     */
    Boolean createIndex(Function<IndexSettings.Builder, ObjectBuilder> settingFn,
                     Function<TypeMapping.Builder, ObjectBuilder> mappingFn);

/**
     * 删除索引
     * @throws IOException
     */
    Boolean deleteIndex();

/**
     * 修改索引字段信息

     * 字段可以新增，已有的字段只能修改字段的 search_analyzer 属性。
     *
     * @param propertyMap - 索引字段，每个字段都有自己的property
     * @throws IOException
     */
    Boolean updateIndexProperty(HashMap<String, Property> propertyMap);

/**
     * 查询索引列表
     *
     * @return
     * @throws IOException
     */
    GetIndexResponse getIndexList();

/**
     * 查询索引详情
     *
     * @return
     * @throws IOException
     */
    GetIndexResponse getIndexDetail();

/**
     * 检查指定名称的索引是否存在
     *
     * @return - true：存在
     * @throws IOException
     */
    boolean indexExists();

}

#### 2.4.5.基础操作接口实现类

public abstract class ElasticSearchIRepository<T,V> implements IElasticSearchIRepository<T,V> {

@Autowired(required =false)
@Qualifier("elasticsearchClient")
private ElasticsearchClient elasticsearchClient;

protected ElasticSearchDocument getEntityProperties() {
    Class<T> cls = getEntityClass();
    ElasticSearchDocument esDoc = cls.getAnnotation(ElasticSearchDocument .calss);
    return esDoc;
}

/**设置索引全局配置*/
protected abstract Function<IndexSettings.builder, ObjectBuilder<IndexSettings>> getIndexSettings();

/**手动设置映射（不手动设置会自动创建映射，同时在插入时若手动映射时没有的字段也会自动创建）*/
protected abstract Function<TypeMapping.builder, ObjectBuilder<TypeMapping>> getIndexMappings();

protected abstract Class<T> getEntityClass();


@Override
public int update(T entity) {
     try {
        ElasticSearchDocument doc = getEntityProperties();
        UpdateRequest updateRequest = new UpdateRequest.Builder()
                .index(doc.index())
                .id(entity.getId().toString())
                .doc(entity)
                .build();
        UpdateResponse updateResponse = elasticsearchClient.update(updateRequest, entity.getClass());
        return updateResponse != null && StringUtils.isNotEmpty(updateResponse.id()) ? 1 : 0;
     }
     catch (IOException e) {
        log.error(e);
     }
     return 0;
}

@Override
public PageInfo getListByPage(int pageIndex, int pageSize) {
List list = new ArrayList<>();
try {
ElasticSearchDocument doc = getEntityProperties();
ElasticClientUtils elasticClientUtils = new ElasticClientUtils();
EsQueryDTO dto = new EsQueryDTO();
dto.setIndex(paeIndex);
dto.setSize(pageSize);
dto.setIndexName(doc.index());
list = elasticClientUtils.queryPage(elasticsearchClient, dto, getEntityClass());
return new PageInde(pageIndex, pageSize, (long)list.size(), list);
}
catch (IOException e) {
log.error(e);
}
return new PageInde(pageIndex, pageSize, 0L, list);
}

@Override
public int delete(V id) {
try {
ElasticSearchDocument doc = getEntityProperties();
DeleteResponse delete = elasticsearchClient.delete(d -> d
.index(doc.index())
.id(id.toString()));
return delete.forcedRefresh() ? 1 : 0;
}
catch (IOException e) {
log.error(e);
}
return 0;
}

@Override
public List<T> getAll() {
     try {
        ElasticSearchDocument doc = getEntityProperties();
        ElasticClientUtils elasticClientUtils = new ElasticClientUtils();
        EsQueryDTO dto = new EsQueryDTO();
        dto.setIndexName(doc.index());
        return elasticClientUtils.queryAll(elasticsearchClient, dto, getEntityClass());
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public long count() {
     try {
        ElasticSearchDocument doc = getEntityProperties();
        EsQueryDTO dto = new EsQueryDTO();
        dto.setIndexName(doc.index());
        return ElasticClientUtils.queryCountByFiled(elasticsearchClient, dto);
     }
     catch (IOException e) {
        log.error(e);
     }
     return 0;
}

@Override
public IndexResponse createByFluentDSL(T entity) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        IndexResponse response = elasticsearchClient.index(index -> idx
                 .index(doc.index())
                 .id(entity.getId().toString())
                 .document(entity));
        return response;
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public IndexResponse createByBuilderPattern(T entity) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        IndexRequest.Builder<Object> indexReqBuilder = new IndexRequest.Builder<>();

        indexReqBuilder.index(doc.index());
        indexReqBuilder.id(entity.getId().toString());
        indexReqBuilder.document(entity);
        return elasticsearchClient.index(indexReqBuilder.build());
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public BulkResponse bulkCreate(List<T> documents) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        BulkRequest.Builder br = new BulkRequest.Builder();
        documents.stream()
            .forEach(esDocument -> br
                    .operations(op -> op
                            .index(idx -> idx
                                    .index(doc.index())
                                    .id(esDocument.getId().toString())
                                    .document(esDocument))));

        return elasticsearchClient.bulk(br.build());
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public T getById(V id) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        GetResponse<Object> response = elasticsearchClient.get(g -> g
                    .index(doc.index())
                    .id(id.toString()),
            Object.class);
    return response.found() ? FastJsonUtil.fromJson(response.source().toString(), getEntityClass()) : null;
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public ObjectNode getObjectNodeById(V id) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        GetResponse<ObjectNode> response = elasticsearchClient.get(g -> g
                    .index(doc.index())
                    .id(id.toString()),
            ObjectNode.class);

    return response.found() ? response.source() : null;
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}



@Override
public BulkResponse bulkDeleteByIds(List<V> docIds) {

    try {
        ElasticSearchDocument doc = getEntityProperties();
        BulkRequest.Builder br = new BulkRequest.Builder();

         // 将每一个对象都放入builder中
         docIds.stream().forEach(id -> br
            .operations(op -> op
                    .delete(d -> d
                            .index(doc.index())
                            .id(id.toString()))));

         return elasticsearchClient.bulk(br.build());
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

/*自动创建映射/
@Override
public Boolean createIndex() {
try {
ElasticSearchDocument doc = getEntityProperties();
CreateIndexResponse response = elasticsearchClient.indices().create(c -> c.index(doc.index()));
log.info(“createIndex方法，acknowledged={}”, response.acknowledged());
return response.acknowledged();
}
catch (IOException e) {
log.error(e);
}
return false;
}

/**手动创建映射*/
@Override
public Boolean createIndex(Function<IndexSettings.Builder, ObjectBuilder<IndexSettings>> settingFn,
                        Function<TypeMapping.Builder, ObjectBuilder<TypeMapping>> mappingFn) {

    try {
        ElasticSearchDocument doc = getEntityProperties();
        CreateIndexResponse response = elasticsearchClient
            .indices()
            .create(c -> c
                    .index(doc.index())
                    .settings(settingFn)
                    .mappings(mappingFn)
            );
    log.info("createIndex方法，acknowledged={}", response.acknowledged());
      return response.acknowledged();
     }
     catch (IOException e) {
        log.error(e);
     }
     return false;
    
}

@Override
public Boolean deleteIndex() {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        DeleteIndexResponse response = elasticsearchClient.indices().delete(c -> c.index(doc.index()));
    log.info("deleteIndex方法，acknowledged={}", response.acknowledged());
    return response.acknowledged();
     }
     catch (IOException e) {
        log.error(e);
     }
     return false;
    
}

@Override
public Boolean updateIndexProperty(HashMap<String, Property> propertyMap) {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        PutMappingResponse response = elasticsearchClient.indices()
            .putMapping(typeMappingBuilder ->
                    typeMappingBuilder
                            .index(doc.index())
                            .properties(propertyMap)
            );
    log.info("updateIndexMapping方法，acknowledged={}", response.acknowledged());
    return response.acknowledged();
     }
     catch (IOException e) {
        log.error(e);
     }
     return false;
}

@Override
public GetIndexResponse getIndexList() {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        //使用 * 或者 _all都可以
    GetIndexResponse response = elasticsearchClient.indices().get(builder -> builder.index("_all"));
    log.info("getIndexList方法，response.result()={}", response.result().toString());
    return response;
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}

@Override
public GetIndexResponse getIndexDetail() {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        GetIndexResponse response = elasticsearchClient.indices().get(builder -> builder.index(doc.index()));
    log.info("getIndexDetail方法，response.result()={}", response.result().toString());
    return response;
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
    
}

@Override
public boolean indexExists() {
    try {
        ElasticSearchDocument doc = getEntityProperties();
        return elasticsearchClient.indices().exists(b -> b.index(doc.index())).value();
     }
     catch (IOException e) {
        log.error(e);
     }
     return null;
}  

}

### 2.5.业务


#### 2.5.1.接口



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）**
![img](https://img-blog.csdnimg.cn/img_convert/446cb3b98373f534dd6bd40c254ebaba.jpeg)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
n null;
        
    }

    @Override
    public boolean indexExists() {
        try {
            ElasticSearchDocument doc = getEntityProperties();
            return elasticsearchClient.indices().exists(b -> b.index(doc.index())).value();
         }
         catch (IOException e) {
            log.error(e);
         }
         return null;
    }  

}

2.5.业务

2.5.1.接口

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）
[外链图片转存中…(img-xclQlmUg-1713130485094)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！