file d'attente de messages
Sans surprise, de nombreux camarades ont besoin d'utiliser la file d'attente des messages avant de l'avoir étudiée à fond (comme moi), mais au moins après avoir étudié une série de rhétorique sur Wikipedia et l'encyclopédie Baidu, j'ai presque compris, alors j'ai gagné Je crois que ceux qui peuvent venir ici ont leur propre compréhension des files d'attente de messages.
Comment comprendre la file d'attente des messages
Comment comprendre? Vous avez mangé chez McDonald's. Cela peut être comparé au producteur qui commande la nourriture. La vitesse de votre commande est plus rapide que la vitesse de livraison. Par conséquent, lorsque de nombreuses personnes commandent la nourriture, les nouvelles de la commande entreront dans le système. Ce point La liste des repas terminés peut être comprise comme une file d'attente de messages, et le traiteur est équivalent à un consommateur, qui lit une information de commande dans le menu, puis complète la commande en fonction de la demande. Cette information de commande disparaît, qui peut être comparé aux consommateurs de Un message est consommé dans la file d'attente, ce qui devrait être la même raison.
comparaison horizontale
J'ai interrogé ActiveMQ avec précision, et je n'ai pas beaucoup d'intérêt à faire des comparaisons horizontales. Tout comme lorsque j'ai lu le "Guide d'achat des téléphones mobiles Huawei", si j'insiste sur une comparaison horizontale de Huawei, Samsung, Apple, Nokia, et PHS, je n'aurai que le sentiment que vous êtes gêné. . Si vous voulez connaître la différence entre les différentes technologies de file d'attente de messages, veuillez vous rendre sur : >>> cnblog est là pour le plaisir : sélection MQ <<<
accomplir
Pour le projet, je n'ai pas utilisé le projet existant pour créer un nouveau programme de base Springboot.
La structure de mon projet est la suivante pour faciliter la compréhension :
Installer activeMQ
J'utilise ici un serveur Linux. Si vous êtes un serveur Windows, il y a de bonnes nouvelles que ce blogueur a lancé une coopération approfondie avec Baidu. Si vous avez des questions, vous pouvez aller directement à Baidu, hahaha. >>> ActiveMQ sous Windows <<<
Sous 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
Vous pouvez comprendre d'autres commandes activemq par vous-même. Si vous êtes un serveur cloud et que vous devez vous connecter à distance, le service activemq est autorisé par défaut, mais l'interface de gestion Web en arrière-plan n'est pas disponible. Vous devez trouver conf/jetty.xml avant de commencer , et y mettre 127.0 .0.1 est changé en 0.0.0.0, l'emplacement est vers la ligne 120 :
alors le navigateur accède, le port du système de gestion d'arrière-plan ne reconnaît pas 8161, le port API est 61616, ici l'accès 127.0.0.1 :8161, vous devez saisir le nom d'utilisateur et le mot de passe par défaut admin/admin , suivis d'une auto-modification, puis cliquer sur manage activemq broker pour accéder à l'interface de gestion :
L'installation est maintenant terminée.
importation de colis
Il est nécessaire d'importer les packages associés dans pom, ici importe les packages de dépendance de démarrage springboot associés :
<!-- 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>
Comme il s'agit d'une exigence du programme Web, la dépendance de démarrage Web doit également être importée et certains autres packages peuvent être importés en fonction de vos propres besoins.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
Configuration de la file d'attente des messages
Configurez ensuite le MQ dans le fichier de configuration. Votre préférence personnelle est d'utiliser le fichier de configuration 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秒
Dans la configuration ci-dessus, le nom de la file d'attente et le nom du sujet ne sont pas les attributs de l'élément de configuration par défaut dans la dépendance de démarrage activeMQ, mais pour plus de commodité, une configuration MQ personnalisée est établie et ces deux attributs y sont définis, qui sont utilisés à représenter Les noms des deux files d'attente peuvent être laissés indéfinis, il peut s'agir de variables statiques codées en dur ou globales, selon les besoins.
Vient ensuite la classe de configuration activeMQ, qui définit les écouteurs en deux modes :
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;
}
}
producteur
Ensuite, il y a le producteur. Le producteur est principalement utilisé pour générer des messages (envoyer des messages). Voici les interfaces d'envoi de message du producteur en deux modes :
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);
}
}
consommateur
Ensuite, il y a le consommateur. Une fois que le producteur a envoyé le message à la file d'attente, en raison de l'existence de l'écouteur, le consommateur peut écouter le nouveau message, puis consommer le message d'une file d'attente spécifique pour terminer le travail :
consommateur de file d'attente :
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);
}
}
sujet consommateur :
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);
}
}
autre configuration
Il doit être dans le programme d'entrée, autoriser la configuration personnalisée et démarrer la file d'attente des messages. J'ai également configuré l'emplacement du package de base du composant d'analyse ici :
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);
}
}
test
En exécutant le projet, on peut conclure de ce qui précède que le chemin d'accès du message produit par le producteur de file d'attente est /mq/queue/send, et le chemin d'accès du producteur de sujet est /mq/topic/send. va tester : le sujet est le même, ici
je ne le répéterai plus, et je finirai de répandre des fleurs.
Références et citations :
Blog Garden-Fengzhiyuxie-SpringBoot intègre ActiveMq :
https://www.cnblogs.com/yufeng218/p/11509486.html