3.Rabbit MQ 代码（简单实现）

1. 导入 pom.xml 包（也可以在创建 springboot 工程时自带）

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

       

2. Rabbit Mq 加载配置

   1. package com.ky.config;
      
      
      import org.springframework.amqp.core.Binding;
      import org.springframework.amqp.core.BindingBuilder;
      import org.springframework.amqp.core.DirectExchange;
      import org.springframework.amqp.core.FanoutExchange;
      import org.springframework.amqp.core.Message;
      import org.springframework.amqp.core.Queue;
      import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
      import org.springframework.amqp.rabbit.connection.CorrelationData;
      import org.springframework.amqp.rabbit.core.RabbitTemplate;
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.context.annotation.Bean;
      import org.springframework.context.annotation.Configuration;
      
      @Configuration
      public class RabbitmqConfig {
      	
      	@Autowired
      	private CachingConnectionFactory connectionFactory;
      
      	//点对点队列名
      	public static final String DIR_SELFHELP_QUERY_NAME = "self.help.dir.queue";
      
      	//点对多队列名
      	public static final String FUN_SELFHELP_QUERY_NAME = "self.help.fun.queue";
      	
      	//点对点交换机名
      	public static final String DIRECTEXCHANGE = "self.help.dirExchange";
      	
      	//点对多交换机名
      	public static final String FANOUTEXCHANGE = "self.help.fanExchange";
      	
      	//绑定id
      	public static final String IMMEDIATE_ROUTING_ID = "self.help.immediate.routing";
      	
      	
      	//创建一个点对点消费的队列
      	@Bean
      	public Queue directImmediateQueue() {
      		// 第一个参数是创建的 queue 的名字，第二个参数是否支持持久化
      		return new Queue(DIR_SELFHELP_QUERY_NAME, false);
      	}
       
      	//创建一个点对多消费的队列
      	@Bean
      	public Queue fanoutImmediateQueue() {
      		return new Queue(FUN_SELFHELP_QUERY_NAME, false);
      	}
      	
      	//点对点交换机
      	@Bean
      	public DirectExchange derectImmediateExchange() {
      		/**
      		 *  一共有三种构造方法
      		 *  第一种：可以只传 exchange 的名字
      		 *  第二种：可以传 exchange 名字，是否支持持久化，是否可以自动删除
      		 *  第三种在第二种参数上可以增加 Map，Map 中可以存放自定义 exchange 中的参数
      		 */
      		return new DirectExchange(DIRECTEXCHANGE, true, false);
      	}
      	
      	//点对多交换机
      	@Bean
      	public FanoutExchange fanoutImmediateExchange() {
      		return new FanoutExchange(FANOUTEXCHANGE, true, false);
      	}
      	
      	//点对点绑定
      	@Bean
      	public Binding immediateBinding() {
                  // 把点对点消费的队列和点对点消费的交换机绑定在一起
      		return BindingBuilder.bind(directImmediateQueue()).to(derectImmediateExchange()).with(IMMEDIATE_ROUTING_ID);
      	}
      	
      	//点对多绑定
      	@Bean
      	public Binding FunImmediateBinding() {
                   // 把点对点消费的队列和点对点消费的交换机绑定在一起
      		return BindingBuilder.bind(fanoutImmediateQueue()).to(fanoutImmediateExchange());
      	}
      
      	//消息监听
      	@Bean
      	public RabbitTemplate RabbitTemplate() {
      		connectionFactory.setPublisherConfirms(true);
      		connectionFactory.setPublisherReturns(true);
      		RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
      		rabbitTemplate.setMandatory(true);
      		rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
      			
      			@Override
      			public void confirm(CorrelationData correlationData, boolean ack, String cause) {
      				// TODO Auto-generated method stub
      				System.out.println("消息发送成功");
      			}
      		});
      		rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
      			
      			@Override
      			public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
      				// TODO Auto-generated method stub
      				System.out.println("消息丢失");
      			}
      		});
      		return rabbitTemplate;
      	}
      }

       

3. Rabbit Mq 发送以及消费
   1. 点对点发送

      1. @Component
         public class Sender {
         	@Autowired
         	RabbitTemplate rabbitTemplate;
         	
         	public void send(String message) {
                      // 第一个参数是要绑定的交换机，第二个参数是点对点的 ID，第三个参数是要传输的信息
         		rabbitTemplate.convertAndSend(RabbitmqConfig.DIRECTEXCHANGE, RabbitmqConfig.IMMEDIATE_ROUTING_ID, message);
         	}
         }

          

   2. 点对多发送

      1. @Component
         public class Sender {
         	@Autowired
         	RabbitTemplate rabbitTemplate;
         	
         	public void send(String message) {
                      // 第一个参数是要绑定的交换机，第二个参数会自动忽略，第三个参数是信息
         		rabbitTemplate.convertAndSend(RabbitmqConfig.FANOUTEXCHANGE, RabbitmqConfig.IMMEDIATE_ROUTING_ID, message);
         	}
         }

          

   3. 消费

      1. @Component
         public class Receiver {
         
         	@RabbitHandler
              // queues = 消费的队列
         	@RabbitListener(queues = RabbitmqConfig.FUN_SELFHELP_QUERY_NAME)
         	public void immediateProcess(String message) {
         		System.out.println(message);
         	}
         }