Duas formas de vinculação do Spring RabbitMQ.

Normalmente, o uso do RabbitMq precisa primeiro criar vhost, exchange, fila no console do RabbitMq e, em seguida, criar ligação de chave de roteamento. Obviamente, essa operação também pode ser realizada por meio da API correspondente.

Modo de operação APi

Obviamente, se você usar o Spring, todo o processo de vinculação será relativamente fácil. Afinal, é mais problemático criar e vincular no console, e esse processo deve ser repetido após a alteração do ambiente.

método um:

Crie um relacionamento de vinculação no estilo @Bean

package cn.kanyun.module;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRabbitMqConfig {


    /**
     * description 配置交换机,不同类型的可以声明成不同的，比如fanout、direct、topic等
     * param durable:持久性 autoDelete:自动删除
     * return org.springframework.amqp.core.DirectExchange
     **/
    @Bean
    DirectExchange myDirectExchange(){
        // name:交换机的名称
        // durable：交换机有持久(durable)和暂存(transient)两个状态。
        // autoDelete：当所有与之绑定的消息队列都完成了对此交换机的使用后，删掉它。默认是true
        return new DirectExchange("KanyunExchange",true,false);
    }

    /**
     * description 配置队列
     * param durable,autoDeletet,exclusive
     * return org.springframework.amqp.core.Queue
     * createTime 2020/9/14 18:54
     **/
    @Bean
    Queue myDirectQueue(){
        //durable,autoDeletet:
        //exclusive:只被一个连接使用，当连接关闭后，队列即将被删除
        return new Queue("myDirectQueue",true,false,false);
    }

    /**
     * description 绑定 同时配置路由键
     *  队列与交换机的绑定，通过routingKey来绑定，fanout模式是不需要routingKey的，因为他是直接绑定队列的
     * param []
     * return org.springframework.amqp.core.Binding
     * createTime 2020/9/14 19:03
     **/
    @Bean
    Binding myDirectBinding(){
        // 队列 -> 交换机 -> 路由键
        return BindingBuilder.bind(myDirectQueue()).to(myDirectExchange()).with("myDirectRoutingKey");
    }


//可以绑定多个

//    @Bean
//    public Binding mybind1(){
//        return BindingBuilder.bind(queue).to(topicExchange).with("topic.#");
//    }
//    @Bean
//    public Binding mybind2(){
//        return BindingBuilder.bind(queue1).to(topicExchange).with("topic.*");
//    }
}

Pode-se ver que através da configuração acima, quando o projeto inicia, o switch, a fila e o relacionamento de ligação são todos criados. Na verdade, esse método parece mais problemático, porque escreve mais @Bean, o que parece deslumbrante.

Método 2:

Configure apenas consumidores.

    @RabbitListener(bindings = {@QueueBinding(value = @Queue(value="kanyun.queue",durable = "true"),
    exchange = @Exchange(value = "kanyun_exchange_1",durable = "true"),key = "kanyun.route.key")})
    public void handleMessage(byte[] message){
        System.out.println("消费消息");
        System.out.println(new String(message));
    }

Dessa forma, trocas, filas e ligações também podem ser criadas automaticamente. É mais intuitivo do que o método anterior. Mas não tão flexível quanto a primeira maneira.

aplicativo.yml

spring:
  rabbitmq:
    addresses: 127.0.0.1:5672
    username: guest
    password: guest

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

Duas formas de vinculação do Spring RabbitMQ.

Guess you like