cola de mensajes
No en vano, hay muchos camaradas que necesitan usar la cola de mensajes antes de haberla estudiado a fondo (como yo), pero al menos después de estudiar una serie de retórica en Wikipedia y la Enciclopedia Baidu, casi lo entiendo, así que gané. No entraré en detalles aquí. Creo que aquellos que pueden venir aquí básicamente tienen su propia comprensión de las colas de mensajes.
Cómo entender la cola de mensajes
¿Como entender? Ha comido en McDonald's. Se puede comparar con el productor que ordena la comida. La velocidad de su pedido es más rápida que la velocidad de entrega. Por lo tanto, cuando muchas personas ordenan la comida, la noticia del pedido ingresará al sistema. Este punto La lista de comidas completas puede entenderse como una cola de mensajes, y el proveedor es equivalente a un consumidor, que lee una parte de la información del pedido del menú y luego completa el pedido de acuerdo con la demanda. Esta información del pedido desaparece, que se puede comparar con los consumidores de Un mensaje se consume en la cola, que debería ser la misma razón.
comparación horizontal
He consultado con precisión ActiveMQ, y no tengo mucho interés en hacer comparaciones horizontales, al igual que cuando leo la "Guía para comprar teléfonos móviles Huawei", si insisto en una comparación horizontal de Huawei, Samsung, Apple, Nokia, y PHS, solo sentiré que estás avergonzado. . Si desea conocer la diferencia entre las diferentes tecnologías de colas de mensajes, diríjase a: >>> cnblog está aquí para divertirse: selección de MQ <<<
lograr
Para el proyecto, no utilicé el proyecto existente para crear un nuevo programa básico de Springboot.
La estructura de mi proyecto es la siguiente para una fácil comprensión:
Instalar activeMQ
Estoy usando un servidor Linux aquí. Si eres un servidor Windows, hay buenas noticias de que este blogger ha iniciado una cooperación profunda con Baidu. Si tienes alguna pregunta, puedes ir directamente a Baidu, jajaja. >>> ActiveMQ bajo Windows <<<
Bajo Linux:
# 下载源码安装包
wget https://ftp.tsukuba.wide.ad.jp/software/apache//activemq/5.16.3/apache-activemq-5.16.3-bin.tar.gz
# 解压
tar -xzvf apache-activemq-5.16.3-bin.tar.gz
# 启动
cd ./apache-activemq-5.16.3/bin
./activemq start
Puede comprender otros comandos de activemq por sí mismo. Si es un servidor en la nube y necesita conectarse de forma remota, el servicio de activemq está habilitado de manera predeterminada, pero la interfaz de administración web en segundo plano no está disponible. Debe encontrar conf/jetty.xml antes de comenzar , y poner 127.0 en él .0.1 se cambia a 0.0.0.0, la ubicación es sobre la línea 120:
luego accede el navegador, el puerto del sistema de administración de fondo no reconoce 8161, el puerto API es 61616, aquí acceda a 127.0.0.1 :8161, debe ingresar el nombre de usuario y la contraseña predeterminados admin/admin, seguidos de la automodificación, y luego hacer clic en administrar el agente de activemq para ingresar a la interfaz de administración:
La instalación está completa.
importación de paquetes
Es necesario importar paquetes relacionados en pom, aquí se importan los paquetes de dependencia de inicio Springboot relacionados:
<!-- activeMQ起步依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<!-- activeMQ连接池 -->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-pool</artifactId>
<version>5.15.0</version>
</dependency>
Debido a que es un requisito del programa web, la dependencia de inicio web también debe importarse, y algunos otros paquetes pueden importarse según sus propias necesidades.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
Configuración de la cola de mensajes
Luego configure el MQ en el archivo de configuración. La preferencia personal es usar el archivo de configuración yaml.
server:
port: 8898
spring:
activemq:
broker-url: tcp://127.0.0.1:61616
user: admin
password: admin
non-blocking-redelivery: false # 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
send-timeout: 0 # 等待消息发送响应的时间。设置为0等待永远。
in-memory: true
queue-name: examQueue # queue队列的名称
topic-name: examTopic # topic队列的名称
pool:
enabled: true # 启用连接池
max-connections: 100 # 最大连接数
idle-timeout: 30000 # 空闲的连接过期时间，默认为30秒
En la configuración anterior, el nombre de la cola y el nombre del tema no son los atributos en el elemento de configuración predeterminado en la dependencia de inicio de activeMQ, pero por conveniencia, se establece una configuración de MQ personalizada y estos dos atributos se definen en ella, que se utilizan para representar Los nombres de las dos colas se pueden dejar sin definir.Pueden ser variables estáticas globales o codificadas de forma rígida, según los requisitos.
La siguiente es la clase de configuración activeMQ, que define los oyentes en dos modos:
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.config.SimpleJmsListenerContainerFactory;
import org.springframework.jms.core.JmsMessagingTemplate;
import javax.jms.ConnectionFactory;
import javax.jms.Queue;
import javax.jms.Topic;
@Configuration
//@ConfigurationProperties(prefix = "spring.activemq")
public class MQConfig {
@Value("${spring.activemq.broker-url}")
private String brokerUrl;
@Value("${spring.activemq.user}")
private String username;
@Value("${spring.activemq.password}")
private String password;
@Value("${spring.activemq.queue-name}")
private String queueName;
@Value("${spring.activemq.topic-name}")
private String topicName;
@Bean(name = "queue")
public Queue queue() {
return new ActiveMQQueue(queueName);
}
@Bean(name = "topic")
public Topic topic() {
return new ActiveMQTopic(topicName);
}
@Bean
public ConnectionFactory connectionFactory(){
return new ActiveMQConnectionFactory(username, password, brokerUrl);
}
@Bean
public JmsMessagingTemplate jmsMessageTemplate(){
return new JmsMessagingTemplate(connectionFactory());
}
// 在Queue模式中，对消息的监听需要对containerFactory进行配置
@Bean("queueListener")
public JmsListenerContainerFactory<?> queueJmsListenerContainerFactory(ConnectionFactory connectionFactory){
SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setPubSubDomain(false);
return factory;
}
//在Topic模式中，对消息的监听需要对containerFactory进行配置
@Bean("topicListener")
public JmsListenerContainerFactory<?> topicJmsListenerContainerFactory(ConnectionFactory connectionFactory){
SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setPubSubDomain(true);
return factory;
}
}
productor
Luego está el productor. El productor se utiliza principalmente para generar mensajes (enviar mensajes). Aquí están las interfaces de envío de mensajes del productor en dos modos:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.jms.Destination;
import javax.jms.Queue;
import javax.jms.Topic;
@RestController
@RequestMapping("/mq")
public class ProducerController {
@Autowired
private JmsMessagingTemplate jmsMessagingTemplate;
@Autowired
private Queue queue;
@Autowired
private Topic topic;
@PostMapping("/queue/send")
public String sendQueue(@RequestBody String str) {
this.sendMessage(this.queue, str);
return "success";
}
@PostMapping("/topic/send")
public String sendTopic(@RequestBody String str) {
this.sendMessage(this.topic, str);
return "success";
}
// 发送消息，destination是发送到的队列，message是待发送的消息
private void sendMessage(Destination destination, final String message){
jmsMessagingTemplate.convertAndSend(destination, message);
}
}
consumidor
Luego está el consumidor. Después de que el productor envía el mensaje a la cola, debido a la existencia del oyente, el consumidor puede escuchar el nuevo mensaje y luego consumir el mensaje de una cola específica para completar el trabajo:
consumidor de cola:
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class QueueConsumerListener {
//queue模式的消费者
@JmsListener(destination="${spring.activemq.queue-name}", containerFactory="queueListener")
public void readActiveQueue(String message) throws InterruptedException {
Thread.sleep(3000); //模拟时间复杂度较高的工作
System.out.println("queue接受到：" + message);
}
}
consumidor del tema:
package com.javafeng.mqdemo.consumer;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class TopicConsumerListener {
//topic模式的消费者
@JmsListener(destination="${spring.activemq.topic-name}", containerFactory="topicListener")
public void readActiveQueue(String message) {
Thread.sleep(3000); //模拟时间复杂度较高的工作
System.out.println("topic接受到：" + message);
}
}
otra configuración
Debe estar en el programa de entrada, permitir la configuración personalizada e iniciar la cola de mensajes. También configuré la ubicación del paquete básico del componente de escaneo aquí:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.jms.annotation.EnableJms;
@SpringBootApplication(scanBasePackages = {
"com.javafeng.mqdemo"})
@EnableConfigurationProperties // 允许自定义配置，也就是让MQConfig生效
@EnableJms //启动消息队列
public class MqdemoApplication {
public static void main(String[] args) {
SpringApplication.run(MqdemoApplication.class, args);
}
}
prueba
Al ejecutar el proyecto, se puede concluir de lo anterior que la ruta de acceso del mensaje producido por el productor de la cola es /mq/queue/send, y la ruta de acceso del productor del tema es /mq/topic/send. probaré: el tema es el mismo, aquí
no lo repetiré más, y terminaré de esparcir flores.
Referencias y citas:
Blog Garden-Fengzhiyuxie-SpringBoot integra ActiveMq:
https://www.cnblogs.com/yufeng218/p/11509486.html