springAMQP

关于springAMQP

spring:
  rabbitmq:
    host: xxx.xxx.xxx.xxx
    port: 5672
    virtual-host: /
    username: xxxxxx
    password: xxxxxx

创建测试类发送消息

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "你好啊，大帅逼！";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }

创建消息接收方法 

@Component
public class SpringRabbitListener {
    @RabbitListener(queues = "simple.queue")
    public void ListenSimpleQueueMessage(String msg) throws InterruptedException{
        System.out.println("Spring 接收到的信息:[" + msg +"]");
    }
}

配置yaml文件

spring:
  rabbitmq:
    host: xxx.xxx.xxx.xxx
    port: 5672
    virtual-host: /
    username: xxxxxx
    password: xxxxxx

启动消息发送的测试类并且启动接收

关于发布和订阅模型

测试案例

 

@Configuration
public class FanoutConfig {

    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("xn2001.fanout");
    }

    /**
     * 声明队列
     * @return Queue
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    @Bean
    public Queue fanoutQueue3(){
        return new Queue("fanout.queue3");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(FanoutExchange fanoutExchange,Queue fanoutQueue1){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    @Bean
    public Binding bindingQueue2(FanoutExchange fanoutExchange,Queue fanoutQueue2){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
    @Bean
    public Binding bindingQueue3(FanoutExchange fanoutExchange,Queue fanoutQueue3){
        return BindingBuilder.bind(fanoutQueue3).to(fanoutExchange);
    }

}

检查是否绑定成功去rabbitmq中去查看交换机中是否有绑定

绑定成功 

做测试消费者

@RabbitListener(queues = "fanout.queue1")
    public void ListenFanoutQueueMessage3(String msg) throws InterruptedException{
        System.out.println("消费者1.........接收到的信息:[" + msg +"]");
        Thread.sleep(200);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void ListenFanoutQueueMessage4(String msg) throws InterruptedException{
        System.out.println("消费者2.........接收到的信息:[" + msg +"]");
        Thread.sleep(200);
    }

    @RabbitListener(queues = "fanout.queue3")
    public void ListenFanoutQueueMessage5(String msg) throws InterruptedException{
        System.out.println("消费者3.........接收到的信息:[" + msg +"]");
        Thread.sleep(200);
    }

做消息的发送者

    @Test
    public void testSendFanoutExchange(){
        //交换机名称
        String ExchangeName = "xn2001.fanout";
        //消息
        String Message = "hello,everyone";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(ExchangeName,"",Message);
    }

结果

DirectExchange路由交换

 

代码如下

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "yunjie.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public  void ListenDirectQueue1(String msg){
        System.out.println("消费者收到Directqueue1的信息:[" + msg +"]");
    }


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "yunjie.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public  void ListenDirectQueue2(String msg){
        System.out.println("消费者收到Directqueue2的信息:[" + msg +"]");
    }

创建测试类

    @Test
    public void testSendFanoutExchange(){
        //交换机名称
        String ExchangeName = "yunjie.direct";
        //消息
        String Message = "hello,yellow";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(ExchangeName,"yellow",Message);
    }

    @Test
    public void testSendDirectExchange(){
        //交换机名称
        String ExchangeName = "yunjie.direct";
        //消息
        String Message = "hello,blue";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(ExchangeName,"blue",Message);
    }

描述下Direct交换机与Fanout交换机的差异？
·Fanout交换机将消息路由给每一个与之绑定的队列
·Direct交换机根据RoutingKey判断路由给哪个队列
·如果多个队列具有相同的RoutingKey,则与Fanout功能类似
基于＠RabbitListener注解声明队列和交换机有哪些常见注解？
·@Queue
·@Exchange

TopicExchange交换

 实现思路

 创建队列,交换机

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "yunjie.topic",type = ExchangeTypes.TOPIC),
            key = {"china.#"}
    ))
    public  void ListenTopicQueue1(String msg){
        System.out.println("消费者收到Topicqueue1的信息:[" + msg +"]");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "yunjie.topic",type = ExchangeTypes.TOPIC),
            key = {"#.news"}
    ))
    public  void ListenTopicQueue2(String msg){
        System.out.println("消费者收到Topicqueue2的信息:[" + msg +"]");
    }

 创建测试类

    @Test
    public void testSendTopicExchange(){
        //交换机名称
        String ExchangeName = "yunjie.topic";
        //消息
        String Message = "大帅逼要发财了";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(ExchangeName,"china.news",Message);
    }


    @Test
    public void testSendTopicExchange2(){
        //交换机名称
        String ExchangeName = "yunjie.topic";
        //消息
        String Message = "今天天气不错!!!!";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(ExchangeName,"china.weather",Message);
    }

结果

AMQP的消息转换

创建发送消息

    @Test
    public void testSendObjectQueue(){
        Map<String,Object> msg = new HashMap<>();
        msg.put("name","柳岩");
        msg.put("age", 21);
        //发送消息
        rabbitTemplate.convertAndSend("object.queue",msg);
    }

 接收到了,但是转成序列化了,不是发送的,需要转换

 启动类中添加Bean

    @Bean
    public MessageConverter MessageConverter(){
        return new Jackson2JsonMessageConverter();
    }

测试发消息

    @Test
    public void testSendObjectQueue(){
        Map<String,Object> msg = new HashMap<>();
        msg.put("name","柳岩");
        msg.put("age", 21);
        //发送消息
        rabbitTemplate.convertAndSend("object.queue",msg);
    }

接收消息

    @RabbitListener(queues = "object.queue")
    public void ListenObjectQueue(Map<String,Object> msg){
        System.out.println("消费者收到objectqueue的信息:[" + msg +"]");
    }

结果