87-java-rabbitMQ(4)-springBoot整合RabbitMQ

springboot整合rabbitMQ

说明:spring-boot-starter-amqp,默认整合的就是rabbitMQ,所以springboot的启动环境会自动注入一个rabbitTemplate对象.

生产者

package com.gl.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author gl
 * @time 2020-06-23 0:14
 * @function : 测试消息生产者
 * @step :
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class TestRabbitMq {

    /**
     * 这是springboot构建amqp启动环境的时候注入的rabbit的模板对象
     */
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 这是第一种模型
     * hello world
     */
    @Test
    public void producer_hello(){
        rabbitTemplate.convertAndSend("hello","hello world!!");
    }

    /**
     * 这是第二种模型
     * work queue
     * 注意测试的时候,一定要在rabbitMQ的管理界面删除前面生成的queue,因为会冲突.
     */
    @Test
    public void producer_workQueue(){
        for (int i= 0; i < 10; i ++){
            rabbitTemplate.convertAndSend("work","work模型!!" + i);
        }
    }

    /**
     * 第三种模型
     * 发布订阅模式 --- fanout
     * 注意测试的时候,一定要在rabbitMQ的管理界面删除前面生成的queue,因为会冲突.
     */
    @Test
    public void producer_publishAndSubcribe(){
        for (int i= 0; i < 10; i ++) {
            rabbitTemplate.convertAndSend("exchange_publish", "", "发布订阅模式!!" + i);
        }
    }

    /**
     * 第四种模型
     * 路由模式 --- direct
     * 注意测试的时候,一定要在rabbitMQ的管理界面删除前面生成的queue,因为会冲突.
     */
    @Test
    public void producer_routing(){
        rabbitTemplate.convertAndSend("exchange_routing", "info", "路由模式!!");
    }

    /**
     * 第五种模型
     * 通配符模式 --- topics
     * 注意测试的时候,一定要在rabbitMQ的管理界面删除前面生成的queue,因为会冲突.
     */
    @Test
    public void producer_topic(){
        rabbitTemplate.convertAndSend("exchange_topic", "order.name", "topics模式!!");
    }

}

消费者

1.第一种工作模式hello world

/**
 * @author gl
 * @time 2020-06-23 0:20
 * @function : consumer
 * @step :第一种工作模式hello world
 */
@Component
//监听hello这个队列,并且设置这个队列的属性
//默认创建的队列就是持久化的,非独占的,不是自动删除的队列
@RabbitListener(queuesToDeclare = @Queue(value = "hello",autoDelete = "true",durable = "true"))
public class Consumer_Hello {

    //回调方法,指明本方法为监听到消息的回调方法
    @RabbitHandler
    public void receive(String message){
        System.out.println("=======================message:" + message);
    }

}

2.第二种工作模式 work queues

/**
 * @author gl
 * @time 2020-06-23 0:33
 * @function : consumer
 * @step : 第二种工作模式  work queues
 */
@Component
public class Consumer_WorkQueue {

    //第一个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void consume1(String message){
        System.out.println("消费者1:" + message);
    }

    //第二个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void consume2(String message){
        System.out.println("消费者2:" + message);
    }
}

3.第三种工作模式 发布订阅模式

/**
 * @author gl
 * @time 2020-06-23 0:51
 * @function : consumer
 * @step : 第三种工作模式  发布订阅模式
 * 交换机类型   fanout
 */
@Component
public class Consumer_PublishAndSubcribe {

    /**
     * 消费者1
     * @param message  这是监听到的消息
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //如果@Queue没有指定名字,则表示为临时队列
                    exchange = @Exchange(value = "exchange_publish",type = "fanout") //绑定交换机
            )
    })
    public void consume1(String message){
        System.out.println("消费者1:" + message);
    }

    /**
     * 消费者2
     * @param message  这是监听到的消息
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //如果@Queue没有指定名字,则表示为临时队列
                    exchange = @Exchange(value = "exchange_publish",type = "fanout") //绑定交换机
            )
    })
    public void consume2(String message){
        System.out.println("消费者2:" + message);
    }
}

4.第四种工作模式 routing

/**
 * @author gl
 * @time 2020-06-23 1:14
 * @function : consumer
 * @step : 第四种工作模式 routing
 * 交换机类型  direct
 */
@Component
public class Consumer_routing {
    /**
     * 消费者1
     * @param message  这是监听到的消息
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //如果@Queue没有指定名字,则表示为临时队列
                    exchange = @Exchange(value = "exchange_routing",type = "direct"), //绑定交换机,默认的交换机类型就是directs
                    key = {"error","info","warn"} //指定路由key
            )
    })
    public void consume1(String message){
        System.out.println("消费者1:" + message);
    }

    /**
     * 消费者1
     * @param message  这是监听到的消息
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //如果@Queue没有指定名字,则表示为临时队列
                    exchange = @Exchange(value = "exchange_routing",type = "direct"), //绑定交换机,默认的交换机类型就是directs
                    key = {"error"} //指定路由key
            )
    })
    public void consume2(String message){
        System.out.println("消费者2:" + message);
    }
}

5.第五种模式 topic(通配符模式)

/**
 * @author gl
 * @time 2020-06-23 1:26
 * @function :第五种模式  topic(通配符模式)
 * @step : 交换机类型 --- topic
 */
@Component
public class Consumer_topics {

    /**
     * 第一个消费者
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //临时队列
                    exchange = @Exchange(name = "exchange_topic" ,type = "topic"), //交换机名称,交换机类型
                    key = {"user.name","user.*"} //routingKey
            )
    })
    public void consume1(String message){
        System.out.println("消费者1:" + message);
    }


    /**
     * 第二个消费者
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, //临时队列
                    exchange = @Exchange(name = "exchange_topic" ,type = "topic"),
                    key = {"order.#","productor.*","user.*"}
            )
    })
    public void consume2(String message){
        System.out.println("消费者2:" + message);
    }
}