最新资讯

本文还有配套的精品资源，点击获取

简介：WebLogic Server是Oracle提供的主流Java企业级中间件，广泛用于部署高可用、可扩展的分布式应用。JMS（Java Message Service）作为标准消息传递API，支持异步通信与系统解耦。本文结合源码与工具实践，深入讲解如何在WebLogic中配置和使用JMS服务，涵盖队列、主题、消息驱动Bean（MDB）、事务管理及安全机制等内容。通过“src”源码目录与“lib”依赖库的实际结构，帮助开发者掌握JMS资源创建、消息收发、集群容错与性能调优等关键技能，构建高效稳定的 enterprise 级消息系统。

1. WebLogic与JMS集成概述

WebLogic Server作为企业级Java EE应用服务器，内置了高性能的JMS消息引擎，支持可靠、可扩展的消息传递。JMS（Java Message Service）是Java平台标准的消息中间件API，用于实现异步通信与解耦架构。WebLogic通过其JMS服务提供队列（Queue）和主题（Topic）两种消息模型，支持持久化、事务、安全控制及集群高可用等企业级特性。本章将为后续配置与开发奠定理论基础。

2. JMS模块配置与核心资源创建

在企业级Java应用中，消息中间件是实现异步通信、系统解耦和高可用架构的核心组件。Oracle WebLogic Server作为成熟的Java EE容器，内置了强大的JMS（Java Message Service）支持能力，能够为分布式系统提供稳定的消息传递服务。要充分发挥WebLogic的JMS功能，必须正确配置JMS模块及相关核心资源——包括JMS服务器、连接工厂（ConnectionFactory）、目的地（Destination）等。本章将深入探讨如何通过WebLogic控制台或WLST脚本完成这些关键资源的创建与优化配置，并结合实际场景分析其背后的运行机制。

合理的JMS资源配置不仅影响系统的性能与可靠性，还直接决定消息是否能被持久化存储、是否具备故障转移能力以及能否满足高并发需求。特别是在微服务架构日益普及的今天，基于队列或主题的消息驱动模式已成为跨服务通信的标准方式之一。因此，掌握JMS模块的配置方法，是构建可扩展、容错性强的企业级消息系统的前提条件。

我们将从底层基础设施开始，逐步构建完整的JMS环境。首先介绍JMS服务器的配置过程，重点说明如何绑定持久化存储以确保消息不丢失；接着详细阐述JMS模块的创建流程及连接工厂的属性设置；然后深入讲解队列与主题的管理策略，涵盖配额控制、转发规则等高级特性；最后搭建测试环境并验证整个配置的有效性，确保后续开发和部署工作可以顺利进行。

2.1 JMS服务器配置

JMS服务器是WebLogic平台上承载所有JMS操作的运行时实体。它负责管理消息的存储、传输、分发以及与目的地之间的交互。一个JMS服务器必须关联到特定的WebLogic服务器实例或集群成员上，并且通常需要绑定一个持久化存储来保证消息的可靠传递，尤其是在发生服务器宕机的情况下仍能恢复未处理的消息。

2.1.1 创建JMS服务器并绑定持久化存储

在WebLogic中，JMS服务器本身并不自动创建，必须手动定义。创建过程中最关键的一步是为其指定一个持久化存储（Persistent Store），用于保存持久化消息。若未配置持久化存储，JMS服务器只能处理非持久化消息，一旦服务器重启，所有未消费的消息将会丢失。

持久化存储类型选择

WebLogic支持两种类型的持久化存储：

推荐在生产环境中使用 JDBC Store ，因为它更容易集成到集群环境中，支持共享存储，从而实现跨服务器的消息恢复。

创建文件持久化存储示例（控制台方式）

1. 登录WebLogic Admin Console。
2. 导航至 Services > Persistent Stores > New > File Store 。
3. 输入名称 MyFileStore ，选择目标服务器（例如 Server-0 ）。
4. 设置目录路径（如 /u01/oracle/stores/jms ），点击“Finish”。

# 目录需提前创建并赋予WebLogic进程读写权限
mkdir -p /u01/oracle/stores/jms
chown oracle:oracle /u01/oracle/stores/jms

WLST脚本自动化创建JMS服务器与文件存储

以下是一个完整的WLST Python脚本，用于批量创建文件存储和JMS服务器：

connect('weblogic', 'welcome1', 't3://localhost:7001')

edit()
startEdit()

try:
    # 创建File Store
    cd('/')
    cmo.createFileStore('MyFileStore')

    cd('/FileStores/MyFileStore')
    cmo.setDirectory('/u01/oracle/stores/jms')
    cmo.addTarget(getMBean('/Servers/Server-0'))

    # 创建JMS Server并绑定Store
    cd('/')
    cmo.createJMSServer('MyJMSServer')

    cd('/JMSServers/MyJMSServer')
    cmo.setPersistentStore(getMBean('/FileStores/MyFileStore'))
    cmo.addTarget(getMBean('/Servers/Server-0'))

    save()
    activate()
    print("✅ JMS Server 和 File Store 创建成功")
except Exception as e:
    print("❌ 配置失败:", str(e))
    cancelEdit('y')

代码逻辑逐行解读：

• connect() ：连接到WebLogic管理服务器。
• edit()/startEdit() ：开启配置编辑会话。
• createFileStore() ：在域级别创建一个新的文件存储对象。
• setDirectory() ：指定该存储使用的本地文件路径。
• addTarget() ：将存储绑定到具体的服务器实例。
• createJMSServer() ：创建JMS服务器实例。
• setPersistentStore() ：将之前创建的File Store赋给JMS服务器，启用持久化能力。
• save()/activate() ：提交更改并生效。

参数说明：
- MyFileStore ：自定义名称，用于标识存储。
- /u01/oracle/stores/jms ：应确保存在且权限正确。
- Server-0 ：目标托管服务器名，需已存在。

消息持久化流程图（Mermaid）

graph TD
    A[生产者发送持久化消息] --> B[JMS Server接收消息]
    B --> C{是否配置 Persistent Store?}
    C -- 是 --> D[写入File Store或JDBC Store]
    C -- 否 --> E[仅存于内存，重启即丢]
    D --> F[消息落盘成功]
    F --> G[通知生产者ACK]
    G --> H[等待消费者拉取消息]
    H --> I[消费后从Store删除]

此流程清晰地展示了消息从发送到落盘再到消费的完整路径，强调了持久化存储的关键作用。

2.1.2 配置JMS服务器的高可用与负载均衡策略

在企业级部署中，单点JMS服务器存在明显的可用性风险。为了提升系统的鲁棒性，必须通过集群部署和故障转移机制实现高可用（HA）。WebLogic允许将多个JMS服务器分布在不同的Managed Server上，并借助 通用JMS服务器（Uniform Distributed Destination, UDD） 实现负载均衡与自动故障切换。

集群中的JMS服务器部署模型

使用JDBC Store实现共享存储（高可用基础）

当JMS服务器部署在集群中时，建议使用 JDBC Store 而非File Store，因为后者无法被多个服务器同时访问。

-- 示例：为JDBC Store准备Oracle数据库表结构
CREATE TABLE WLS_JDBC_STORE (
    ID NUMBER PRIMARY KEY,
    DATA BLOB NOT NULL,
    XID VARCHAR2(255)
);

在控制台中配置JDBC Store步骤如下：

1. 创建JDBC数据源（如 jdbc/JmsDataSource ）。
2. 进入 Services > Persistent Stores > New > JDBC Store 。
3. 选择之前创建的数据源。
4. 指定表前缀（如 WLS_JDBC_STORE ）。
5. 绑定到集群中的多个服务器。

故障转移与负载均衡机制

WebLogic通过以下机制保障JMS高可用：

• 自动迁移（Migration） ：当某台服务器宕机，其上的JMS服务器可在预设策略下迁移到其他健康节点。
• 客户端重连（Client Reconnect） ：JMS客户端可通过T3集群地址自动发现新位置。
• 分布式队列负载均衡 ：消息投递均匀分布到各成员队列。

// 客户端连接工厂使用集群地址
String connectionURL = "t3://server1:7001,server2:7002,server3:7003";
InitialContext ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jndi/connectionFactory");
Connection conn = cf.createConnection(); // 自动选择活跃节点

参数说明：
- t3://... ：T3协议支持集群感知，比IIOP更高效。
- JNDI名称必须在所有节点一致。
- 客户端无需知道具体服务器位置，由WebLogic透明路由。

高可用架构流程图（Mermaid）

graph LR
    Client[JMS客户端] --> LB[WebLogic集群前端负载均衡器]
    LB --> S1[Server-1 + JMS-1]
    LB --> S2[Server-2 + JMS-2]
    LB --> S3[Server-3 + JMS-3]

    S1 --> DB[(共享JDBC Store)]
    S2 --> DB
    S3 --> DB

    subgraph 故障转移
        S1 -.->|宕机| S2
        S2 -.->|接管| S1的任务
    end

该图展示了典型的WebLogic集群JMS部署结构，其中所有JMS服务器共享同一个数据库存储，确保即使某个节点失效，消息也不会丢失，且可在其他节点继续处理。

此外，WebLogic提供了 Whole Server Migration 和 Service Migration 两种迁移策略：
- Whole Server Migration ：整个服务器实例迁移（适用于虚拟化环境）。
- Service Migration ：仅迁移JMS服务（轻量级，响应更快）。

合理配置迁移策略，结合心跳检测与自动恢复机制，可显著提升系统的容灾能力。

2.2 JMS模块与连接工厂

JMS模块是组织JMS资源的逻辑单元，类似于Java中的包（package）。它包含连接工厂、队列、主题等资源定义，并可通过JNDI对外暴露。JMS模块分为两种类型：
- 系统模块（System Module） ：由WebLogic内部管理，一般不推荐修改。
- 自定义模块（Custom Module） ：用户自行创建，便于版本管理和部署。

2.2.1 创建JMS模块并配置连接工厂（ConnectionFactory）

创建JMS模块是配置JMS资源的第一步。模块中最重要的资源之一是 连接工厂（ConnectionFactory） ，它是客户端获取JMS连接的入口。

控制台创建JMS模块流程

1. 进入 Services > Messaging > JMS Modules > New 。
2. 输入名称 MyJMSModule ，选择目标（单服务器或集群）。
3. 创建完成后，进入模块详情页，点击“New Resource”添加资源。
4. 选择“Connection Factory”，输入JNDI名（如 jndi/cf ）。
5. 设置客户端ID（可选），启用XA事务支持。

WLST脚本创建JMS模块与连接工厂

connect('weblogic', 'welcome1', 't3://localhost:7001')
edit()
startEdit()

try:
    # 创建JMS模块
    create('MyJMSModule', 'JMSSystemResource')
    cd('/JMSSystemResources/MyJMSModule')
    set('Targets', jarray.array([ObjectName('com.bea:Name=Server-0,Type=Server')], ObjectName))

    # 创建子部署（Subdeployment），用于绑定JMS服务器
    cd('/JMSSystemResources/MyJMSModule')
    create('JmsSubDeploy', 'SubDeployment')

    # 创建ConnectionFactory
    cd('/JMSSystemResources/MyJMSModule/JMSResource/MyJMSModule')
    cf = create('MyConnectionFactory', 'ConnectionFactory')

    # 设置JNDI名称
    cf.setJNDIName('jndi/cf')

    # 配置事务与会话池
    cf.getTransactionParams().setXaConnectionFactoryEnabled(true)
    cf.getClientParams().setClientIdPolicy('Restricted')
    cf.getConnectionParams().setMaxConnections(50)

    save()
    activate()
    print("✅ JMS模块与连接工厂创建成功")
except Exception as e:
    print("❌ 配置异常:", str(e))
    cancelEdit('y')

代码逻辑逐行解读：

• create('MyJMSModule', 'JMSSystemResource') ：注册一个名为MyJMSModule的JMS模块。
• set('Targets') ：将模块部署到指定服务器。
• create('JmsSubDeploy', 'SubDeployment') ：子部署用于将资源绑定到特定JMS服务器。
• create('MyConnectionFactory', 'ConnectionFactory') ：在模块内创建连接工厂。
• setJNDIName() ：设定客户端查找用的JNDI路径。
• setXaConnectionFactoryEnabled(true) ：启用XA分布式事务支持。
• setMaxConnections(50) ：限制最大连接数，防止资源耗尽。

参数说明：
- XaConnectionFactoryEnabled ：若涉及数据库与消息的两阶段提交，必须开启。
- ClientIdPolicy ：限制每个连接工厂只能有一个固定ClientID，避免冲突。
- MaxConnections ：根据应用负载调整，过高可能导致线程阻塞。

2.2.2 连接工厂的属性设置与JNDI绑定

连接工厂的属性直接影响客户端行为，主要包括：

JNDI绑定验证命令

# 使用weblogic.WLST查看JNDI树
java weblogic.WLST
connect('weblogic','welcome1','t3://localhost:7001')
ls(jndiName='jndi')

输出应包含：

jndi/cf --> ConnectionFactory

表示绑定成功，客户端可通过该名称查找到连接工厂。

2.3 JMS目的地配置

JMS目的地是消息发送的目标地址，分为 队列（Queue） 和 主题（Topic） 两类。它们分别对应点对点和发布/订阅模型。

2.3.1 队列（Queue）与主题（Topic）的创建与管理

队列创建（WLST脚本）

cd('/JMSSystemResources/MyJMSModule/JMSResource/MyJMSModule')
queue = create('MyQueue', 'Queue')

queue.setJNDIName('jndi/queue')
queue.setSubDeploymentName('JmsSubDeploy')  # 关联子部署

主题创建

topic = create('MyTopic', 'Topic')
topic.setJNDIName('jndi/topic')
topic.setSubDeploymentName('JmsSubDeploy')

说明：
- setSubDeploymentName() 必须与前面定义的子部署名称一致，否则资源不会激活。
- 队列允许多个消费者，但每条消息仅被一个消费者处理。
- 主题支持一对多广播，所有订阅者都能收到消息。

2.3.2 目的地的高级配置：阈值、配额与转发策略

配置消息配额（Quota）

cd('/JMSSystemResources/MyJMSModule/JMSResource/MyJMSModule')
quota = create('HighVolumeQuota', 'Quota')

quota.setBytesMaximum(104857600)  # 100MB
quota.setMessagesMaximum(5000)
quota.setPolicy('FIFO')  # 超限时按先进先出丢弃

# 应用到队列
queue.getCachingParams().setTotalCachingEnabled(true)
queue.setQuota(quota)

参数说明：
- BytesMaximum ：最大字节数。
- MessagesMaximum ：最多消息条数。
- Policy ：溢出策略，可选 FIFO , Priority , ExpirationFirst 。

转发策略（Forwarding Destinations）

可用于实现消息路由：

bridge = create('ErrorBridge', 'MessageDrivenBean')
bridge.setSourceDestination(queue)
bridge.setTargetDestination(errorQueue)
bridge.setSelector("JMSRedelivered = TRUE")

即当消息重试多次失败后，自动转发至错误队列供人工干预。

2.4 配置验证与测试环境搭建

2.4.1 使用控制台和WLST脚本进行配置验证

查看JMS服务器状态

servers = getMBean('/JMSServers')
for server in servers:
    print(f"{server.getName()} -> State: {server.getState()}")

正常状态应为 ACTIVE 。

检查持久化存储健康状况

store = getMBean('/FileStores/MyFileStore')
print(f"Location: {store.getDirectory()}, State: {store.getState()}")

2.4.2 配置测试JMS客户端环境与依赖库

Maven依赖（用于Java客户端）

    com.oracle.weblogic
    wlthint3client
    14.1.1.0

简易测试程序（发送消息）

InitialContext ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jndi/cf");
Destination queue = (Destination) ctx.lookup("jndi/queue");

Connection conn = cf.createConnection();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = sess.createProducer(queue);

TextMessage msg = sess.createTextMessage("Hello WebLogic JMS!");
prod.send(msg);
System.out.println("消息已发送");

运行此程序前，确保WebLogic服务器启动且JNDI路径正确。

最终，完整的JMS环境应在控制台的 Monitoring > Statistics 中显示活动连接、消息数量等指标，证明配置已生效。

3. JMS消息模型与消息处理机制

消息驱动架构的核心在于消息模型与处理机制的设计。在JMS（Java Message Service）中，支持两种主要的消息传递模型： 点对点（Point-to-Point, P2P） 和 发布/订阅（Publish/Subscribe, Pub/Sub） 。这两种模型在应用场景、消息生命周期、消费者行为等方面存在显著差异。理解它们的异同对于设计高可用、可扩展的企业级消息系统至关重要。本章将深入探讨这两种消息模型的工作原理、使用场景，并通过代码示例展示其在WebLogic环境下的实现方式。

3.1 队列与主题模型对比

3.1.1 点对点（P2P）与发布/订阅（Pub/Sub）模式的原理

在JMS中， 队列（Queue） 实现了 点对点（P2P） 模型，而 主题（Topic） 实现了 发布/订阅（Pub/Sub） 模型。它们在消息传递机制上有着本质的区别。

点对点（P2P）模型

• 消息发送方（生产者） 将消息发送到一个 队列（Queue）
• 多个消费者 可以监听同一个队列，但 每条消息只会被一个消费者消费一次
• 消息具有 持久性（可配置） ，即使在消费者未启动时，消息也会被保留
• 适用于 任务队列、订单处理、工作流调度 等场景

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

• 发布者（Publisher） 向一个 主题（Topic） 发送消息
• 多个订阅者（Subscriber） 可以订阅该主题， 每条消息会被所有订阅者接收
• 支持 持久订阅（Durable Subscriber） 和 非持久订阅（Non-Durable Subscriber）
• 适用于 广播通知、实时数据推送、新闻订阅 等场景

两种模型的对比表格

3.1.2 不同模型在实际业务中的适用场景

选择合适的模型取决于具体的业务需求：

• P2P模型适用于需要确保任务被处理且仅被处理一次的场景 ，例如银行交易处理、支付队列、后台批处理等。
• Pub/Sub模型适用于需要广播信息或实时通知的场景 ，例如股票行情推送、实时日志聚合、系统状态广播等。

代码示例：P2P模式下的队列发送与接收

// 发送端代码
public class QueueSender {
    public static void main(String[] args) throws Exception {
        InitialContext context = new InitialContext();
        ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
        Destination queue = (Destination) context.lookup("jms/MyQueue");

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

        TextMessage message = session.createTextMessage("这是P2P队列消息");
        producer.send(message);

        session.close();
        connection.close();
    }
}

// 接收端代码
public class QueueReceiver {
    public static void main(String[] args) throws Exception {
        InitialContext context = new InitialContext();
        ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
        Destination queue = (Destination) context.lookup("jms/MyQueue");

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

        connection.start();
        Message message = consumer.receive();
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            System.out.println("收到队列消息：" + textMessage.getText());
        }

        session.close();
        connection.close();
    }
}

代码逻辑分析

1. InitialContext 获取JNDI上下文，用于查找连接工厂和目的地。
2. ConnectionFactory 创建连接对象，建立与JMS服务器的通信。
3. Session 表示一个会话，定义了事务性和确认模式（ AUTO_ACKNOWLEDGE ）。
4. MessageProducer 用于发送消息， producer.send() 将消息发送到指定队列。
5. MessageConsumer 用于接收消息， consumer.receive() 阻塞式接收。

参数说明

• Session.AUTO_ACKNOWLEDGE ：自动确认模式，适用于大多数业务场景。
• false ：表示不启用事务，若启用事务则应设为 true 并调用 session.commit() 。

3.2 消息发送与接收机制

3.2.1 同步与异步消息消费方式

JMS支持两种主要的消息消费方式： 同步接收 和 异步接收（监听器模式） 。

同步接收

• 通过 MessageConsumer.receive() 方法获取消息
• 是一种阻塞式调用，适用于低并发、简单处理逻辑
• 适合对消息消费顺序有严格要求的场景

异步接收

• 使用 MessageListener 接口实现回调机制
• 消息到达后自动触发 onMessage() 方法进行处理
• 支持高并发、非阻塞式消息处理
• 适合实时性强、吞吐量高的系统

异步接收示例代码

public class AsyncTopicSubscriber implements MessageListener {
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println("收到异步消息：" + ((TextMessage) message).getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        InitialContext context = new InitialContext();
        ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
        Destination topic = (Destination) context.lookup("jms/MyTopic");

        Connection connection = factory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer(topic);

        consumer.setMessageListener(new AsyncTopicSubscriber());
        connection.start();

        System.out.println("等待消息...");
    }
}

代码逻辑分析

1. 实现 MessageListener 接口，重写 onMessage() 方法
2. 创建连接和会话，创建消费者对象
3. 调用 setMessageListener() 注册监听器
4. 启动连接后，自动接收并处理消息

参数说明

• connection.start() ：启动连接，开始监听消息
• setMessageListener() ：注册监听器，设置异步回调机制

3.2.2 消息确认模式（Auto Acknowledge、Client Acknowledge等）

JMS定义了多种消息确认方式，常见的包括：

• Session.AUTO_ACKNOWLEDGE ：自动确认，适用于大多数场景
• Session.CLIENT_ACKNOWLEDGE ：客户端手动确认
• Session.DUPS_OK_ACKNOWLEDGE ：允许重复确认，适用于性能优先场景
• Session.SESSION_TRANSACTED ：事务性会话，需调用 session.commit()

示例代码：使用客户端确认模式

Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
MessageConsumer consumer = session.createConsumer(queue);
Message message = consumer.receive();
if (message instanceof TextMessage) {
    TextMessage textMessage = (TextMessage) message;
    System.out.println("收到消息：" + textMessage.getText());
    message.acknowledge(); // 手动确认
}

参数说明

• Session.CLIENT_ACKNOWLEDGE ：启用客户端手动确认模式
• message.acknowledge() ：显式调用确认方法，确保消息被正确消费

3.3 消息驱动Bean（MDB）的开发与部署

3.3.1 MDB的生命周期与并发处理机制

消息驱动Bean（Message-Driven Bean, MDB） 是EJB中专门用于处理异步消息的组件。它运行在容器中，自动监听指定的JMS目的地，具备良好的并发处理能力。

MDB的生命周期

1. 容器创建MDB实例并初始化
2. MDB监听JMS目的地
3. 消息到达时，容器调用 onMessage() 方法
4. 消息处理完成后，容器进行确认或回滚
5. MDB实例可被复用，提高性能

并发处理机制

• MDB支持 多线程并发消费
• 可通过配置 maxSessions 控制并发线程数
• 支持事务回滚、消息重试机制

UML时序图：MDB消息处理流程

sequenceDiagram
    participant JMS as JMS Server
    participant MDB as Message-Driven Bean
    participant EJBContainer as EJB Container
    participant AppServer as Application Server

    JMS->>EJBContainer: 发送消息到监听的JMS目的地
    EJBContainer->>MDB: 调用onMessage()方法
    MDB->>MDB: 处理消息逻辑
    MDB->>EJBContainer: 消息确认或回滚
    EJBContainer->>JMS: 提交或回滚事务

3.3.2 部署到WebLogic服务器并配置监听器属性

步骤一：创建EJB项目

使用Maven创建一个EJB项目，结构如下：

my-ejb-project/
├── src/
│   └── main/
│       └── java/
│           └── com/example/mdb/MyMDB.java
└── pom.xml

步骤二：编写MDB类

@MessageDriven(name = "MyMDB", activationConfig = {
    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
    @ActivationConfigProperty(propertyName = "destination", propertyValue = "jms/MyQueue")
})
public class MyMDB implements MessageListener {
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println("MDB收到消息：" + ((TextMessage) message).getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

参数说明

• @MessageDriven ：声明这是一个消息驱动Bean
• activationConfig ：配置监听的JMS类型和目的地名称
• destinationType ：目标类型（Queue或Topic）
• destination ：JNDI名称

步骤三：打包并部署到WebLogic

mvn clean package

将生成的 .jar 文件通过 WebLogic 控制台或 WLST 脚本部署到服务器：

java weblogic.Deployer -adminurl t3://localhost:7001 -username weblogic -password weblogic123 -deploy my-ejb-project.jar

3.4 消息类型与序列化处理

3.4.1 文本消息（TextMessage）、对象消息（ObjectMessage）与字节消息（BytesMessage）

JMS支持多种消息类型，常见的包括：

示例：使用ObjectMessage传输对象

// 发送端
ObjectMessage objMsg = session.createObjectMessage();
MyData data = new MyData("测试数据", 123);
objMsg.setObject(data);
producer.send(objMsg);

// 接收端
if (message instanceof ObjectMessage) {
    MyData data = (MyData) ((ObjectMessage) message).getObject();
    System.out.println("收到对象消息：" + data.toString());
}

3.4.2 自定义对象序列化与反序列化实现

若使用 ObjectMessage ，对象必须实现 Serializable 接口：

public class MyData implements Serializable {
    private String name;
    private int value;

    public MyData(String name, int value) {
        this.name = name;
        this.value = value;
    }

    // Getter / Setter / toString()
}

自定义序列化方式（如JSON）

Gson gson = new Gson();
String json = gson.toJson(data);
TextMessage msg = session.createTextMessage(json);
producer.send(msg);

if (message instanceof TextMessage) {
    String json = ((TextMessage) message).getText();
    MyData data = gson.fromJson(json, MyData.class);
}

优缺点对比

本章从消息模型的对比出发，详细介绍了P2P与Pub/Sub模型的原理与适用场景，并通过代码示例展示了其在WebLogic平台下的实现方式。同时，深入探讨了消息的同步与异步消费机制、确认模式，以及消息驱动Bean的生命周期与并发处理机制。最后，讲解了JMS消息类型的使用及其序列化方式的选择，为后续章节的高级应用打下坚实基础。

4. JMS高级特性与企业级应用

JMS（Java Message Service）不仅支持基本的消息传递功能，还提供了诸如事务管理、高可用性、消息持久化和安全性等高级特性，这些特性对于构建企业级的分布式系统至关重要。本章将深入探讨这些高级功能，并结合企业级应用场景进行详细解析，帮助读者掌握如何在WebLogic Server中高效地利用JMS来实现可靠、安全、可扩展的消息通信架构。

4.1 JMS与事务管理（JTA）集成

事务管理是确保系统中多个操作要么全部成功、要么全部失败的重要机制。在JMS中，事务管理可以通过本地事务（Local Transaction）或分布式事务（JTA, Java Transaction API）来实现。在企业级应用中，JMS通常需要与数据库或其他资源管理器协同工作，此时使用JTA可以实现跨资源的事务一致性。

4.1.1 本地事务与分布式事务的配置

本地事务（Local Transaction）

本地事务是指在一个会话（Session）内进行的消息发送或接收操作被包含在事务中。以下是一个使用本地事务发送消息的示例代码：

ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
Connection connection = factory.createConnection();
Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
Destination destination = (Destination) context.lookup("jms/MyQueue");

MessageProducer producer = session.createProducer(destination);
TextMessage message = session.createTextMessage("Hello, JMS with Local Transaction!");
producer.send(message);

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

代码解析：

• createSession(true, Session.SESSION_TRANSACTED) ：启用本地事务。
• session.commit() ：提交事务，若发送失败则不会提交。
• session.rollback() ：可在异常处理中调用以回滚事务。

分布式事务（JTA）

当JMS操作需要与数据库操作在同一个事务中完成时，必须使用JTA。以下是一个典型的Spring Boot整合JTA的示例配置（使用Atomikos）：

    org.springframework.boot
    spring-boot-starter-jta-atomikos

@JmsListener(destination = "jms/MyQueue")
@Transactional
public void processMessage(String message) {
    // 消费消息并更新数据库
    jdbcTemplate.update("INSERT INTO messages (content) VALUES (?)", message);
}

参数说明：

• @Transactional ：表示该方法应在事务中执行。
• Atomikos作为JTA事务管理器，协调JMS与数据库事务。

逻辑分析：

• 消息消费与数据库操作在一个事务中，确保数据一致性。
• 若数据库操作失败，JMS消息不会被确认，从而避免数据丢失。

4.1.2 保证消息发送与数据库操作的原子性

在企业级系统中，常需保证“发送消息”与“数据库更新”操作的原子性。使用JTA事务可以实现这一目标，如下图所示：

sequenceDiagram
    participant Client
    participant MDB
    participant DB
    participant JMS

    Client->>MDB: 发送请求
    MDB->>JMS: 启动JTA事务
    MDB->>DB: 更新数据库
    JMS->>MDB: 提交事务
    MDB->>Client: 返回结果

图示说明：

• JTA事务协调JMS与数据库资源。
• 所有操作在事务中完成，失败则整体回滚。

4.2 高可用性与故障转移配置

高可用性是企业系统设计的重要目标之一。WebLogic Server 提供了丰富的机制来实现JMS的高可用性，包括集群部署、故障切换、消息重发等。

4.2.1 JMS服务器与目的地的集群部署

将JMS服务器和目的地部署在集群中，可以提高系统的可用性和负载均衡能力。以下是WebLogic控制台中配置JMS集群的步骤：

1. 登录 WebLogic 控制台。
2. 导航至 Services → Messaging → JMS Modules 。
3. 创建或编辑JMS模块，选择 Distributed Destination （分布式目的地）。
4. 将该目的地分配到集群中的多个JMS服务器节点上。

分布式队列配置示例：

优势分析：

• 消息可被多个服务器处理，避免单点故障。
• 自动负载均衡，提升系统吞吐量。

4.2.2 故障切换机制与消息重发策略

WebLogic 支持自动故障切换（Failover）和消息重发机制。当某个JMS服务器宕机时，客户端会自动连接到其他可用节点。

配置步骤：

1. 在 ConnectionFactory 中启用 HA 设置。
2. 配置 ReconnectEnabled = true 和 ReconnectAttempts = -1 （无限次重连）。
3. 设置 ReconnectInterval = 5000 （单位：毫秒）。

Java客户端代码示例：

Properties props = new Properties();
props.put("weblogic.jndi.WLInitialContextFactory", "t3://server-1:7001,server-2:7002");
props.put(Context.SECURITY_PRINCIPAL, "weblogic");
props.put(Context.SECURITY_CREDENTIALS, "password");

InitialContext context = new InitialContext(props);
ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
Connection connection = factory.createConnection();
connection.setExceptionListener(exception -> {
    System.out.println("JMS Connection Exception: " + exception.getMessage());
});

逻辑说明：

• 使用多地址连接（server-1与server-2），支持故障切换。
• 异常监听器可捕获连接中断事件，实现自定义处理逻辑。

4.3 消息持久化与性能优化

消息持久化是确保消息在系统故障时不会丢失的重要机制。然而，持久化操作可能会影响系统性能。因此，合理的优化策略是企业应用中必须考虑的内容。

4.3.1 持久化消息的存储机制与性能影响

WebLogic 支持将消息持久化到文件系统或JDBC持久化存储（如数据库）。以下是两种方式的对比：

配置步骤：

1. 在 WebLogic 控制台中创建持久化存储（Persistent Store）。
2. 选择 JDBC 或 File Store。
3. 绑定到JMS服务器。

性能影响分析：

• 文件系统存储 I/O 效率高，适合单节点部署。
• JDBC 存储支持集群环境，但每次写入需访问数据库，延迟较高。

4.3.2 消息缓冲、并发消费与批量处理策略

为了提升性能，WebLogic 提供了多种优化策略：

• 消息缓冲（Message Paging） ：将消息缓存到内存，减少磁盘I/O。
• 并发消费（Message-Driven Bean Pool Size） ：设置MDB线程池大小，提升并发能力。
• 批量确认（Batch Acknowledge） ：减少每次确认的网络开销。

优化配置示例：

    MyJMSServer
    MyCluster
    MyJDBCStore
    1024

代码逻辑说明：

• message-buffer-size ：控制内存中缓存的消息数量，单位为KB。
• 增大缓冲区可减少持久化频率，提高吞吐量。

并发消费配置：

在部署描述符 ejb-jar.xml 中配置MDB并发：

    MyMessageDrivenBean
    
        20
    

优化建议：

• 根据消息流量动态调整线程池大小。
• 对于高吞吐量场景，启用批量确认和缓冲机制。

4.4 安全性配置与访问控制

在企业环境中，安全性是消息系统不可忽视的一环。WebLogic 提供了完善的JMS安全机制，包括基于角色的访问控制、用户认证与SSL加密通信等。

4.4.1 配置JMS资源的安全策略与角色权限

步骤一：创建用户与角色

1. 登录 WebLogic 控制台。
2. 导航至 Security Realms → myrealm → Users and Groups 。
3. 创建用户 jmsUser 和角色 jmsProducer 、 jmsConsumer 。

步骤二：配置JMS资源权限

1. 进入 Services → Messaging → JMS Modules 。
2. 编辑目标队列或主题，选择 Security 标签。
3. 为角色 jmsProducer 和 jmsConsumer 授予相应权限。

权限说明：

4.4.2 用户认证与SSL加密通信实现

用户认证配置

在JMS客户端连接时，需提供用户名和密码：

ConnectionFactory factory = (ConnectionFactory) context.lookup("jms/MyConnectionFactory");
Connection connection = factory.createConnection("jmsUser", "password");

启用SSL加密通信

1. 在 WebLogic 控制台中启用SSL：
   - 进入 Environment → Servers → server-name → Configuration → SSL 。
   - 启用 SSL Listen Port，并配置密钥库与信任库。

2. 客户端连接时使用 t3s 协议：

props.put(Context.PROVIDER_URL, "t3s://localhost:7002");

安全策略总结：

• 通过角色控制访问权限，防止越权操作。
• 使用SSL加密传输，保障数据安全。
• 定期更新密钥与证书，防止中间人攻击。

小结：

本章深入探讨了JMS在WebLogic中的高级特性，包括事务管理、高可用性配置、消息持久化优化以及安全性控制。通过本地事务与JTA的结合，可以实现业务操作的原子性；集群部署与故障切换机制保障了系统的高可用；合理配置持久化和并发策略可显著提升性能；而完善的权限控制与SSL加密则为系统安全提供了保障。这些内容构成了企业级JMS应用的核心支撑体系，是构建健壮、高效、安全消息系统的关键基础。

5. JMS项目实战与运维监控

5.1 项目结构与集成流程

在企业级Java应用中，良好的项目结构是保障可维护性、可扩展性和团队协作效率的关键。尤其在将JMS消息中间件集成到WebLogic平台时，合理的目录组织和依赖管理显得尤为重要。

5.1.1 基于src与lib目录的标准项目结构解析

一个典型的基于Maven或Ant构建的Java EE项目应遵循如下标准结构：

my-jms-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/jms/
│   │   │       ├── JmsProducer.java
│   │   │       ├── JmsConsumer.java
│   │   │       └── MessageProcessorMDB.java
│   │   ├── resources/
│   │   │   └── jndi.properties
│   │   └── webapp/
│   │       └── WEB-INF/web.xml
├── lib/
│   ├── wlthint3client.jar      // WebLogic Thin Client
│   ├── jms.jar                 // JMS API
│   └── spring-jms-5.3.21.jar   // 可选框架依赖
├── build.xml                   // Ant 构建脚本（若使用）
└── pom.xml                     // Maven 配置文件

其中：
- src/main/java 存放核心业务逻辑与JMS相关代码；
- resources 包含JNDI配置、日志配置等外部化参数；
- lib 目录用于存放非Maven托管的本地库，如WebLogic客户端jar包；
- wlthint3client.jar 是连接WebLogic服务器必需的轻量级客户端驱动。

JNDI配置示例（jndi.properties）：

java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory
java.naming.provider.url=t3://localhost:7001
java.naming.security.principal=weblogic
java.naming.security.credentials=welcome1

该配置允许Java应用通过T3协议连接至WebLogic Server，并查找已绑定的ConnectionFactory和Queue。

5.1.2 集成WebLogic JMS模块与Spring Boot等框架

现代微服务架构常采用Spring Boot作为开发框架。将其与WebLogic JMS集成可通过以下方式实现：

步骤一：添加依赖（pom.xml）

    org.springframework.boot
    spring-boot-starter-artemis
    


${project.basedir}/lib/wlthint3client.jar

步骤二：配置自定义JMS连接工厂Bean

@Configuration
public class JmsConfig {

    @Bean
    public ConnectionFactory jmsConnectionFactory() throws NamingException {
        InitialContext ctx = new InitialContext();
        return (ConnectionFactory) ctx.lookup("jms/MyConnectionFactory");
    }

    @Bean
    public JmsTemplate jmsTemplate() {
        JmsTemplate template = new JmsTemplate();
        template.setConnectionFactory(jmsConnectionFactory());
        template.setDefaultDestinationName("jms/MyQueue");
        return template;
    }
}

步骤三：使用JmsTemplate发送消息

@Service
public class OrderService {

    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendOrder(String orderId) {
        jmsTemplate.convertAndSend(orderId, message -> {
            message.setStringProperty("MSG_TYPE", "ORDER_CREATED");
            return message;
        });
    }
}

此集成模式实现了松耦合设计，便于后续迁移到其他JMS提供者或云原生消息系统。

此外，在多环境部署中建议通过Spring Profiles区分开发、测试与生产配置：

spring:
  profiles: prod
  jndi:
    initial: weblogic.jndi.WLInitialContextFactory
    provider-url: t3://prod-wls-cluster:7001

这种结构化集成方式不仅提升了项目的清晰度，也为后续的监控与调优奠定了基础。

本文还有配套的精品资源，点击获取

简介：WebLogic Server是Oracle提供的主流Java企业级中间件，广泛用于部署高可用、可扩展的分布式应用。JMS（Java Message Service）作为标准消息传递API，支持异步通信与系统解耦。本文结合源码与工具实践，深入讲解如何在WebLogic中配置和使用JMS服务，涵盖队列、主题、消息驱动Bean（MDB）、事务管理及安全机制等内容。通过“src”源码目录与“lib”依赖库的实际结构，帮助开发者掌握JMS资源创建、消息收发、集群容错与性能调优等关键技能，构建高效稳定的 enterprise 级消息系统。

本文还有配套的精品资源，点击获取