尚品汇-商品上下架完善（更新ES）、延迟消息（四十四） ...

莱莱 · 2024-9-9 01:31:41

目次：
（1）改造商品搜刮上下架
（2）延迟消息
（1）改造商品搜刮上下架

定义商品上下架常量

在rabbit-util模块中导入常量类MqConst。

复制代码

/**
* 商品上下架.
*/
public static final String EXCHANGE_DIRECT_GOODS = "exchange.direct.goods";
public static final String ROUTING_GOODS_UPPER = "goods.upper";
public static final String ROUTING_GOODS_LOWER = "goods.lower";
//队列
public static final String QUEUE_GOODS_UPPER = "queue.goods.upper";
public static final String QUEUE_GOODS_LOWER = "queue.goods.lower";

复制代码

service-list与service-product引入依赖与配置

<dependency>
<groupId>com.atguigu.gmall</groupId>
<artifactId>rabbit-util</artifactId>
<version>1.0</version>
</dependency>

复制代码

service-product发送消息
我在商品上架与商品添加时发送消息

商品上架
实现类

@Override
@Transactional
public void onSale(Long skuId) {
// 更改销售状态
SkuInfo skuInfoUp = new SkuInfo();
skuInfoUp.setId(skuId);
skuInfoUp.setIsSale(1);
skuInfoMapper.updateById(skuInfoUp);
//商品上架交换机路由key 队列
rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_GOODS, MqConst.ROUTING_GOODS_UPPER, skuId);
}

复制代码

商品下架

@Override
@Transactional
public void cancelSale(Long skuId) {
// 更改销售状态
SkuInfo skuInfoUp = new SkuInfo();
skuInfoUp.setId(skuId);
skuInfoUp.setIsSale(0);
skuInfoMapper.updateById(skuInfoUp);
//商品下架交换机路由key 队列
rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_GOODS, MqConst.ROUTING_GOODS_LOWER, skuId);
}

复制代码

service-list消费消息

package com.atguigu.gmall.list.receiver;
import com.atguigu.gmall.constant.MqConst;
import com.atguigu.gmall.list.service.SearchService;
import com.rabbitmq.client.Channel;
import lombok.SneakyThrows;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class ListReceiver {
@Autowired
private SearchService searchService;
//监听上架队列
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
value =@Queue(value = MqConst.QUEUE_GOODS_UPPER,durable = "true",autoDelete = "false"),
exchange =@Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,autoDelete = "false"),
key = {MqConst.ROUTING_GOODS_UPPER}
))
public void upperGoodsToEs(Long skuId, Message message, Channel channel){
try {
//判断
if(skuId!=null){
//操作搜索模块操作ES的上架方法
searchService.upperGoods(skuId);
}
} catch (Exception e) {
//写入日志文件，，写入数据库，对接程序员手机短信
e.printStackTrace();
}
//消息确认 // 参数一：消息的唯一标识，参数二：是否批量确认 false 确认一个消息，true 批量确认
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
//监听下架队列
//监听上架队列
@SneakyThrows
@RabbitListener(bindings = @QueueBinding(
value =@Queue(value = MqConst.QUEUE_GOODS_LOWER,durable = "true",autoDelete = "false"),
exchange =@Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,autoDelete = "false"),
key = {MqConst.ROUTING_GOODS_LOWER}
))
public void lowerGoodsToEs(Long skuId, Message message, Channel channel){
try {
//判断
if(skuId!=null){
//操作搜索模块操作ES的下架方法
searchService.lowerGoods(skuId);
}
} catch (Exception e) {
//写入日志文件，，写入数据库，对接程序员手机短信
e.printStackTrace();
}
//消息确认 // 参数一：消息的唯一标识，参数二：是否批量确认 false 确认一个消息，true 批量确认
channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
}
}

复制代码

测试
启动后台管理页面
http://localhost:8888/#/product/sku/list
操作商品的上架，下架。动态更改es中的数据。

全部下架，页面查看：

上架几个：

（2）延迟消息

前面解决了搜刮与商品服务的题目，下面解决这个题目订单取消题目：

延迟消息有两种实现方案：

基于死信队列
集成延迟插件

1.基于死信实现延迟消息

使用RabbitMQ来实现延迟消息必须先了解RabbitMQ的两个概念：消息的TTL和死信Exchange，通过这两者的组合来实现延迟队列
消息的TTL（Time To Live）

消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。凌驾了这个时间，我们认为这个消息就死了，称之为死信。
怎样设置TTL：
我们创建一个队列queue.temp，在Arguments 中添加x-message-ttl 为5000 （单位是毫秒），那所在压在这个队列的消息在5秒后会消散。
死信互换机 Dead Letter Exchanges

一个消息在满足如下条件下，会进死信路由，记住这里是路由而不是队列，一个路由可以对应很多队列。
（1）一个消息被Consumer拒收了，而且reject方法的参数里requeue是false。也就是说不会被再次放在队列里，被其他消费者使用。
（2）上面的消息的TTL到了，消息逾期了。
（3）队列的长度限制满了。排在前面的消息会被抛弃大概扔到死信路由上。
Dead Letter Exchange其实就是一种普通的exchange，和创建其他exchange没有两样。只是在某一个设置Dead Letter Exchange的队列中有消息逾期了，会自动触发消息的转发，发送到Dead Letter Exchange中去。

我们现在可以测试一下延迟队列。
（1）创建死信队列
（2）创建互换机
（3）创建互换器与队列之间的绑定
（4）创建队列
代码实现

在service-mq 中添加配置类：前面我们使用注解的方式举行创建互换机队列，下面我们用配置类举行创建

package com.atguigu.gmall.mq.config;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DeadLetterMqConfig {
// 声明一些变量
public static final String exchange_dead = "exchange.dead";
public static final String routing_dead_1 = "routing.dead.1";
public static final String routing_dead_2 = "routing.dead.2";
public static final String queue_dead_1 = "queue.dead.1";
public static final String queue_dead_2 = "queue.dead.2";
// 定义交换机
@Bean
public DirectExchange exchange(){
return new DirectExchange(exchange_dead,true,false,null);
}
@Bean
public Queue queue1(){
// 设置如果队列一出现问题，则通过参数转到exchange_dead，routing_dead_2 上！
HashMap<String, Object> map = new HashMap<>();
// 参数绑定此处的key 固定值，不能随意写
map.put("x-dead-letter-exchange",exchange_dead);
map.put("x-dead-letter-routing-key",routing_dead_2);
// 设置延迟时间
map.put("x-message-ttl", 10 * 1000);
// 队列名称，是否持久化，是否独享、排外的【true:只可以在本次连接中访问】，是否自动删除，队列的其他属性参数
return new Queue(queue_dead_1,true,false,false,map);
}
@Bean
public Binding binding(){
// 将队列一通过routing_dead_1 key 绑定到exchange_dead 交换机上
return BindingBuilder.bind(queue1()).to(exchange()).with(routing_dead_1);
}
// 这个队列二就是一个普通队列
@Bean
public Queue queue2(){
return new Queue(queue_dead_2,true,false,false,null);
}
// 设置队列二的绑定规则
@Bean
public Binding binding2(){
// 将队列二通过routing_dead_2 key 绑定到exchange_dead交换机上！
return BindingBuilder.bind(queue2()).to(exchange()).with(routing_dead_2);
}
}

复制代码

配置发送消息

package com.atguigu.gmall.mq.controller;
@RestController
@RequestMapping("/mq")
@Slf4j
public class MqController {
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RabbitService rabbitService;
@GetMapping("sendDeadLettle")
public Result sendDeadLettle() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
this.rabbitService.convertAndSend(DeadLetterMqConfig.exchange_dead, DeadLetterMqConfig.routing_dead_1, "我是延迟消息");
System.out.println(" 消息发送时间："+sdf.format(new Date()) );
return Result.ok();
}
}

复制代码

消息接收方

package com.atguigu.gmall.mq.receiver;
@Component
@Configuration
public class DeadLetterReceiver {
//消费的是队列2，队列1,没有人消息，超过超时时间后会变成死信
@RabbitListener(queues = DeadLetterMqConfig.queue_dead_2)
public void get(String msg) {
System.out.println("Receive:" + msg);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("消息接收时间: " + sdf.format(new Date()));
System.out.println("消息内容为："+msg)
}
}

复制代码

2.基于延迟插件实现延迟消息

Rabbitmq实现了一个插件x-delay-message来实现延时队列
插件安装
1. 首先我们将刚下载下来的rabbitmq_delayed_message_exchange-3.9.0.ez文件上传到RabbitMQ所在服务器，下载地址：https://www.rabbitmq.com/community-plugins.html
2. 切换到插件所在目次，执行 docker cp rabbitmq_delayed_message_exchange-3.9.0.ez rabbitmq:/plugins 下令，将刚插件拷贝到容器内plugins目次下
3. 执行 docker exec -it rabbitmq /bin/bash 下令进入到容器内部，并 cd plugins 进入plugins目次
4. 执行 ls -l|grep delay 下令查看插件是否copy成功
5. 在容器内plugins目次下，执行 rabbitmq-plugins enable rabbitmq_delayed_message_exchange 下令启用插件
6. exit下令退出RabbitMQ容器内部，然后执行 docker restart rabbitmq 下令重启RabbitMQ容器
代码实现

在service-mq 中添加类

配置队列

package com.atguigu.gmall.mq.config;
@Configuration
public class DelayedMqConfig {
public static final String exchange_delay = "exchange.delay";
public static final String routing_delay = "routing.delay";
public static final String queue_delay_1 = "queue.delay.1";
@Bean
public Queue delayQeue1() {
// 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
return new Queue(queue_delay_1, true);
}
@Bean
public CustomExchange delayExchange() {
Map<String, Object> args = new HashMap<String, Object>();
args.put("x-delayed-type", "direct");
return new CustomExchange(exchange_delay, "x-delayed-message", true, false, args);
}
@Bean
public Binding delayBbinding1() {
return BindingBuilder.bind(delayQeue1()).to(delayExchange()).with(routing_delay).noargs();
}
}

复制代码

发送消息：这个延迟插件，需要使用rabbitTemplate，上面的可以使用rabbitService封装的service

@GetMapping("sendelay")
public Result sendDelay() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
this.rabbitTemplate.convertAndSend(DelayedMqConfig.exchange_delay, DelayedMqConfig.routing_delay, "我是延迟插件的消息", new MessagePostProcessor() {
@Override
public Message postProcessMessage(Message message) throws AmqpException {
message.getMessageProperties().setDelay(10 * 1000);//消息的延迟时间
System.out.println("延迟插件消息发送时间："+sdf.format(new Date()) );
return message;//放行消息
}
});
return Result.ok();
}

复制代码

接收消息