任务调度框架
Java中如何实现定时任务？
比如：
1.每天早上6点定时执行
2.每月最后一个工作日，考勤统计
3.每个月25号信用卡还款
4.会员生日祝福
5.每隔3秒，自动提醒
10分钟的超时订单的自动取消，每隔30秒或1分钟查询一次订单，拿当前的时间上前推10分钟
定时任务，资源会有误差的存在，如果使用定时任务
定时任务，用于统计的时候最多。
自动统计考勤，一般0点之后开始统计，可以使用定时任务
nacos心跳
晚上要求和采购部门生成采购单，达到最低预警值的时候，去发给采购部门
我们可以通过任务调度框架实现上述的需求
任务调度框架，可以实现定时任务，实现间隔多少时间的重复执行，实现指定日期的重复执行
电商自动好评，间隔时间长的，误差几分钟，影响不大。
java中任务调度框架：
1、Spring Task spring自带的
2、Quartz 古老的框架
3、XXL-Job
4、第三方云平台-比如说：阿里云-SchedulerX等等
选择一个:Spring Task
2个注解+
包：task任务、job
使用步骤：
1、开关类，使用注解
@EnableScheduling // 开启任务调度
2、定义定时任务
@Scheduled(cron = "0/3 * * * ?")
CORN表达式：
秒 分 时 日 月 星期几 年 其中，只有年可以省略
定时任务，需要重复执行的方法
CORN表达式：
特殊字符串，主要用来描述时间的，用于任务调度等
https://cron.qqe2.com/
/ 间隔
- 是连续
, 枚举值
L 最后，星期、日中用
W 有效工作日
LW 某个月最后一个工作日
# 用于确定每个月第几个星期几，母亲节或父亲节
4#2 某个月的第二个星期三 4代表星期三，中文的时候有可能不影响
项目名：SpringTask01
Spring Web、Lombok
RabbitMq实现延迟：
死信+延迟消息处理
死信：RabbitMQ的队列中的消息，满足以下条件任意其一就会成为死信消息：
1.消息被拒绝
2.消息过期
3.队列满了
死信交换器:专门用来转发队列中的死信消息，将死信消息转发到指定的队列中
十分钟未支付，取消订单？
十分钟之后，消息会过期，过期后，通过死信交换器转发队列中的死信消息，将死信消息转发到指定的队列中，由消费者去处理。
我们可以通过死信+死信交换器实现延迟消息处理
RabbitMQ实现延迟消息处理有2种方式：
1、死信+死信交换器 代码实现（可控，更方便一些）
2、延迟消息插件
1、死信+死信交换器 代码实现（可控，更方便一些）
发送消息，到队列1，（产生延迟队列，产生死信）
一个消息，过一段时间，实现消费。
核心：
1.队列 是2个队列，第1个队列： 目的 产生死信（1.设置有效期2.不设置消费者），借助死信交换器，把产生的死信发到指定的队列中
第二个对了：目的 消费死信，这里获取的信息，时间就是延迟的，延迟的就是上面的有效期
2.1个交换器
死信交换器，整个系统一般就一个，可以用来转发各个功能产生的死信，是Direct类型的交换，通过RK进行消息匹配到对应的队列中。
RabbitMQ的消息的有效期有2种设置方式：
1.设置队列上的有效期，整个队列中所有消息都使用
2.可以在每个消息上设置有效期，这种适用于有多个不同有效期的消息
如果队列和消息都有有效期，谁短听谁的。
代码：
RabbitMQ02
实现：
1.pom
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- RabbitMQ -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
</dependencies>
2.代码：
config-RabbitMQConfig
package com.yd.rabbitmq02.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
/**
* @author MaoXiqi
* @organization: Lucky
* @create 2023-10-16 11:35:54
* @description RabbitMQConfigApi
*/
@Configuration
public class RabbitMQConfig {
// 1.创建2个队列
@Bean
public Queue createQ1() {
// 1.设置队列 内部消息有效期 设置死信交换器 设置RK
HashMap<String, Object> params = new HashMap<>();
// 设置队列中每个消息的有效期 单位 毫秒
params.put("x-message-ttl", 3000);
// 设置对应的死信交换器
params.put("x-dead-letter-exchange", "dead-ex-yd");
// 设置交换器匹配的路由名称
params.put("x-dead-letter-routing-key", "test");
return QueueBuilder.durable("dl-q01").withArguments(params).build();
}
@Bean
public Queue createQ2() {
return new Queue("dl-q02");
}
// 2.创建1个交换器（1.fanout 2，direct 3.topic 4.header）-死信交换器direct类型
@Bean
public DirectExchange createDe() {
return new DirectExchange("dead-ex-yd");
}
// 3.创建1个绑定
@Bean
public Binding createBd1(DirectExchange de) {
return BindingBuilder.bind(createQ2()).to(de).with("test");
}
}
2.1.创建两个队列
1、设置队列，内部消息有效期 设置死信交换器 设置RK 注意：参数名是固定的，值根据业务需求去改，值 单位是毫秒
2.2创建1个交换器（1.fanout 2.direct 3.tipic
4.header）-死信交换器direct类型
2.3.创建一个绑定
controller-DeadController
@GetMapping("send")
public String sendDead(String msg) {
System.out.println("发送消息," + msg + ",发送时间:" + System.currentTimeMillis());
template.convertAndSend("", "dl-q01", msg);
return "ok";
}
发送
监听消息-主要是为了消费：
listener-DeadListener
@RabbitListener(queues = "dl-q02")
public void handler(String m) {
System.out.println("延迟消息,"+m+",接受时间:" +System.currentTimeMillis());
}
yml：
spring:
rabbitmq:
host: 121.36.5.100
port: 5672
username: guest
password: guest
server:
port: 8082
测试：
RabbitMQ事务：
数据库中事务：保证数据一致性，特别是多个操作要么都成功，要么都失败
RabbitMQ事务：一次性发多条消息，需要开启事务，
RabbitMQ也有自己的事务，如果本次
使用步骤：
源码：RabbitMQ02
1.创建配置类
2.使用基于事务发送
3.监听消息
1.创建配置类
config-RabbitMQTranConfig
1.准备一个队列
2.创建事务管理器
// 创建事务管理器
@Bean
public RabbitTransactionManager createTran(ConnectionFactory factory) {
return new RabbitTransactionManager(factory);
}
2.controller-TranController
开启事务
发送消息
// 事务
@Transactional // 需要开启SpringBoot的事务机制
@GetMapping("sendmsg")
public String sendMsg(String msg, int count) {
// 开启 RabbitMQ的通道的事务
template.setChannelTransacted(true);
// 发送消息
for (int i = 0; i < count; i++) {
template.convertAndSend("", "yd-tran-q01", msg + "--" + count);
// 出错，看看 事务是否生效
if (i==2) {
System.out.println(1/0);
}
}
return "ok";
}
3.listener-DeadListener
// 事务
@RabbitListener(queues = "yd-tran-q01")
public void handler2(String msg) {
System.out.println("监听消息"+msg);
// 处理业务逻辑 出错了
}
手动ACK
RabbitMQ怎么防止消息丢失:
1.发送端没有发送过去
解决：
1.用事务
2.confirm消息确认机制 万能：转人工处理
2.MQ服务器丢失，MQ服务器蹦了，
解决：开启持久化
3.消费端消息丢失：
解决：自动应答，改成开始手动ACK
消息确认机制：默认是自动确认
消息的发送和接收是异步
RabbitMQ如何防止消息丢失：
代码：
config-RabbitMqTranConfig
//消费消息的⼿动应答
@Bean
public Queue createQ4() {
return new Queue("yd-ack-q01");
}
controller-DeadController
// 事务
@Transactional // 需要开启SpringBoot的事务机制
@GetMapping("sendmsg")
public String sendMsg(String msg, int count) {
// 开启 RabbitMQ的通道的事务
template.setChannelTransacted(true);
// 发送消息
for (int i = 0; i < count; i++) {
template.convertAndSend("", "yd-tran-q01", msg + "--" + count);
// 出错，看看 事务是否生效
if (i==2) {
System.out.println(1/0);
}
}
return "ok";
}
listener-DeadListener
一般设置个上限，比如最多三次
@RabbitListener(queues = "yd-ack-q01")
public void handler3(String msg, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
//消费者获取消息，默认采用的自动应答，就是获取就应答，这样MQ服务器就删除消息
//还可以手动应答:结果:1.成功(MQ删除)2.失败(MQ消息)
System.out.println("收到ACK消息，监听消息:" + msg);
//拒绝消息 参数说明：1.消息id 2.结果 true 成功 false 拒绝 3.是否把消息添加回队列中
channel.basicNack(tag,false,true);
//成功消息 参数说明：1.消息id 2.结果 true 成功 false 拒绝
//channel.basicAck(tag,true);
// 处理业务逻辑 出错了
}
消费消息的手动应答：
RabbitMQ默认的消费者消息获取模式采用的是手动应答
但是这种有缺陷，可能会出现，消息获取了但是业务出了问题，导致MQ也自动删除了消息，最终导致业务没有执行
所以为了解决这种问题，可以开启手动应答模式，结合自己的业务执行情况，如果业务执行成功，那么就成功应答，如果失败了，就拒绝消息，同时把消息再加回队列，这样就可以再次消息再次处理（加个上限）
测试
RabbitMQ如何保证消息的幂等性：
幂等性就是重复消费。
解决：
1.生成一个全局id，存入redis或者数据库，在消费者消费消息之前，查询一下该消息是否有小费过。
2.
用户充值，重复消费，相当如充值了多次，是一定要杜绝的。
不要返回值的时候，可以用RabbitMQ替代OpenFegin，因为消费完就不回了。MQ默认是单向的
短信发信可以用MQ，这个业务要做，做起来可能会很耗时，中间要经过运营商，过程不可控
RabbitMQ应用场景
消息通信，发送消息和接收消息，是异步
1.实现服务通信
用在微服务中，实现2个服务的通信，这种不带返回值的，只是为了执行另一个服务的方法执行
2.解决耗时操作
比如：邮件、短信、第三方接口等，比较耗时
3.解耦
4.提升性能
5.重复代码封装
6.削峰填谷（订单先下到redis中，再通过MQ和延迟队列，慢慢的从redis搬到mysql中）
关键词：异步、解耦、延迟
