18、企业级服务-JMS

Java Message Service (JMS)

---

一. 引言

Java Message Service (JMS) 是 Java 平台上用于实现消息oriented middleware（消息中间件）的标准API。它为企业级应用中的异步通信提供了一种高效、灵活且可靠的方式，允许不同的系统组件之间通过发送和接收消息进行通信，而无需直接依赖彼此的实现细节。JMS支持两种主要的消息模型：点对点（Point-to-Point，基于队列）和发布-订阅（Publish-Subscribe，基于主题）。在本讲义中，我们将详细探讨JMS的核心概念，包括消息队列、主题、生产者与消费者模式，并通过实践实现一个异步消息通信的示例。

---

二. JMS 概念

JMS是Java EE的一部分，主要用于在分布式系统中实现异步消息传递。通过JMS，应用程序可以以松耦合的方式交互，提高系统的响应能力和容错性。以下是JMS的一些关键概念：

• 消息：信息的载体，可以是文本、对象、字节流等。
• 消息代理：负责处理和路由消息的中间件，如ActiveMQ、IBM MQ等。
• 生产者：发送消息的应用程序或组件。
• 消费者：接收并处理消息的应用程序或组件。
• Destination：消息的目的地，可以是队列（Queue）或主题（Topic）。
• 会话：定义了消息的发送和接收的上下文。
• 连接工厂：用于创建连接到消息代理的连接。

---

三. 消息队列与主题

JMS支持两种主要的消息目标：队列和主题。它们的主要区别在于消息的分发方式和使用场景。

1、 消息队列（Queue）

• 定义：消息队列是点对点（Point-to-Point）的通信模型。消息被发送到一个特定的队列，消费者从该队列中接收消息。
• 特点：
  • 一次性消费：一条消息只能被一个消费者接收。
  • 持久化：支持消息持久化，确保消息在传输过程中不丢失。
  • FIFO顺序：消息按发送顺序被消费。
• 适用场景：
  • 单播通信，例如订单处理流程。
  • 需要保证消息可靠性和顺序性的场景。

案例：在一个在线购物系统中，订单消息被发送到一个队列，订单处理系统从队列中取出订单进行处理。

2、 主题（Topic）

• 定义：主题是基于发布-订阅（Publish-Subscribe）的消息模型。生产者发送消息到主题，多个消费者可以订阅该主题并接收消息。
• 特点：
  • 一条消息可以被多个消费者接收。
  • 支持广播或选择性过滤消息分发。
  • 消费者只能接收其订阅时存在的消息。
• 适用场景：
  • 广播信息，如系统公告、新闻推送。
  • 需要实时数据分发的场景，如股票行情、实时更新。

案例：在一个新闻平台中，新闻文章被发布到一个主题，多个移动应用订阅该主题并接收最新的新闻推送。

---

四. JMS 生产者与消费者模式

在JMS中，生产者和消费者是核心的角色，共同构成了异步消息传递的基本模式。

1、 生产者（Producer）

• 角色：负责创建和发送消息到目标Destination（队列或主题）。
• 实现步骤：
  1. 获取连接工厂，并创建连接。
  2. 创建会话。
  3. 创建消息Destination（队列或主题）。
  4. 创建消息，填充内容。
  5. 通过消息生产者发送消息。
  6. 关闭资源。

示例代码：发送消息到队列

import jakarta.jms.*;  

public class MessageProducer {  
    public static void main(String[] args) {  
        ConnectionFactory connectionFactory = null;  
        Connection connection = null;  
        Session session = null;  
        MessageProducer producer = null;  
        Queue queue = null;  

        try {  
            Context context = new InitialContext();  
            connectionFactory = (ConnectionFactory) context.lookup("jms/ConnectionFactory");  
            queue = (Queue) context.lookup("jms/MyQueue");  

            connection = connectionFactory.createConnection();  
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
            producer = session.createProducer(queue);  

            TextMessage message = session.createTextMessage("Hello, JMS!");  
            producer.send(message);  
            System.out.println("消息已发送。");  
        } catch (JMSException | NamingException e) {  
            e.printStackTrace();  
        } finally {  
            try {  
                if (producer != null) producer.close();  
                if (session != null) session.close();  
                if (connection != null) connection.close();  
            } catch (JMSException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

2、 消费者（Consumer）

• 角色：负责接收并处理来自Destination的消息。
• 实现步骤：
  1. 获取连接工厂，并创建连接。
  2. 创建会话。
  3. 获取消息Destination（队列或主题）。
  4. 创建消息消费者。
     5.侦听消息，并在消息到达时处理。
  5. 关闭资源。

示例代码：从队列接收消息

import jakarta.jms.*;  

public class MessageConsumer {  
    public static void main(String[] args) {  
        ConnectionFactory connectionFactory = null;  
        Connection connection = null;  
        Session session = null;  
        Queue queue = null;  
        MessageConsumer consumer = null;  

        try {  
            Context context = new InitialContext();  
            connectionFactory = (ConnectionFactory) context.lookup("jms/ConnectionFactory");  
            queue = (Queue) context.lookup("jms/MyQueue");  

            connection = connectionFactory.createConnection();  
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  
            consumer = session.createConsumer(queue);  

            // 异步接收消息  
            consumer.setMessageListener(new MessageListener() {  
                @Override  
                public void onMessage(Message message) {  
                    if (message instanceof TextMessage) {  
                        try {  
                            String text = ((TextMessage) message).getText();  
                            System.out.println("接收到消息：" + text);  
                        } catch (JMSException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                }  
            });  

            System.out.println("等待接收消息...");  
            connection.start();  
        } catch (JMSException | NamingException e) {  
            e.printStackTrace();  
        } finally {  
            try {  
                if (consumer != null) consumer.close();  
                if (session != null) session.close();  
                if (connection != null) connection.close();  
            } catch (JMSException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

---

五. 实践：实现异步消息通信

在本节中，我们将通过一个实践示例，展示如何使用JMS实现异步消息通信。这个示例包括以下步骤：

1. 设置消息代理：安装和配置ActiveMQ。
2. 创建JMS客户端项目：创建一个Maven项目并添加必要的依赖。
3. 实现消息生产者：编写一个Java类发送消息到队列。
4. 实现消息消费者：编写一个Java类接收并处理队列中的消息。
5. 运行和测试：启动消息代理，运行生产者和消费者，验证消息传递过程。

1、 环境设置

• 安装ActiveMQ：
  1. 从官网下载并安装ActiveMQ。
  2. 配置运行环境，如设置用户名和密码。
  3. 启动ActiveMQ服务器。
• 创建Maven项目：
  1. 使用IDE或Maven命令创建一个新项目。
  2. 在pom.xml中添加JMS和ActiveMQ的依赖。

示例pom.xml依赖：

<dependencies>  
    <dependency>  
        <groupId>jakarta.jmsgroupId>  
        <artifactId>jakarta.jms-apiartifactId>  
        <version>3.1.0version>  
    dependency>  
    <dependency>  
        <groupId>org.apache.activemqgroupId>  
        <artifactId>activemq-brokerartifactId>  
        <version>5.17.3version>  
    dependency>  
    <dependency>  
        <groupId>org.apache.activemqgroupId>  
        <artifactId>activemq-clientartifactId>  
        <version>5.17.3version>  
    dependency>  
dependencies>  

2、 实现消息生产者

编写一个Java类，使用JMS API向ActiveMQ的队列发送消息。

import jakarta.jms.*;  

import javax.naming.Context;  
import javax.naming.InitialContext;  
import java.util.Properties;  

public class MessageProducer {  
    public static void main(String[] args) {  
        // 配置ActiveMQ连接工厂  
        Properties properties = new Properties();  
        properties.setProperty(Context.INITIAL_CONTEXT_FACTORY,  
                "org.apache.activemq.jndi.ActiveMQInitialContextFactory");  
        properties.setProperty(Context.PROVIDER_URL, "tcp://localhost:61616");  

        try {  
            // 获取JNDI上下文  
            Context context = new InitialContext(properties);  

            // 查找连接工厂和队列  
            ConnectionFactory connectionFactory =  
                    (ConnectionFactory) context.lookup("ConnectionFactory");  
            Queue queue = (Queue) context.lookup("MyQueue");  

            // 创建连接和会话  
            Connection connection = connectionFactory.createConnection();  
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  

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

            // 创建和发送消息  
            TextMessage message = session.createTextMessage("您好，JMS！");  
            producer.send(message);  
            System.out.println("消息已发送。");  

            // 关闭资源  
            producer.close();  
            session.close();  
            connection.close();  
        } catch (JMSException | javax.naming.NamingException e) {  
            e.printStackTrace();  
        }  
    }  
}  

3、 实现消息消费者

编写一个Java类，从ActiveMQ的队列中异步接收和处理消息。

import jakarta.jms.*;  

import javax.naming.Context;  
import javax.naming.InitialContext;  
import java.util.Properties;  

public class MessageConsumer {  
    public static void main(String[] args) {  
        // 配置ActiveMQ连接工厂  
        Properties properties = new Properties();  
        properties.setProperty(Context.INITIAL_CONTEXT_FACTORY,  
                "org.apache.activemq.jndi.ActiveMQInitialContextFactory");  
        properties.setProperty(Context.PROVIDER_URL, "tcp://localhost:61616");  

        try {  
            // 获取JNDI上下文  
            Context context = new InitialContext(properties);  

            // 查找连接工厂和队列  
            ConnectionFactory connectionFactory =  
                    (ConnectionFactory) context.lookup("ConnectionFactory");  
            Queue queue = (Queue) context.lookup("MyQueue");  

            // 创建连接和会话  
            Connection connection = connectionFactory.createConnection();  
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  

            // 创建消息消费者并设置监听器  
            MessageConsumer consumer = session.createConsumer(queue);  
            consumer.setMessageListener(new MessageListener() {  
                @Override  
                public void onMessage(Message message) {  
                    if (message instanceof TextMessage) {  
                        try {  
                            String text = ((TextMessage) message).getText();  
                            System.out.println("接收到消息：" + text);  
                        } catch (JMSException e) {  
                            e.printStackTrace();  
                        }  
                    }  
                }  
            });  

            // 启动连接以接收消息  
            connection.start();  
            System.out.println("等待接收消息...");  
        } catch (JMSException | javax.naming.NamingException e) {  
            e.printStackTrace();  
        }  
    }  
}  

4、 运行和测试

1. 启动ActiveMQ：
   打开终端，运行ActiveMQ的启动脚本，例如：

   activemq start  
   

2. 创建队列：

   • 访问ActiveMQ Web Console：http://localhost:8161/admin
   • 使用用户名和密码登录，默认为admin/admin。
   • 在“Queues”标签下，点击“Add”按钮，输入MyQueue作为队列名称，创建新的队列。

3. 运行消息生产者：
   执行MessageProducer类，观察控制台输出，应该显示“消息已发送。”

4. 运行消息消费者：
   在另一个终端窗口中执行MessageConsumer类，观察控制台输出，应该显示“接收到消息：您好，JMS！”。同时，ActiveMQ Web Console中的队列也应该显示消息已被消费。

注意事项：

• 确保ActiveMQ服务正在运行，并且端口61616和8161处于监听状态。
• 检查JNDI配置是否正确，特别是Context.INITIAL_CONTEXT_FACTORY和Context.PROVIDER_URL的设置。
• 如果出现连接失败，检查防火墙设置或网络问题，确保客户端能够连接到ActiveMQ服务器。
• 在关闭应用程序之前，确保所有JMS资源（如连接、会话、生产者/消费者）都已正确关闭，以避免资源泄漏。

---

六. JMS的优势

• 异步通信：消除同步阻塞，提高系统响应速度。
• 可靠性：支持消息持久化和事务管理，确保消息传递可靠。
• 松耦合：生产者和消费者之间无需直接依赖，提高系统的灵活性和维护性。
• 高扩展性：支持多个消费者和生产者，适合分布式和高并发场景。

---

七. 常见问题及最佳实践

• 问题1：消息丢失
  • 原因：消息未配置持久性，或消息存储介质出现故障。
  • 解决方案：确保消息持久性，配置合适的存储机制，定期备份数据。
• 问题2：性能瓶颈
  • 原因：高并发场景下，消息队列处理能力不足。
  • 解决方案：优化消息代理配置，增加消息代理的节点数量，使用集群提高吞吐量。
• 问题3：连接泄漏
  • 原因：未正确关闭JMS连接、会话或消费者。
  • 解决方案：在finally块中确保所有JMS资源被关闭，避免资源泄漏。

最佳实践：

• 使用Connection Pool：通过连接池优化JMS连接的创建和管理，提升性能。
• 配置合理的会话和消费者：根据负载需求调整会话和消费者的数量，确保高效处理消息。
• 实现可靠的消息确认机制：确保消息被正确接收和处理，避免消息丢失或重复处理。
• 监控和日志记录：定期监控JMS系统的性能和健康状态，及时发现和解决问题。

---

八. 总结

通过本讲义，我们详细探讨了Java Message Service (JMS)的核心概念，包括消息队列、主题、生产者与消费者模式，并通过一个实践示例实现了异步消息通信。JMS为企业级应用提供了一种高效、可靠的通信方式，能够有效分离系统的不同组件，提升系统的可扩展性和响应能力。掌握JMS的使用和配置，对于构建高效、可靠的分布式系统至关重要。

关键点总结：

1. 理解JMS的两种消息模型：消息队列（点对点）和主题（发布-订阅）适用于不同的场景。
2. 掌握生产者和消费者的实现：熟悉JMS API，能够编写发送和接收消息的代码。
3. 配置和管理消息代理：如ActiveMQ的安装、配置和监控。
4. 实现异步消息通信：通过实际代码示例理解消息的发送和接收过程。
5. 确保可靠性和性能：配置持久性、事务性和优化连接管理，提升系统稳定性和性能。