RabbitMQ实现数据库与ElasticSearch的数据同步和分享文件过期处理

已于 2023-09-11 01:01:23 修改
阅读量1.5k 收藏
点赞数
分类专栏： Java 文章标签： rabbitmq elasticsearch java mysql
于 2023-09-04 19:27:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ManGooo0/article/details/132675938
版权

🎈 1 参考文档

RabbitMQ实现数据库与ElasticSearch的数据同步 | Hannya。-CSDN

企业级开发项目实战——基于RabbitMQ实现数据库、elasticsearch的数据同步 | 波总说先赚它一个小目标-CSDN

SPringBoot集成RabbitMQ实现30秒过期删除功能 | 军大君-CSDN

🔍 2 个人需求

  1. 当进行文件上传、文件创建、文件重命名等操作时：

    通过RabbitMQ：

    • 生产者：文件服务，执行上传、创建、重命名等文件操作，将用户文件信息（例如文件名、文件ID等）发送到RabbitMQ新增队列。
    • 消费者：查询服务，监听RabbitMQ新增队列，一旦收到消息，将用户文件信息新增或更新到Elasticsearch中。

  2. 文件删除时：

    通过RabbitMQ：

    • 生产者：文件服务，执行文件删除操作，将用户文件ID发送到RabbitMQ删除队列。
    • 消费者：查询服务，监听 RabbitMQ 队列，一旦收到消息，通过用户文件ID从Elasticsearch中删除相应的用户文件信息。

  3. 根据文件名进行文件模糊查询：

    通过OpenFeign：

    • 生产者：文件服务，查询服务调用文件服务提供的OpenFeign接口，通过用户文件ID从查询该用户文件是否存在。
    • 消费者：查询服务，如果不存在，将数据根据用户文件ID从Elasticsearch中删除。

  4. 分享文件时间到期处理：

    通过RabbitMQ的TTL（生存时间） + 死信队列：

    • 生产者：文件服务， 使用TTL模拟一个“延时队列”，在文件分享时间到期后，将消息传递到死信队列。
    • 消费者：文件服务，死信监听器监听到之后，将分享文件的分享状态改为已过期状态。

🔈3 声明

只是提供思路，代码不是很完整，直接复制运行不了。

最后面有完整网盘项目代码。

🚀4 OpenFeign相关部分（查询服务）

4.1 引入依赖

<!-- nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- openfeign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- loadbalancer -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

4.2 application.yml

spring:
  # nacos注册的服务名
  application:
    name: netdisk-search
  cloud:
    nacos:
      discovery:
        # 配置注册服务的IP地址
        server-addr: （IP地址）:8848
        username: nacos
        password: nacos

4.3 FileFeignService 接口

@FeignClient(name = "netdisk-file", configuration = FeignInterceptor.class)
public interface FileFeignService {
    @RequestMapping("/file/getUserFile/{userFileId}")
    ResultResponse<Boolean> getUserFile(@PathVariable Long userFileId);
}

4.4 @EnableFeignClients 注解

@ComponentScan(value = "com.cauli.search.*")
@EnableFeignClients(basePackages = "com.cauli.search")
@SpringBootApplication
public class NetdiskSearchApplication {
    public static void main(String[] args) {
        SpringApplication.run(NetdiskSearchApplication.class, args);
    }
}

🚀5 Elasticsearch相关部分（查询服务）

5.1 引入依赖

<!-- elasticsearch -->
<dependency>
    <groupId>co.elastic.clients</groupId>
    <artifactId>elasticsearch-java</artifactId>
    <version>8.0.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>
<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>2.0.1</version>
</dependency>

5.2 application.yml

# elasticsearch相关的配置
elasticsearch:
  # ES网关地址
  hostname: （IP地址）
  # ES网关端口
  port: 9200
  # ES网官方方案
  scheme: http

5.3 ElasticSearchConfig 配置类

@Configuration
public class ElasticSearchConfig {
    @Value("${elasticsearch.hostname}")
    String hostname;

    @Value("${elasticsearch.port}")
    int port;

    @Value("${elasticsearch.scheme}")
    String scheme;

    @Bean
    public ElasticsearchClient elasticsearchClient(){
        // 创建低级客户端
        RestClient client = RestClient.builder(new HttpHost(hostname, port,scheme)).build();
		// 创建API客户端，使用Jackson映射器创建传输层
        ElasticsearchTransport transport = new RestClientTransport(client,new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);
    }
}

5.4 Elasticsearch 服务类和服务实现类

public interface ElasticsearchService {
    /**
     * 更新ES数据
     *
     * @param fileSearchDTO
     */
    void uploadES(FileSearchDTO fileSearchDTO);

    /**
     * 删除ES数据
     *
     * @param userFileId
     */
    void deleteES(Long userFileId);


    /**
     * 搜索ES数据
     *
     * @return
     */
    List<SearchFileVO> searchES(SearchFileQueryDTO searchFileVO);
}


@Slf4j
@Service
public class ElasticsearchServiceImpl implements ElasticsearchService {
    @Autowired
    private ElasticsearchClient elasticsearchClient;

    @Resource
    private FileFeignService feignService;

    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
            12, // 核心线程数
            20, // 最大线程数
            1, // 线程存活时间
            TimeUnit.SECONDS, // 存活时间单位
            new ArrayBlockingQueue<>(1000) // 任务队列
    );

    public void uploadES(FileSearchDTO fileSearchDTO) {
        executor.execute(() -> {
            try {
                elasticsearchClient.index(i -> i.index("file_search")
                        .id(fileSearchDTO.getUserFileId())
                        .document(fileSearchDTO));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }

    public void deleteES(Long userFileId) {
        executor.execute(() -> {
            try {
                elasticsearchClient.delete(d -> d
                        .index("file_search")
                        .id(String.valueOf(userFileId)));
            } catch (Exception e) {
                log.debug("ES删除操作失败，请检查配置");
            }
        });
    }

    @Override
    public List<SearchFileVO> searchES(SearchFileQueryDTO searchFileQueryDTO) {
        int pageNum = (int) searchFileQueryDTO.getPageNum() - 1;
        int pageSize = (int) (searchFileQueryDTO.getPageSize() == 0 ? 10 : searchFileQueryDTO.getPageSize());

        SearchResponse<FileSearchDTO> search = null;
        try {
            search = elasticsearchClient.search(s -> s
                    .index("file_search")
                    .query(_1 -> _1
                            .bool(_2 -> _2
                                    .must(_3 -> _3
                                            .bool(_4 -> _4
                                                    .should(_5 -> _5
                                                            .match(_6 -> _6
                                                                    .field("fileName")
                                                                    .query(searchFileQueryDTO.getFileName())))
                                                    .should(_5 -> _5
                                                            .wildcard(_6 -> _6
                                                                    .field("fileName")
                                                                    .wildcard("*" + searchFileQueryDTO.getFileName() + "*")))
                                            ))
                                    .must(_3 -> _3
                                            .term(_4 -> _4
                                                    .field("userId")
                                                    .value(StpUtil.getLoginIdAsLong())))
                            ))
                    .from(pageNum)
                    .size(pageSize)
                    .highlight(h -> h
                            .fields("fileName", f -> f.type("plain")
                                    .preTags("<span class='keyword'>").postTags("</span>"))
                            .encoder(HighlighterEncoder.Html)), FileSearchDTO.class);
        } catch (IOException e) {
            e.printStackTrace();
        }

        List<SearchFileVO> searchFileVOList = new ArrayList<>();
        if (search != null) {
            for (Hit<FileSearchDTO> hit : search.hits().hits()) {
                SearchFileVO searchFileVO = new SearchFileVO();
                BeanUtil.copyProperties(hit.source(), searchFileVO);
                searchFileVO.setHighLight(hit.highlight());
                searchFileVOList.add(searchFileVO);

                // 如果文件不存在，也从ES中删除
                if (!feignService.getUserFile(searchFileVO.getUserFileId()).getData()) {
                    executor.execute(() -> this.deleteES(searchFileVO.getUserFileId()));

                }
            }
        }
        return searchFileVOList;
    }
}

5.5 ElasticsearchController 前端控制器

@RestController
@RequestMapping("/search")
public class ElasticsearchController {
    @Autowired
    private ElasticsearchService elasticService;

    @GetMapping(value = "/searchFile")
    public RestResult<SearchFileVO> searchFile(SearchFileQueryDTO searchFileQueryDTO) {
        List<SearchFileVO> searchFileVOList = elasticService.searchES(searchFileQueryDTO);
        return RestResult.success().dataList(searchFileVOList, searchFileVOList.size());
    }
}

5.6 相关实体类

/**
 * 文件搜索VO
 */
@Data
public class SearchFileVO {
    @JsonSerialize(using = ToStringSerializer.class)
    private Long userFileId;

    private String fileName;

    private String filePath;

    private String extendName;

    private Long fileSize;

    private String fileUrl;

    private Map<String, List<String>> highLight;

    private Integer isDir;
}

/**
 * 文件搜索DTO
 */
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class FileSearchDTO {
    private String indexName;

    private String userFileId;

    private String fileId;

    private String fileName;

    private String content;

    private String fileUrl;

    private Long fileSize;

    private Integer storageType;

    private String identifier;

    private Long userId;

    private String filePath;

    private String extendName;

    private Integer isDir;

    private String deleteTime;

    private String deleteBatchNum;
}

/**
 * 文件查询条件DTO
 */
@Data
public class SearchFileQueryDTO {
    @ApiModelProperty("文件名")
    private String fileName;

    @ApiModelProperty("当前页")
    private long pageNum;

    @ApiModelProperty("每页数量")
    private long pageSize;
}

🚀6 RabbitMQ相关部分

6.1 生产者部分（文件服务）

6.1.1 引入依赖

<!-- nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- RabbitMQ（我的SpringBoot是2.6.8的） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

6.1.2 完整application.yml

server:
  port: 8083
spring:
  # MySQL配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/（数据库名）?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
    username: root
    password: （MySQL密码）
  # nacos注册的服务名
  application:
    name: netdisk-file
  cloud:
    nacos:
      discovery:
        # 配置注册服务的IP地址
        server-addr: （IP地址）:8848
        username: nacos
        password: nacos
  # rabbitmq相关的配置
  rabbitmq:
    host: （IP地址）
    port: 5672
    virtual-host: （虚拟主机名，比如：/file）
    username: （用户名，默认：guest）
    password: （密码，默认：guest）

6.1.3 RabbitMQConfig 配置类

@Configuration
public class RabbitMQConfig {
    // 普通交换机
    public static final String FILE_EXCHANGE = "file.exchange";

    // 文件保存相关
    public static final String QUEUE_FILE_SAVE = "queue.file.save";
    public static final String KEY_FILE_SAVE = "key.file.save";

    // 文件删除相关
    public static final String QUEUE_FILE_REMOVE = "queue.file.remove";
    public static final String KEY_FILE_REMOVE = "key.file.remove";

    // 死信相关
    public static final String DEAD_LETTER_EXCHANGE = "deadLetter.exchange";
    public static final String DEAD_LETTER_QUEUE = "deadLetter.queue";
    public static final String KEY_FILE_DEAD_LETTER = "key.file.dead.letter";

    //延迟队列
    public static final String DELAY_QUEUE = "delay.queue";

    /**
     * 文件保存队列
     *
     * @return
     */
    @Bean
    public Queue queueFileSave() {
        return new Queue(QUEUE_FILE_SAVE);
    }

    /**
     * 文件删除队列
     *
     * @return
     */
    @Bean
    public Queue queueFileRemove() {
        return new Queue(QUEUE_FILE_REMOVE);
    }

    /**
     * 交换机
     *
     * @return
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(FILE_EXCHANGE);
    }

    /**
     * 绑定文件保存队列到交换机
     *
     * @return
     */
    @Bean
    public Binding bindFileSave() {
        return BindingBuilder.bind(queueFileSave()).to(topicExchange()).with(KEY_FILE_SAVE);
    }

    /**
     * 绑定文件删除队列到交换机
     *
     * @return
     */
    @Bean
    public Binding bindFileRemove() {
        return BindingBuilder.bind(queueFileRemove()).to(topicExchange()).with(KEY_FILE_REMOVE);
    }

    /**
     * 定义延时队列
     *
     * @return
     */
    @Bean
    public Queue delayQueue() {
        //设置死信交换机和路由key
        return QueueBuilder.durable(DELAY_QUEUE)
                //如果消息过时，则会被投递到当前对应的死信交换机
                .withArgument("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE)
                //如果消息过时，死信交换机会根据routing-key投递消息到对应的队列
                .withArgument("x-dead-letter-routing-key", KEY_FILE_DEAD_LETTER)
                .build();
    }

    /**
     * 定义死信交换机
     *
     * @return
     */
    @Bean
    public TopicExchange deadLetterExchange() {
        return new TopicExchange(DEAD_LETTER_EXCHANGE);
    }

    /**
     * 定义死信队列
     *
     * @return
     */
    @Bean
    public Queue deadLetterQueue() {
        return new Queue(DEAD_LETTER_QUEUE);
    }

    /**
     * 绑定死信队列到死信交换机
     *
     * @return
     */
    @Bean
    public Binding deadLetterBinding() {
        return BindingBuilder.bind(deadLetterQueue()).to(deadLetterExchange()).with(KEY_FILE_DEAD_LETTER);
    }
}

6.1.4 FileDealComp 文件逻辑处理组件伪代码

/**
 * 文件逻辑处理组件
 */
@Slf4j
@Component
public class FileDealComp {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
            12, // 核心线程数
            20, // 最大线程数
            1, // 线程存活时间
            TimeUnit.SECONDS, // 存活时间单位
            new ArrayBlockingQueue<>(1000) // 任务队列
    );

    /**
     * 更新ES数据
     *
     * @param userFileId
     */
    public void uploadES(Long userFileId) {
        executor.execute(() -> {
            FileSearchDTO fileSearchDTO = new FileSearchDTO();
            // 通过用户文件ID查询用户文件信息
            ...
            // 通过文件ID查询文件信息
            ...
            // 将用户文件信息和文件信息同步到fileSearchDTO对象
            ...  
           	// 消息队列更新ES
            rabbitTemplate.convertAndSend(RabbitMQConfig.FILE_EXCHANGE, RabbitMQConfig.KEY_FILE_SAVE, fileSearchDTO);
        });
    }

    /**
     * 删除ES数据
     *
     * @param userFileId
     */
    public void deleteES(Long userFileId) {
        // 消息队列删除ES
        rabbitTemplate.convertAndSend(RabbitMQConfig.FILE_EXCHANGE, RabbitMQConfig.KEY_FILE_REMOVE, userFileId);
    }
   
    /**
     * 分享文件过期处理
     *
     * @param shareBatchNum 分享批次号
     */
    public void expiredShareFile(String shareBatchNum) {
        Share share = new Share();
        // 根据分享批次号获取分享信息
        ...
        // 将分享信息同步到share对象
        ...
        // 定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long differenceInMillis = 0;
        try {
            // 解析日期字符串为日期对象
            Date shareDate = sdf.parse(share.getShareTime());
            Date endDate = sdf.parse(share.getEndTime());
            // 计算时间差（毫秒数）
            differenceInMillis = endDate.getTime() - shareDate.getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        // 存活时间
        String expiration = Long.toString(differenceInMillis);
        // 延时队列
        rabbitTemplate.convertAndSend(RabbitMQConfig.DELAY_QUEUE, share, message -> {
            message.getMessageProperties().setExpiration(expiration);
            return message;
        });
    }
}

6.1.5 ExpiredShareFileListener 过期的分享文件处理监听器

@Slf4j
@Component
@RabbitListener(queues = "my-dlx-queue")
public class ExpiredShareFileListener {
    @Autowired
    private ShareService shareService;

    // 死信相关
    public static final String DEAD_LETTER_EXCHANGE = "deadLetter.exchange";
    public static final String DEAD_LETTER_QUEUE = "deadLetter.queue";
    public static final String KEY_FILE_DEAD_LETTER = "key.file.dead.letter";

    @RabbitListener(bindings = {
            @QueueBinding(
                    key = KEY_FILE_DEAD_LETTER,
                    value = @Queue(value = DEAD_LETTER_QUEUE, durable = "true"),
                    exchange = @Exchange(value = DEAD_LETTER_EXCHANGE, type = ExchangeTypes.TOPIC, ignoreDeclarationExceptions = "true")
            )})
    public void receiveShareMessage(Share share) {
        log.info("监听到文件过期处理操作：{}", share);

        // 将share的分享状态改为已过期 → 将share的shareStatus由0改为1
        ...

        log.info("操作完成：{}", share);
    }
}

6.2 消费者部分（查询服务）

6.2.1 引入依赖

<!-- RabbitMQ （我的SpringBoot是2.6.8的） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

6.2.2 完整application.yml

server:
  port: 8084
spring:
  # MySQL配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/（数据库名）?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true
    username: root
    password: （MySQL密码）
  # nacos注册的服务名
  application:
    name: netdisk-search
  cloud:
    nacos:
      discovery:
        # 配置注册服务的IP地址
        server-addr: （IP地址）:8848
        username: nacos
        password: nacos
  mvc:
    path match:
      matching-strategy: ant_path_matcher
  servlet:
    multipart:
      enabled: true
      # 单个文件最大限制
      max-file-size: 1024MB
      # 多个文件最大限制
      max-request-size: 2048MB
  # rabbitmq相关的配置
  rabbitmq:
    host: （IP地址）
    port: 5672
    virtual-host: （虚拟主机名，比如：/file）
    username: （用户名，默认：guest）
    password: （密码，默认：guest）

# elasticsearch相关的配置
elasticsearch:
  # ES网关地址
  hostname: （IP地址）
  # ES网关端口
  port: 9200
  # ES网官方方案
  scheme: http

6.2.3 FileMQListener 文件处理消息队列监听

@Slf4j
@Component
public class FileMQListener {
    // 普通交换机
    public static final String FILE_EXCHANGE = "file.exchange";

    // 文件保存相关
    public static final String QUEUE_FILE_SAVE = "queue.file.save";
    public static final String KEY_FILE_SAVE = "key.file.save";

    // 文件删除相关
    public static final String QUEUE_FILE_REMOVE = "queue.file.remove";
    public static final String KEY_FILE_REMOVE = "key.file.remove";

    @Autowired
    private ElasticsearchService elasticsearchService;

    /**
     * 监听文件信息添加操作
     *
     * @param fileSearchDTO
     */
    @RabbitListener(bindings = {@QueueBinding(
            key = KEY_FILE_SAVE,
            value = @Queue(value = QUEUE_FILE_SAVE, durable = "true"),
            exchange = @Exchange(value = FILE_EXCHANGE, type = ExchangeTypes.TOPIC, ignoreDeclarationExceptions = "true"))})
    public void receiveFileSaveMessage(FileSearchDTO fileSearchDTO) {
        try {
            log.info("监听到文件信息添加操作：{}", fileSearchDTO);
            
            // 更新ES数据
            elasticsearchService.uploadES(fileSearchDTO);
            
            log.info("添加完成：{}", fileSearchDTO);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 监听文件信息删除操作
     *
     * @param userFileId
     */
    @RabbitListener(bindings = {@QueueBinding(
            key = KEY_FILE_REMOVE,
            value = @Queue(value = QUEUE_FILE_REMOVE, durable = "true"),
            exchange = @Exchange(value = FILE_EXCHANGE, type = ExchangeTypes.TOPIC, ignoreDeclarationExceptions = "true"))})
    public void receiveFileDeleteMessage(Long userFileId) {
        try {
            log.info("监听到文件信息删除操作：{}", userFileId);
            
            // 删除ES数据
            elasticsearchService.deleteES(userFileId);
            
            log.info("文件信息删除完成：{}", userFileId);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

📫7 代码仓库

netdisk-cloud | Gitee

Cau1i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ElasticSearch-Kafka-RabbitMQ
weixin_73241486的博客
04-04 578
Elasticsearch 是基于 Lucene 的 Restful 的分布式实时全文搜索引擎， 每个字段都被索引并可被搜索，可以快速存储、搜索、分析海量的数据。Kafka是分布式发布-订阅消息系统是一个可划分的，冗余备份的持久性的日志服务，它主要用于处理流式数据。组件:主题(Topic)：Kafka主题是一堆或一组消息。生产者(Producer)：在Kafka，生产者发布通信以及向Kafka主题发布消息。消费者(Consumer)：Kafka消费者订阅了一个主题，并且还从主题中读取和处理消息。
【ElasticSearch】深入探索 ElasticSearch 对数据的聚合、查询自动补全、与数据库间的同步问题以及使用 RabbitMQ 实现与数据库间的同步
qq_61635026的博客
10-13 788
在本文中，我们将深入探讨 ElasticSearch 在数据处理中的关键功能，包括数据聚合、查询自动补全以及与数据库的同步问题。首先，我们将聚焦于 ElasticSearch 强大的聚合功能，解释什么是聚合以及如何通过 DSL 语句和 RestClient 实现各种聚合操作。这一功能能够让我们更深入地了解和分析存储在 ElasticSearch 中的数据。随后，我们将介绍查询自动补全功能，重点探讨拼音分词器、自定义分词器，以及如何通过 DSL 实现搜索的自动补全功能。
ElasticSearch - 在 微服务项目 中基于 RabbitMQ 实现 ES 和 MySQL 数据异步同步（考点）
CYK_byte的博客
09-29 2308
微服务 架构的项目上，不同的业务往往会在不同的微服务上，比如 “商品数据管理业务” 和 “商品数据搜索业务” 肯定会在两个不同的微服务上，那么跨微服务的项目就没办法直接操作了.
SpringBoot 集成 rabbitMq 消息队列解决ElasticSearch增量数据同步问题
long19901216的博客
07-06 645
SpringBoot 集成 rabbitMq 消息队列解决ElasticSearch增量数据同步问题
RabbitMQ实现数据库与ElasticSearch的数据同步
asd747571569的博客
12-29 3738
生产者消费者导入MQ的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 添加配置 spring: rabbitmq: host: localhost port: 5672 username: admin passwo
springboot整合elasticsearch8.3并通过rabbitMq同步mysql数据库的demo
最新发布
04-25
在本文中，我们将深入探讨如何将Spring Boot与Elasticsearch 8.3集成，并通过RabbitMQ实现MySQL数据库的数据同步。这是一个非常实用的场景，特别是在大数据处理和实时搜索需求日益增长的今天。以下是对这个Demo的...
java多个数据库实现数据同步
03-16
7. **微服务架构**：在微服务中，每个服务通常维护自己的数据库，通过API Gateway或Service Mesh进行服务间的通信，实现数据同步。这种方法强调服务自治，但需要良好的服务间协调机制。 在实现过程中，需要注意以下...
SpringBoot定时任务实现Oracle和mysql数据同步
12-21
Spring Boot作为Java领域的一个热门微服务框架，提供了强大的定时任务功能，能够帮助我们实现不同数据库间的数据同步，比如Oracle到MySQL。本篇文章将详细讲解如何利用Spring Boot的定时任务特性，结合Java的相关...
Dubbo+Solr+RabbitMQ实现Solr数据同步 DataSyncParent.zip
08-15
在IT行业中，构建高效、实时的数据同步系统是关键任务之一，尤其在大数据处理和搜索服务领域。本项目“Dubbo+Solr+RabbitMQ实现Solr数据同步”结合了三个核心组件，以构建一个可靠的分布式数据同步解决方案。以下是...
RabbitMQ工具类实现配置文件动态创建队列和绑定
02-21
本篇文章将重点讲解如何使用RabbitMQ结合Java实现一个工具类，动态地根据配置文件创建队列和绑定。 首先，我们需要了解RabbitMQ的基本概念。在RabbitMQ中，队列（Queue）是存储消息的地方，生产者（Producer）发送...
基于springcloud+Netty+MQ+mysql的分布式即时聊天系统源码+数据库+项目说明.zip
01-09
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 3、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。 基于springcloud+Netty+MQ+mysql的分布式即时聊天系统源码+数据库+项目说明.zip # KT-Chat 分布式即时聊天系统 **技术选型**：Java、SpringCloud、Nacos、Sentinel、Netty、MySQL、Redis、RocketMQ 等 **项目描述**：项目基于 SpringCloud Gateway + Nacos + Sentinel + OpenFeign 作为分布式系统架构，基于 Netty 实现高性能网络通信。主要功能有：一对一聊天以及群组聊天、好友管理、群组管理等。 项目独立完成，包括需求分析、设计、开发实现。 关于我在项目中使用 MySQL 读写分离的总结：[MySQL主从延迟的解决方案](https://blog.csdn.net/KIMTOU/article/details/125033199) ## 用例分析 用户能够在聊天系统上进行网络通信，与好友进行实时一对一聊天，与群组成员进行群聊。用户用例图如下所示： 1. 用户登录：登录系统 2. 聊天：包含与好友进行一对一聊天，与群组成员进行群聊。 3. 群聊管理：新建群聊、加入群聊、退出群聊。 4. 好友管理：显示好友列表，添加、删除好友。 5. 在线离线状态显示：查看好友的在线、离线状态。 6. 聊天记录管理：将聊天记录存入数据库，能够显示、删除存储的聊天记录。 <img src="https://cdn.tojintao.cn/Chat原理图.png" alt="img" style="zoom:67%;" /> ## 系统设计 #### 系统总体设计 分布式即时聊天系统分为用户信息子系统、长连接管理子系统、聊天信息子系统共三个子系统，API 网关负责将请求路由至各个子系统。 * 用户信息子系统包含权限校验模块、用户登录模块、好友管理模块，其中好友管理模块包括好友列表、添加好友、删除好友功能； * 长连接管理子系统包含在线状态管理模块、聊天主模块、消息推送模块，其中聊天主模块包括一对一聊天和群聊功能； * 聊天信息子系统包含群聊管理模块、聊天记录管理模块，其中群聊管理模块包括新建群聊、加入群聊、退出群聊功能。 <img src="https://cdn.tojintao.cn/KT-Chat系统结构图.png" style="zoom:67%;" /> #### 系统架构设计 ![](https://cdn.tojintao.cn/KT-Chat系统架构设计.png) 项目基于 Nacos 作为注册中心，将各个服务注册进 Nacos，包括 Netty 服务端；使用 SpringCloud Gateway 作为服务网关，是所有请求的统一入口；限流组件使用 Sentinel；基于 Netty 进行通信、维护长连接；RocketMQ 作为消息队列，处理聊天消息的异步入库以及解决分布式 Netty 节点问题； Zookeeper 用于分布式 id 的生成；Redis 用于记录用户在线状态以及记录 Netty 节点的元数据；MySQL 对数据进行持久化。 ## 运行截图 #### 一对一聊天 ![](https://cdn.tojintao.cn/聊天测试1.PNG) #### 群聊 ![](https://cdn.tojintao.cn/群聊测试1.PNG) ## 启动说明 1. 启动本项目时，需提前启动 Nacos、RocketMQ、MySQL、Redis、ElasticSearch、Sentinal 实例。 2. conntector 与 connector-2 这两个模块并不一样，connector-2 使用了 Dubbo 进行消息转发（实验阶段），而 connector 使用 Feign 进行 HTTP 调用转发消息。启动 connector 就行了。 3. 每个服务都允许运行多个实例。
spring-boot操作dubbo、elasticsearch、kafka、rabbitmq
09-06
spring-boot操作dubbo、elasticsearch、kafka、rabbitmq、rocketmq、redis、mongodb等等demo，比较全面，基本包含所有常用的软件。。。亲测可以用，maven项目。
elasticsearch【es】+Rabbitmq【mq】实现搜索功能
onekeeper的博客
04-16 249
使用elasticsearch技术实现商品搜索功能，相对mysql，效率更高，分词查找更合理！用来存储商品搜索数据的实体类。
Elasticsearch Rabbitmq
weixin_46259203的博客
03-06 285
ElasticSearch 7.x 默认不再支持指定索引类型, 默认索引类型是_doc 新增: PUT 删除: DELETE 修改: POST 查询: GET/POST 获得索引结构只能用GET /map 1.创建搜索请求对象 SearchRequest 2.创建搜索源构建者对象 准备查询构建者对象QueryBuilders.matchQuery()方法 3.用搜索源构建者对象builder .query( )方法; 4.将搜索构建者对象searchSearch加入到搜索请求对象中, searchReq
EsAppender代码不当导致队列Mq队列停止消费的问题
大脸猫的博客
11-11 342
问题出现&解决 在我们的系统中对MQ消息的消费代码类似如下： private void consumer2Xxx() { EXECUTOR_SERVICE.submit(() -> { try { //mq队列监听 new xxxListener(){ ...
关于我在SpringCloudAlibaba运用和入门Rocketmq
一个爱运动的程序员的博客
12-23 1364
文章目录学习目标学习内容一、MQ简介1、什么是MQ2、MQ的应用场景3、常见的MQ产品二、RocketMQ入门1、RocketMQ环境搭建2、RocketMQ的架构及概念3、RocketMQ控制台安装三、消息发送和接收1、发送消息2、接收消息四、案例1、订单微服务发送消息2、用户微服务订阅消息五、发送不同类型的消息1、普通消息2、顺序消息3、事务消息六、消息消费要注意的细节 学习目标 学习内容 一、MQ简介 1、什么是MQ MQ（Message Queue）是一种跨进程的通信机制，用于传递消息。通俗点说，就
mysql + canal + rocketMq + elasticsearch实现mysql/elasticsearch数据同步
qq_23975117的博客
09-02 301
myql+canal+rocketMq+elasticsearch 实现数据从mysql到elasticsearch实时同步
分布式 SpringCloudAlibaba、Feign与RabbitMQ实现MySQL到ES数据同步
wanghuichen的博客
04-08 779
MySQL 数据 如何同步到ES，重磅来袭，面试高频 ？ 一文彻底搞定！
springboot+elasticsearch + rabbitMQ实现全文检索（项目搭建）
weixin_34254823的博客
12-20 316
最近做一个社区类的项目：实现全文检索 开发完成做一个总结记录。 spring-boot-1.5.9.RELEASE ES 5.6.4 首先搭建ES环境 引用大佬文章搭建ES环境： https://blog.csdn.net/u012270682/article/details/72934270 cluster.name: my-application node.name:...
基于RabbitMQ实现数据库、elasticsearch的数据同步，要求如下： - 商品上架时：search-service新增商品到elasticsearch - 商品下架时：search-service删除elasticsearch中的商品
03-27
实现步骤如下： 1. 在商品上架时，数据库会新增一条商品数据，利用RabbitMQ将该数据发送到search-service中。 2. 在search-service中，监听RabbitMQ的消息队列，获取到新增的商品数据，将其新增到Elasticsearch中。 3. 在商品下架时，数据库会删除该商品数据，同样利用RabbitMQ将该数据发送到search-service中。 4. 在search-service中，监听RabbitMQ的消息队列，获取到删除的商品数据，将其从Elasticsearch中删除。 具体实现中，可以使用RabbitMQ的消息队列作为中间件，将数据库和search-service解耦，实现数据同步。同时，需要在search-service中进行Elasticsearch的相关操作，如新增或删除商品数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值