Spring Boot 整合 AMQP

RabbitMQ 安装 https://blog.csdn.net/kangguang/article/details/104551284

一.添加依赖

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

二、添加配置文件信息 

spring.rabbitmq.host=localhost
spring.rabbitmq.post=5672
spring.rabbitmq.username=kangxg
spring.rabbitmq.password=123

二、RabbitMQ 提供了4种不同到Exchange 策略 

• Direct
• Fanout
• Topic
• Header 不常用

 三、.Direct 策略使用

1.DirectChange配置

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitDirectConfig {
    public  final static  String DIRECTNAME = "kxg-direct";
    @Bean
    Queue queue()
    {
        return  new Queue("hello-queue");
    }

    @Bean
    DirectExchange directExchange()
    {
        return  new DirectExchange(DIRECTNAME,true,false);
    }

    @Bean
    Binding binding()
    {
        return BindingBuilder.bind(queue())
                .to(directExchange())
                .with("direct");
    }
}

DirectChange 三个参数是：名字、重启后是否依然有效以及长期未使用是否删除

directExchange和 binding两个方法可以不添加

2.配置消费者

@Component
public class DrectReceiver {
      private String receiveMsg;

    @RabbitListener(queues = "hello-queue")
    public  void handle1(String msg)
    {
        System.out.println("DirectReceiver:"+msg);
        setReceiveMsg("DirectReceiver:<"+msg+">");
    }

    public String getReceiveMsg() {
        return receiveMsg;
    }

    public void setReceiveMsg(String receiveMsg) {
        this.receiveMsg = receiveMsg;
    }
}

3.在 控制器中添加测试方法 

@RestController
public class RabbitMQController {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Autowired
    DrectReceiver drectReceiver;
    @RequestMapping("/direct")
    public String  direct()
    {
        rabbitTemplate.convertAndSend("hello-queue","来自RabbitMQ 的问候");
        return  drectReceiver.getReceiveMsg();
    }
}

4.使用Postman测试

四、Fanout

1.添加配置文件

@Configuration
public class RabbitFanoutConfig {
    public  final static  String FANOUTNAME = "kxg-fanout";
    @Bean
    Queue queueOne()
    {
        return  new Queue("queue-one");
    }
    @Bean
    Queue queueTwo()
    {
        return  new Queue("queue-two");
    }
    @Bean
    FanoutExchange fanoutExchange()
    {
        return  new FanoutExchange(FANOUTNAME,true,false);
    }

    @Bean
    Binding bindingOne()
    {
        return BindingBuilder.bind(queueOne()).to(fanoutExchange());
    }

    @Bean
    Binding bindingTwo()
    {
        return BindingBuilder.bind(queueTwo()).to(fanoutExchange());
    }
}

2.添加接收者

@Component
public class FanoutReceiver {
    @RabbitListener(queues = "queue-one")
    public  void handle1(String msg)
    {
        System.out.println("FanoutReceiver:handle1<"+msg +">");
    }

    @RabbitListener(queues = "queue-two")
    public  void handle2(String msg)
    {
        System.out.println("FanoutReceiver:handle2<"+msg +">");
    }
}

3.配置控制器

@RestController
public class RabbitMQController {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/fanout")
    public void   fanout()
    {
        rabbitTemplate.convertAndSend(RabbitFanoutConfig.FANOUTNAME,null,"来自RabbitMQ Fanout 的问候");

    }

}

4.浏览器测试http://localhost:9000/fanout

4.总结：

Fanout 与Direct不同的是 FanoutExchange的数据交换策略是把所有到达FanoutExchange的消息转发到与它绑定的Queue，routingKey将不再起作用

Direct的路由策略是将消息绑定到一个DirectExchange上，当消息到来时会被转发到与该 条消息routing Key相同的Queue 上

五、Topic策略

Queue通过routingkey 绑定到TopicExchange上，当消息到达TopicExchange后，TopicExchange根据消息当routingkey将消息路由到一个或者多个Queue上

1.添加策略配置文件

@Configuration
public class RabbitTopicConfig {
    public  final static  String TOPICNAME = "kxg-topic";
    @Bean
    TopicExchange topicExchange()
    {
        return  new TopicExchange(TOPICNAME,true,false);
    }
    @Bean
    Queue javaQueue()
    {
        return  new Queue("java");
    }
    @Bean
    Queue ocQueue()
    {
        return  new Queue("object-C");
    }

    @Bean
    Queue softQueue()
    {
        return  new Queue("soft");
    }


    @Bean
    Binding bindingJava()
    {
        return BindingBuilder.bind(javaQueue()).to(topicExchange()).with("java.#");
    }

    @Bean
    Binding bindingOc()
    {
        return BindingBuilder.bind(ocQueue()).to(topicExchange()).with("oc.#");
    }

    @Bean
    Binding bindingSwift()
    {
        return BindingBuilder.bind(softQueue()).to(topicExchange()).with("#.soft.#");
    }
}

• java.# 匹配routingkey 凡是以java开头的 
• oc.#匹配routingkey 凡是以oc开头的 
• #.soft.#匹配routingkey 凡是包含 soft的 

2.添加Topic消息接收者

@Component
public class TopicReceiver {
    @RabbitListener(queues = "soft")
    public  void handle1(String msg)
    {
        System.out.println("SoftReceiver:<"+msg+">");
    }

    @RabbitListener(queues = "java")
    public  void handle2(String msg)
    {
        System.out.println("JavaReceiver:<"+msg+">");
    }

    @RabbitListener(queues = "object-C")
    public  void handle3(String msg)
    {
        System.out.println("OCReceiver:<"+msg+">");
    }
}

3.添加消息发送方法

    @RequestMapping("/topic")
    public void   topic()
    {
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPICNAME,"java.language","java语言");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPICNAME,"oc.language","Object-c语言");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPICNAME,"java.soft","Java 开发");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPICNAME,"oc.soft","Object-c 开发");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPICNAME,"soft.language","软件 开发");
    }

4.浏览器访问http://localhost:9000/topic