SpringBoot整合RabbitMQ

1.Hello World模型

1.导包

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

2.编写properties文件

#ip地址
spring.rabbitmq.host=114.55.219.117
#端口
spring.rabbitmq.port=5672
#用户名
spring.rabbitmq.username=xbb
#密码
spring.rabbitmq.password=123456

3.编写配置文件

	@Bean
    public Queue queueHelloWorld(){
        return new Queue("queueHelloWorld");
    }

4.controller

/**
     * hello world模型
     * @return
     */
    @RequestMapping("sendMsg")
    public Object sendMsg(){
        rabbitMQService.sendMsg();
        return "发送成功";
    }

5.service

@Service
public class RabbitMQService implements IRabbitMQService {

    @Autowired
    private RabbitMQManager rabbitMQManager;

    @Override
    public void sendMsg() {
        rabbitMQManager.sendWork();
    }
}

6.编写manager

@Component
public class RabbitMQManager {
    
    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * 发送消息到工作模型
     */
    public void sendWork(){
        amqpTemplate.convertAndSend("queueWork","hello world");
    }
}

7.编写消费者

@Component
public class WorkReceiveListener {

    /**
     * hello world模型
     * @param msg
     */
    @RabbitListener(queues = {"queueHelloWorld"})
    public void receiveMsg(String msg, Channel channel, Message message){
        System.out.println("消费者1收到："+msg);
    }
}

2.work模型

生产者：

/**
     * work模型发送消息
     */
    public void sendWorkMsg(){
        for (int i = 0; i < 5; i++) {
            amqpTemplate.convertAndSend("queueWork","hello,work");
        }
    }

消费者：

/**
     * work模型消费者1
     * @param msg
     * @param channel
     * @param message
     */
    @RabbitListener(queues = {"queueWork"})
    public void receiveMsg1(String msg, Channel channel, Message message){
        System.out.println("消费者1收到"+msg);
        System.out.println("通道是:"+channel);
        System.out.println("传输数据封装:"+message);

    }

    /**
     * work模型消费者2
     * @param msg
     * @param channel
     * @param message
     */
    @RabbitListener(queues = {"queueWork"})
    public void receiveMsg2(String msg, Channel channel, Message message){
        System.out.println("消费者2收到"+msg);
        System.out.println("通道是:"+channel);
        System.out.println("传输数据封装:"+message);

    }

3.发布订阅模型

1.配置文件

/**
     * 发布订阅模型队列1
     * @return
     */
    @Bean
    public Queue queueFanout1(){
        return new Queue("queueFanout1");
    }

    /**
     * 发布订阅模型队列2
     * @return
     */
    @Bean
    public Queue queueFanout2(){
        return new Queue("queueFanout2");
    }

    /**
     * 发布订阅模型交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("exchange-fanout");
    }

    /**
     * 将发布订阅队列1绑定到交换机
     * @param queueFanout1
     * @param fanoutExchange
     * @return
     */
    @Bean
    public Binding bindingExchange1(Queue queueFanout1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queueFanout1).to(fanoutExchange);
    }

    /**
     * 将发布订阅队列2绑定到交换机
     * @param queueFanout2
     * @param fanoutExchange
     * @return
     */
    @Bean
    public Binding bindingExchange2(Queue queueFanout2,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queueFanout2).to(fanoutExchange);
    }

2.生产者：

/**
     * 模拟发布订阅模型发送消息
     */
    public void sendFanoutMsg(){
        amqpTemplate.convertAndSend("exchange-fanout","","hello.fanout");
    }

3.消费者：

/**
     * 发布订阅模型消费者1
     * @param msg
     */
    @RabbitListener(queues = {"queueFanout1"})
    public void receiveFanoutMsg1(String msg){
        System.out.println("发布订阅模型消费者1收到："+msg);
    }

    /**
     * 发布订阅模型消费者2
     * @param msg
     */
    @RabbitListener(queues = {"queueFanout2"})
    public void receiveFanoutMsg2(String msg){
        System.out.println("发布订阅模型消费者2收到："+msg);
    }

4.路由模型

1.配置

/**
     * 路由模型队列1
     * @return
     */
    @Bean
    public Queue queueRouting1(){
        return new Queue("queueRouting1");
    }

    /**
     * 路由模型队列2
     * @return
     */
    @Bean
    public Queue queueRouting2(){
        return new Queue("queueRouting2");
    }

    /**
     * 路由类型交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("exchange-direct");
    }

    /**
     * 将路由队列1绑定到交换机
     * @param queueRouting1
     * @param directExchange
     * @return
     */
    @Bean
    public Binding bindingDirectExchange1(Queue queueRouting1,DirectExchange directExchange){
        return BindingBuilder.bind(queueRouting1).to(directExchange).with("hello");
    }

    /**
     * 将路由队列2绑定到交换机
     * @param queueRouting2
     * @param directExchange
     * @return
     */
    @Bean
    public Binding bindingDirectExchange2(Queue queueRouting2,DirectExchange directExchange){
        return BindingBuilder.bind(queueRouting2).to(directExchange).with("world");
    }

2.生产者：

/**
     * 模拟路由模型发送消息
     */
    public void sendRoutingMsg(){
        amqpTemplate.convertAndSend("exchange-direct","world","hello world");
    }

3.消费者：

/**
     * 路由key为hello的消费者
     * @param msg
     */
    @RabbitListener(queues = {"queueRouting1"})
    public void receiveDirectMsg1(String msg){
        System.out.println("路由key为hello的消费者收到："+msg);
    }

    /**
     * 路由key为world的消费者
     * @param msg
     */
    @RabbitListener(queues = {"queueRouting2"})
    public void receiveDirectMsg2(String msg){
        System.out.println("路由key为world的消费者收到："+msg);
    }

5.topic模型

1.配置

/**
     * topic模型队列1
     * @return
     */
    @Bean
    public Queue queueTopic1(){
        return new Queue("queue-topic1");
    }

    /**
     * topic模型队列2
     * @return
     */
    @Bean
    public Queue queueTopic2(){
        return new Queue("queue-topic2");
    }

    /**
     * topic模型交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("exchange-topic");
    }

    /**
     * 将topic模型队列1绑定到交换机
     * @param queueTopic1
     * @param topicExchange
     * @return
     */
    @Bean
    public Binding bindingTopicExchange1(Queue queueTopic1,TopicExchange topicExchange){
        return BindingBuilder.bind(queueTopic1).to(topicExchange).with("#.hello");
    }

    /**
     * 将topic模型队列2绑定到交换机
     * @param queueTopic2
     * @param topicExchange
     * @return
     */
    @Bean
    public Binding bindingTopicExchange2(Queue queueTopic2,TopicExchange topicExchange){
        return BindingBuilder.bind(queueTopic2).to(topicExchange).with("#.world");
    }

2.生产者：

/**
     * 模拟topic模型发送消息
     */
    public void sendTopicMsg(){
        amqpTemplate.convertAndSend("exchange-topic","hello.world","hello world");
    }

3.消费者：

@RabbitListener(queues = {"queue-topic1"})
    public void receiveTopicMsg1(String msg){
        System.out.println("路由为#.hello的消费者收到:"+msg);
    }

    @RabbitListener(queues = {"queue-topic2"})
    public void receiveTopicMsg2(String msg){
        System.out.println("路由为#.world的消费者收到:"+msg);
    }

6.confirm机制

在properties开启confirm机制

#开启confirm机制
spring.rabbitmq.publisher-confirm-type=correlated

生产者：

	RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean b, String s) {
            System.out.println("确认机制");
        }
    };
	/**
     * confirm 机制
     */
    public void sendConfirmMsg(){
        rabbitTemplate.setConfirmCallback(confirmCallback);
        rabbitTemplate.convertAndSend("hello world");
    }

消费者：

@RabbitListener(queues = {"queue-confirm"})
    public void receiveConfirmMsg(String msg){
        System.out.println("收到："+msg);
    }

7.return机制

#开启return机制
spring.rabbitmq.publisher-returns=true

配置

/**
     * return机制队列1
     * @return
     */
    @Bean
    public Queue queueReturn1(){
        return new Queue("queue-return1");
    }

    /**
     * return机制队列2
     * @return
     */
    @Bean
    public Queue queueReturn2(){
        return new Queue("queue-return2");
    }

    /**
     * return机制交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutReturnExchange(){
        return new FanoutExchange("exchange-return");
    }

    /**
     * return机制将队列1绑定到交换机
     * @param queueReturn1
     * @param fanoutReturnExchange
     * @return
     */
    @Bean
    public Binding bindingReturnExchange1(Queue queueReturn1,FanoutExchange fanoutReturnExchange){
        return BindingBuilder.bind(queueReturn1).to(fanoutReturnExchange);
    }

    /**
     * return机制将队列2绑定到交换机
     * @param queueReturn2
     * @param fanoutReturnExchange
     * @return
     */
    @Bean
    public Binding bindingReturnExchange2(Queue queueReturn2,FanoutExchange fanoutReturnExchange){
        return BindingBuilder.bind(queueReturn2).to(fanoutReturnExchange);
    }

生产者：

	RabbitTemplate.ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {
        @Override
        public void returnedMessage(Message message, int i, String s, String s1, String s2) {
            System.out.println("监听到不可达的消息");
            System.out.println("状态码："+i+"---文本信息:"+s+"---交换机名字:"+s1+"----路由的key:s2");
        }
    };
    
	/**
     * return机制
     */
    public void sendReturnMsg(){
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(returnCallback);
        rabbitTemplate.convertAndSend("exchange-return","","hello world");
    }

消费者：

	@RabbitListener(queues = {"queue-return1"})
    public void receiveReturnMsg1(String msg){
        System.out.println("return消费者1收到："+msg);
    }

    @RabbitListener(queues = {"queue-return2"})
    public void receiveReturnMsg2(String msg){
        System.out.println("return消费者2收到："+msg);
    }

8.ttl队列

编写配置

	/**
     * ttl队列
     * @return
     */
    @Bean
    public Queue queueTTL(){
        Map<String,Object> map = new HashMap<>();
        map.put("x-message-ttl",5000);
        return new Queue("queue-TTL",false,false,false,map);
    }

生产者：

/**
     * ttl队列
     */
    public void sendTTLMsg(){
        rabbitTemplate.convertAndSend("queue-TTL","wolegequ");
    }