Conceitos básicos e introdução do RocketMQ

Estrutura básica do MQ

• mensagem: objeto de dados de mensagem
• produto: Programar código, gerar mensagens, enviar mensagens para filas
• consumidor: código do programa, fila de monitor (bind), obter mensagem, executar código de consumo
• fila: Rocketmq rabbitmq kafka este software de middleware de fila de mensagens.

confiar

<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>

caso:

produtos

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());
    }
}

Consumidor

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);
    }
}

ideia central

1.nameserver

NameServer é um registro de roteamento de tópico simples que suporta registro dinâmico e descoberta de tópicos e corretores.
Inclui principalmente duas funções:

• Gerenciamento do Broker, o NameServer aceita as informações de registro do cluster do Broker e as salva como os dados básicos das informações de roteamento. Em seguida, forneça um mecanismo de detecção de heartbeat para verificar se o Broker ainda está ativo;
• Gerenciamento de informações de roteamento, cada NameServer salvará todas as informações de roteamento sobre o cluster do Broker e informações de fila para consultas do cliente. Produtor e Consumidor podem conhecer as informações de roteamento de todo o cluster do Broker através do NameServer, de forma a entregar e consumir mensagens.

O NameServer geralmente possui várias instâncias implantadas e as instâncias não se comunicam entre si. O Broker registra suas próprias informações de roteamento com cada NameServer, de modo que cada instância do NameServer salva uma informação de roteamento completa. Quando um NameServer fica offline por algum motivo, o cliente ainda pode obter informações de roteamento de outros NameServers.

• Resumindo: o nameserver atua como um coordenador, quem usar a informação deve se registrar no nameserver, e quem quiser usar a informação cadastral deve ir até o nameserver para capturá-la de forma síncrona. O broker deve ser usado como um container rocketmq
  pelo código produtor e consumidor.

2.corretor

O Broker é o principal responsável pelo armazenamento, entrega e consulta de mensagens e pela garantia de alta disponibilidade dos serviços.

• O NameServer quase não possui nós de estado, portanto pode ser implantado em um cluster sem nenhuma sincronização de informações entre os nós. A implementação do agente é relativamente complexa.
• Na arquitetura Master-Slave, o Broker é dividido em Master e Slave. Um Master pode corresponder a vários Slaves, mas um Slave só pode corresponder a um Master. A relação correspondente entre Master e Slave é definida especificando o mesmo BrokerName e diferentes BrokerId. BrokerId é 0 para Master e diferente de zero para Slave. O mestre também pode implantar vários.

3. Fila de tópicos

• Entendimento simples, um tópico é uma coleção de uma classe de mensagens , e toda vez que enviamos uma mensagem, devemos especificar uma mensagem para vincular a um determinado tópico.

• Uma determinada mensagem enviada pelo produtor só pode apontar para um tópico, e várias mensagens podem apontar para o mesmo tópico. Existem várias filas de mensagens no mesmo tópico para armazenar mensagens, e o consumidor pode consumir mensagens de diferentes tópicos de acordo com os tópicos inscritos. Isso pode atingir o isolamento do negócio.

• Por exemplo, o tema do comércio eletrônico pode ser pedido, o tema também pode ser carrinho e também pode ser relacionado a produtos...

• Um tipo de mensagem, desde o formato dos dados até o formato do corpo, é completamente consistente. Não haverá " primeira mensagem " o corpo é uma string normal e a segunda mensagem é um objeto Json. É impossível para a primeira mensagem atrasar a mensagem (cancelamento da contagem regressiva da ordem de pagamento) e a segunda mensagem é uma mensagem síncrona normal.
  

4. fila fila

A entidade física (unidade mínima) para armazenar mensagens. Um Tópico pode conter múltiplas Filas (a chave para representação distribuída), e cada Fila armazena as mensagens do Tópico. Uma Fila de Tópico também é chamada de Partição** (Partição**) de mensagens em um Tópico.

Nota: As mensagens na Fila de um Tópico só podem ser consumidas por um consumidor em um grupo de consumidores (lógica do ponto de consumo). As mensagens em uma Fila não permitem que vários consumidores do mesmo grupo de consumidores consumam ao mesmo tempo.

5. Produtor

Pergunta: Através da compreensão dos conceitos acima, como os produtores, servidores de nomes e corretores interagem.

• Inicie o servidor de nomes para salvar as informações de roteamento do corretor
• Uma vez criado o tópico, salve-o no broker e gere uma fila ao mesmo tempo. Esses dados são salvos como informações de roteamento no servidor de nomes
• O produtor obtém as informações de registro (roteamento) do cluster atual do servidor de nomes
• Ao enviar uma mensagem, conecte-se ao broker específico para encontrar a fila específica do tópico específico para enviar a mensagem. As informações específicas usadas são refletidas no SendResult retornado

6. Agrupamento de consumidores e agrupamento de produtores

O produtor de mensagem é responsável por produzir mensagens. É essencialmente um pedaço de código no programa. O Produtor entrega a mensagem ao agente intermediário. Localiza o tópico, carrega o balanceamento e armazena-o na fila. Todos os produtores de mensagens no RocketMQ aparecem na forma de um grupo de produtores (Grupo de Produtores)
. Um grupo de produtores é uma coleção de produtores do mesmo tipo que geram mensagens do mesmo tipo e esses produtores enviam mensagens do mesmo tipo de tópico. Um grupo de produtores pode enviar mensagens para vários tópicos ao mesmo tempo.

Todos os consumidores de mensagens no RocketMQ aparecem na forma de grupos de consumidores (Grupo de consumidores). Um grupo de consumidores é uma coleção de consumidores do mesmo tipo, que consomem mensagens do mesmo tipo de tópico e correspondem ao mesmo tipo de dados de mensagem. O grupo de consumidores permite o balanceamento de carga (distribuindo uniformemente diferentes filas em um tópico para diferentes consumidores no mesmo grupo de consumidores) e tolerância a falhas (se um consumidor desligar, outros consumidores no grupo de consumidores podem continuar a executar a lógica de consumo .

Como há várias filas no tópico, um grupo de consumidores pode ter no máximo o mesmo número de membros consumidores da fila e não mais, é impossível ligar a fila para consumir mensagens.

7. Pontos de consumo

Todos os dados relacionados ao deslocamento são registrados na fila, como:

• Deslocamento mínimo: todos 0
• Offset máximo: o número de mensagens atuais

A compensação também é registrada no consumidor

• O offset mínimo de consumo da fila de tópicos correspondente ao grupo atual, e o offset máximo da fila (através destes dois valores é possível saber qual mensagem o consumidor atual consome e quanto fica sem consumir)
•