springboot+rabbitmq整合

最新推荐文章于 2023-12-07 19:40:29 发布
最新推荐文章于 2023-12-07 19:40:29 发布
阅读量88 收藏
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/Amos-Turing/p/10040730.html
版权

一、新建maven工程：springboot-rabbitmq

 

 

二、引入springboot和rabbitmq的依赖

复制代码 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.springboot.rabbitmq</groupId> <artifactId>springboot-rabbitmq</artifactId> <version>0.0.1-SNAPSHOT</version> <name>springboot-rabbitmq</name> <description>springboot-rabbitmq</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.1.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> </dependencies> </project>
复制代码 
spring-boot-starter-test是为了后面写测试类用，
spring-boot-starter-amqp才是真正的使用rabbitmq的依赖

三、在src/main/resources里面新增application.properties
该配置文件主要是对rabbimq的配置信息
复制代码

spring.application.name=springboot-rabbitmq
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.virtual-host=/

 
复制代码

四、新建springboot主类Application

该类初始化创建队列、转发器，并把队列绑定到转发器

复制代码 
package com.rabbit;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.FanoutExchange; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.TopicExchange; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class Application { final static String queueName = "hello"; @Bean public Queue helloQueue() { return new Queue("hello"); } @Bean public Queue userQueue() { return new Queue("user"); } //===============以下是验证topic Exchange的队列==========  @Bean public Queue queueMessage() { return new Queue("topic.message"); } @Bean public Queue queueMessages() { return new Queue("topic.messages"); } //===============以上是验证topic Exchange的队列========== //===============以下是验证Fanout Exchange的队列==========  @Bean public Queue AMessage() { return new Queue("fanout.A"); } @Bean public Queue BMessage() { return new Queue("fanout.B"); } @Bean public Queue CMessage() { return new Queue("fanout.C"); } //===============以上是验证Fanout Exchange的队列==========  @Bean TopicExchange exchange() { return new TopicExchange("exchange"); } @Bean FanoutExchange fanoutExchange() { return new FanoutExchange("fanoutExchange"); } /** * 将队列topic.message与exchange绑定，binding_key为topic.message,就是完全匹配 * @param queueMessage * @param exchange * @return */ @Bean Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) { return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message"); } /** * 将队列topic.messages与exchange绑定，binding_key为topic.#,模糊匹配 * @param queueMessage * @param exchange * @return */ @Bean Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) { return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#"); } @Bean Binding bindingExchangeA(Queue AMessage,FanoutExchange fanoutExchange) { return BindingBuilder.bind(AMessage).to(fanoutExchange); } @Bean Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) { return BindingBuilder.bind(BMessage).to(fanoutExchange); } @Bean Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) { return BindingBuilder.bind(CMessage).to(fanoutExchange); } public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args); } }
复制代码

五、各种情景实现

1、最简单的hello生产和消费实现（单生产者和单消费者）

生产者：

复制代码 
package com.rabbit.hello;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class HelloSender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello1 " + new Date(); System.out.println("Sender1 : " + sendMsg); this.rabbitTemplate.convertAndSend("helloQueue", sendMsg); } }
复制代码

消费者:

复制代码 
package com.rabbit.hello;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver1 { @RabbitHandler public void process(String hello) { System.out.println("Receiver1 : " + hello); } }
复制代码

controller：

复制代码 
package com.rabbit.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import com.rabbit.hello.HelloSender1; @RestController @RequestMapping("/rabbit") public class RabbitTest { @Autowired private HelloSender1 helloSender1; @Autowired private HelloSender1 helloSender2; @PostMapping("/hello") public void hello() { helloSender1.send(); } }
复制代码

启动程序，执行：

结果如下：

Sender1 : hello1 Thu May 11 17:23:31 CST 2017
Receiver2  : hello1 Thu May 11 17:23:31 CST 2017

 

2、单生产者-多消费者

生产者：

复制代码 
package com.rabbit.hello;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class HelloSender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send(String msg) { String sendMsg = msg + new Date(); System.out.println("Sender1 : " + sendMsg); this.rabbitTemplate.convertAndSend("helloQueue", sendMsg); } }
复制代码

消费者1：

复制代码 
package com.rabbit.hello;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver1 { @RabbitHandler public void process(String hello) { System.out.println("Receiver1 : " + hello); } }
复制代码

消费者2：

复制代码 
package com.rabbit.hello;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver2 { @RabbitHandler public void process(String hello) { System.out.println("Receiver2 : " + hello); } }
复制代码

controller:

复制代码 
package com.rabbit.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import com.rabbit.hello.HelloSender1; @RestController @RequestMapping("/rabbit") public class RabbitTest { @Autowired private HelloSender1 helloSender1; @Autowired private HelloSender1 helloSender2; @PostMapping("/hello") public void hello() { helloSender1.send("hello1"); } /** * 单生产者-多消费者 */ @PostMapping("/oneToMany") public void oneToMany() { for(int i=0;i<10;i++){ helloSender1.send("hellomsg:"+i); } } }
复制代码

用post方式执行：

http://127.0.0.1:8080/rabbit/oneToMany

结果如下：

复制代码 
Sender1 : hellomsg:0Thu May 11 17:37:59 CST 2017
Sender1 : hellomsg:1Thu May 11 17:37:59 CST 2017
Sender1 : hellomsg:2Thu May 11 17:37:59 CST 2017
Sender1 : hellomsg:3Thu May 11 17:37:59 CST 2017
Sender1 : hellomsg:4Thu May 11 17:37:59 CST 2017
Sender1 : hellomsg:5Thu May 11 17:37:59 CST 2017 Sender1 : hellomsg:6Thu May 11 17:37:59 CST 2017 Sender1 : hellomsg:7Thu May 11 17:37:59 CST 2017 Sender1 : hellomsg:8Thu May 11 17:37:59 CST 2017 Sender1 : hellomsg:9Thu May 11 17:37:59 CST 2017 Receiver2 : hellomsg:1Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:0Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:3Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:4Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:5Thu May 11 17:37:59 CST 2017 Receiver2 : hellomsg:2Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:6Thu May 11 17:37:59 CST 2017 Receiver2 : hellomsg:7Thu May 11 17:37:59 CST 2017 Receiver2 : hellomsg:8Thu May 11 17:37:59 CST 2017 Receiver1 : hellomsg:9Thu May 11 17:37:59 CST 2017
复制代码

从以上结果可知，生产者发送的10条消息，分别被两个消费者接收了

 

3、多生产者-多消费者

生产者1：

复制代码 
package com.rabbit.hello;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloSender1 {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(String msg) {
        String sendMsg = msg + new Date();
        System.out.println("Sender1 : " + sendMsg);
        this.rabbitTemplate.convertAndSend("helloQueue", sendMsg);
    }

}
复制代码

生产者2：

复制代码 
package com.rabbit.hello;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloSender2 {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(String msg) {
        String sendMsg = msg + new Date();
        System.out.println("Sender2 : " + sendMsg);
        this.rabbitTemplate.convertAndSend("helloQueue", sendMsg);
    }

}
复制代码

消费者1：

复制代码 
package com.rabbit.hello;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "helloQueue")
public class HelloReceiver1 {

    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver1  : " + hello);
    }

}
复制代码

消费者2：

复制代码 
package com.rabbit.hello;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "helloQueue")
public class HelloReceiver2 {

    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver2  : " + hello);
    }

}
复制代码

controller:

复制代码 
    /**
     * 多生产者-多消费者
     */
    @PostMapping("/manyToMany")
    public void manyToMany() { for(int i=0;i<10;i++){ helloSender1.send("hellomsg:"+i); helloSender2.send("hellomsg:"+i); } }
复制代码

 

用post方式执行：

http://127.0.0.1:8080/rabbit/manyToMany

结果如下：

复制代码 
Sender1 : hellomsg:0Fri May 12 09:08:50 CST 2017
Sender2 : hellomsg:0Fri May 12 09:08:50 CST 2017
Sender1 : hellomsg:1Fri May 12 09:08:50 CST 2017
Sender2 : hellomsg:1Fri May 12 09:08:50 CST 2017
Sender1 : hellomsg:2Fri May 12 09:08:50 CST 2017
Sender2 : hellomsg:2Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:3Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:3Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:4Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:4Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:5Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:5Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:6Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:6Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:7Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:7Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:8Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:8Fri May 12 09:08:50 CST 2017 Sender1 : hellomsg:9Fri May 12 09:08:50 CST 2017 Sender2 : hellomsg:9Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:0Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:0Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:1Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:1Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:2Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:2Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:3Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:3Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:4Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:4Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:5Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:5Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:6Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:6Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:7Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:8Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:8Fri May 12 09:08:50 CST 2017 Receiver1 : hellomsg:7Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:9Fri May 12 09:08:50 CST 2017 Receiver2 : hellomsg:9Fri May 12 09:08:50 CST 2017
复制代码

和一对多一样，接收端仍然会均匀接收到消息

 

4、实体类传输

springboot完美的支持对象的发送和接收，不需要格外的配置。

实体类（必须实现序列化接口）：

复制代码 
package com.rabbit.user;

import java.io.Serializable;

public class User implements Serializable{ private String name; private String pass; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPass() { return pass; } public void setPass(String pass) { this.pass = pass; } }
复制代码

 

生产者：

复制代码 
package com.rabbit.user;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class UserSender { @Autowired private AmqpTemplate rabbitTemplate; public void send() { User user=new User(); user.setName("hzb"); user.setPass("123456789"); System.out.println("user send : " + user.getName()+"/"+user.getPass()); this.rabbitTemplate.convertAndSend("userQueue", user); } }
复制代码

消费者：

复制代码 
package com.rabbit.user;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "userQueue") public class UserReceiver { @RabbitHandler public void process(User user) { System.out.println("user receive : " + user.getName()+"/"+user.getPass()); } }
复制代码

controller:

复制代码 
    /**
     * 实体类传输测试
     */
    @PostMapping("/userTest")
    public void userTest() { userSender.send(); }
复制代码

用post方式执行：

http://127.0.0.1:8080/rabbit/userTest

结果如下：

user send : hzb/123456789
user receive  : hzb/123456789

 

5、topic ExChange示例

topic 是RabbitMQ中最灵活的一种方式，可以根据binding_key自由的绑定不同的队列

首先对topic规则配置，这里使用两个队列来测试（也就是在Application类中创建和绑定的topic.message和topic.messages两个队列），其中topic.message的bindting_key为

“topic.message”，topic.messages的binding_key为“topic.#”；

生产者：

复制代码 
package com.rabbit.topic;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class TopicSender { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String msg1 = "I am topic.mesaage msg======"; System.out.println("sender1 : " + msg1); this.rabbitTemplate.convertAndSend("exchange", "topic.message", msg1); String msg2 = "I am topic.mesaages msg########"; System.out.println("sender2 : " + msg2); this.rabbitTemplate.convertAndSend("exchange", "topic.messages", msg2); } }
复制代码

消费者1（topic.message）

复制代码 
package com.rabbit.topic;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "topic.message") public class topicMessageReceiver { @RabbitHandler public void process(String msg) { System.out.println("topicMessageReceiver : " +msg); } }
复制代码

消费者２（topic.messages）

复制代码 
package com.rabbit.topic;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "topic.messages") public class topicMessagesReceiver { @RabbitHandler public void process(String msg) { System.out.println("topicMessagesReceiver : " +msg); } }
复制代码

controller:

复制代码 
    /**
     * topic exchange类型rabbitmq测试
     */
    @PostMapping("/topicTest")
    public void topicTest() { topicSender.send(); }
复制代码

用post方式执行：

http://127.0.0.1:8080/rabbit/topicTest

结果如下：

sender1 : I am topic.mesaage msg======
sender2 : I am topic.mesaages msg########
topicMessageReceiver  : I am topic.mesaage msg======
topicMessagesReceiver  : I am topic.mesaage msg======
topicMessagesReceiver  : I am topic.mesaages msg########

由以上结果可知：sender1发送的消息,routing_key是“topic.message”，所以exchange里面的绑定的binding_key是“topic.message”，topic.＃都符合路由规则;所以sender1

发送的消息，两个队列都能接收到；

sender2发送的消息，routing_key是“topic.messages”，所以exchange里面的绑定的binding_key只有topic.＃都符合路由规则;所以sender2发送的消息只有队列

topic.messages能收到。

 

 

6、fanout ExChange示例

Fanout 就是我们熟悉的广播模式或者订阅模式，给Fanout转发器发送消息，绑定了这个转发器的所有队列都收到这个消息。

这里使用三个队列来测试（也就是在Application类中创建和绑定的fanout.A、fanout.B、fanout.C）这三个队列都和Application中创建的fanoutExchange转发器绑定。

生产者：

复制代码 
package com.rabbit.fanout;

import java.util.Date;

import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class FanoutSender { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String msgString="fanoutSender :hello i am hzb"; System.out.println(msgString); this.rabbitTemplate.convertAndSend("fanoutExchange","abcd.ee", msgString); } }
复制代码

消费者A:

复制代码 
package com.rabbit.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "fanout.A") public class FanoutReceiverA { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverA : " + msg); } }
复制代码

消费者Ｂ：

复制代码 
package com.rabbit.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "fanout.B") public class FanoutReceiverB { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverB : " + msg); } }
复制代码

消费者C:

复制代码 
package com.rabbit.fanout;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component @RabbitListener(queues = "fanout.C") public class FanoutReceiverC { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverC : " + msg); } }
复制代码

controller:

复制代码 
    /**
     * fanout exchange类型rabbitmq测试
     */
    @PostMapping("/fanoutTest")
    public void fanoutTest() { fanoutSender.send(); }
复制代码

用post方式执行：

http://127.0.0.1:8080/rabbit/fanoutTest

结果如下：

fanoutSender :hello i am hzb
FanoutReceiverC  : fanoutSender :hello i am hzb
FanoutReceiverB  : fanoutSender :hello i am hzb
FanoutReceiverA  : fanoutSender :hello i am hzb

由以上结果可知：就算fanoutSender发送消息的时候，指定了routing_key为"abcd.ee"，但是所有接收者都接受到了消息

 

7、带callback的消息发送

增加回调处理，这里不再使用application.properties默认配置的方式，会在程序中显示的使用文件中的配置信息。该示例中没有新建队列和exchange，用的是第5节中的topic.messages队列和exchange转发器。消费者也是第5节中的topicMessagesReceiver

rabbitmq配置类：

复制代码 
package com.rabbit.callback;

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Scope; public class RabbitConfig { @Value("${spring.rabbitmq.host}") private String addresses; @Value("${spring.rabbitmq.port}") private String port; @Value("${spring.rabbitmq.username}") private String username; @Value("${spring.rabbitmq.password}") private String password; @Value("${spring.rabbitmq.virtual-host}") private String virtualHost; @Value("${spring.rabbitmq.publisher-confirms}") private boolean publisherConfirms; @Bean public ConnectionFactory connectionFactory() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory(); connectionFactory.setAddresses(addresses+":"+port); connectionFactory.setUsername(username); connectionFactory.setPassword(password); connectionFactory.setVirtualHost(virtualHost); /** 如果要进行消息回调，则这里必须要设置为true */ connectionFactory.setPublisherConfirms(publisherConfirms); return connectionFactory; } @Bean /** 因为要设置回调类，所以应是prototype类型，如果是singleton类型，则回调类为最后一次设置 */ @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) public RabbitTemplate rabbitTemplatenew() { RabbitTemplate template = new RabbitTemplate(connectionFactory()); return template; } }
复制代码

生产者：

复制代码 
package com.rabbit.callback;

import java.util.Date;
import java.util.UUID; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.amqp.rabbit.support.CorrelationData; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class CallBackSender implements RabbitTemplate.ConfirmCallback{ @Autowired private RabbitTemplate rabbitTemplatenew; public void send() { rabbitTemplatenew.setConfirmCallback(this); String msg="callbackSender : i am callback sender"; System.out.println(msg ); CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString()); System.out.println("callbackSender UUID: " + correlationData.getId()); this.rabbitTemplatenew.convertAndSend("exchange", "topic.messages", msg, correlationData); } public void confirm(CorrelationData correlationData, boolean ack, String cause) { // TODO Auto-generated method stub System.out.println("callbakck confirm: " + correlationData.getId()); } }
复制代码

消费者：第5节中的topicMessagesReceiver

controller:

    @PostMapping("/callback")
    public void callbak() {
        callBackSender.send();
    }

用post方式执行：

http://127.0.0.1:8080/rabbit/callback

结果如下：

callbackSender : i am callback sender
callbackSender UUID: cd0c80a6-4c65-4bf9-b4f8-f3b1180755d6
callbakck confirm: cd0c80a6-4c65-4bf9-b4f8-f3b1180755d6
topicMessagesReceiver  : callbackSender : i am callback sender

从上面可以看出callbackSender发出的UUID，收到了回应，又传回来了。

转载于:https://www.cnblogs.com/Amos-Turing/p/10040730.html

dongchan1847
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot+rabbitmq整合示例程
weixin_33693070的博客
05-11 177
关于什么是rabbitmq，请看另一篇文： http://www.cnblogs.com/boshen-hzb/p/6840064.html 一、新建maven工程：springboot-rabbitmq     二、引入springboot和rabbitmq的依赖 &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...
SpringBoot整合RabbitMQ
weixin_43381041的博客
12-23 126
1.导入RabbitMQ依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2.开启@RabbitListener 配置 在启动类中加入@EnableRabbit开启配置 package com.atguig
java.lang.IllegalArgumentException: Address 127.0.0.1:5672:5672 seems to contain an unquoted IPv6
xu990128638的专栏
02-26 3003
1. 应用程序报错如下: Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'rabbitConnectionFactory' defined in class path resource [org/springframework/boot/a...
RabbitMQ系列--异常:com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<
M_Joes_17的博客
10-10 1万+
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'rabbitMQSender': Unsatisfied dependency expressed through field 'admin'; nested exception is org.sprin...
SpringBoot 中使用 RabbitTemplate
qq_46539281的博客
07-26 4581
3.直接使用，导入rabbitTemplate类，使用rabbitTemplate.convertAndSend()方法。写在配置文件中，由RabbitProperties这个类进行读取，封装到ConnectionFactory中。（包括交换机选择与队列的配置，绑定），选择的模式在这里配置。1.写application.properties中的rabbitMq的连接配置等。0.rabbtMq的本地服务，得开启。（跟redis差不多）RabbitConfig（rabbitMq的配置类）......
SpringBoot+redis+RabbitMq整合实例
07-13
Spring boot+redis+rabbitMq实例整合的简单例子，可用来参考学习
springboot+整合rabbitmq的全套代码
09-15
reabbitmq的完整学习 >rabbitMq软件上传到liunx服务器 >RabbitMQ入门 ...>Springboot整合RabbitMQ >SpringBoot整合RabbitMQ(交换机与多个队列绑定) >RabbitMQ-集群搭建>负载均衡-HAProxy 完整链接地址: ...
springboot+rabbitmq
02-09
springboot整合rabbitmq： 1、单个生产者单个消费者 2、topic: 是RabbitMQ中最灵活的一种方式，可以根据binding_key自由的绑定不同的队列 3、Fanout: 就是我们熟悉的广播模式或者订阅模式，给Fanout转发器发送消息，...
springboot+websocket+Stomp+RabbitMq 实现多人聊天室
08-26
springboot 整合websocket，使用rabbitmq作为消息代理。 实现单点推送消息和多点推送消息， 以及加上了消息确认消息回调。
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
rabbitmq-component:rabbitmq组件
04-20
rabbitmq-component rabbitmq组件
Springboot 整合RabbitMq ，用心看完这一篇就够了
热门推荐
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
【springboot错误】 Failed to instantiate [org.springframework.transaction.interceptor.BeanFactoryTransac
qq_28736639的博客
07-08 5440
在起来的一个项目中，使用原有的配置，进行启动，发现一直有一个错误循环打印，都是fegin类： getTypeForFactoryBean:1516] : Bean creation exception on non-lazy FactoryBean type check: org.springframework.beans.factory.UnsatisfiedDependencyExcep...
SpringBoot 集成RabbitMQ
July_whj
10-07 1456
SpringBoot 集成RabbitMQ 一、Docker安装Rabbit MQ 运行下面命令，docker 可自动拉取镜像，并启动mq。 dockerrun-d--namerabbitmq-p5671:5671-p5672:5672-p4369:4369-p25672:25672-p15671:15671-p15672:15672rabbitmq:management 我们执行完成后可以运行docker ps查看下mq运行情况 我们看到RabbitMq...
dapr-添加rabbitmq-Component
码农的专栏
10-11 718
一、进入目录： cd /root/.dapr/components 二、新建：rabbitmq.yaml apiVersion: dapr.io/v1alpha1 kind: Component metadata: name: rabbitmq-pubsub namespace: default spec: type: pubsub.rabbitmq version: v1 metadata: - name: host value: "amqp://admin:ad
如何在Spring Boot中集成RabbitMQ
最新发布
weixin_43866043的博客
12-07 1061
在Spring Boot集成的RabbitMQ应用中，通常会在消费者处理消息时发生异常的情况下，明确地将消息发送到死信队列。如果点进来，没有显示这个绑定队列，就说明配置的不对，后续也无法消费，点进队列后，就会显示队列中的消息了。避免消息丢失：死信队列确保无法处理的消息不会被丢失，而是存储在一个特定的地方，供进一步的检查和处理。队列达到最大长度：如果队列设置了最大长度并达到这个限制，最老的消息可能会被移动到死信队列。在这个例子中，如果在处理消息的过程中发生异常，消息会被明确地拒绝，并发送到配置的死信队列。
RabbitMQ 学习笔记（一）
志趣
08-16 245
RabbitMQ 学习笔记（一）开启web管理界面程序连接RabbitMQ 开启web管理界面 启动RabbitMQ 通过rabbitmq-plugins list查看RabbitMQ的rabbitmq_management项并没有被开启 通过命令rabbitmq-plugins enable rabbitmq_management 开启 管理插件 可以看到与rabbitmq_managem...
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3623
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
Springboot+RabbitMQ整合示例
默存
09-25 7070
一、RabbitMQ简介 MQ全称为Message Queue,消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了...
springboot与rabbitmq整合
03-29
Spring Boot与RabbitMQ整合可以通过以下步骤进行： 1. 添加依赖 在Spring Boot项目中，可以通过在pom.xml文件中添加以下依赖来使用RabbitMQ： ``` <groupId>org.springframework.boot <artifactId>spring-boot...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值