springBoot整合rabbitMQ

-1. rabbitMQ机制

1. 生产者发送消息到路由器(一些模式下路由时使用路由键绑定队列，一些模式下直接绑定队列)或者队列
2. 消费者监听队列(多个消费者监听一个队列的话，会依次从队列里取消息(取出的消息不一样))
3. 路由器有三个模式：
   --- Fanout方式，路由器给所有绑定的队列发消息(发送的消息是一样的)
   --- Direct方式，路由器给符合路由键的队列发消息(发送的消息是一样的)
   --- Topic方式 ，路由器给符合动态路由键的队列发消息(发送的消息是一样的)

0. rabbitMQ的五种工作模式

1. 生产者把消息放入队列，一个消费者去消费消息
2. 生产者把消息放入队列，依次让若干消费者去消费消息（每个消费者的消息都不一样）
3. 生产者把消息放入交换器，交换器把消息发给所有的绑定这个交换器的队列，消费者从各自的队列中取消息
4. 生产者把消息放入交换器，交换器通过路由键把消息发给通过这个路由键绑定这个交换器的队列，消费者从各自的队列中取消息
5. 生产者把消息放入交换器，交换器通过动态路由键把消息发给通过这个动态路由键绑定这个交换器的队列，消费者从各自的队列中取消息

1.导入依赖

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

2.配置yml

spring:
  rabbitmq:
    host: 192.168.175.128 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: root
    password: rootpassword
    virtual-host: /  # 设置虚拟路径，不同虚拟路径下的队列是隔离的
    listener:
      simple:
        prefetch: 1  # 每次只分配一个任务

3.编写Producer和Consumer

1,2方式

public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void setOne() {
        rabbitTemplate.convertAndSend("队列名",要发送的对象);
    }
}
  
public class Consumer {
    //可以多个方法共同监听一个队列(模式2)
    @RabbitListener(queuesToDeclare = @Queue("队列名"))
    public void getTwo(String msg){
        System.out.println(msg+"------------------------");
    }

    @RabbitListener(queuesToDeclare = @Queue("队列名"))
    public void getTwo2(String msg){
        System.out.println(msg+"++++++++++++++++++++++++");
    }
}

fanout方式

public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void setOne() {
        rabbitTemplate.convertAndSend("交换机名","",要发送的对象);
    }
}
 
// 将多个队列绑定到交换机，并给队列一绑定多个监听器(作用机制和类型二相同，即依次分发)
public class Consumer {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("队列名1"), 
            exchange = @Exchange(value = "交换机名",type = ExchangeTypes.FANOUT)
    ))
    public void getTwo(String msg){
        System.out.println(msg+"------------------------");
    }

    @RabbitListener(queuesToDeclare = @Queue("队列名1"))
    public void getTwoo(String msg){
        System.out.println(msg+"------------------------");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("队列名2"), 
            exchange = @Exchange(value = "交换机名",type = ExchangeTypes.FANOUT)
    ))
    public void getTwo2(String msg){
        System.out.println(msg+"------------------------");
    }
}

direct方式

public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void setOne() {
        rabbitTemplate.convertAndSend("交换机名","路由键",要发送的对象);
    }
}
  
public class Consumer {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue,
            exchange = @Exchange(value = "交换机名",type = ExchangeTypes.DIRECT),
            key = {"路由键1","路由键2",...}
    ))
    public void getTwo(String msg){
        System.out.println(msg+"------------------------");
    }
}

topic方式

public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void setOne() {
        rabbitTemplate.convertAndSend("交换机名","路由键",要发送的对象);
    }
}
  
public class Consumer {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue,
            exchange = @Exchange(value = "交换机名",type = ExchangeTypes.TOPIC),
            key = {"路由键1","路由键2",...}  //可以用*和#占位
    ))
    public void getTwo(String msg){
        System.out.println(msg+"------------------------");
    }
}