elasticSearch 8.2.3 + spring boot + es client 极快上手

使用前提：

安装jdk, 最低1.8 ，尽量新版本，配置好java_home

第一步：下载

es下载地址：https://www.elastic.co/downloads/past-releases#elasticsearch 选择 8.2.3 版本

ik分词器下载：https://github.com/medcl/elasticsearch-analysis-ik
拼音分词器下载：自己百度一下，类似

第二步： 解压

以windows 版本为例（linux 把windows 配置的打包上去也是可以的，这里不做单独介绍）

1：把 elasticsearch-8.2.3 解压到你想要的盘
2：elasticsearch-8.2.3 里面找到 plugins 文件夹 ，进入，新建文件夹analysis-ik
3：把下载好的ik分词器8.2.3 解压到创建好的文件夹里面

第三步：编辑配置

回到elasticsearch-8.2.3 文件夹，进入config 目录
编辑：elasticsearch.yml 文件
添加：
#跨域
http.cors.enabled: true
http.cors.allow-origin: “*”
#ssl认证 改为false
xpack.security.http.ssl:
enabled: false
keystore.path: certs/http.p12

编辑 jvm.options 文件
#虚拟机参数，默认是4g，我的电脑没有这么大内存，你们可以自行调节
-Xms512m
-Xmx512m

第四步：启动

回到elasticsearch-8.2.3 文件夹，进入 bin 文件夹，启动 elasticsearch.bat
启动失败：可能会提示你jdk 版本过低，或者 找不到java_home ,es_home ,自己上网解决
启动成功：第一次启动成功会出现账户密码，
访问 你的 ip:9200
注意：如果没有记住账户密码，就要 修改 elasticsearch.yml 取消密码验证
进入es 后删除一个授权认证的索引.security-7，再修改需要认证，再重新启动（不懂就百度）

第五步：下载 elasticsearch-head

可以下载安装 elasticsearch-head
也可以使用谷歌浏览器的插件 (推荐快速上手使用)：Multi elasticsearch head


好了，es 现在开始就安装完成了

第六步：集成spring boot

java 操作es 有好几种方式
今天介绍使用的是基于 lambda 表达式的 es Client
maven

  <!-- ES java api -->
        <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.2.3</version>
        </dependency>
        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>

yml

# spring相关配置
spring:
  elasticsearch:
    rest:
      uris: localhost:9200
      username: elastic
      password: nIFNHw9FyrB7UnW*Rh9p
      connection-timeout: 10s

第七步：es crud

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.SortOrder;
import co.elastic.clients.elasticsearch._types.mapping.Property;
import co.elastic.clients.elasticsearch._types.query_dsl.Query;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.search.Highlight;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.indices.CreateIndexResponse;
import co.elastic.clients.transport.endpoints.BooleanResponse;
import co.elastic.clients.util.ObjectBuilder;
import com.find.home.common.entity.EsDTO;
import com.find.home.common.entity.EsResDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;


/**
 * EsClient 
 *
 * @author admin
 */

@Component
@Slf4j
public class EsClient {

    /**
     * 索引名称
     */
    public static final String HOUSE_INDEX = "xxxxx";

    @Resource
    private ElasticsearchClient client;

    /**
     * 判断索引是否存在
     *
     * @return
     * @throws Exception
     */
    public Boolean isExistsIndex() throws IOException {
        BooleanResponse exists = client.indices().exists(o -> o.index(HOUSE_INDEX));
        return exists.value();
    }

    /**
     * 创建索引并添加mapping字段映射
     *
     * @throws Exception
     */
    public boolean createIndex() throws Exception {
        log.info("创建ES索引开始");
        // 新的索引有三个字段，每个字段都有自己的property，这里依次创建
        Property keywordProperty = Property.of(o -> o.keyword(kBuilder -> kBuilder));
        //ik_smart,试过拼音分词器，想过不理想
        Property textProperty = Property.of(o -> o.text(tBuilder -> tBuilder.analyzer("ik_max_word").searchAnalyzer("ik_smart")));
        Property integerProperty = Property.of(o -> o.integer(iBuilder -> iBuilder));
        Property longProperty = Property.of(o -> o.long_(lBuilder -> lBuilder));
        Property dateProperty = Property.of(o -> o.date(dBuilder -> dBuilder.format("yyyy-MM-dd HH:mm:ss")));

        Map<String, Property> esDTO = new HashMap<>(16);
        esDTO.put("id", longProperty);
        esDTO.put("groupName", textProperty);
        esDTO.put("provinceCode", integerProperty);
        esDTO.put("cityCode", integerProperty);
        esDTO.put("areaCode", integerProperty);
        esDTO.put("isZjCount", integerProperty);
        esDTO.put("isRentCount", integerProperty);
        esDTO.put("dbGroupId", longProperty);
        esDTO.put("createTime", dateProperty);
        esDTO.put("sendTime", dateProperty);
        esDTO.put("doubanUrl", keywordProperty);
        esDTO.put("images", keywordProperty);
        esDTO.put("title", textProperty);
        esDTO.put("content", textProperty);
        esDTO.put("houseType", integerProperty);
        esDTO.put("rentType", integerProperty);
        esDTO.put("gender", integerProperty);
        esDTO.put("bedroomType", integerProperty);
		//设置分片和映射
        CreateIndexResponse createIndexResponse = client.indices()
                .create(c -> c.index(HOUSE_INDEX)
                        .settings(s -> s.numberOfShards("1").numberOfReplicas("1"))
                        .mappings(m -> m.properties(esDTO)));
        log.info("创建ES索引结束,结果：{}", createIndexResponse.acknowledged());
        return createIndexResponse.acknowledged();
    }


    /**
     * 通过id 查询数据
     *
     * @param id id
     * @return EsDTO
     * @throws IOException
     */
    public EsDTO getById(Long id) throws IOException {
        GetResponse<EsDTO> response = client.get(g -> g
                        .index(HOUSE_INDEX)
                        .id(id   ""),
                EsDTO.class
        );
        return response.source();
    }

    /**
     * 条件查询，不分页
     *
     * @param query
     * @return
     * @throws IOException
     */
    public List<EsDTO> getList(Query query) throws IOException {
        List<EsDTO> list = new ArrayList<>();
        SearchResponse<EsDTO> response = client.search(s -> s
                        .index(HOUSE_INDEX)
                        .query(query),
                EsDTO.class
        );
        List<Hit<EsDTO>> hits = response.hits().hits();
        for (Hit<EsDTO> hit : hits) {
            list.add(hit.source());
        }
        return list;
    }

    /**
     * 分页查询
     *
     * @param query 查询参数
     * @param size  每页大小
     * @param from  第几页
     * @return
     * @throws IOException
     */
    public EsResDTO getPage(Query query, int from, int size) {
    	//高亮
        Highlight of = Highlight.of(h -> {
                    h.fields("title", hf -> hf.preTags("<em>").postTags("</em>"));
                    h.fields("content", hf -> hf.preTags("<em>").postTags("</em>"));
                    return h;
                }
        );
        List<EsDTO> list = new ArrayList<>();
        SearchResponse<EsDTO> response = null;
        Function<SearchRequest.Builder, ObjectBuilder<SearchRequest>> searchRequest = builder -> {
            builder.index(HOUSE_INDEX)
                    .query(query)
                    .size(size)
                    .from(from)
                    .sort(so -> so.score(ss -> ss.order(SortOrder.Desc)))
                    .sort(so -> so.field(v -> v.field("sendTime").order(SortOrder.Desc)))
                    .highlight(of);
            return builder;
        };
        try {
            response = client.search(searchRequest, EsDTO.class);
        } catch (Exception e) {
            log.error("es 查询出错：{}", e.getMessage());
            e.printStackTrace();
        }
        List<Hit<EsDTO>> hits = response.hits().hits();
        for (Hit<EsDTO> hit : hits) {
            EsDTO source = hit.source();
            Map<String, List<String>> highlight = hit.highlight();
            source.setHighlight(highlight);
            list.add(source);
        }
        EsResDTO esResDTO = new EsResDTO();
        esResDTO.setList(list);
        esResDTO.setTotal(response.hits().total().value());
        return esResDTO;
    }


    /**
     * 单个保存(修改id 一样就会修改)
     *
     * @param esDTO
     * @return
     * @throws IOException
     */
    public String save(EsDTO esDTO) throws IOException {
        IndexRequest.Builder<EsDTO> indexReqBuilder = new IndexRequest.Builder<>();
        indexReqBuilder.index(HOUSE_INDEX);
        indexReqBuilder.id(esDTO.getId()   "");
        indexReqBuilder.document(esDTO);
        IndexResponse response = client.index(indexReqBuilder.build());
        return response.id();
    }

    /**
     * 批量添加
     *
     * @param list
     * @throws IOException
     */
    public void bulkSave(List<EsDTO> list) throws IOException {
        BulkRequest.Builder br = new BulkRequest.Builder();
        for (EsDTO o : list) {
            br.operations(op -> op
                    .index(idx -> idx
                            .index(HOUSE_INDEX)
                            .id(o.getId()   "")
                            .document(o)
                    )
            );
        }
        client.bulk(br.build());
    }

    /***
     * 通过id 删除
     * @param id
     * @throws IOException
     */
    public void removeById(Long id) throws IOException {
        DeleteRequest de = DeleteRequest.of(d -> d.index(HOUSE_INDEX).id(id   ""));
        client.delete(de);
    }

    /***
     * 通过id 批量删除
     * @param ids
     * @throws IOException
     */
    public void removeById(List<Long> ids) throws IOException {
        BulkRequest.Builder br = new BulkRequest.Builder();
        // 将每一个product对象都放入builder中
        ids.stream()
                .forEach(id -> br
                        .operations(op -> op
                                .delete(d -> d
                                        .index(HOUSE_INDEX)
                                        .id(id   ""))));
        client.bulk(br.build());
    }

    /**
     * 根据查询进行删除
     *
     * @param query
     * @throws IOException
     */
    public void delQuery(Query query) throws IOException {
        DeleteByQueryRequest de = DeleteByQueryRequest.of(d -> d.index(HOUSE_INDEX).query(query));
        client.deleteByQuery(de);
    }
}

DTO

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

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

/**
 * 返回结果数据传输类
 *
 * @author admin
 */
@Data
@ApiModel(value = "EsDTO", description = "es数据")
public class EsDTO implements Serializable {
   
    @ApiModelProperty(value = "房源id")
    private Long id;

    @ApiModelProperty(value = "小组名称")
    private String groupName;

    @ApiModelProperty(value = "省代码")
    private Integer provinceCode;

    @ApiModelProperty(value = "市代码")
    private Integer cityCode;

    @ApiModelProperty(value = "区县代码")
    private Integer areaCode;

    @ApiModelProperty(value = "中介数")
    private Integer isZjCount;

    @ApiModelProperty(value = "出租数")
    private Integer isRentCount;

    @ApiModelProperty(value = "小组id")
    private Long dbGroupId;

    @ApiModelProperty(value = "创建时间")
    private String createTime;
    @ApiModelProperty(value = "发帖时间")
    private String sendTime;


    @ApiModelProperty(value = "链接")
    private String doubanUrl;

    @ApiModelProperty(value = "图片")
    private String images;

    @ApiModelProperty(value = "图片集合")
    private List<String> imagesList;

    @ApiModelProperty(value = "标题")
    private String title;

    @ApiModelProperty(value = "内容")
    private String content;

    @ApiModelProperty(value = "房型 0： 单间 1： 1房 2： 2房 3：3房 4：4房，5：5房")
    private Integer houseType;

    @ApiModelProperty(value = "出租类型：0：整租 1:合租 2:转租")
    private Integer rentType;

    @ApiModelProperty(value = "卧室类型：0：主卧 1：次卧")
    private Integer bedroomType;

    @ApiModelProperty(value = "性别限制：0： 限男  1 限女")
    private Integer gender;

    @ApiModelProperty(value = "高亮")
    private Map<String, List<String>> highlight;

}

DTO

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

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

/**
 * 返回结果数据传输类
 *
 * @author admin
 */
@Data
@ApiModel(value = "EsResDTO", description = "es数据")
public class EsResDTO implements Serializable {
    private List<EsDTO> list;
    private Long total;

}

好了，今天这个b班就到此为止了，周末快乐

这篇好文章是转载于：学新通技术网