springboot中rabbitmq集成——单项目
这两天看了下activemq和rabbitmq，现在跟大家分享下rabbitmq在springboot中的集成及使用。
依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-amqpartifactId>
dependency>
- 1
- 2
- 3
- 4
具体代码：
@SpringBootApplication
public class RabbitmqApplication implements CommandLineRunner{
@Autowired
RabbitTemplate rabbitTemplate;//使用springboot配置好的队列RabbitTemplate
public static void main(String[] args) {
SpringApplication.run(RabbitmqApplication.class, args);
}
/**
* 定义目的地队列，命名为my-rabbitmq
* 这里实际上是要往rabbitmq里注册队列名称
* */
@Bean
public Queue myQueue(){
return new Queue("my-rabbitmq");
}
public void run(String... args) throws Exception {
//ͨ使用RabbitTemplate的convertAndSend发送给队列my-rabbitmq消息
rabbitTemplate.convertAndSend("my-rabbitmq", "这是我rabbitmq的测试消息");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
继承CommandLineRunner是消息队列能够在项目启动的时候直接执行。
接收（消费）消息的代码，（现在先以一个项目来操作）：
@Component
public class Receiver {
private static final Logger log = LoggerFactory.getLogger(Receiver.class);
@RabbitListener(queues="my-rabbitmq")
public void receive(String message){
System.out.println("我收到的消息是："+message);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
@RabbitListener(queues=”my-rabbitmq”)是用来监听消息队列的，如果队列中有消息将直接在这里被消费掉。
启动项目，控制台log如下：
我收到的消息是：这是我rabbitmq的测试消息成功消费掉了。
定义两个消息的接收器，代码稍作改动：
public void run(String... args) throws Exception {
for (int i = 0; i < 10; i++) {
rabbitTemplate.convertAndSend("my-rabbitmq", "这里的值是"+i);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
这里一次发送十条消息。
消息接收器代码：
@RabbitListener(queues="my-rabbitmq")
public void receive1(String message){
log.info("我是第一个消费监听器，去消费了:"+message);
}
@RabbitListener(queues="my-rabbitmq")
public void receive2(String message){
log.info("我是第二个消费监听器，去消费了:"+message);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
我是第一个消费监听器，去消费了:这里的值是0
我是第二个消费监听器，去消费了:这里的值是1
我是第一个消费监听器，去消费了:这里的值是2
我是第二个消费监听器，去消费了:这里的值是3
我是第一个消费监听器，去消费了:这里的值是4
我是第二个消费监听器，去消费了:这里的值是5
我是第一个消费监听器，去消费了:这里的值是6
我是第二个消费监听器，去消费了:这里的值是7
我是第一个消费监听器，去消费了:这里的值是8
我是第二个消费监听器，去消费了:这里的值是9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
上面的log可以看到，两个消息接收器都有收到消息，而且是轮询消费消息的，具体是不是一样的大家可以多试几次。
传递对象：
这里分成两种讨论，1、引用的java中的对象，以Map为例；2、自己定义的实体类对象。
1、传递Map
修改代码：
public void run(String... args) throws Exception {
HashMap<String, Object> hm=new HashMap<String, Object>();
hm.put("name", "庞坤");
hm.put("age", 28);
hm.put("address", "上海漕河泾开发区");
rabbitTemplate.convertAndSend("my-rabbitmq", hm);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
@RabbitListener(queues="my-rabbitmq")
public void receive(HashMap hm){
System.out.println("我接收到消息是:"+hm);
}
- 1
- 2
- 3
- 4
启动项目，看到log：
我接收到消息是:{address=上海漕河泾开发区, name=庞坤, age=28}
2、自己定义的实体类对象。
注意，这里一定要对User序列化
@Component
public class User implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private String userName="";
private Integer age=0;
private String address="";
/**
*省略getter和setter
*/
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
生成消息
public void run(String... args) throws Exception {
User user=new User();
user.setUserName("庞坤");
user.setAge(28);
user.setAddress("上海市徐汇区漕河泾开发区");
rabbitTemplate.convertAndSend("my-rabbitmq", user);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
消费消息
@RabbitListener(queues="my-rabbitmq")
public void receive(User user) {
System.out.println("我收到的消息是:"+user);
System.out.println("Address:"+user.getAddress());
System.out.println("UserName:"+user.getUserName());
System.out.println("Age:"+user.getAge());
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
控制台log：
我收到的消息是:com.rhett.rabbitmq.User@3289bb89
Address:上海市徐汇区漕河泾开发区
UserName:庞坤
Age:28
- 1
- 2
- 3
- 4
注意下user对象com.rhett.rabbitmq.User@3289bb89，直接指向发送的消息的实体类，两个项目之间消费消息的时候这里会有问题。
具体解决方案我会在下篇文章多项目之间说明。
参考书籍：汪云飞老师的 spring boot实战