Antes, grabamos el código java nativo usando rabbitmq. Es muy simple, similar al código jdbc nativo. El objeto de conexión se extrae como una clase de herramienta. El productor y el consumidor obtienen el objeto de conexión a través de la clase de herramienta y luego obtienen el objeto de canal Registrar el intercambio o cola, etc., enviar y recibir mensajes.
En el desarrollo empresarial, usamos principalmente el marco de Spring para integrar otras tecnologías. Springboot es más conveniente para proporcionar varios iniciadores para agregar rápidamente dependencias, completar la integración y usarlo de inmediato.
- Agregar dependencia
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
Configuración de escritura La información de configuración incluye ip, puerto, host virtual, nombre de usuario y contraseña, y es coherente con la información de configuración requerida por el código Java nativo.
spring:
application:
name: spirngboot-rabbitmq
rabbitmq:
host: 192.168.20.128
port: 5672
virtual-host: /vh
username: wuwl
password: 123456
- Escritura y pruebas
Este artículo se centra en los primeros cinco modelos de uso común, integrando rabbitmq sobre la base del marco spirngboot y probándolo.
(1) modelo Hello World
Este es un modelo de conexión directa simple: el productor envía el mensaje directamente a la cola de mensajes y el consumidor lo recibe directamente después de vincular la cola de mensajes, uno a uno.
spring-boot-starter-amqpSe nos proporciona una org.springframework.amqp.rabbit.core.RabbitTemplateclase para facilitar nuestro uso rabbitmq, y se puede inyectar de forma automática.
Clase de prueba de productor:
@SpringBootTest(classes = RabbitmqDemoApplication.class)
@RunWith(SpringRunner.class)
public class RabbitmqDemoApplicationTests {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testHelloQueues(){
rabbitTemplate.convertAndSend("hello","hello world");
}
}
El productor envía un mensaje a la cola llamado hola, pero en ausencia de un consumidor, el productor no tiene significado. Además, convertAndSendel primer parámetro del método no significa la cola de mensajes, pero routingKeyencontramos la interfaz definida originalmente basada en el código fuente y vemos lo siguiente:
/**
* Convert a Java object to an Amqp {@link Message} and send it to a default exchange
* with a specific routing key.
*
* @param routingKey the routing key
* @param message a message to send
* @throws AmqpException if there is a problem
*/
void convertAndSend(String routingKey, Object message) throws AmqpException;
El segundo parámetro es el Objecttipo, lo que significa que se puede pasar cualquier tipo de objeto. Este método convierte el objeto en un Amqpmensaje y lo envía a un intercambio predeterminado, y routingKeyes el contenido del primer parámetro, sin mencionar la información de la cola de mensajes. Sin embargo, podemos analizar eso, aquí routingKeyy queuesdebería ser el mismo nombre.
Categoría de consumidor:
@Component
@RabbitListener(queuesToDeclare = @Queue("hello"))
public class HelloQueuesConsumer {
@RabbitHandler
public void consume(String msg){
System.out.println("消费消息：" + msg + " " + System.currentTimeMillis());
}
}
El código anterior es equivalente a:
@Component
public class HelloQueuesConsumer {
@RabbitListener(queuesToDeclare = @Queue("hello"))
public void consume(String msg){
System.out.println("消费消息：" + msg + " " + System.currentTimeMillis());
}
}
- @RabbitListener se puede marcar en la clase, debe usarse con la anotación @RabbitHandler
- @RabbitListener está marcado en la clase para indicar que cuando se recibe un mensaje, se entregará al método @RabbitHandler para su procesamiento, qué método se usa para procesar, de acuerdo con el tipo de parámetro después de la conversión de MessageConverter
Inicie el método de prueba directamente, es decir, el productor, puede ver que el
consumidor ha recibido la información en la cola de mensajes y la ha impreso.
(2) Modelo de colas de trabajo
Método de prueba del productor, la clase es consistente con el primer modelo
@Test
public void testWorkQueues(){
for (int i = 0; i < 20; i++) {
rabbitTemplate.convertAndSend("work","work index " + i);
}
}
Categoría de consumidor:
@Component
public class WorkQueuesConsumer {
@RabbitListener(queuesToDeclare = @Queue("work"))
public void consume1(String msg){
System.out.println("consumer1消费消息：" + msg);
}
@RabbitListener(queuesToDeclare = @Queue("work"))
public void consume2(String msg){
System.out.println("consumer2消费消息：" + msg);
}
}
Inicie el método de prueba del productor: el
consumidor 1 y el consumidor 2 distribuyen uniformemente las tareas del mensaje en la cola. Incluso si la eficiencia de ejecución de los dos es inconsistente, se distribuyen por igual.
(3) Modelo de publicación / suscripción
Método de prueba del productor:
for (int i = 0; i < 20; i++) {
rabbitTemplate.convertAndSend("amq.fanout","","fanout msg " + i);
}
Categoría de consumidor:
@Component
public class FanoutQueuesConsumer {
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.fanout",
type = "fanout"))})
public void consume1(String msg) {
System.out.println("consumer1消费消息：" + msg);
}
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.fanout",
type = "fanout"))})
public void consume2(String msg) {
System.out.println("consumer2消费消息：" + msg);
}
}
Tenga en cuenta la información del interruptor aquí
Inicie el método de prueba del productor: aquí
solo se pega parte de la información de impresión. Dos consumidores reciben el mismo mensaje. El productor envía el mensaje al intercambio, que se envía a todas las colas de mensajes temporales registradas en el intercambio, y luego el consumidor obtiene los mensajes en la cola.
(4) Modelo de enrutamiento
Método de prueba del productor:
@Test
public void testDirectQueues(){
rabbitTemplate.convertAndSend("amq.direct","info","routingKey is info");
rabbitTemplate.convertAndSend("amq.direct","warn","routingKey is warn");
rabbitTemplate.convertAndSend("amq.direct","error","routingKey is error");
}
El enrutamiento también se ha convertido en un modelo de distribución, y el tipo de conmutador correspondiente es directo
Categoría de consumidor:
@Component
public class DirectQueuesConsumer {
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.direct",
type = "direct"),
key = {
"info", "warn", "error"})})
public void consume1(String msg) {
System.out.println("consumer1消费消息：" + msg);
}
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.direct",
type = "direct"),
key = "error")})
public void consume2(String msg) {
System.out.println("consumer2消费消息：" + msg);
}
}
Inicie la clase de prueba del productor: el
consumidor uno está configurado con tres tipos de clave de enrutamiento, por lo que se pueden recibir los tres tipos de mensajes y el consumidor dos solo puede recibir mensajes de tipo de error.
(5) Modelo de tema
Método de prueba del productor:
@Test
public void testTopicQueues(){
rabbitTemplate.convertAndSend("amq.topic","file.info","routingKey is info");
rabbitTemplate.convertAndSend("amq.topic","file.warn","routingKey is warn");
rabbitTemplate.convertAndSend("amq.topic","file.error","routingKey is error");
}
Categoría de consumidor:
@Component
public class TopicQueuesConsumer {
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.topic",
type = "topic"),
key = {
"#"})})
public void consume1(String msg) {
System.out.println("consumer1消费消息：" + msg);
}
@RabbitListener(bindings = {
@QueueBinding(value = @Queue,
exchange = @Exchange(
value = "amq.topic",
type = "topic"),
key = "*.error")})
public void consume2(String msg) {
System.out.println("consumer2消费消息：" + msg);
}
}
Inicie el método de prueba del productor: el
consumidor 1 está configurado routingKeypara #aceptar cualquier tipo de mensaje, que *representa una palabra, y el consumidor 2 puede aceptar mensajes con cualquier palabra agregada .errorcomo routingKey.