# SpringBoot integra RabbitMQ

SpringBoot integra RabbitMQ

RabbitMQ

concepto

RabbitMQ es un tipo de middleware de mensajes que implementa AMQP (Advanced Message Queueing Protocol). Originalmente se originó en sistemas financieros y se utiliza para almacenar y reenviar mensajes en sistemas distribuidos. Tiene un buen desempeño en términos de facilidad de uso, escalabilidad y alta disponibilidad. . RabbitMQ se implementa principalmente para lograr un desacoplamiento bidireccional entre sistemas. Cuando el productor genera una gran cantidad de datos, el consumidor no puede consumirlos rápidamente, por lo que se necesita una capa intermedia. Guarde estos datos.

Instalación de Windows

• Referencia de instalación del entorno de Windows RabbitMq https://blog.csdn.net/zhm3023/article/details/82217222

Breve descripción

• cola: cola, cada cola puede tener varios consumidores, pero un mensaje solo será consumido por un consumidor

• intercambio: Intercambio, la cola se puede vincular al intercambio y el intercambio envía mensajes a la cola en función del enrutamiento u otra información coincidente.

modo

• Modo simple: modo de conexión directa sin interruptor. Solo hay un consumidor en una cola

• Modo de trabajo: varios consumidores en una cola

• Modo directo: se requiere un conmutador, la clave de enrutamiento del conmutador se utiliza para hacer coincidir con precisión la cola y enviar a la cola correspondiente

• Modo de tema: un modo de coincidencia aproximada a través de enrutamiento y clave de enrutamiento. Hay comodines disponibles. Por ejemplo, key.1 se obtendrá mediante la cola vinculada a la clave de enrutamiento. *

• fanout: modo de transmisión, no se requiere clave de enrutamiento, para todas las colas vinculadas al conmutador

---

SpringBoot integra RabbitMq

Ejemplo simple

Introducir la dependencia de Maven

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

配置 yml

spring:  
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

Crea colas, intercambios

@Configuration
public class RebbitMqConfig {
    
    

    /**
     * 队列名
     */
    private static final String LOG_QUEUE = "log_queue";

    /**
     * 交换机名
     */
    public static final String LOG_EXCHANGE = "log_exchange";
    public static final String MESSAGE_QUEUE = "message_queue";
    public static final String MESSAGE_EXCHANGE = "message_exchange";
    public static final String DIRECT_ROUTINGKEY = "test";

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue createLogQueue() {
    
    
        return new Queue(LOG_QUEUE);
    }

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue createMessageQueue() {
    
    
        return new Queue(MESSAGE_QUEUE);
    }

    /**
     * 创建交换机
     * @return
     */
    @Bean
    public FanoutExchange logExchange() {
    
    
        return new FanoutExchange(LOG_EXCHANGE);
    }

    /**
     * 创建交换机
     * @return
     */
    @Bean
    public DirectExchange messageExchange() {
    
    
        return new DirectExchange(MESSAGE_EXCHANGE);
    }

    /**
     * 队列与交换机进行绑定
     * @return
     */
    @Bean
    public Binding bindingFanout() {
    
    
        return BindingBuilder.bind(createLogQueue()).to(logExchange());
    }

    /**
     * 队列与交换机绑定并添加路由key（direct和topic模式）
     * @return
     */
    @Bean
    public Binding bindingDirect() {
    
    
        return BindingBuilder.bind(createMessageQueue()).to(messageExchange()).with(DIRECT_ROUTINGKEY);
    }
}

Ejemplo de productor simple

@RestController
@RequestMapping("/rabbit")
public class RabbitMqProduct {
    
    

    /**
     * 队列名
     */
    private static final String LOG_QUEUE = "log_queue";

    /**
     * 交换机名
     */
    public static final String LOG_EXCHANGE = "log_exchange";
    
    public static final String DIRECT_ROUTINGKEY = "test";


    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/test1")
    public void sendMessage() {
    
    
        String context = "simple---> " + new Date();
        //如果没有配置默认交换机,直接传入queue的name
        rabbitTemplate.convertAndSend(LOG_QUEUE, context);
        //如果配置了默认的交换机，（交换机，queue_name，内容）
        rabbitTemplate.convertAndSend("", DIRECT_ROUTINGKEY, context);
    }

    @RequestMapping("/test2")
    public void sendMessages() {
    
    
        String context = "direct---> " + new Date();
        //（交换机名称,路由的key,内容）
        rabbitTemplate.convertAndSend(LOG_EXCHANGE, DIRECT_ROUTINGKEY, context);
    }
}

Ejemplo de consumidor simple

@Component
public class RabbitMqConsume {
    
    

    //基础注解，指定queue的名称，可以多个。如果是simple不需要交换机的直接写队列名称就好。
    //如果是其他的也想只指定一个queues——name的话，需要上面的配置类配置queue或者其他绑定关系
    @RabbitListener(queues = "log_queue")
    @RabbitHandler
    public void processSimpleMsg(String message) {
    
    
        System.out.println("########################received simple" + message);
    }

}

Se completa la integración simple. . .