springboot中使用rabbitmq

交换机：

交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存储消息，在启用 ack模式后，交换机找不到队列会返回错误。交换机有四种类型: Direct，topic,Headers and Fanout;

1. Direct Exchange：Direct Exchange 是 RabbitMQ 默认的交换机模式，也是最简单的模式，根据 key 全文匹配去寻找队列。

2. Topic Exchange

Topic Exchange 转发消息主要是根据通配符。 在这种交换机下，队列和交换机的绑定会

定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发

消息

3. Fanout Exchange

Fanout Exchange 消息广播的模式，不管路由键或者是路由模式，会把消息发给绑定给它的

全部队列，如果配置了 routing_key 会被忽略。

4. springboot集成rabbitmq的实现：

1. 配置 pom 包，主要是添加 spring-boot-starter-amqp 的支持

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

2. 配置文件

spring:
  application:
    name: rabbitmq
  # 集成RabbitMQ
  rabbitmq:
    host: 47.103.86.69
    port: 5672
    username: lisi
    password: 123456

3. 队列配置

1. 简单模式实现：

//配置交换机： Direct Exchange（绑定路邮件的交换机）
@Configuration
public class RabbitConfig {

    public static final String QUEUE_NAME ="hello";

    @Bean
    public Queue queue(){
        return new Queue(QUEUE_NAME);
    }
    @Bean
    public Queue queue2(){
      Queue queue =  new Queue("abc");
      queue.getArguments().put("x-max-length",5);
      return queue;
    }

}

//消息的生产者
@Component
public class Sender {

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * 生成消息并放入队列中
     */
    public void sendEmail(String content){
        //发送的内容
//        String content = "我注册成功了，发送一个邮件！";
        //要把信息放入队列的名称
        String queueName = RabbitConfig.QUEUE_NAME;
        amqpTemplate.convertAndSend(queueName,content);

    }
}

//消息的接受者 消费者
@Component
@RabbitListener(queues = RabbitConfig.QUEUE_NAME)
@Log4j2
public class Receiver {


    /**
     * 接收到消息
     */
    @RabbitHandler
    public void receiveEmailMessage(String content){
        log.error("发送邮件，邮件的内容："+content);
    }


}

2. Topic Exchange实现 路由模式

//Topic Exchange 配置
@Configuration
public class TopicConfig {

   public static final String message = "topic.message";
   public static final String messages = "topic.messages";

    //队列message
    @Bean
    public Queue queueMessage() {
        return new Queue(TopicConfig.message);
    }

    //队列messages
    @Bean
    public Queue queueMessages() {
        return new Queue(TopicConfig.messages);
    }

    /*
        创建TopicExchange
     */
    @Bean
    public TopicExchange exchange(){
        return new TopicExchange("my_topic");
    }

    /**
     * 把队列绑定到TopicExchange上
     */
    @Bean
    public Binding bindingMessage(Queue queueMessage,TopicExchange exchange){

        return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
    }
    @Bean
    public Binding bindingMessages(Queue queueMessages,TopicExchange exchange){

        return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
    }

}

//生产者模式 需要制定路由关系  消息推送到那个交换机上
@Component
public class Sender3 {

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * 发送到topic队列的消息
     */
    public void sendTopicMessage(){
        //交换机名称
        String exchangeName = "my_topic";

        amqpTemplate.convertAndSend(exchangeName,"topic.message","我是topic信息");
    }
}

消费者和简单模式一致

3. Fanout Exchange 广播者模式或者订阅者模式

//订阅者模式交换机和队列之间的路由
@Configuration
public class FanoutConfig {

    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }
    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }
    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    //交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanout_exchange");
    }

    //把ABC三个队列绑定到fanout_exchange上
    @Bean
    public Binding bindA(Queue queueA,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queueA).to(fanoutExchange);
    }
    @Bean
    public Binding bindB(Queue queueB,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queueB).to(fanoutExchange);
    }
    @Bean
    public Binding bindC(Queue queueC,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(queueC).to(fanoutExchange);
    }

}

//生产者模式
@Component
public class Sender3 {

    @Autowired
    private AmqpTemplate amqpTemplate;



    /**
     * 发送到fanout队列的消息
     */
    public void sendFanoutMessage(){
        //交换机名称
        String exchangeName = "fanout_exchange";

        amqpTemplate.convertAndSend(exchangeName,"","订阅信息：华尔街日报最新消息");
    }



}

消费者模式和简单模式一致