SpringBoot3.0.7整合Elasticsearch8.7.1

最新推荐文章于 2024-04-10 10:44:50 发布
最新推荐文章于 2024-04-10 10:44:50 发布
阅读量715 收藏 4
点赞数 2
分类专栏： SpringBoot整合Es 文章标签： spring boot elasticsearch mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w3133089132/article/details/132256878
版权

这里的案例是围绕着查询诗词来进行练习的

主页下载里有数据库，自取！！！！！！！

1.添加依赖

添加springboot整合es的依赖

 <dependencies>
         <!--redis的依赖-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
         </dependency>
         <!--es的依赖-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
 ​
         <dependency>
             <groupId>com.mysql</groupId>
             <artifactId>mysql-connector-j</artifactId>
             <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
         </dependency>
         
         <!--MyBatis Plus依赖-->
         <dependency>
             <groupId>com.baomidou</groupId>
             <artifactId>mybatis-plus-boot-starter</artifactId>
             <version>3.5.3.1</version>
         </dependency>
 </dependencies>

2.nacos配置中心

必须在nacos提前配置好datasource.yml和redis.yml

datasource.yml的配置:

Data ID:datasource.yml

配置格式：选择YAML

 
spring:
   datasource:
     url: jdbc:mysql://192.168.*****:3306/${db.name}?serverTimezone=Asia/Shanghai
     driver-class-name: com.mysql.cj.jdbc.Driver
     username: root
     password: 123456

redis.yml:

Data ID:redis.yml

配置格式：选择YAML

 spring:
   data:
     redis:
       password: 123456
       host: 192.168.****
       port: 6379

3.添加配置

application.yml文件：

 spring:
   #服务名称
   application:
     name: poetry
   #链接es的配置
   elasticsearch:
     uris: http://192.168.*****:9200
     username: jipiao
     password: 123456
 #要链接数据库的名
 db:
   name: poetry

bootstrap.yml文件：

 spring:
   cloud:
     nacos:
       #nacos访问链接
       server-addr: 192.168.******:8848   #访问路径
       #从nacos配置中心里读取配置文件
       config:
         file-extension: yaml   #配置中心配置的类型
         shared-configs:
           - data-id: datasource.yml     #配置中心中要访使用的配置名称
             refresh: true               #开启热启动（动态刷新）
           - data-id: redis.yml
             refresh: true

4.编写启动类

 @SpringBootApplication
 @MapperScan("com.axjy.poetry")
 public class GushiApplication {
 ​
     public static void main(String[] args) {
         SpringApplication.run(GushiApplication.class, args);
     }
 ​
 }

5.添加pojo实体类

 package com.axjy.poetry.pojo;
 ​
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import lombok.Data;
 ​
 import java.io.Serializable;
 import java.time.LocalDateTime;
 ​
 @Data
 public class Poetry implements Serializable {
 ​
     private String _class;
 ​
     /**
      * 诗词编号
      */
     private Integer id;
     /**
      * 标题
      */
     private String title;
     /**
      * 内容
      */
     private String content;
     /**
      * 朝代
      */
     private String dynasty;
     /**
      * 作者
      */
     private String name;
     /**
      * 作者描述
      */
     private String intro;
 ​
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
     @JsonSerialize(using = LocalDateTimeSerializer.class)
     @JsonDeserialize(using = LocalDateTimeDeserializer.class)
     private LocalDateTime updateTime;
 }
 ​

6.添加mapper

 

package com.axjy.poetry.mapper;
 ​
 import com.axjy.poetry.pojo.Poetry;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Select;
 ​
 import java.util.List;
 ​
 @Mapper
 public interface PoetryMapper {
     @Select("select t1.id, name,title,content,updateTime,t1.dynasty from poetry t1 join poetry_author t2 on t1.author_id=t2.id")
     List<Poetry> searchAll();
 }
 ​

7.添加一个测试类

创建测试类的原因是要进行创建索引和初始化数据

 package com.axjy.poetry;
 ​
 import com.axjy.poetry.elastic.DocSource;
 import com.axjy.poetry.mapper.PoetryMapper;
 import com.axjy.poetry.pojo.Poetry;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.annotation.Resource;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
 import org.springframework.data.elasticsearch.core.IndexOperations;
 import org.springframework.data.elasticsearch.core.query.IndexQuery;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 @SpringBootTest
 public class PoetryApplicationTest {
     @Resource
     private ElasticsearchTemplate elasticsearchTemplate;
 ​
     @Resource
     private PoetryMapper poetryMapper;
 ​
     /**
      * 创建索引
      */
     @Test
     void createIndex(){
         //用于创建es索引
         IndexOperations opt = elasticsearchTemplate.indexOps(DocSource.class);
         //判断索引是否存在，存在就先删除再创建，不存在就直接创建
         if (opt.exists()){
             //删除索引
             opt.delete();
         }
         //创建索引
         opt.createWithMapping();
         System.out.println("创建索引映射成功!");
     }
 ​
     /**
      * 初始化数据源
      */
     @SneakyThrows
     @Test
     void initData(){
         List<Poetry> list = poetryMapper.searchAll();
         List<IndexQuery> queries = new ArrayList<>();
         int count=0;
         for (int i=0;i < list.size();i++) {
             Poetry poetry = list.get(i);
             IndexQuery indexQuery = new IndexQuery();
             indexQuery.setId(poetry.getId()+"");
             ObjectMapper objectMapper = new ObjectMapper();
             String json = objectMapper.writeValueAsString(poetry);
             indexQuery.setSource(json);
             queries.add(indexQuery);
             if(i % 2000 == 0) {
                 elasticsearchTemplate.bulkIndex(queries, DocSource.class);
                 queries.clear();
                 System.out.println("提交了《--"+(++count)+"--》次");
             }
 ​
         }
 ​
         if (queries.size()>0){
             elasticsearchTemplate.bulkIndex(queries, DocSource.class);
             queries.clear();
             System.out.println("提交了《--"+(++count)+"--》次");
         }
         System.out.println("\n-------添加完毕!-------");
     }
 }
 ​

8.添加查询的测试类

 package com.axjy.poetry;
 ​
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
 import co.elastic.clients.elasticsearch._types.query_dsl.MatchQuery;
 import co.elastic.clients.elasticsearch._types.query_dsl.RangeQuery;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
 import co.elastic.clients.elasticsearch.core.search.Highlight;
 import co.elastic.clients.elasticsearch.core.search.Hit;
 import co.elastic.clients.json.JsonData;
 import com.axjy.poetry.pojo.Poetry;
 import jakarta.annotation.Resource;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 ​
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
 ​
 @SpringBootTest
 public class SearchTest {
 ​
     @Resource
     private ElasticsearchClient client;
 ​
     @SneakyThrows
     @Test
     void testMatch(){
         LocalDate endDate2 = LocalDate.now();
         DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
         String endDate = endDate2.format(fmt);
 ​
         //查询条件
         MatchQuery query1 = MatchQuery.of(builder -> builder.field("content").query("三峽"));
         RangeQuery query2 = RangeQuery.of(builder -> builder.field("updateTime").lte(JsonData.of(endDate)));
 ​
         BoolQuery bool = BoolQuery.of(builder -> builder.must(query1._toQuery(),query2._toQuery()));
 ​
         //构建查询构造器
         Highlight highlight = Highlight.of(builder -> builder.fields("content",h->h.preTags("\33[31;1m").postTags("\33[30;2m")));
 ​
         //查询分页
         SearchResponse<Poetry> resp = client.search(builder -> builder.index("poetry").highlight(highlight).query(bool._toQuery()).from(0).size(10), Poetry.class);
 ​
         System.out.println("-----------"+resp.hits().total().value());
 ​
         //得到命中
         List<Hit<Poetry>> list = resp.hits().hits();
 ​
         //高亮
             List<Poetry> list2 = list.stream().map(hit->{
                 Poetry poetry = hit.source();
             //得到高亮的片段
             String segment = hit.highlight().get("content").get(0);
             //内容的片段
             poetry.setContent(segment);
             return poetry;
         }).toList();
 ​
         list2.forEach(System.out::println);
     }
 }

9.将数据存入redis里面

添加一个测试文件

 package com.axjy.poetry;
 ​
 import com.axjy.poetry.pojo.Poetry;
 import jakarta.annotation.Resource;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.ValueOperations;
 ​
 import java.time.LocalDateTime;
 ​
 @SpringBootTest
 public class RedisTest {
     @Resource
     private RedisTemplate redisTemplate;
 ​
     //将数据存储到redis当中
     @Test
     void save(){
         Poetry poetry = new Poetry();
         poetry.setName("李白");
         poetry.setUpdateTime(LocalDateTime.now());
         ValueOperations valueOperations = redisTemplate.opsForValue();
         valueOperations.set("jp:1001",poetry);
     }
 ​
     //取出redis里的数据
     @Test
     void get(){
         ValueOperations valueOperations = redisTemplate.opsForValue();
         Poetry poetry = (Poetry) valueOperations.get("jp:1001");
         System.out.println(poetry);
     }
 }
 
 

编写后台程序了

1.添加PoetryVo类、Pager分页类、DocSource文档类

PoetryVo类：

 package com.axjy.poetry.elastic;
 ​
 import lombok.Data;
 ​
 import java.time.LocalDate;
 ​
 @Data
 public class PoetryVo {
     private String keyword;
     private String dynasty;
     private LocalDate startDate;
     private LocalDate endDate;
 ​
     //排序
     private String sort; //updateTime
 ​
     private int pageNo;
     private int pageSize;
 }
 ​

Pager分页类:

 package com.axjy.poetry.elastic;
 import lombok.Data;
 ​
 import java.util.List;
 ​
 @Data
 public class Pager {
     private List rows;
 ​
     private long total;
 ​
 }
DocSource文档类:

 package com.axjy.poetry.elastic;
 ​
 import co.elastic.clients.util.DateTime;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.annotations.Field;
 import org.springframework.data.elasticsearch.annotations.FieldType;
 ​
 import java.time.LocalDateTime;
 ​
 @Document(indexName = "poetry")
 public class DocSource {
     /**
      * 标题
      */
     @Field(type = FieldType.Text,analyzer = "ik_max_word")
     private String title;
     /**
      * 内容
      */
     @Field(type = FieldType.Text,analyzer = "ik_max_word")
     private String content;
     /**
      * 朝代
      */
     @Field(type = FieldType.Keyword)
     private String dynasty;
     /**
      * 作者
      */
     @Field(type = FieldType.Text,analyzer = "ik_smart")
     private String name;
     /**
      * 作者描述
      */
     @Field(type = FieldType.Text,analyzer = "ik_max_word")
     private String intro;
 ​
     @Field(type = FieldType.Date,pattern = "uuuu-MM-dd||uuuu-MM-dd HH:mm")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
     @JsonSerialize(using = LocalDateTimeSerializer.class)
     @JsonDeserialize(using = LocalDateTimeDeserializer.class)
     private LocalDateTime updateTime;
 }
 ​

2.添加service

 package com.axjy.poetry.service;
 ​
 import com.axjy.poetry.elastic.Pager;
 import com.axjy.poetry.elastic.PoetryVo;
 ​
 public interface PoetryService {
 ​
     Pager query(PoetryVo vo);
 }
 ​

3.添加实现service接口的impl类

 package com.axjy.poetry.service;
 ​
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
 import co.elastic.clients.elasticsearch._types.ScoreSort;
 import co.elastic.clients.elasticsearch._types.SortOptions;
 import co.elastic.clients.elasticsearch._types.SortOrder;
 import co.elastic.clients.elasticsearch._types.query_dsl.*;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
 import co.elastic.clients.elasticsearch.core.search.Highlight;
 import co.elastic.clients.elasticsearch.core.search.HighlightField;
 import co.elastic.clients.json.JsonData;
 import com.axjy.poetry.elastic.Pager;
 import com.axjy.poetry.elastic.PoetryVo;
 import com.axjy.poetry.mapper.PoetryMapper;
 import com.axjy.poetry.pojo.Poetry;
 import jakarta.annotation.Resource;
 import lombok.SneakyThrows;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 ​
 import java.time.format.DateTimeFormatter;
 import java.util.List;
 ​
 @Service("poetryService")
 public class PoetryServiceImpl implements PoetryService{
 ​
     @Resource
     private ElasticsearchClient client;
 ​
     @SneakyThrows
     @Override
     public Pager query(PoetryVo vo) {
         //动态bool构造器
         BoolQuery.Builder boolBuilder = new BoolQuery.Builder();
 ​
         if (StringUtils.hasLength(vo.getDynasty())){
             TermQuery query = TermQuery.of(builder -> builder.field("dynasty").value(vo.getDynasty()));
             boolBuilder.must(query._toQuery());
         }
         DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
         if (vo.getStartDate()!=null){
             RangeQuery query = RangeQuery.of(builder -> builder.field("updateTime").gte(JsonData.of(vo.getStartDate().format(fmt))));
             boolBuilder.must(query._toQuery());
         }
         if (vo.getEndDate()!=null){
             RangeQuery query = RangeQuery.of(builder -> builder.field("updateTime").lt(JsonData.of(vo.getEndDate().plusDays(1).format(fmt))));
             boolBuilder.must(query._toQuery());
         }
 ​
         if (StringUtils.hasLength(vo.getKeyword())){
             MultiMatchQuery query = MultiMatchQuery.of(builder -> builder.fields("name^4","title^3","content").query(vo.getKeyword()));
         }
         Highlight.Builder hb = new Highlight.Builder();
         HighlightField hf = new HighlightField.Builder().build();
 ​
         hb.preTags("<strong style=\"color: red;\">").postTags("</strong>");
         hb.fields("name",hf);
         hb.fields("content",hf);
         hb.fields("title",hf);
 ​
         Highlight highlight = hb.build();
 ​
         int offset = (vo.getPageNo()-1)* vo.getPageSize();
 ​
         //处理排序
         SortOptions.Builder sort = new SortOptions.Builder();
         if (StringUtils.hasLength(vo.getSort())){
             if ("updateTime".equals(vo.getSort())){
                 sort.field(builder -> builder.field("updateTime").order(SortOrder.Desc));
             }else if (vo.getSort().equals("tuijian")){
                 sort.score(ScoreSort.of(builder -> builder.order(SortOrder.Desc)));
             }
         }else {
             sort.score(ScoreSort.of(builder -> builder.order(SortOrder.Desc)));
         }
 ​
         //处理高亮、分页、排序
         SearchResponse<Poetry> resp = client.search(builder ->
                 builder.index("poetry")
                         .highlight(highlight)
                         .query(boolBuilder.build()._toQuery())
                         .from(offset)
                         .size(vo.getPageSize())
                         .sort(sort.build())
                 ,Poetry.class);
 ​
         long total = resp.hits().total().value();
         System.out.println();
         Pager pager = new Pager();
         pager.setTotal(total);
         List<Poetry> rows = resp.hits().hits().stream().map(hit->{
             Poetry poetry = hit.source();
             //处理分页高亮
             //是否存在高亮状态（如果分页结果包含该文本时再进行处理高亮）
             if (hit.highlight().containsKey("name")){
                 poetry.setName(hit.highlight().get("name").get(0));
             }
             if (hit.highlight().containsKey("title")){
                 poetry.setTitle(hit.highlight().get("title").get(0));
             }
             if (hit.highlight().containsKey("content")){
                 poetry.setContent(hit.highlight().get("content").get(0));
             }
             return poetry;
         }).toList();
 ​
         pager.setRows(rows);
         return pager;
     }
 }

4.添加Result工具类

 package com.axjy.poetry.controller;
 ​
 import lombok.Data;
 ​
 @Data
 public class Result {
     private boolean success;
     private Object data;
     private String code;
     private String img;
 ​
     public static Result success(Object data){
         Result result = new Result();
         result.setSuccess(true);
         result.setData(data);
         return result;
     }
 }

5.最后一步，添加Controller类

 package com.axjy.poetry.controller;
 ​
 import com.axjy.poetry.elastic.Pager;
 import com.axjy.poetry.elastic.PoetryVo;
 import com.axjy.poetry.service.PoetryService;
 import jakarta.annotation.Resource;
 import org.springframework.web.bind.annotation.CrossOrigin;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 ​
 @CrossOrigin
 @RestController
 public class PoetryController {
     @Resource
     private PoetryService poetryService;
 ​
     @RequestMapping("/poetry/query")
     private Result query(@RequestBody PoetryVo vo){
         Pager pager = poetryService.query(vo);
         return Result.success(pager);
     }
 }

最后，前端访问/poetry/query路径就可以直接访问查询了（记得传入要进行搜索的词语）

王仔小馒头¹
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot3.0 整合 ElasticSearch8.5.0 及使用
weixin_46925850的博客
12-06 5903
SpringBoot3.0 整合 ElasticSearch8.5.0 及使用
Springboot3.1+Elasticsearch8.x匹配查询
weixin_43189060的博客
06-16 3186
在这里面，spring-boot-starter-data-elasticsearch是3.1.0的，里面的spring-data-elasticsearch是5.1.0的，服务器上的Elasticsearch用的是8.7.0的。中配置，新版的配置与旧版的不太一样，从ElasticsearchProperties.java中可以看到，前缀是spring.elasticsearch，主机配置项已经变成了。第一步当然是配置依赖。
继 SpringBoot 3.0，Elasticsearch8.0 官宣：拥抱 Java 17
dotNET跨平台
02-16 808
大家好，我是君哥。新版任你发，我用 Java 8，这可能是当下 Java 开发者的真实写照。不过时代可能真的要抛弃 Java 8，全面拥抱 Java 17 了。Spring Boot 3....
spring3.0.7与cxf2.7.4整合jar包
03-24
从官网下载的cxf包太多，实际应用中，绝大部分都是非必须的，为了方便广大学习者，本附件提供了spring3.0.7与cxf2.7.4整合所需要的最少jar包，欢迎大家下载！
SpringBoot 3整合Elasticsearch 8_springboot 使用 es8
最新发布
2301_76224377的博客
04-10 460
最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！
Tipask问答系统 v3.0.7
12-05
Tipask是一款开放源码的PHP问答系统，基于Laravel框架开发，容易扩展，具有强大的负载能力和稳定性。 经过1年多的设计、开发和1个多月的测试，Tipask社区版v3.0beta版本正式发布了！ 目前系统整体构架php框架采用的是Laravel + 前端 Bootstrap , 系统采用了大
SpringBoot集成Elasticsearch（已实现各种ES操作，上手即可用
11-12
本实例为博主原创，属于简单易上手并且能够拿来就用的SpringBoot ES 项目，全文使用的是ElasticsearchTemplate进行开发。 本实例涵盖ES中的各类操作，如索引操作、CRUD操作、批处理、结果排序、分页查询、检索查询、关键字查询、高亮显示、逻辑查询、过滤查询、分组查询等等。并且已经过生产环境验证，各位可放心使用。如有不对之处欢迎在博客中留言交流。谢谢！
elasticsearchTest:springboot集成elasticsearch
05-17
elasticsearchTest springboot集成elasticsearch elasticsearch5.6.9 项目所用依赖 spring-data-elasticsearch-3.0.7.RELEASE,spring-boot-starter-data-elasticsearch-2.0.2.RELEASE(版本很重要！) gradle中添加依赖:compile('org.springframework.boot:spring-boot-starter-data-elasticsearch')
springboot3整合elasticsearch8.7.0实现为bean对象创建索引添加映射
m0_54250110的博客
04-19 2804
要注意版本对应关系目前我使用的都是最新的版本，没有问题，未来版本变动请根据版本对照表修改版本目前(2023.04.19)这个对照表还未写Spring Data Elasticsearch5.0.5对应的es版本(目前的最新版本)，最高就写了5.0.1支持8.5.3，不过经过我实测和官方作者的回答，Spring Data Elasticsearch5.0.5是支持es8.7.0的。
Elasticsearch 搜索测试与集成Springboot3
yumuing‘s bolg
03-25 1048
它能够一定程度上解决，在一个普通数据库处理上亿条数据时的查询效率低下的同时无法优秀地排列好用户所需要的数据，一次性上亿条数据没有经过正确地排列，用户很难找到想要的数据。并且，用户输入的数据可能不太准确，它也能够进行模糊查询，这种模糊查询是依靠计算得来的，而不是简单地匹配数据。本系列博文将从零开始一步步实现将 ES 集成到 springboot3 中，并在一个社区项目中进行实际应用测试，本文为系列第一篇，后续，博文仍在整理，请持续关注博主，了解更多相关知识。
springboot整合elasticsearch8
winsanity的博客
10-12 4327
springboot整合elasticsearch8
cxf-2.7.3与spring3.0.7整合实例
06-03
使用cxf-2.7.3和spring3.0.7做的一个简单实例，适合初学者
redis-3.0.7.tar
11-15
redis-3.0.7.tar
Elasticsearch第三谈（SpringBoot集成Elasticsearch）
小游子YKY的博客
09-02 4009
官方文档JavaApi：https://www.elastic.co/guide/en/elasticsearch/client/index.html 1、导入依赖 保证版本和本机版本一致 <properties> <java.version>11</java.version> <elasticsearch.version>7.8.1</elasticsearch.version> </properties> <depend
elasticsearch8.5版本集成springboot高版本3.0.0开发
JackieJia的博客
12-22 378
elasticsearch8.5版本集成springboot高版本3.0.0开发
ElasticJob3.0整合SpringBoot，ElasticJob-Lite【ElasticJob入门篇】
小道仙的后宫
07-04 4643
一、前言 1-1、什么是ElasticJob 我们之前在SpringBoot项目里面使用定时任务，先是开启定时任务 @EnableScheduling，然后使用 @Scheduled(cron = “*/1 * * * * ?”) 二、使用 2-1、作业 作业其实就是定时任务，每一个作业就是一个定时任务。 作业的种类有多种简单作业、数据流作业、脚本作业、HTTP作业（3.0.0-beta 提供） 2-1-1、普通作业 普通作业只需要实现SimpleJob接口，然后重写execute方法。 impo
SpringBoot3整合Elasticsearch8.x之全面保姆级教程
热爱编程的你我
03-15 3394
SpringBoot3整合Elasticsearch8.x之全面保姆级教程,非常全面
SpringBoot3集成ElasticSearch
【积累】，是一个长期持续的过程。
08-16 3509
Elasticsearch是一个分布式、RESTful风格的搜索和数据分析引擎，适用于各种数据类型，数字、文本、地理位置、结构化数据、非结构化数据；
Elastic Search 8.7.1 整合springboot 并使用构建通用查询
qq_28036897的博客
05-31 585
Elastic Search 8.7.1 整合springboot 并使用构建通用查询。
springboot3.0整合nacos
08-02
问题: springboot3.0整合nacos 回答: 在Spring Boot 3.0中整合Nacos，你需要在pom.xml文件中添加相应的依赖。具体的依赖包括：spring-cloud-starter-bootstrap、spring-boot-starter-web、spring-cloud-starter-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值