springcloud整合rabbitmq

一，需要引入的依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
     <groupId>org.springframework.amqp</groupId>
     <artifactId>spring-rabbit-test</artifactId>
     <scope>test</scope>
</dependency>
<dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <scope>test</scope>
</dependency>

application.yml

spring:
  application:
    # 服务名称 - 服务之间使用名称进行通讯
    name: test-rabbit
  rabbitmq:
    host: 192.168.*.*  #rabbit服务器的ip地址
    port: 5672
    username: ems
    password: 123
    virtual-host: /ems  #虚拟主机

 

二、使用单元测试做为发送消息的生产者

package com.yangli.blogtool.test;

import com.yangli.blogtool.RabbitApplication;
import javafx.application.Application;
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.SpringJUnit4ClassRunner;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.test
 * @Date:Created in 2020/3/27 15:04
 * @Modify By:
 */

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = RabbitApplication.class)
public class RabbitMqTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 模式一：helloword
     */
    @Test
    public void helloword() {
        //convertAndSend 转换并发送消息
        /**
         * 参数1：队列名称 如果没有消费者消费该队列的消息，该队列是不会被新建到rabbit中的
         * 参数2：需要发送的消息  spring会将其转成 byte[] 格式的
         */
        rabbitTemplate.convertAndSend("hello", "hello word 模式");
    }

    /**
     * 模式二：work Queue
     * 工作列队默认是均衡发布消息
     * 如果需要实现能者多劳需要实现额外的配置
     */
    @Test
    public void workQueue() {
        for (int i = 1; i <= 10; i++) {
            /**
             * 参数1：队列名称 如果没有消费者消费该队列的消息，该队列是不会被新建到rabbit中的
             * 参数2：需要发送的消息  spring会将其转成 byte[] 格式的
             */
            rabbitTemplate.convertAndSend("work", "work queue 模式[" + i + "]");
        }
    }

    /**
     * 模式三：Publish/Subscribe fanout 订阅/发布 广播模式
     */
    @Test
    public void fanout() {
        /**
         * 参数1：交换机名称 如果没有消费者消费该交换机的消息，该交换机是不会被新建到rabbit中的
         * 参数2：路由，订阅/发布 广播模式 是不需要路由的，此处可以用空代替
         * 参数3：需要发送的消息  spring会将其转成 byte[] 格式的
         */
        rabbitTemplate.convertAndSend("logs_fanout","","Publish/Subscribe fanout 订阅/发布 广播模式");
    }

    /**
     * 模式四：routing 之 direct 直连模式
     */
    @Test
    public void direct() {
        /**
         * 参数1：交换机名称 如果没有消费者消费该交换机的消息，该交换机是不会被新建到rabbit中的
         * 参数2：路由，routing 之 direct 直连模式
         * 参数3：需要发送的消息  spring会将其转成 byte[] 格式的
         */
        rabbitTemplate.convertAndSend("logs_direct","error","routing 之 direct 直连模式");
    }

    /**
     * 模式五：routing 之 topic 主题模式
     */
    @Test
    public void topic() {
        /**
         * 参数1：交换机名称 如果没有消费者消费该交换机的消息，该交换机是不会被新建到rabbit中的
         * 参数2：路由，routing 之 topic 主题模式, 多个单词之间可以用 . 分隔开
         * 参数3：需要发送的消息  spring会将其转成 byte[] 格式的
         */
        rabbitTemplate.convertAndSend("logs_topic","public.user.get","routing 之 topic 主题模式");
    }

}

3.hello word 模式的消费者

package com.yangli.blogtool.rabbit;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.rabbit
 * @Date:Created in 2020/3/27 15:49
 * @Modify By:
 */
@Component
/**
 * queuesToDeclare：声明队列
 * 队列注解 @Queue 属性的含义-- value：队列名称; durable：是否持久化; autoDelete：是否自动删除; exclusive：是否独占队列
 */
@RabbitListener(queuesToDeclare = @Queue(value = "hello",durable = "false",autoDelete = "true",exclusive = "false"))
public class HelloConsumer {

    @RabbitHandler
    public void getMsg(String message) {
        System.err.println("消费：" + message);
    }

}

 4.Work Queue 模式消费者

package com.yangli.blogtool.rabbit;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.rabbit
 * @Date:Created in 2020/3/27 16:20
 * @Modify By:
 */
@Component
public class WorkQueueConsumer {

    @RabbitListener(queuesToDeclare = @Queue(value = "work",durable = "false",autoDelete = "true",exclusive = "false"))
    public void getWorkMsg1 (String message) {
        System.err.println("消费者1：" + message);
    }

    @RabbitListener(queuesToDeclare = @Queue(value = "work",durable = "false",autoDelete = "true",exclusive = "false"))
    public void getWorkMsg2 (String message) {
        System.err.println("消费者2：" + message);
    }
}

5.Publish/Subscribe fanout 订阅/发布 广播模式

package com.yangli.blogtool.rabbit;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.rabbit
 * @Date:Created in 2020/3/27 16:35
 * @Modify By:
 */
@Component
public class FanoutConsumer {

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {@QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_fanout",type = "fanout"))})
    public void getMsg1(String message) {
        System.err.println("消费者1:" + message);
    }

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {@QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_fanout",type = "fanout"))})
    public void getMsg2(String message) {
        System.err.println("消费者2:" + message);
    }
}

6.routing 之 direct 直连模式 的消费者

package com.yangli.blogtool.rabbit;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.rabbit
 * @Date:Created in 2020/3/27 16:47
 * @Modify By:
 */
@Component
public class DirectConsumer {

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_direct",type = "direct"),key = {"info","error","warning"})
    })
    public void getMsg1 (String message) {
        System.err.println("消费者1:" + message);
    }

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_direct",type = "direct"),key = {"info"})
    })
    public void getMsg2 (String message) {
        System.err.println("消费者2:" + message);
    }
}

 6.routing 之 topic 主题模式 的消费者

package com.yangli.blogtool.rabbit;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Author: 
 * @Despriction:
 * @Package: com.yangli.blogtool.rabbit
 * @Date:Created in 2020/3/27 16:59
 * @Modify By:
 */
@Component
public class TopicComsumer {

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_topic",type = "topic"),key = {"public.*"})
    })
    public void getMsg1 (String message) {
        System.err.println("消费者1:" + message);
    }

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_topic",type = "topic"),key = {"public.#"})
    })
    public void getMsg2 (String message) {
        System.err.println("消费者2:" + message);
    }

    //@Queue不包含属性的情况下，表示声明一个临时对列以减少内存的消耗
    @RabbitListener(bindings = {
            @QueueBinding(value = @Queue,exchange = @Exchange(value = "logs_topic",type = "topic"),key = {"public.user.*"})
    })
    public void getMsg3 (String message) {
        System.err.println("消费者3:" + message);
    }

}