SpringBoot integra RabbitMQ (básico)

1. Preparação ambiental

1. Insira as dependências correspondentes no arquivo pom:

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

2. Configure o RabbitMQ no arquivo de configuração application.yml:

spring:
    #rabbitmq配置
  rabbitmq:
    host: 192.168.150.152#rabbitMq的服务器地址
    port: 5672
    username: root #用户名
    password: 123456 #密码
    virtual-host: /hjl #虚拟主机

2. Integração

Modo simples ponto a ponto

① Declare a fila no arquivo de configuração

@SpringBootConfiguration
public class RabbitMqConfig {
    
    
    /**
     * hello队列名称
     */
    public static final String HELLO_MSG_QUEUE = "hello.msg.queue";
   
    /**
     * 声明hello队列
     *
     * @return
     */
    @Bean
    public Queue getHelloQueue() {
    
    
    	//参数一：队列名；参数二：是否持久化队列
        return new Queue(HELLO_MSG_QUEUE, true);
    }


}

②Crie um produtor

@SpringBootTest
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    
    
    @Resource
    private RabbitTemplate rabbitTemplate;
    @Test
    public void sendHello() {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            rabbitTemplate.convertAndSend(RabbitMqConfig.HELLO_MSG_QUEUE, "hello world" + i);
        }
    }
}

Após o envio da mensagem com sucesso, verifique na página de gerenciamento web: Insira a descrição da imagem aqui
você pode ver que a mensagem é gerada na fila correspondente
③ Crie um consumidor

@Component
public class RabbitMqConsumer {
    
    
    @RabbitListener(queues = RabbitMqConfig.HELLO_MSG_QUEUE)
    public void listenHelloMsg(String message) {
    
    
        System.out.println("接受时间："+System.currentTimeMillis());
        System.out.println("转发消息是：" + message);
    }
}

Inicie o projeto e você verá que a mensagem foi consumida com sucesso:
Insira a descrição da imagem aqui

Fila de trabalho (vários consumidores correspondem a uma fila)

①Declare a fila

@SpringBootConfiguration
public class RabbitMqConfig {
    
    
    /**
     * work队列名称
     */
    public static final String WORK_MSG_QUEUE = "work.msg.queue";
    /**
     * 声明work队列
     *
     * @return
     */
    @Bean
    public Queue getWorkQueue() {
    
    
        //参数一：队列名；参数二：是否持久化队列
        return new Queue(WORK_MSG_QUEUE, true);
    }
}

②Crie um produtor

@SpringBootTest
@RunWith(SpringRunner.class)
public class WorkMqTest {
    
    
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void send() {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            rabbitTemplate.convertAndSend(RabbitMqConfig.WORK_MSG_QUEUE, "这是一条工作队列消息" + i);
        }
    }
}

③Criar consumidores (múltiplos)

@Component
public class RabbitMqConsumer {
    
    
    @RabbitListener(queues = RabbitMqConfig.WORK_MSG_QUEUE)
    public void listenWork1(String message) {
    
    
        System.out.println("消费者一转发消息是：" + message);
    }
    @RabbitListener(queues = RabbitMqConfig.WORK_MSG_QUEUE)
    public void listenWork2(String message) {
    
    
        System.out.println("消费者二转发消息是：" + message);
    }
}

Insira a descrição da imagem aqui
Você pode ver que ambos os consumidores consumiram com sucesso as mensagens na fila de palavras.

Modo de publicação e assinatura

① declarar fila, alternar e vincular


@SpringBootConfiguration
public class RabbitMqConfig {
    
    
   /**
     * publish队列1
     */
    public static final String PUBLISH_MSG_QUEUE1 = "publish.msg.queue1";
    /**
     * publish队列2
     */
    public static final String PUBLISH_MSG_QUEUE2 = "publish.msg.queue2";
    /**
     * publish交换机
     */
    public static final String PUBLISH_EXCHANGE = "publish.exchange";

   
    /**
     * Publish队列
     *
     * @return
     */
    @Bean
    public Queue getPublishQueue1() {
    
    
        return new Queue(PUBLISH_MSG_QUEUE1, true);
    }
    /**
     * Publish队列
     *
     * @return
     */
    @Bean
    public Queue getPublishQueue2() {
    
    
        return new Queue(PUBLISH_MSG_QUEUE2, true);
    }
    /**
     * Publish交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange publishExchange() {
    
    
        FanoutExchange exchange = new FanoutExchange(PUBLISH_EXCHANGE, true, false);
        return exchange;
    }

    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindPublishExchangeQueue1() {
    
    
        Binding binding = BindingBuilder.bind(getPublishQueue1()).to(publishExchange());
        return binding;
    }
    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindPublishExchangeQueue2() {
    
    
        Binding binding = BindingBuilder.bind(getPublishQueue2()).to(publishExchange());
        return binding;
    }

②Crie um produtor

@SpringBootTest
@RunWith(SpringRunner.class)
public class PublishMqTest {
    
    
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void send() {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            //参数一：交换机名称;参数二:routingKey(广播模式不传)；参数三：消息体
            rabbitTemplate.convertAndSend(RabbitMqConfig.PUBLISH_EXCHANGE, null, "这是一条工作队列消息" + i);
        }
    }
}

③Criar consumidores (múltiplos)

@Component
public class PublishConsumer {
    
    
    @RabbitListener(queues = RabbitMqConfig.PUBLISH_MSG_QUEUE1)
    public void listenDead1(String message) {
    
    
        System.out.println("消费者一接收消息：" + message);
    }
    @RabbitListener(queues = RabbitMqConfig.PUBLISH_MSG_QUEUE2)
    public void listenDead2(String message) {
    
    
        System.out.println("消费者二接收消息：" + message);
    }
}

Insira a descrição da imagem aqui
Pode-se observar que os dois centros de consumo recebem todas as mensagens do produtor, ao contrário da fila de trabalho, o consumidor da fila de trabalho consome apenas algumas mensagens, enquanto este modo consome todas as mensagens.

modo de roteamento

Insira a descrição da imagem aqui
①Declare a fila


@SpringBootConfiguration
public class RabbitMqConfig {
    
    
   
    /**
     * routing交换机
     */
    public static final String ROUTING_EXCHANGE = "routing.exchange";
    /**
     * routing队列1
     */
    public static final String ROUTING_MSG_QUEUE1 = "routing.msg.queue1";
    /**
     * routing队列2
     */
    public static final String ROUTING_MSG_QUEUE2 = "routing.msg.queue2";

    /**
     * routing队列
     *
     * @return
     */
    @Bean
    public Queue getRoutingQueue1() {
    
    
        return new Queue(ROUTING_MSG_QUEUE1, true);
    }

    /**
     * routing队列
     *
     * @return
     */
    @Bean
    public Queue getRoutingQueue2() {
    
    
        return new Queue(ROUTING_MSG_QUEUE2, true);
    }

    /**
     * Publish交换机
     *
     * @return
     */
    @Bean
    public DirectExchange routingExchange() {
    
    
        DirectExchange exchange = new DirectExchange(ROUTING_EXCHANGE, true, false);
        return exchange;
    }

    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindRoutingExchangeQueue1() {
    
    
        Binding binding = BindingBuilder.bind(getRoutingQueue1()).to(routingExchange()).with("routingKey1");
        return binding;
    }

    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindRoutingExchangeQueue2() {
    
    
        Binding binding = BindingBuilder.bind(getRoutingQueue2()).to(routingExchange()).with("routingKey2");
        return binding;
    }
}

②Crie um produtor

@SpringBootTest
@RunWith(SpringRunner.class)
public class RoutingMqTest {
    
    
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void send() {
    
    
            //参数一：交换机名称;参数二:routingKey（交换机与队列绑定的key）；参数三：消息体
            rabbitTemplate.convertAndSend(RabbitMqConfig.ROUTING_EXCHANGE, "routingKey1", "队列一：这是一条路由消息消息");
            rabbitTemplate.convertAndSend(RabbitMqConfig.ROUTING_EXCHANGE, "routingKey2", "队列二：这是一条路由消息消息");
    }
}

③Criar consumidores

@Component
public class RoutingConsumer {
    
    
    @RabbitListener(queues = RabbitMqConfig.ROUTING_MSG_QUEUE1)
    public void listenDead1(String message) {
    
    
        System.out.println("消费者一接收消息：" + message);
    }

    @RabbitListener(queues = RabbitMqConfig.ROUTING_MSG_QUEUE2)
    public void listenDead2(String message) {
    
    
        System.out.println("消费者二接收消息：" + message);
    }
}

Resultados da execução:
Insira a descrição da imagem aqui
x é óbvio: diferentemente do modo de publicação-assinatura, este modo requer que o switch e a fila sejam vinculados por meio de routingKey, e o produtor pode enviar mensagens para a fila especificada especificando routingKey.

Modo curinga

① declarar fila, alternar


@SpringBootConfiguration
public class RabbitConfig {
    
    

    /**
     * topic交换机
     */
    public static final String TOPIC_EXCHANGE = "topic.exchange";
    /**
     * topic队列1
     */
    public static final String TOPIC_MSG_QUEUE1 = "topic.msg.queue1";
    /**
     *topic队列2
     */
    public static final String TOPIC_MSG_QUEUE2 = "topic.msg.queue2";

    /**
     * routing队列
     *
     * @return
     */
    @Bean
    public Queue getTopicQueue1() {
    
    
        return new Queue(TOPIC_MSG_QUEUE1, true);
    }
    /**
     * routing队列
     *
     * @return
     */
    @Bean
    public Queue getTopicQueue2() {
    
    
        return new Queue(TOPIC_MSG_QUEUE2, true);
    }
    /**
     * Publish交换机
     *
     * @return
     */
    @Bean
    public TopicExchange topIcExchange() {
    
    
        TopicExchange exchange = new TopicExchange(TOPIC_EXCHANGE, true, false);
        return exchange;
    }

    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindTopicExchangeQueue1() {
    
    
        Binding binding = BindingBuilder.bind(getTopicQueue1()).to(topIcExchange()).with("topKey.*");
        return binding;
    }
    /**
     * 绑定队列和交换机
     *
     * @return
     */
    @Bean
    public Binding bindTopicExchangeQueue2() {
    
    
        Binding binding = BindingBuilder.bind(getTopicQueue2()).to(topIcExchange()).with("topKey.#");
        return binding;
    }
}

②Crie um produtor

@SpringBootTest
@RunWith(SpringRunner.class)
public class TopicMqTest {
    
    
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void send() {
    
    
        //参数一：交换机名称;参数二:routingKey(广播模式不传)；参数三：消息体
        rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_EXCHANGE, "topic.key1", "这是一条通配符模式消息一");
        rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_EXCHANGE, "topic.key1.key2", "这是一条通配符模式消息二");
    }
}

③Criar consumidores

@Component
public class TopicConsumer {
    
    
    @RabbitListener(queues = RabbitConfig.TOPIC_MSG_QUEUE1)
    public void listenDead1(String message) {
    
    
        System.out.println("消费者一接收消息：" + message);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_MSG_QUEUE2)
    public void listenDead2(String message) {
    
    
        System.out.println("消费者二接收消息：" + message);
    }
}

Os resultados da execução são os seguintes:
Insira a descrição da imagem aqui
Você pode ver que: diferente do modo de roteamento, o tópico suporta chaves de roteamento no modo curinga, em particular, "*" só pode substituir uma palavra; e "#" pode substituir múltiplas;