首页手记消息中间件底层原理教程：入门详解

消息中间件底层原理教程：入门详解

标签：

中间件

概述

本文档详细介绍了消息中间件的底层原理，涵盖了消息中间件的基本概念、应用场景、基本组件和消息传递模型等内容。文章还深入讲解了消息队列和主题的概念，并通过示例代码展示了消息中间件的安装与使用方法。本文档旨在帮助读者全面理解消息中间件底层原理。

引入消息中间件的概念

什么是消息中间件

消息中间件是一种软件基础设施，用于在分布式系统中实现应用间的消息传递。它提供了在不同应用程序、系统或服务之间进行通信的能力，无论它们是运行在同一网络上还是位于完全不同的网络中。消息中间件的核心作用是提供一种机制，使应用程序能够发送、接收和管理消息。

消息中间件通过提供一个标准的接口和协议来简化消息处理，使得开发者可以专注于应用程序的逻辑，而不需要关心底层通信细节。在分布式系统中，消息中间件能够帮助实现解耦、负载均衡、消息路由和协议转换等功能。

消息中间件的作用和应用场景

解耦应用

消息中间件通常用于实现应用间解耦，使得一个应用的变更不会直接影响到其他应用。例如，Web应用可能需要与多个后端服务通信，这些服务可能运行在不同的服务器上，使用不同的协议。通过引入消息中间件，Web应用可以将消息发送到消息队列，而后端服务可以从队列中获取消息进行处理。

负载均衡

消息中间件可以实现负载均衡，通过将消息分发到多个消费者，可以均衡地处理大量请求，提高系统的处理能力和响应速度。

消息路由和协议转换

消息中间件可以实现消息的路由，根据消息的类型或属性将消息路由到特定的消费者。此外，消息中间件还可以实现协议转换，将一种协议的消息转换为另一种协议的消息，从而使得不同系统之间能够相互通信。

异步处理

消息中间件支持异步处理，使得消息可以在不同时间点被处理。这对于需要长时间运行的任务或有延迟要求的系统非常有用。

容错和可靠性

消息中间件通常提供了内置的容错机制，如持久化消息、消息确认机制等，以确保消息的可靠传递。

消息队列和主题

消息队列和主题是消息中间件中的基本概念，用于实现消息的传递和消费。

应用场景实例

电子商务：订单处理、库存管理、支付系统等。
金融服务：证券交易、银行转账、保险理赔处理等。
日志收集和分析：日志的收集、传输、存储和分析。
实时分析：用户行为分析、实时监控等。

消息中间件的基本组件

消息中间件通常包含以下几个基本组件：

生产者和消费者

生产者（Producer）

生产者负责创建并发送消息到消息队列或主题。生产者可以是任何能够发送消息的应用程序或服务，通常负责将业务逻辑中的数据转换为消息格式，并将其发送到消息中间件。

消费者（Consumer）

消费者负责从消息队列或主题中接收并处理消息。消费者可以是任何能够接收并处理消息的应用程序或服务，通常负责从消息中间件中获取消息，并执行相应的业务逻辑。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class MessageProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列或主题）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, World!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;

public class MessageConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列或主题）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

消息队列和主题

消息队列（Queue）

消息队列是一种点对点（P2P）的消息模型。在队列中，每个消息只能被一个消费者消费一次。生产者将消息发送到队列，消费者从队列中获取并处理消息。队列通常用于处理顺序消息，确保消息按照发送顺序被消费。

消息主题（Topic）

消息主题是一种发布/订阅（Pub/Sub）的消息模型。在主题中，生产者发布消息到主题，多个消费者可以同时订阅并接收相同的消息。主题通常用于广播消息，实现多对多的消息传递。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（主题）
        javax.jms.Destination destination = session.createTopic("TestTopic");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, World!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;

public class TopicConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（主题）
        javax.jms.Destination destination = session.createTopic("TestTopic");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

消息路由和协议

消息路由

消息中间件通常支持多种路由策略，例如基于消息属性、基于消息内容、基于时间等。路由策略可以动态调整，以适应不同的业务需求。以下是一个简单的路由示例：

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class RouteMessage {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列或主题）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, Route Message!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

协议支持

消息中间件通常支持多种网络协议，如AMQP、MQTT、STOMP等，以确保能够与各种系统进行通信。以下是一个支持多种协议的示例：

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class ProtocolSupport {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列或主题）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, Protocol Support!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

消息传递模型详解

点对点模型（P2P）

概述

点对点（P2P）模型是一种典型的队列模型，每个消息只能被一个消费者消费。P2P模型的特点是消息的顺序性和唯一性，确保每个消息只能被一个消费者处理一次。

P2P模型的特点

顺序性：消息按照发送顺序被消费。
唯一性：每个消息只能被一个消费者消费。
持久性：消息可以持久化存储，确保消息不会丢失。
负载均衡：消息可以被多个消费者消费，实现负载均衡。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class P2PProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, P2P!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;

public class P2PConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

发布/订阅模型（Pub/Sub）

概述

发布/订阅（Pub/Sub）模型是一种主题模型，生产者发布消息到主题，多个消费者可以同时订阅并接收相同的消息。Pub/Sub模型的特点是广播消息，实现多对多的消息传递。

Pub/Sub模型的特点

广播性：消息可以被多个消费者消费。
主题：消息发布到主题，消费者订阅主题。
灵活性：可以根据需要订阅或取消订阅主题。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class PubProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（主题）
        javax.jms.Destination destination = session.createTopic("TestTopic");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, Pub/Sub!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;

public class PubConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（主题）
        javax.jms.Destination destination = session.createTopic("TestTopic");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

消息中间件的核心概念

持久化消息

持久化消息是指消息在消息中间件中保存在持久化存储中，即使在系统异常或重启后，消息仍然能够被恢复和处理。持久化消息通常用于关键业务场景，确保消息不会丢失。

持久化消息的特点

可靠性：确保消息不会丢失。
持久化存储：消息存储在持久化存储中。
系统异常恢复：在系统异常或重启后，消息仍然能够被处理。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class PersistentProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(true, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, Persistent!");
        producer.send(message);

        // 提交事务
        session.commit();

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

持久化消息的配置

在某些消息中间件中，持久化消息可以通过配置文件进行设置，例如在ActiveMQ中可以通过修改activemq.xml文件来设置队列的持久化属性。

<bean id="defaultQueue" class="org.apache.activemq.command.ActiveMQQueue">
    <property name="physicalName" value="TestQueue"/>
</bean>

<bean id="persistenceAdapter" class="org.apache.activemq.store.amq.AMQPersistenceAdapter">
    <property name="directory" value="${activemq.data}/amq"/>
</bean>

<bean id="transportConnectors" class="org.apache.activemq.camel.component.ActiveMQComponent">
    <property name="brokerURL" value="tcp://localhost:61616"/>
</bean>

消息确认机制

消息确认机制是一种确保消息可靠传递的机制。在消息被消费者成功处理后，消费者向消息中间件发送确认消息，以告知消息已经被成功处理。如果消息没有被确认，消息中间件将重新发送消息，直到收到确认消息为止。

消息确认机制的特点

可靠性：确保消息被消费者成功处理。
重试机制：如果消息没有被确认，消息中间件将重新发送消息。
消费者确认：消费者向消息中间件发送确认消息。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class AcknowledgingConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(true, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
                // 确认消息
                message.acknowledge();
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

事务管理

事务管理是一种确保消息可靠传递的机制。事务管理可以确保消息的发送和接收操作在同一个事务中进行，如果事务失败，消息将被回滚，以确保消息的完整性。

事务管理的特点

事务性：确保消息的发送和接收操作在同一个事务中进行。
事务回滚：如果事务失败，消息将被回滚。
事务提交：如果事务成功，消息将被提交。

示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class TransactionalProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(true, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, Transaction!");
        producer.send(message);

        // 提交事务
        session.commit();

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

常见消息中间件介绍

消息中间件有多种实现，每种实现都有其特点和适用场景。下面介绍几种常见的消息中间件：

RabbitMQ

RabbitMQ 是一个基于AMQP协议的开源消息代理实现。它支持多种消息模型，包括点对点（P2P）、发布/订阅（Pub/Sub）等。RabbitMQ 具有良好的可扩展性、可靠性和灵活性，广泛应用于各种业务场景中。

RabbitMQ 特点

AMQP 协议：支持AMQP协议，可以与其他支持AMQP协议的系统进行通信。
高可用性：支持集群模式，实现高可用性。
消息持久化：支持持久化消息，确保消息不会丢失。
消息确认机制：支持消息确认机制，确保消息被可靠处理。
多种消息模型：支持点对点（P2P）、发布/订阅（Pub/Sub）等多种消息模型。

RabbitMQ 安装和使用示例

安装 RabbitMQ

在Ubuntu上安装RabbitMQ：

sudo apt-get update
sudo apt-get install rabbitmq-server

启动 RabbitMQ 服务：

sudo systemctl start rabbitmq-server

使用 RabbitMQ 示例代码

Java 示例代码

import com.rabbitmq.client.*;

public class RabbitProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        // 创建连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        String queueName = "TestQueue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 发送消息
        String message = "Hello, RabbitMQ!";
        channel.basicPublish("", queueName, null, message.getBytes("UTF-8"));

        // 关闭资源
        channel.close();
        connection.close();
    }
}

import com.rabbitmq.client.*;

public class RabbitConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        // 创建连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        String queueName = "TestQueue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 创建消费者
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Received message: " + message);
        };

        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
    }
}

Apache Kafka

Apache Kafka 是一个高吞吐量、分布式、基于发布/订阅的消息系统。Kafka 由 LinkedIn 开发并开源，现在由 Apache 孵化。Kafka 主要用于实时数据流处理，支持高并发、高可用性、分布式部署。

Kafka 特点

高吞吐量：支持高吞吐量的消息处理。
分布式部署：支持分布式部署，实现高可用性。
持久化消息：支持持久化消息，确保消息不会丢失。
消息路由：支持多种消息路由策略，实现灵活的消息传递。
广泛的应用：广泛应用于大数据处理、实时分析、日志收集等场景。

Kafka 安装和使用示例

安装 Kafka

在Ubuntu上安装Kafka：

sudo apt-get update
sudo apt-get install kafka

启动 Kafka 服务：

bin/zookeeper-server-start.sh config/zookeeper.properties
bin/kafka-server-start.sh config/server.properties

使用 Kafka 示例代码

Java 示例代码

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<>("TestTopic", "key", "Hello, Kafka!"));
        producer.close();
    }
}

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

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

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("TestTopic"));

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

ActiveMQ

ActiveMQ 是一个基于Java的消息代理实现，支持多种消息模型，包括点对点（P2P）、发布/订阅（Pub/Sub）等。ActiveMQ 支持多种协议，包括AMQP、MQTT、STOMP等，具有良好的可扩展性和灵活性。

ActiveMQ 特点

多种消息模型：支持点对点（P2P）、发布/订阅（Pub/Sub）等多种消息模型。
多种协议支持：支持多种协议，包括AMQP、MQTT、STOMP等。
高可靠性：支持持久化消息，确保消息不会丢失。
消息确认机制：支持消息确认机制，确保消息被可靠处理。
易用性：提供丰富的API和配置选项，易于使用和集成。

ActiveMQ 安装和使用示例

安装 ActiveMQ

在Ubuntu上安装ActiveMQ：

sudo apt-get update
sudo apt-get install activemq

启动 ActiveMQ 服务：

sudo systemctl start activemq

使用 ActiveMQ 示例代码

Java 示例代码

import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息生产者
        javax.jms.MessageProducer producer = session.createProducer(destination);

        // 创建并发送消息
        javax.jms.TextMessage message = session.createTextMessage("Hello, ActiveMQ!");
        producer.send(message);

        // 关闭资源
        producer.close();
        session.close();
        connection.close();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;

public class ActiveMQConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");

        // 创建连接
        javax.jms.Connection connection = connectionFactory.createConnection();
        connection.start();

        // 创建会话
        javax.jms.Session session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);

        // 创建目标（队列）
        javax.jms.Destination destination = session.createQueue("TestQueue");

        // 创建消息消费者
        javax.jms.MessageConsumer consumer = session.createConsumer(destination);

        // 接收并处理消息
        consumer.setMessageListener(message -> {
            try {
                System.out.println("Received message: " + ((javax.jms.TextMessage) message).getText());
            } catch (javax.jms.JMSException e) {
                e.printStackTrace();
            }
        });

        // 关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

消息中间件的安装与使用入门

消息中间件的安装步骤通常包括下载安装包、配置环境变量、启动服务等步骤。不同消息中间件的具体安装步骤可能会有所不同，下面以RabbitMQ为例介绍安装和配置的基本步骤。

安装指南

操作系统要求

RabbitMQ 支持多种操作系统，包括Linux、Windows、macOS等。本文档以Ubuntu操作系统为例介绍安装步骤。

下载安装包

在Ubuntu系统上，可以通过APT包管理器直接安装RabbitMQ：

sudo apt-get update
sudo apt-get install rabbitmq-server

启动服务

安装完成后，可以通过以下命令启动RabbitMQ服务：

sudo systemctl start rabbitmq-server

验证安装

可以通过以下命令验证RabbitMQ服务是否启动成功：

sudo systemctl status rabbitmq-server

配置环境变量

RabbitMQ通过配置环境变量来设置各种参数，如连接地址、用户名、密码等。可以通过编辑配置文件来设置这些参数，例如在Ubuntu系统中，可以在/etc/rabbitmq/rabbitmq-env.conf文件中设置环境变量。

RABBITMQ_NODE_PORT=5672
RABBITMQ_NODENAME=rabbit@localhost
RABBITMQ_DEFAULT_USER=admin
RABBITMQ_DEFAULT_PASS=admin

配置队列和主题

可以使用RabbitMQ提供的管理界面或命令行工具来配置队列和主题。例如，可以通过以下命令创建一个队列：

rabbitmqadmin declare queue name=TestQueue durable=true

基本配置和使用

在实际应用中，通常需要配置生产者和消费者的配置参数，例如连接地址、用户名、密码等。可以通过编辑配置文件或使用编程语言提供的API来配置这些参数。

示例代码

Java 示例代码

import com.rabbitmq.client.*;

public class RabbitProducer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setUsername("admin");
        factory.setPassword("admin");

        // 创建连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        String queueName = "TestQueue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 发送消息
        String message = "Hello, RabbitMQ!";
        channel.basicPublish("", queueName, null, message.getBytes("UTF-8"));

        // 关闭资源
        channel.close();
        connection.close();
    }
}

import com.rabbitmq.client.*;

public class RabbitConsumer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setUsername("admin");
        factory.setPassword("admin");

        // 创建连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明队列
        String queueName = "TestQueue";
        channel.queueDeclare(queueName, true, false, false, null);

        // 创建消费者
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Received message: " + message);
        };

        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
    }
}

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

倚天杖

手记
篇

粉丝

47

获赞与收藏

187

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

消息中间件底层原理教程：入门详解

解耦应用

负载均衡

消息路由和协议转换

异步处理

容错和可靠性

消息队列和主题

应用场景实例

生产者（Producer）

消费者（Consumer）

示例代码

消息队列（Queue）

消息主题（Topic）

示例代码

消息路由

协议支持

概述

P2P模型的特点

示例代码

概述

Pub/Sub模型的特点

示例代码

持久化消息的特点

示例代码

持久化消息的配置

消息确认机制的特点

示例代码

事务管理的特点

示例代码

RabbitMQ 特点

RabbitMQ 安装和使用示例

Kafka 特点

Kafka 安装和使用示例

ActiveMQ 特点

ActiveMQ 安装和使用示例

操作系统要求

下载安装包

启动服务

验证安装

配置环境变量

配置队列和主题

基本配置和使用

示例代码

阅读免费教程