springboot+rabbitmq实现多个生产者多个消费者
第一个项目配置
配置文件
rabbitmq:
addresses: 127.0.0.1:5672
username: root
password: 123456
listener:
simple:
concurrency: 5
max-concurrency: 10
acknowledge-mode: manual
prefetch: 1
retry:
initial-interval: 1000
connection-timeout: 15000
virtual-host: /
publisher-confirms: true
监听器
package com.luntek.cloudplatform.listener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
/**
* 用于RabbitMQ的消息确认机制
*
* @author Administrator
* @Date 2019/10/12 0012 下午 1:19
* @Created by Czw
*/
@Slf4j
@Component
public class RabbitmqConfirmListener implements RabbitTemplate.ConfirmCallback {
/**
* 回调函数:confirm确认rabbitmq的ack接收情况
*
* @param correlationData 消息信息
* @param ack 消息是否返回成功
* @author Czw
* @date 2019/10/12 0015 下午 8:51
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String s) {
log.debug("RabbitMQ回调函数，CorrelationData：{},是否成功：{}", correlationData, ack);
//获取消息ID
String messageId = correlationData == null ? "" : correlationData.getId();
String messageReturn = correlationData == null ? "" : correlationData.toString();
if (ack) {
log.info("RabbitMQ回调函数返回成功,messageId为： {} ，内容为： {} ", messageId, messageReturn);
} else {
log.error("RabbitMQ回调函数返回失败");
}
}
}
生产者
package com.luntek.cloudplatform.rabbitmq.producer;
import com.luntek.cloudplatform.listener.RabbitmqConfirmListener;
import com.luntek.cloudplatform.utils.Constants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
/**
* 线上赛项组织消息生产者，用于同步数据到云平台项目
*
* @author Czw
* @Date 2019/6/3 0003 上午 11:26
*/
@Slf4j
@Component
public class CompetitionSender {
/**
* 自动注入发送消息的模板
*/
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RabbitmqConfirmListener rabbitmqConfirmListener;
/**
* 将需要删除的参赛编号信息发送到队列中
* 删除数据，fanout模式，rout值失效，根据queue绑定，exchange必须相同
*
* @param cards 参赛者参赛编号，删除云平台上的用户数据
* @author Czw
* @date 2020/5/21 0021 下午 4:04
*/
public void sendDeleteCompetitor(String cards) {
log.info("***芯云学院RabbitMQ开始发送消息***");
//correlationData消息唯一id
CorrelationData correlationData = new CorrelationData();
String messageId = UUID.randomUUID().toString();
correlationData.setId(messageId);
//设置消息确认机制
rabbitTemplate.setConfirmCallback(rabbitmqConfirmListener);
//exchange
rabbitTemplate.convertAndSend(Constants.EXCHANGE_COMPETITOR_DELETE,
//routingKey 路由key 在rabbitmq中交换机Rout Key对应的值
"competition.luntek",
//消息体内容
cards,
//correlationData消息唯一id
correlationData);
log.info("*****RabbitMQ发送消息完成,消息ID为，{} ,参赛信息为competitions: {} *****", messageId, cards);
}
}
消费者
package com.luntek.cloudplatform.rabbitmq.consumer;
import com.luntek.cloudplatform.emus.RoleEnum;
import com.luntek.cloudplatform.entity.User;
import com.luntek.cloudplatform.service.MicroService;
import com.luntek.cloudplatform.service.UserService;
import com.luntek.cloudplatform.utils.Constants;
import com.luntek.cloudplatform.utils.FastDFSClientUtil;
import com.luntek.cloudplatform.utils.FastDFSUtil;
import com.luntek.cloudplatform.utils.JsonUtil;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;
/**
* 线上赛项组织消息生产者，用于同步数据到云平台项目
*
* @author Czw
* @Date 2019/6/3 0003 上午 11:28
*/
@Slf4j
@Component
public class CompetitionReceiver {
@Autowired
private UserService userService;
@Autowired
private MicroService microService;
/*
@RabbitListener 自动在RabbitMQ上面添加交换机、队列，以及设置相关属性；
@Queue和@Exchange的durable属性都是设置队列为持久化。确保退出或者崩溃
的时候，将会丢失所有队列和消息（交换机没设置是因为该属性默认true）；
@RabbitHandler 只是标识方法如果有消息过来消费者要消费的时候调用这个方法
*/
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = Constants.QUEUE_COMPETITOR_ADD, durable = "true"),
exchange = @Exchange(name = Constants.EXCHANGE_COMPETITOR_ADD, type = "topic"),//交换机名称，durable指是否持久化到数据库，type：模式
key = "competition.*" //路由匹配规则
))
@RabbitHandler
public void competitionMessage(@Payload String competitions,
@Headers Map<String, Object> headers,
Channel channel) throws Exception {
//消费者操作
log.info("*****CompetitionReceiver:{}，开始消费*****", competitions);
if (competitions != null) {
log.info("***CompetitionReceiver开始解析文件内容***");
List<User> userList = new ArrayList<>();
List<String> list = JsonUtil.jsonToObject(competitions, List.class);
for (String s : list) {
User user = new User();
user.setId(UUID.randomUUID().toString());
user.setLoginTime(0);
user.setCreateTime(new Date());
user.setCreateBy("");
user.setUpdateTime(new Date());
user.setUpdateBy("");
user.setVersion(0);
user.setName("");
user.setTodayIntegral(0);
user.setTotalIntegral(0);
user.setSchoolId(Constants.COMPETITION_SCHOOL);
User userInfo = userService.getByUserId(s);
if (userInfo != null) {
log.error("***用户ID {} 已经存在***", s);
continue;
}
user.setUserId(s);
user.setIcon("");
user.setPassword(Constants.ORIGIN_PASSWORD);
user.setRoleId(RoleEnum.CANDIDATE.getCode());
userList.add(user);
}
if (userList.size() > 0) {
//保存数据
userService.addBatchUser(userList);
}
//ACK 手动签收消息，告诉对方消息签收成功,唯一标识ID
Long deliverTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
channel.basicAck(deliverTag, false);
}
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = Constants.QUEUE_COMPETITOR_CLOUD_DELETE, durable = "true"),
//交换机名称，durable指是否持久化到数据库，type：模式 fanout订阅者模式
exchange = @Exchange(name = Constants.EXCHANGE_COMPETITOR_DELETE, type = "fanout"),
key = "competition.*" //路由匹配规则
))
/**
* @RabbitHandler 只是标识方法如果有消息过来消费者要消费的时候调用这个方法
*/
@RabbitHandler
@Transactional(rollbackFor = {Exception.class})
public void competitionDeleteMessage(@Payload String cards,
@Headers Map<String, Object> headers,
Channel channel) throws Exception {
log.info("***云平台中订阅者模式消费者，信息为：{}***", cards);
//ACK 手动签收消息，告诉对方消息签收成功
Long deliverTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
//唯一标识ID
channel.basicAck(deliverTag, false);
}
}
第二个项目
配置文件
rabbitmq:
addresses: 127.0.0.1:5672
username: root
password: 123456
listener:
simple:
concurrency: 5
max-concurrency: 10
acknowledge-mode: manual
prefetch: 1
retry:
initial-interval: 1000
connection-timeout: 15000
virtual-host: /
publisher-confirms: true
监听器
package com.luntek.cloudplatform.listener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
/**
* 用于RabbitMQ的消息确认机制
*
* @author Administrator
* @Date 2019/10/12 0012 下午 1:19
* @Created by Czw
*/
@Slf4j
@Component
public class RabbitmqConfirmListener implements RabbitTemplate.ConfirmCallback {
/**
* 回调函数:confirm确认rabbitmq的ack接收情况
*
* @param correlationData 消息信息
* @param ack 消息是否返回成功
* @author Czw
* @date 2019/10/12 0015 下午 8:51
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String s) {
log.debug("RabbitMQ回调函数，CorrelationData：{},是否成功：{}", correlationData, ack);
//获取消息ID
String messageId = correlationData == null ? "" : correlationData.getId();
String messageReturn = correlationData == null ? "" : correlationData.toString();
if (ack) {
log.info("RabbitMQ回调函数返回成功,messageId为： {} ，内容为： {} ", messageId, messageReturn);
} else {
log.error("RabbitMQ回调函数返回失败");
}
}
}
生产者
package com.luntek.certificate.rabbitmq.producer;
import com.luntek.certificate.listener.RabbitmqConfirmListener;
import com.luntek.certificate.utils.StaticParams;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
/**
* 线上赛项组织消息生产者，用于同步数据到云平台项目
*
* @author Czw
* @Date 2019/6/3 0003 上午 11:26
*/
@Slf4j
@Component
public class CompetitionSender {
/**
* 自动注入发送消息的模板
*/
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private RabbitmqConfirmListener rabbitmqConfirmListener;
/**
* 同步数据到云平台，topic模式，数据根据rout来消费
*
* @param competitions 同步数据到云平台的参赛者数据
* @author Czw
* @date 2020/5/21 0021 下午 4:04
*/
public void send(String competitions) {
log.info("*****RabbitMQ开始发送消息*****");
//correlationData消息唯一id
CorrelationData correlationData = new CorrelationData();
String messageId = UUID.randomUUID().toString();
correlationData.setId(messageId);
//设置消息确认机制
rabbitTemplate.setConfirmCallback(rabbitmqConfirmListener);
//exchange
rabbitTemplate.convertAndSend(StaticParams.EXCHANGE_COMPETITOR_ADD,
//routingKey 路由key 在rabbitmq中交换机Rout Key对应的值
"competition.luntek",
//消息体内容
competitions,
//correlationData消息唯一id
correlationData);
log.info("*****RabbitMQ发送消息完成,消息ID为，{} ,参赛信息为competitions: {} *****", messageId, competitions);
}
/**
* 将需要删除的获取参赛编号信息发送到队列中
* 删除数据，fanout模式，rout值失效，根据queue绑定，exchange必须相同
*
* @param cards 参赛者参赛编号，删除云平台上的用户数据
* @author Czw
* @date 2020/5/21 0021 下午 4:04
*/
public void sendDeleteCompetitor(String cards) {
log.info("***芯云学院RabbitMQ开始发送消息***");
//correlationData消息唯一id
CorrelationData correlationData = new CorrelationData();
String messageId = UUID.randomUUID().toString();
correlationData.setId(messageId);
//设置消息确认机制
rabbitTemplate.setConfirmCallback(rabbitmqConfirmListener);
//exchange
rabbitTemplate.convertAndSend(StaticParams.EXCHANGE_COMPETITOR_DELETE,
//routingKey 路由key 在rabbitmq中交换机Rout Key对应的值
"competition.luntek",
//消息体内容
cards,
//correlationData消息唯一id
correlationData);
log.info("*****RabbitMQ发送消息完成,消息ID为，{} ,参赛信息为competitions: {} *****", messageId, cards);
}
}
消费者
package com.luntek.certificate.rabbitmq.consumer;
import com.luntek.certificate.mapper.OnlineCompetitionMapper;
import com.luntek.certificate.utils.JsonUtil;
import com.luntek.certificate.utils.StaticParams;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
/**
* 线上赛项组织消息生产者，用于同步数据到云平台项目
*
* @author Czw
* @Date 2019/6/3 0003 上午 11:28
*/
@Slf4j
@Component
public class CompetitionReceiver {
@Autowired
private OnlineCompetitionMapper onlineCompetitionMapper;
/**
* 将需要删除的用户身份证信息发送到队列中
* 删除数据，fanout模式，rout值失效，根据queue绑定，exchange必须相同
*
* @author Czw
* @param cards 参赛者身份证，删除云平台上的用户数据
* @date 2020/5/21 0021 下午 4:13
* @RabbitHandler 只是标识方法如果有消息过来消费者要消费的时候调用这个方法
*/
@RabbitListener(bindings = @QueueBinding(
value = @Queue(value = StaticParams.QUEUE_COMPETITOR_CERTIFICATE_DELETE, durable = "true"),
//交换机名称，durable指是否持久化到数据库，type：模式 fanout订阅者模式
exchange = @Exchange(name = StaticParams.EXCHANGE_COMPETITOR_DELETE, type = "fanout"),
key = "competition.*" //路由匹配规则
))
@RabbitHandler
public void competitionDeleteMessage(@Payload String cards,
@Headers Map<String, Object> headers,
Channel channel) throws Exception {
log.info("***芯云学院中订阅者模式消费者，信息为：{}***", cards);
//ACK 手动签收消息，告诉对方消息签收成功,唯一标识ID
Long deliverTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
channel.basicAck(deliverTag, false);
}
}
效果
rabbitmq中的exchange和queue
在第二个项目中调用生产者发送消息，两个项目的消费者同时收到消息能进行消费
