首页手记 MQ消息队列入门详解：轻松掌握消息队列基础

MQ消息队列入门详解：轻松掌握消息队列基础

标签：

中间件

概述

MQ消息队列是一种软件系统，用于在不同应用程序或组件之间异步传递和分发消息。它提供了可靠的消息传递服务，支持多种消息传递协议，确保跨平台和跨语言的兼容性。MQ消息队列在系统解耦、异步处理和削峰填谷等方面发挥着重要作用，同时具备高可用性和可扩展性。

MQ消息队列简介

1.1 什么是MQ消息队列

MQ消息队列是一种软件系统，用于在不同应用程序或组件之间异步传递和分发消息。它提供了可靠的消息传递服务，允许发送方和接收方在不直接连接的情况下进行通信。MQ消息队列支持多种消息传递协议，如AMQP、JMS、Kafka协议等，以确保跨平台和跨语言的兼容性。

1.2 MQ消息队列的作用和优势

作用

解耦：消息队列允许应用程序之间解耦，这意味着一个系统的变化不会直接影响到其他系统。
异步处理：通过引入消息队列，可以将请求解耦，从而实现异步处理。这样可以提高系统的响应速度和吞吐量。
削峰填谷：在高峰期处理大量请求时，消息队列可以存储多余请求，然后在低谷期逐步处理。
可靠传输：消息队列提供多种机制来确保消息的可靠传输，包括确认机制和重试机制。

优势

高可用性：通过集群和冗余机制，可以保证系统的高可用性。
可扩展性：消息队列支持水平扩展，可以轻松地添加更多的节点来处理更多的请求。
灵活性：消息队列可以支持多种消息传递协议，使得不同系统之间可以灵活地进行通信。
数据持久化：消息队列提供了数据持久化功能，确保消息不会因为系统故障而丢失。

MQ消息队列的工作原理

2.1 消息的发送与接收流程

消息发送与接收的流程如下：

发送方将消息发送到消息队列。
消息队列接收并存储消息。
消费者从消息队列中接收消息并进行处理。
消息确认：消费者处理完消息后，发送确认消息给消息队列，消息队列根据确认机制进行相应的处理。

2.1.1 发送消息

发送消息时，发送方需要创建一个消息对象，设置消息体和消息类型，然后将消息发送到指定的消息队列。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')

print(" [x] Sent 'Hello World!'")
connection.close()

2.1.2 接收消息

接收消息时，消费者需要从消息队列中获取消息，并处理消息体。然后根据消息队列的确认机制发送确认消息，确认消息已经被处理。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

2.2 消息队列的组成元素

2.2.1 消息对象

消息对象是消息队列的基本单元，它包含两部分：

消息体：实际的数据内容。
消息属性：包含消息的元数据，如消息的类型、优先级、过期时间等。

2.2.2 消息队列

消息队列是一个数据结构，用于存储多个消息对象。消息队列可以支持多种队列类型，如点对点队列（P2P）和发布/订阅队列（Pub/Sub）。

2.2.3 发送者

发送者是发送消息的客户端或应用，它可以将消息直接发送到消息队列。

2.2.4 接收者

接收者是消费消息的客户端或应用，它可以从前端队列中获取消息并进行处理。

2.2.5 中间件

消息队列通常由中间件支持，中间件负责消息的传递、路由和存储。常见的消息队列中间件包括RabbitMQ、Kafka、ActiveMQ等。

MQ消息队列的常见类型

3.1 Apache Kafka

Apache Kafka是一个分布式流处理平台，它既可以用于实时分析，也可以作为消息队列使用。

3.1.1 Kafka的特点

高吞吐量：Kafka设计用于处理大量数据流，每秒可以处理数百万条消息。
持久化：Kafka可以将消息持久化到磁盘，确保数据不会丢失。
分布式：Kafka支持分布式部署，可以扩展到多台机器上。
可靠性：Kafka提供了消息的可靠传递机制，包括消息的确认机制。

3.1.2 Kafka的架构

Kafka集群由多个节点（Broker）组成，每个节点可以运行在不同的机器上。每个节点可以管理多个主题（Topic），每个主题可以由多个分区（Partition）组成。消费者可以根据需要读取一个或多个分区的消息。

3.1.3 Kafka的使用场景

日志聚合：Kafka可以实时聚合和存储日志数据。
实时分析：Kafka可以用于实时分析，如实时监控、实时推荐等。
流处理：Kafka可以用于流处理，如数据流处理、实时计算等。

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("my-topic", "key", "value"));
        producer.close();
    }
}

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("my-topic"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            consumer.commitSync();
        }
    }
}

3.2 RabbitMQ

RabbitMQ是一个基于AMQP协议的消息队列实现，它支持多种消息传递模式，并提供了一系列可靠的特性来确保消息的传递。

3.2.1 RabbitMQ的特点

多语言支持：RabbitMQ支持多种编程语言，如Java、Python、C等。
灵活的消息路由：RabbitMQ支持多种消息路由模式，如点对点、发布/订阅等。
可靠的消息传递：RabbitMQ提供了消息的持久化、确认机制和重试机制。
高可用性：RabbitMQ支持集群和镜像队列，可以保证系统的高可用性。

3.2.2 RabbitMQ的架构

RabbitMQ由多个节点（Node）组成，每个节点可以运行在不同的机器上。每个节点可以管理多个队列（Queue），每个队列可以由多个交换机（Exchange）组成。生产者和消费者可以连接到不同的节点上。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')

print(" [x] Sent 'Hello World!'")
connection.close()

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

3.3 ActiveMQ

ActiveMQ是一个基于JMS规范的消息队列实现，它支持多种消息传递模式，并提供了一系列可靠性和安全性特性。

3.3.1 ActiveMQ的特点

安全性：ActiveMQ提供了多种安全特性，如身份验证、授权、消息加密等。
持久化：ActiveMQ提供了消息的持久化存储，确保消息不会丢失。
集群支持：ActiveMQ支持集群部署，可以实现负载均衡和故障转移。
扩展性：ActiveMQ支持水平扩展，可以轻松地添加更多的节点来处理更多的请求。

3.3.2 ActiveMQ的架构

ActiveMQ由多个节点（Broker）组成，每个节点可以运行在不同的机器上。每个节点可以管理多个队列（Queue），每个队列可以由多个主题（Topic）组成。生产者和消费者可以连接到不同的节点上。

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQProducer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageProducer producer = session.createProducer(queue);
        TextMessage message = session.createTextMessage("Hello World!");
        producer.send(message);
        session.close();
        connection.close();
    }
}

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQConsumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageConsumer consumer = session.createConsumer(queue);
        TextMessage message = (TextMessage) consumer.receive();
        System.out.println("Received: " + message.getText());
        session.close();
        connection.close();
    }
}

MQ消息队列的安装与配置

4.1 下载与安装MQ消息队列

安装MQ消息队列的步骤如下：

下载软件包：根据MQ消息队列的类型选择合适的安装包，如RabbitMQ、Kafka、ActiveMQ等。
解压安装包：将安装包解压到指定的目录。
配置环境变量：根据MQ消息队列的要求配置环境变量，如设置JAVA_HOME、KAFKA_HOME等。
启动服务：根据MQ消息队列的要求启动服务，如执行bin/rabbitmq-server、bin/kafka-server-start.sh等。

示例：RabbitMQ的安装

安装RabbitMQ的步骤如下：

下载RabbitMQ：

wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.10.1/rabbitmq-server_3.10.1-1_all.deb

安装RabbitMQ：

sudo dpkg -i rabbitmq-server_3.10.1-1_all.deb

启动RabbitMQ：
```
sudo service rabbitmq-server start
```

示例：Kafka的安装

wget https://downloads.apache.org/kafka/2.8.0/kafka_2.13-2.8.0.tgz
tar -xzf kafka_2.13-2.8.0.tgz
cd kafka_2.13-2.8.0
bin/zookeeper-server-start.sh config/zookeeper.properties &
bin/kafka-server-start.sh config/server.properties

示例：ActiveMQ的安装

wget http://archive.apache.org/dist/activemq/5.16.0/apache-activemq-5.16.0-bin.tar.gz
tar -xzf apache-activemq-5.16.0-bin.tar.gz
cd apache-activemq-5.16.0
bin/activemq start

4.2 基本配置与启动服务

4.2.1 RabbitMQ配置

RabbitMQ可以通过配置文件或命令行参数进行配置。配置文件通常位于/etc/rabbitmq/目录下，如rabbitmq.conf。

# 管理插件
plugins.rabbitmq_management = enabled

# 集群设置
cluster_formation.node_type = disc
cluster_formation.type = multicast
cluster_formation.node_port = 25672
cluster_formation.autodiscovery_address = 192.168.1.100

# 网络设置
networking.tcp_listen = 0.0.0.0:5672
networking.ssl_listen = 0.0.0.0:5671

4.2.2 Kafka配置

Kafka可以通过配置文件进行配置。配置文件通常位于<KAFKA_HOME>/config目录下，如server.properties。

# Kafka集群设置
listeners=PLAINTEXT://:9092

# 日志设置
log.dirs=/var/log/kafka

# 日志保留设置
log.retention.hours=168
log.retention.check.interval.ms=300000

4.2.3 ActiveMQ配置

ActiveMQ可以通过XML配置文件进行配置。配置文件通常位于<ACTIVEMQ_HOME>/conf目录下，如activemq.xml。

<beans xmlns="http://activemq.apache.org/schema/core">
    <broker xmlns="http://activemq.apache.org/schema/core">
        <transportConnectors>
            <transportConnector uri="tcp://0.0.0.0:61616"/>
        </transportConnectors>
    </broker>
</beans>

MQ消息队列的基本操作

5.1 发送消息

发送消息是消息队列中最基本的操作之一，通过发送消息可以将数据发送到消息队列中。

5.1.1 RabbitMQ发送消息

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')

print(" [x] Sent 'Hello World!'")
connection.close()

5.1.2 Kafka发送消息

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("my-topic", "key", "value"));
        producer.close();
    }
}

5.1.3 ActiveMQ发送消息

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQProducer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageProducer producer = session.createProducer(queue);
        TextMessage message = session.createTextMessage("Hello World!");
        producer.send(message);
        session.close();
        connection.close();
    }
}

5.2 接收消息

接收消息是消息队列中最基本的操作之一，通过接收消息可以消费消息队列中的数据。

5.2.1 RabbitMQ接收消息

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

5.2.2 Kafka接收消息

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("my-topic"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
        }
    }
}

5.2.3 ActiveMQ接收消息

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQConsumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageConsumer consumer = session.createConsumer(queue);
        TextMessage message = (TextMessage) consumer.receive();
        System.out.println("Received: " + message.getText());
        session.close();
        connection.close();
    }
}

5.3 消息确认机制

消息确认机制用于保证消息的可靠性传递。发送方发送消息后，接收方需要确认消息已经被正确处理，然后发送确认消息给发送方。如果接收方没有发送确认消息，发送方会重新发送消息。

5.3.1 RabbitMQ确认机制

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='hello', on_message_callback=callback)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

5.3.2 Kafka确认机制

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("my-topic"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            consumer.commitSync();
        }
    }
}

5.3.3 ActiveMQ确认机制

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQConsumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageConsumer consumer = session.createConsumer(queue);
        TextMessage message = (TextMessage) consumer.receive();
        System.out.println("Received: " + message.getText());
        session.commit();
        session.close();
        connection.close();
    }
}

实践案例与常见问题

6.1 MQ消息队列的应用场景示例

6.1.1 实时日志聚合

使用Kafka可以实时聚合和存储日志数据。日志数据可以由多个日志生成器生成，然后通过Kafka进行聚合和存储。

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class LogProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("logs", "key", "log message"));
        producer.close();
    }
}

6.1.2 异步通信

使用RabbitMQ可以实现系统的异步通信。发送方和接收方可以通过消息队列进行异步通信，以解耦系统组件。

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='async_communication')

channel.basic_publish(exchange='',
                      routing_key='async_communication',
                      body='Async message')

connection.close()

6.1.3 任务队列

使用ActiveMQ可以实现任务队列。任务队列可以用于处理批量任务或定时任务。

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class TaskProducer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("task");
        MessageProducer producer = session.createProducer(queue);
        TextMessage message = session.createTextMessage("Task message");
        producer.send(message);
        session.close();
        connection.close();
    }
}

6.2 常见问题及解决方法

6.2.1 消息丢失

原因

消息队列配置不当：如消息队列没有启用持久化或没有设置适当的确认机制。
消息队列故障：如消息队列服务异常或网络故障导致消息丢失。

解决方法

启用消息持久化：确保消息队列支持消息的持久化存储。
设置消息确认机制：确保消息队列支持消息的确认机制。

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("my-topic"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            consumer.commitSync();
        }
    }
}

6.2.2 消息重复

原因

消息确认机制失败：如消息队列没有正确处理消息的确认机制，导致消息重复发送。
消费者处理失败：如消费者处理消息时失败，导致消息重新发送。

解决方法

实现幂等性：确保消费者处理消息时具有幂等性，即使消息重复发送也不会影响结果。
设置重试机制：确保消息队列支持消息的重试机制，当消息处理失败时可以重新发送。

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQConsumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue("queue");
        MessageConsumer consumer = session.createConsumer(queue);
        TextMessage message = (TextMessage) consumer.receive();
        System.out.println("Received: " + message.getText());
        session.commit();
        session.close();
        connection.close();
    }
}

6.2.3 性能问题

原因

消息队列配置不当：如消息队列没有配置适当的性能参数，如线程池大小、消息队列大小等。
网络延迟：如网络延迟过高，影响消息的传递速度。

解决方法

优化配置参数：确保消息队列配置参数适当，如增加线程池大小、增加消息队列大小等。
优化网络环境：确保网络环境良好，如减少网络延迟等。

6.2.4 消息延迟

原因

消息队列配置不当：如消息队列没有配置适当的延迟参数，如消息队列的过期时间等。
系统负载过高：如系统负载过高，影响消息的处理速度。

解决方法

优化配置参数：确保消息队列配置参数适当，如设置合适的消息队列过期时间等。
优化系统负载：确保系统负载适当，如优化系统资源分配等。

6.2.5 消息队列不可用

原因

消息队列服务异常：如消息队列服务挂掉或网络连接异常等。
消息队列配置不当：如消息队列没有配置适当的启动参数，导致无法启动服务。

解决方法

检查服务状态：确保消息队列服务正常启动并运行。
检查配置文件：确保消息队列配置文件正确无误，如配置文件中的节点地址、端口等。
重启服务：如果服务异常，重启服务可以恢复消息队列的可用性。
集群部署：如果单节点消息队列不可用，可以考虑部署消息队列集群以增强系统的可用性。
监控系统状态：通过监控系统状态，及时发现并解决问题，以保证消息队列的稳定运行。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

炎炎设计

手记
篇

粉丝

74

获赞与收藏

371

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

MQ消息队列入门详解：轻松掌握消息队列基础

作用

优势

2.1.1 发送消息

2.1.2 接收消息

2.2.1 消息对象

2.2.2 消息队列

2.2.3 发送者

2.2.4 接收者

2.2.5 中间件

3.1.1 Kafka的特点

3.1.2 Kafka的架构

3.1.3 Kafka的使用场景

3.2.1 RabbitMQ的特点

3.2.2 RabbitMQ的架构

3.3.1 ActiveMQ的特点

3.3.2 ActiveMQ的架构

示例：RabbitMQ的安装

示例：Kafka的安装

示例：ActiveMQ的安装

4.2.1 RabbitMQ配置

4.2.2 Kafka配置

4.2.3 ActiveMQ配置

5.1.1 RabbitMQ发送消息

5.1.2 Kafka发送消息

5.1.3 ActiveMQ发送消息

5.2.1 RabbitMQ接收消息

5.2.2 Kafka接收消息

5.2.3 ActiveMQ接收消息

5.3.1 RabbitMQ确认机制

5.3.2 Kafka确认机制

5.3.3 ActiveMQ确认机制

6.1.1 实时日志聚合

6.1.2 异步通信

6.1.3 任务队列

6.2.1 消息丢失

原因

解决方法

6.2.2 消息重复

原因

解决方法

6.2.3 性能问题

原因

解决方法

6.2.4 消息延迟

原因

解决方法

6.2.5 消息队列不可用

原因

解决方法

阅读免费教程