Annuaire d'articles

Structure de base MQ
compter sur

Structure de base MQ

insérez la description de l'image ici

message : objet de données de message
produit : programmer du code, générer des messages, envoyer des messages aux files d'attente
consommateur : code de programme, surveillance (liaison) de la file d'attente, obtention d'un message, exécution du code de consommation
file d'attente : Rocketmq rabbitmq kafka ces logiciels middleware de file d'attente de messages.

compter sur

<dependency>
    <!--2.2.2底层rocketmq客户端4.9.1-->
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

cas:

produit

public class MyProducer {
    
    
    /**
     * 向rocketmq发送第一条消息
     */
    @Test
    public void sendTest01() throws Exception {
    
    
    //1.准备一个生产者对象,开启长链接
        DefaultMQProducer producer=new DefaultMQProducer();
        //对当前producer设置分组
        producer.setProducerGroup("first-producer-group");
        //连接nameserver localhost:9876
        producer.setNamesrvAddr("localhost:9876");
        //开启长链接
        producer.start();
    //2.封装一个消息对象,我们想要发送的内容,只是消息的一部分
        //创建一个消息对象
        Message message=new Message();
        //消息携带的内容 body
        String msg="当前发送的第一条消息";
        message.setBody(msg.getBytes(StandardCharsets.UTF_8));
        //设置消息主题,分类,按业务分类
        message.setTopic("first-topic-a");
        //主题标签 和key标识 
    //3.调用api方法将消息发送,接收返回结果,查看发送的信息比如状态
        //分为异步发送,同步发送,异步发送性能速度更高,但是无法保证成功.
        //同步发送,性能速度没有异步快,但是可以接收反馈结果
        SendResult send = producer.send(message);
        //result解析获取发送相关的信息
        System.out.println("发送状态:"+send.getSendStatus());
        System.out.println("消息到达主题,队列,broker信息:"+send.getMessageQueue());
    }
}

Consommateur

public class MyConsumer1 {
    
    
    @Test
    public void consumerTest01() throws Exception {
    
    
    //1.构建一个消费者对象,连接nameserver创建长链接
        // push pull的区别 push消费端,消费的消息是队列推送给他的
        // pull 消费端代码执行一次pull 拉取过来一条消息
        // 收邮件 推的, 抢红包 拉取的
        DefaultMQPushConsumer consumer=new DefaultMQPushConsumer();
        //设置nameserver地址
        consumer.setNamesrvAddr("localhost:9876");
        //消费者分组
        consumer.setConsumerGroup("first-consumer-group-a");
        //定义监听的主题,消费端代码会根据定义的主题寻找nameserver路由信息,找到主题的队列进行绑定
        //topic 主题名称,subExpression 定义过滤逻辑 *表示匹配所有
        consumer.subscribe("first-topic-a","*");
    //2.执行api开始监听主题,实现队列的消费
        //提供给consumer一个监听器
        consumer.setMessageListener(new MessageListenerConcurrently() {
    
    
            /**
             * 推送过来的消息,都会调用consumerMessage执行消费逻辑
             * @param list 消息数据 list表示可以批量处理的消息,不是批量消息,list元素只有1个
             * @param consumeConcurrentlyContext
             * @return
             */
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(
                    List<MessageExt> list,
                    ConsumeConcurrentlyContext consumeConcurrentlyContext) {
    
    
                //获取消息 由于不是批量发送只有list一个元素
                MessageExt messageExt = list.get(0);
                messageExt.getMsgId();//唯一的一个标识,每次消息组装的对象都会在发送时,生成一个msgId
                byte[] body = messageExt.getBody();
                //将消息转化
                String message=new String(body, StandardCharsets.UTF_8);
                System.out.println("消费端获取到消息:"+message);
                //context 控制返回确认信息 ackIndex顺序
                //返回消费状态 success 队列会将消息对应当前消费组,移动偏移量,记录消费完成
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        //开启长连接
        consumer.start();
        while (true);
    }
}

Idée centrale

1.serveur de noms

NameServer est un simple registre de routage de sujets qui prend en charge l'enregistrement dynamique et la découverte de sujets et de courtiers.
Il comprend principalement deux fonctions :

Gestion du courtier, NameServer accepte les informations d'enregistrement du cluster Broker et les enregistre en tant que données de base des informations de routage. Ensuite, fournissez un mécanisme de détection de battement de cœur pour vérifier si le courtier est toujours en vie ;
Gestion des informations de routage, chaque NameServer enregistrera toutes les informations de routage sur le cluster Broker et les informations de file d'attente pour les requêtes des clients. Le producteur et le consommateur peuvent connaître les informations de routage de l'ensemble du cluster Broker via le NameServer, afin de livrer et de consommer des messages.

NameServer a généralement plusieurs instances déployées et les instances ne communiquent pas entre elles. Broker enregistre ses propres informations de routage avec chaque NameServer, de sorte que chaque instance de NameServer enregistre une information de routage complète. Lorsqu'un NameServer se déconnecte pour une raison quelconque, le client peut toujours obtenir des informations de routage à partir d'autres NameServers.

En bref : le serveur de noms agit en tant que coordinateur, celui qui utilise les informations doit s'enregistrer auprès du serveur de noms et celui qui souhaite utiliser les informations d'enregistrement doit se rendre sur le serveur de noms pour les capturer de manière synchrone. Le courtier doit être utilisé comme conteneur rocketmq par le code producteur et consommateur
.

2.courtier

Le courtier est principalement responsable du stockage, de la livraison et de l'interrogation des messages et de la garantie de la haute disponibilité des services.

NameServer n'a presque pas de nœuds d'état, il peut donc être déployé dans un cluster sans aucune synchronisation des informations entre les nœuds. Le déploiement du courtier est relativement compliqué.
Dans l'architecture Maître-Esclave, Broker est divisé en Maître et Esclave. Un maître peut correspondre à plusieurs esclaves, mais un esclave ne peut correspondre qu'à un seul maître. La relation correspondante entre le maître et l'esclave est définie en spécifiant le même BrokerName et un BrokerId différent. BrokerId est 0 pour le maître et différent de zéro pour l'esclave. Le maître peut également en déployer plusieurs.

3. File d'attente de sujets

Compréhension simple, un sujet est une collection d'une classe de messages , et chaque fois que nous envoyons un message, nous devons spécifier un message à lier à un certain sujet.
Un certain message envoyé par le producteur ne peut pointer que vers un sujet, et plusieurs messages peuvent pointer vers le même sujet. Il existe plusieurs files d'attente de messages dans le même sujet pour stocker les messages, et le consommateur peut consommer des messages de différents sujets en fonction des sujets auxquels il est abonné. Cela peut permettre d'isoler l'entreprise.
Par exemple, le thème du e-commerce peut être la commande, le thème peut aussi être le panier, et il peut aussi être lié au produit...
Un type de message, du format des données, au format du corps, est totalement cohérent. Il n'y aura pas de " premier message " ; le corps est une chaîne normale, et le deuxième message est un objet Json. Il est impossible que le premier message retarde le message (annulation du compte à rebours de l'ordre de paiement), et le deuxième message est un message synchrone normal.

file d'attente 4.queue

L'entité physique (unité minimale) pour le stockage des messages. Un sujet peut contenir plusieurs files d'attente (la clé de la représentation distribuée), et chaque file d'attente stocke les messages du sujet. Une file d'attente de rubrique est également appelée une partition** (partition**) de messages dans une rubrique.

Remarque : Les messages dans la file d'attente d'un sujet ne peuvent être consommés que par un consommateur dans un groupe de consommateurs (logique de point de consommation). Les messages d'une file d'attente ne permettent pas à plusieurs consommateurs du même groupe de consommateurs de consommer en même temps.
insérez la description de l'image ici

5. Producteur

Question : Grâce à la compréhension des concepts ci-dessus, comment les producteurs, les serveurs de noms et les courtiers interagissent-ils ?

Démarrer le serveur de noms pour enregistrer les informations de routage du courtier
Une fois le sujet créé, enregistrez-le dans le courtier et générez une file d'attente en même temps. Ces données sont enregistrées en tant qu'informations de routage dans le serveur de noms.
Le producteur obtient les informations d'enregistrement (routage) du cluster actuel à partir du serveur de noms
Lors de l'envoi d'un message, connectez-vous au courtier spécifique pour trouver la file d'attente spécifique du sujet spécifique pour envoyer le message. Les informations spécifiques utilisées sont reflétées dans le SendResult renvoyé.

6. Groupement de consommateurs et groupement de producteurs

Le producteur de messages est responsable de la production des messages. Il s'agit essentiellement d'un morceau de code dans le programme. Le producteur transmet le message à l'agent courtier. Trouvez le sujet, équilibrez la charge et stockez-le dans la file d'attente. Les producteurs de messages dans RocketMQ apparaissent tous sous la forme d'un groupe de producteurs (groupe de producteurs)
. Un groupe de producteurs est un ensemble de producteurs du même type qui génèrent des messages du même type, et ces producteurs envoient des messages du même type de sujet. Un groupe de producteurs peut envoyer des messages à plusieurs sujets en même temps.
insérez la description de l'image ici
Les consommateurs de messages dans RocketMQ apparaissent tous sous la forme de groupes de consommateurs (groupe de consommateurs). Un groupe de consommateurs est un ensemble de consommateurs du même type. Ces consommateurs consomment des messages du même type de rubrique et correspondent au même type de données de message. Le groupe de consommateurs permet l'équilibrage de charge (distribuant uniformément différentes files d'attente dans un sujet à différents consommateurs du même groupe de consommateurs) et la tolérance aux pannes (si un consommateur raccroche, les autres consommateurs du groupe de consommateurs peuvent continuer à exécuter la logique de consommation .

Puisqu'il existe plusieurs files d'attente dans le sujet, un groupe de consommateurs peut avoir au plus le même nombre de membres consommateurs que la file d'attente, et pas plus, il est impossible de lier la file d'attente pour consommer des messages.

7. Points de consommation

Toutes les données liées au décalage sont enregistrées dans la file d'attente, telles que :

Décalage minimum : tous 0
Décalage maximum : le nombre de messages en cours

Le décalage est également enregistré dans le consommateur

Le décalage minimum de consommation de la file d'attente du sujet correspondant au groupe courant, et le décalage maximum de la file d'attente (à travers ces deux valeurs, il est possible de savoir quel message le consommateur courant consomme et combien n'est pas consommé)

Concepts de base de RocketMQ et mise en route