springboot 整合 RabbitMQ

参考：https://www.cnblogs.com/hlhdidi/p/6535677.html

MQ: Message  Queue (消息队列)
RabbitMQ:轻量级,易部署，支持多种消息传递协议，可以部署在分布式和联合配置中，以满足高规模，高可用性要求。
支持消息队列，传递确认，灵活路由到队列，多重交换类型（direct, topic ,fanout,headers）
应用场景：应用与应用之间进行通信，而不需要直接调用彼此。
安装：  　　1.安装erlang 2.安装rabbitMQ

百科：

　　Broker：简单来说就是消息队列服务器实体。
　　Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
　　Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
　　Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
　　Routing Key：路由关键字，exchange根据这个关键字进行消息投递。
　　vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。
　　producer：消息生产者，就是投递消息的程序。
　　consumer：消息消费者，就是接受消息的程序。
　　channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

 

 

依赖：

        <!-- rabbitMQ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

 

A应用发消息：

########rabbitMQ##########
spring.application.name=rabbitmq-hello-sending   
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=123456

B应用收消息：

##################
spring.application.name=rabbitmq-hello-receiving
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=123456

 

1. direct：完全根据key进行投递

 

 发送者：

@Component
public class HelloSender {

    @Autowired
    private AmqpTemplate amqpTemplate;
    
    public String send(String name) {
        String content = "hello" + name+ "--" + new Date();
        System.out.println(content);
        amqpTemplate.convertAndSend("hello",content);
        return content;
    }
    
    public String sendObj() {
        Student stu = new Student(1, "xiaoming","10","man");
        amqpTemplate.convertAndSend("hello",stu);
        return "success";
    }
}

接收者：

@Component  
public class HelloReceiver {  
  
 /*   @RabbitListener(queues = "hello")  
    public void process(String hello) {  
        System.out.println("received : " + hello);
    }  */
    
    @RabbitListener(queues = "hello")  
    public void process2(Student student) {  
        System.out.println("received : " + student);
    }  
} 

传输对象的时候需要注意的：1.该对象需要实现Serializable    2.接收者要有对应的实体

2.topic

发送者：

@Configuration
public class TopicSenderConfig {
    
    @Bean("message")
    public Queue queueMessage() {
        return new Queue("topic.message");
    }
    
    @Bean("messages")
    public Queue queueMessages() {
        return new Queue("topic.messages");
    }
    
    @Bean("exchange")
    public TopicExchange exchange() {
        return new TopicExchange("exchange");
    }
    
    @Bean
    public Binding bindingExchangeMessage(@Qualifier("message") Queue queueMessage , TopicExchange exchange) {
        return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
    }
    
    @Bean
    public Binding bindingExchangeMessages(@Qualifier("messages") Queue queueMessages , TopicExchange exchange) {
        return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");//* 表示一个   #表示多个
    }

}

@Component
public class TopicExchangeSender {

    @Autowired
    private AmqpTemplate amqpTemplate;
    
    public String sender(String msg) {
        amqpTemplate.convertAndSend("exchange", "topic.message", msg);
        return msg;
    }
    
    public String sender2(String msg) {
        amqpTemplate.convertAndSend("exchange" , "topic.messages" , msg);
        return msg;
    }
}

根据上面的配置 参数topic.messages可以匹配到2个queue  ，topic.message 只能匹配到一个queue

接收者：

@Component
public class TopicReceived {

    @RabbitListener(queues = "topic.message")
    public void process1(String str) {
        System.out.println("message : " + str);
    }
    
    @RabbitListener(queues = "topic.messages")
    public void process2(String str) {
        System.out.println("message2 : " + str);
    }
}

 

3.fanout

 发送者：

@Configuration
public class FanoutSenderConfig {

    @Bean(name = "Amessage")
    public Queue Amessage() {
        return new Queue("fanout.A");
    }
    
    @Bean(name = "Bmessage")
    public Queue Bmessage() {
        return new Queue("fanout.B");
    }
    
    @Bean(name = "Cmessage")
    public Queue Cmessage() {
        return new Queue("fanout.C");
    }
    
    @Bean
    public FanoutExchange fanoutExchange() {//配置广播路由
        return new FanoutExchange("fanoutExchange");
    }
    
/*    @Bean
    public Binding bindExchangeA(@Qualifier("Amessage") Queue messgeA , FanoutExchange fanout) {
        return BindingBuilder.bind(messgeA).to(fanout);
    }
    
    @Bean
    public Binding bindExchangeB(@Qualifier("Bmessage") Queue messgeB , FanoutExchange fanout) {
        return BindingBuilder.bind(messgeB).to(fanout);
    }*/
/*    @Bean
    public Binding bindExchangeC(@Qualifier("Cmessage") Queue messgeC , FanoutExchange fanout) {
        return BindingBuilder.bind(messgeC).to(fanout);
    }
    */
    
}

看很多教学是这样做的， 但是不绑定也是可以的，fanout就是广播的意思

@Component
public class FanoutSender {

    @Autowired
    private AmqpTemplate amqpTemplate;
    
    public String test() {
        String msg = "fanout " + new Date();
        amqpTemplate.convertAndSend("fanoutExchange", "", msg);
        return msg;
    }
    
}

接收者：

@Component
public class FanoutReceived {

    @RabbitListener(queues = "fanout.A")
    public void a(String str) {
        System.out.println("A: " + str);
    }
    
    @RabbitListener(queues = "fanout.B")
    public void b(String str) {
        System.out.println("B: " + str);
    }
    
    @RabbitListener(queues = "fanout.C")
    public void c(String str) {
        System.out.println("C: " + str);
    }
}

 

4.headers： 省略