以下功能决定了资源服务质量：

以下功能决定了事务管理器的服务质量：

本地事务管理器 是一个事务管理器，只能协调单一资源的事务。本地事务管理器的实现通常嵌入到资源本身中，应用程序使用的事务管理器所使用的事务管理器是一个精简打包程序。

例如，Oracle 数据库有一个内置的事务管理器，它支持解包操作（使用 SQL BEGIN、COMMIT 或 ROLLBACK 语句，或者使用原生 Oracle API）和各种事务隔离级别。对 Oracle 事务管理器的控制可以通过 JDBC 导出，此 JDBC API 则供应用程序用于分离事务。

在此上下文中，了解构成资源是非常重要的。例如，如果您使用 JMS 产品，JMS 资源是 JMS 产品的单一运行实例，而不是单个队列和主题。在有些情况下，如果以不同方式访问相同的基础资源，有时会出现多个资源可能是一个单一资源。例如，您的应用可以直接访问关系数据库（通过 JDBC），间接访问一个对象关系映射工具（如 Hibernate）。在这种情况下，涉及相同的基础事务管理器，因此应该可以在同一事务中注册这些代码片段。

应用程序可以相互独立地工作很多不同的本地事务管理器。例如，您可以有一个用于操作 JMS 队列和主题的 Camel 路由，其中 JMS 端点引用 JMS 事务管理器。另一个路由可以通过 JDBC 访问关系数据库。但是，您不能将 JDBC 和 JMS 访问组合到同一路由中，并使他们参与同一个事务。

全局事务管理器是一个事务管理器，可以在多个资源上协调事务。当您无法依赖资源本身内置的事务管理器时，这是必需的。外部系统有时称为事务处理监控器（TP 监控），能够在不同资源之间协调事务。

以下是对多个资源操作的事务的先决条件：

通常，服务器会直接连接到事务中涉及的资源。但是，在分布式系统中，偶尔需要通过 Web 服务连接到仅间接公开的资源。在这种情况下，您需要一个支持分布式事务的 TP 监控。有几种标准来描述如何支持各种分布式协议的事务，例如，Web 服务的 WS-AtomicTransactions 规格。

如前文中所述，javax.transaction.UserTransaction 通常来自 JavaEE 应用中的 JNDI。但是 Spring 会为很多场景提供这个界面的显式实现。您不需要完整的 JTA 情景，有时应用只需要访问单个资源，如 JDBC。

通常, org.springframework.transaction.PlatformTransactionManager 是 Spring 事务客户端 API，提供经典的事务客户端操作： 开始、提交和 回滚。换句话说，此接口提供了在运行时控制事务的基本方法。

public interface PlatformTransactionManager {

    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    void commit(TransactionStatus status) throws TransactionException;

    void rollback(TransactionStatus status) throws TransactionException;
}

public interface TransactionStatus extends SavepointManager, Flushable {

    boolean isNewTransaction();

    boolean hasSavepoint();

    void setRollbackOnly();

    boolean isRollbackOnly();

    void flush();

    boolean isCompleted();
}

通常，您不会直接使用 PlatformTransactionManager 接口。在 Apache Camel 中，您通常使用事务管理器，如下所示：

本节概述了 Spring Framework 提供的事务管理器实现。该实施分为两类：本地事务管理器和全球交易经理。

从 Camel 开始：

如您所见，您必须 有一些 实现这个接口。根据具体情况，您可以配置所需的平台事务管理器。

InitialContext context = new InitialContext();
UserTransaction ut = (UserTransaction) context.lookup("java:comp/UserTransaction");
TransactionManager tm = (TransactionManager) context.lookup("java:/TransactionManager");

JtaTransactionManager jta = new JtaTransactionManager();
jta.setUserTransaction(ut);
jta.setTransactionManager(tm);

TransactionTemplate jtaTx = new TransactionTemplate(jta);

jtaTx.execute((status) -> {
    // Perform resource access in the context of global transaction.
    return ...;
});

JTA UserTransaction 接口定义如下：

public interface javax.transaction.UserTransaction {

    public void begin();

    public void commit();

    public void rollback();

    public void setRollbackOnly();

    public int getStatus();

    public void setTransactionTimeout(int seconds);
}

UserTransaction 接口定义以下方法：

JTA TransactionManager 接口有以下定义：

interface javax.transaction.TransactionManager {

    // Same as UserTransaction methods

    public void begin();

    public void commit();

    public void rollback();

    public void setRollbackOnly();

    public int getStatus();

    public void setTransactionTimeout(int seconds);

    // Extra TransactionManager methods

    public Transaction getTransaction();

    public Transaction suspend() ;

    public void resume(Transaction tobj);
}

TransactionManager 接口支持 UserTransaction 接口中找到的所有方法。您可以使用 TransactionManager 对象进行事务分离。另外，TransactionManager 对象支持这些方法：

JTA 事务 接口有以下定义：

interface javax.transaction.Transaction {

    public void commit();

    public void rollback();

    public void setRollbackOnly();

    public int getStatus();

    public boolean enlistResource(XAResource xaRes);

    public boolean delistResource(XAResource xaRes, int flag);

    public void registerSynchronization(Synchronization sync);
}

commit（）, rollback（）, setRollbackOnly（） 和 getStatus（） 方法的行为与 UserTransaction 界面中对应的方法相同。实际上，UserTransaction 对象是一种方便的打包程序，它可检索当前的事务，然后在 Transaction 对象上调用对应的方法。

另外，Transaction 接口定义了以下方法，在 UserTransaction 接口中没有对应的项：

Enlisting an XA 资源及事务涉及在 Transaction 接口上调用 enlistResource（） 方法。例如，给定一个 TransactionManager 对象和一个 XAResource 对象，您可以按照如下所示列出 XAResource 对象：

// Java
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import javax.transaction.xa.XAResource;
...
// Given:
// 'tm' of type TransactionManager
// 'xaResource' of type XAResource

// Start the transaction
tm.begin();

Transaction transaction = tm.getTransaction();
transaction.enlistResource(xaResource);

// Do some work...
...

// End the transaction
tm.commit();

列出资源的一个技巧是，资源必须在每个新的事务上被列出，且在开始使用资源前必须被列出该资源。如果您明确获取资源，则可能会得到一个容易出错的代码，这些代码已被 enlistResource（） 调用。此外，有时候，在正确的位置调用 enlistResource（） 可能比较困难，例如，如果您使用可隐藏部分事务详情的框架，就很困难。

通过使用支持Aselisting of XA 资源的功能，而不是明确列出了 XA 资源，而是更容易且更安全。例如，在使用 JMS 和 JDBC 资源的情况下，标准技术是使用支持自动清单的 wrapper 类。

JDBC 和 JMS 访问的通用模式是：

这样，应用程序代码仍然使用 javax.sql.DataSource 和 javax.jms.ConnectionFactory，但在访问这些时，还有额外的功能，通常有问题：

通过自动列出，应用程序代码不需要更改。

有关为 JDBC 数据源和列出打包程序以及 JMS 连接工厂的更多信息，请参阅 第 6 章 使用 JDBC 数据源 和 第 7 章 使用 JMS 连接工厂。

JDBC 数据源实施分为两个类别：

常见 javax.sql.DataSource 实现可能会令人困惑，无法自行创建特定于数据库的连接。即使 通用 数据源可以使用 java.sql.Driver.connect（） 或 java.sql.DriverManager.getConnection（），通常最好使用特定于数据库的 javax.sql.DataSource 实现配置此 通用 数据源。

当 通用 数据源与 JTA 交互时，它 必须配置有 javax.sql.XADataSource 的数据库特定实施。

要关闭图片，通用 数据源 通常不需要 特定于数据库的 javax.sql.ConnectionPoolDataSource 来执行连接池。现有池通常处理没有标准 JDBC 接口（javax.sql.ConnectionPoolDataSource 和 javax.sql.PooledConnection）的池，而是使用自己的自定义实施。

例如，众所周知的通用数据源 Apache Commons DBCP(2).

如上图中所示，驱动程序直接提供 javax.sql.ConnectionPoolDataSource，或利用 org.apache.commons.dbcp2.cpdsadapter.DriverAdapterCPDS 适配器的 帮助，而 DBCP2 实施了 应用服务器 合同之一：

这两个池均在配置阶段获取 javax.sql.ConnectionPoolDataSource 的实例。

这是 DBCP2 中最重要的和有趣的部分：

以下是 DBCP 2 的一般数据源列表：

这里有 两个问题 ：

两种数据源都执行 java.sql.Connection 对象的 池。唯一的 区别是：

推荐的模式是：

以下是一个 规范的示例 ：

// Database-specific, non-pooling, non-enlisting javax.sql.XADataSource
PGXADataSource postgresql = new org.postgresql.xa.PGXADataSource();
// Database-specific configuration
postgresql.setUrl("jdbc:postgresql://localhost:5432/reportdb");
postgresql.setUser("fuse");
postgresql.setPassword("fuse");
postgresql.setCurrentSchema("report");
postgresql.setConnectTimeout(5);
// ...

// Non database-specific, pooling, enlisting javax.sql.DataSource
BasicManagedDataSource pool = new org.apache.commons.dbcp2.managed.BasicManagedDataSource();
// Delegate to database-specific XADatasource
pool.setXaDataSourceInstance(postgresql);
// Delegate to JTA transaction manager
pool.setTransactionManager(transactionManager);
// Non database-specific configuration
pool.setMinIdle(3);
pool.setMaxTotal(10);
pool.setValidationQuery("select schema_name, schema_owner from information_schema.schemata");
// ...

// JDBC code:
javax.sql.DataSource applicationDataSource = pool;

try (Connection c = applicationDataSource.getConnection()) {
    try (Statement st = c.createStatement()) {
        try (ResultSet rs = st.executeQuery("select ...")) {
            // ....

在 Fuse 环境中，有很多配置选项且不需要使用 DBCP2。

使用 pax-jdbc （或 pax-jdbc-mysql,pax-jdbc-oracle, …​）捆绑包时，您可以具有 org.osgi.service.jdbc.DataSourceFactory 服务，注册可用于获取给定数据库的数据源（请参阅 第 6.2.1 节 “特定于数据库及通用数据源”）。但是您还没有实际数据源。

mvn:org.ops4j.pax.jdbc/pax-jdbc-config/1.3.0 捆绑包提供了一个可执行以下操作的托管服务工厂：

以下是从全新的 Fuse 安装开始的详细 规范 步骤指南。

您现在有一个特定于数据库的（还没有池）数据源。您已经将其注入了需要的位置。例如，您可以使用 Karaf 命令来查询数据库：

karaf@root()> feature:install -v jdbc
Adding features: jdbc/[4.2.0.fuse-000237-redhat-1,4.2.0.fuse-000237-redhat-1]
...
karaf@root()> jdbc:ds-list
Mon May 14 08:46:22 CEST 2018 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Name    │ Product │ Version │ URL                                  │ Status
────────┼─────────┼─────────┼──────────────────────────────────────┼───────
mysqlds │ MySQL   │ 5.7.21  │ jdbc:mysql://localhost:3306/reportdb │ OK

karaf@root()> jdbc:query mysqlds 'select * from incident'
Mon May 14 08:46:46 CEST 2018 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
date                  │ summary    │ name   │ details                       │ id │ email
──────────────────────┼────────────┼────────┼───────────────────────────────┼────┼─────────────────
2018-02-20 08:00:00.0 │ Incident 1 │ User 1 │ This is a report incident 001 │ 1  │ user1@redhat.com
2018-02-20 08:10:00.0 │ Incident 2 │ User 2 │ This is a report incident 002 │ 2  │ user2@redhat.com
2018-02-20 08:20:00.0 │ Incident 3 │ User 3 │ This is a report incident 003 │ 3  │ user3@redhat.com
2018-02-20 08:30:00.0 │ Incident 4 │ User 4 │ This is a report incident 004 │ 4  │ user4@redhat.com

在上例中，您可以看到 MySQL 警告。这不是一个问题。可能不提供任何属性（而不仅限于 OSGi JDBC 特定属性）：

karaf@root()> config:property-set --pid org.ops4j.datasource.a7941498-9b62-4ed7-94f3-8c7ac9365313 useSSL false

karaf@root()> jdbc:ds-list
Name    │ Product │ Version │ URL                                  │ Status
────────┼─────────┼─────────┼──────────────────────────────────────┼───────
mysqlds │ MySQL   │ 5.7.21  │ jdbc:mysql://localhost:3306/reportdb │ OK

管理 工厂 PID 配置的属性传递到相关的 org.osgi.service.jdbc.DataSource factory 实施。

pax-jdbc-config 捆绑包处理前缀为 jdbc. 的属性。所有这些属性将删除此前缀，其余名称将随即传递。

下面是一下例子，从全新的 Fuse 安装开始：

karaf@root()> install -s mvn:mysql/mysql-connector-java/5.1.34
Bundle ID: 223
karaf@root()> install -s mvn:org.osgi/org.osgi.service.jdbc/1.0.0
Bundle ID: 224
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-mysql/1.3.0
Bundle ID: 225
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc/1.3.0
Bundle ID: 226
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-pool-common/1.3.0
Bundle ID: 227
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-config/1.3.0
Bundle ID: 228

karaf@root()> config:edit --factory --alias mysql org.ops4j.datasource
karaf@root()> config:property-set osgi.jdbc.driver.name mysql
karaf@root()> config:property-set dataSourceName mysqlds
karaf@root()> config:property-set dataSourceType DataSource
karaf@root()> config:property-set jdbc.url jdbc:mysql://localhost:3306/reportdb
karaf@root()> config:property-set jdbc.user fuse
karaf@root()> config:property-set jdbc.password fuse
karaf@root()> config:property-set jdbc.useSSL false
karaf@root()> config:update

karaf@root()> config:list '(service.factoryPid=org.ops4j.datasource)'
----------------------------------------------------------------
Pid:            org.ops4j.datasource.7c3ee718-7309-46a0-ae3a-64b38b17a0a3
FactoryPid:     org.ops4j.datasource
BundleLocation: ?
Properties:
   dataSourceName = mysqlds
   dataSourceType = DataSource
   felix.fileinstall.filename = file:/data/servers/7.11.1.fuse-7_11_1-00013-redhat-00003/etc/org.ops4j.datasource-mysql.cfg
   jdbc.password = fuse
   jdbc.url = jdbc:mysql://localhost:3306/reportdb
   jdbc.useSSL = false
   jdbc.user = fuse
   osgi.jdbc.driver.name = mysql
   service.factoryPid = org.ops4j.datasource
   service.pid = org.ops4j.datasource.7c3ee718-7309-46a0-ae3a-64b38b17a0a3

karaf@root()> service:list javax.sql.DataSource
[javax.sql.DataSource]
----------------------
 dataSourceName = mysqlds
 dataSourceType = DataSource
 felix.fileinstall.filename = file:${karaf.etc}/org.ops4j.datasource-mysql.cfg
 jdbc.password = fuse
 jdbc.url = jdbc:mysql://localhost:3306/reportdb
 jdbc.user = fuse
 jdbc.useSSL = false
 osgi.jdbc.driver.name = mysql
 osgi.jndi.service.name = mysqlds
 pax.jdbc.managed = true
 service.bundleid = 228
 service.factoryPid = org.ops4j.datasource
 service.id = 246
 service.pid = org.ops4j.datasource.7c3ee718-7309-46a0-ae3a-64b38b17a0a3
 service.scope = singleton
Provided by :
 OPS4J Pax JDBC Config (228)

pax-jdbc-config 捆绑包需要以下属性：

定位并调用相关的 org.osgi.service.jdbc.DataSourceFactory 方法。带有 jdbc. 前缀的属性传递（在删除前缀后），例如 org.osgi.service.jdbc.DataSource factory.createDataSource(properties)。但是，这些属性会在没有删除前缀的情况下添加，例如 javax.sql.DataSource OSGi 服务的属性。

前面的示例显示了如何注册特定于数据库的数据源 工厂。由于 数据源 本身是连接的工厂，因此 org.osgi.service.jdbc.DataSource onnectionFactoryy 可以被视为一个 元数据工厂，应能够生成三种类型的数据源，再加上一种好处，它是 java.sql.Driver）：

例如，pax-jdbc-mysql 注册一个 org.ops4j.pax.jdbc.mysql.impl.MysqlDataSource factory，它将生成：

PostgreSQL 驱动程序本身实施 OSGi JDBC 服务并生成：

如 规范 DataSource 示例 所示，任何 池、通用 数据源（如果希望在 JTA 环境中工作）都需要一个 数据库特定的 数据源来实际获取(XA)连接。

我们已拥有后者，我们需要实际的通用、可靠的连接池。

规范 DataSource 示例 显示如何使用特定数据库数据源配置通用池。pax-jdbc-pool-* 捆绑包与上述 org.osgi.service.jdbc.DataSourceFactory 服务一起工作。

正如 OSGI Enterprise R6 JDBC 规范提供 org.osgi.service.jdbc.DataSourceFactory 标准接口，pax-jdbc-pool-common 提供 专有 org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory 接口：

public interface PooledDataSourceFactory {

    javax.sql.DataSource create(org.osgi.service.jdbc.DataSourceFactory dsf, Properties config)

}

这个界面完全符合这个重要备注，前文中会值得重复操作：

这个接口只是从特定数据库（非后台数据）创建一个池化数据源。或者更精确地说，它是一个数据源工厂 （元数据工厂），将特定于数据库的数据源的工厂转变为池化数据源的因素。

下表显示了哪些捆绑包注册了池化数据源因素。在表格中，o.o.p.j.p 的实例代表 org.ops4j.pax.jdbc.pool。

以上捆绑包只安装数据源因子，而不是数据源本身。应用程序需要调用 javax.sql.DataSource create(org.osgi.service.jdbc.DataSourceFactory dsf, Properties config) 方法的内容。

关于通用数据源的小节 提供了有关如何使用和配置 Apache Commons DBCP 模块的示例。本节演示了如何在 Fuse OSGi 环境中进行此操作。

考虑 第 6.4.1 节 “PAX- JDBC 配置服务” 捆绑包。除了跟踪以下内容外：

该捆绑包还跟踪 org.ops4j.pax.jdbc.pool.common.PooledDataSource elementy 的实例，这些实例由 pax-jdbc-pool-* 捆绑包之一注册。

如果 factory 配置中包含 pool 属性，则 pax-jdbc-config 捆绑包注册的最终数据源是特定于数据库的数据，但是如果 pool=dbcp2之一嵌套在以下之一中：

这与 通用数据源示例 一致。除 pool 属性外，以及 boolean xa 属性（选择非 xa 或 xa 数据源外，org.ops4j.datasource factory PID 可以包含 前缀 属性：

使用每个属性的位置取决于使用哪个 pax-jdbc-pool-* 捆绑包。对于 DBCP2，它是：

# Configuration for pax-jdbc-config to choose and configure specific org.osgi.service.jdbc.DataSourceFactory
dataSourceName = mysqlds
dataSourceType = DataSource
osgi.jdbc.driver.name = mysql
jdbc.url = jdbc:mysql://localhost:3306/reportdb
jdbc.user = fuse
jdbc.password = fuse
jdbc.useSSL = false

# Hints for pax-jdbc-config to use org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory
pool = dbcp2
xa = false

# dbcp2 specific configuration of org.apache.commons.pool2.impl.GenericObjectPoolConfig
pool.minIdle = 10
pool.maxTotal = 100
pool.initialSize = 8
pool.blockWhenExhausted = true
pool.maxWaitMillis = 2000
pool.testOnBorrow = true
pool.testWhileIdle = false
pool.timeBetweenEvictionRunsMillis = 120000
pool.evictionPolicyClassName = org.apache.commons.pool2.impl.DefaultEvictionPolicy

# dbcp2 specific configuration of org.apache.commons.dbcp2.PoolableConnectionFactory
factory.maxConnLifetimeMillis = 30000
factory.validationQuery  = select schema_name from information_schema.schemata
factory.validationQueryTimeout = 2

karaf@root()> feature:install pax-jdbc-pool-dbcp2

karaf@root()> bundle:services -p org.ops4j.pax.jdbc.pool.dbcp2

OPS4J Pax JDBC Pooling DBCP2 (230) provides:
--------------------------------------------
objectClass = [org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory]
pool = dbcp2
service.bundleid = 230
service.id = 337
service.scope = singleton
xa = false
-----
objectClass = [org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory]
pool = dbcp2
service.bundleid = 230
service.id = 338
service.scope = singleton
xa = true

pax-jdbc-pool-narayna 模块几乎都是 pax-jdbc-pool-dbcp2。它为 XA 和非 XA 场景安装 DBCP2- 特定 org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory。唯一的 区别是，在 XA 情景中，会有一个额外的集成点。org.jboss.tm.XAResourceRecovery OSGi 服务由 com.arjuna.ats.arjuna.recovery.recoveryManager(recovery.RecoveryManager )进行注册，这是 Narayana 事务管理器的一部分。

pax-jdbc-pool-transx 捆绑包基于其在 pax-transx-jdbc bundle 上的 org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory 服务。pax-transx-jdbc 捆绑包通过使用 org.ops4j.pax.transx.jdbc.ManagedDataSourceBuilder 工具来创建 javax.sql.DataSource SourceSourceSourceSources。这是 JCA（Java™ 连接器架构）解决方案，后文中 所述。

这个手动部署数据源的示例使用了基于 docker 的 PostgreSQL 安装。在此方法中，不需要 pax-jdbc-config。应用程序代码负责注册特定于数据库及通用数据源。

需要三个捆绑包：

<!--
    Database-specific, non-pooling, non-enlisting javax.sql.XADataSource
-->
<bean id="postgresql" class="org.postgresql.xa.PGXADataSource">
    <property name="url" value="jdbc:postgresql://localhost:5432/reportdb" />
    <property name="user" value="fuse" />
    <property name="password" value="fuse" />
    <property name="currentSchema" value="report" />
    <property name="connectTimeout" value="5" />
</bean>

<!--
    Fuse/Karaf exports this service from fuse-pax-transx-tm-narayana bundle
-->
<reference id="tm" interface="javax.transaction.TransactionManager" />

<!--
    Non database-specific, generic, pooling, enlisting javax.sql.DataSource
-->
<bean id="pool" class="org.apache.commons.dbcp2.managed.BasicManagedDataSource">
    <property name="xaDataSourceInstance" ref="postgresql" />
    <property name="transactionManager" ref="tm" />
    <property name="minIdle" value="3" />
    <property name="maxTotal" value="10" />
    <property name="validationQuery" value="select schema_name, schema_owner from information_schema.schemata" />
</bean>

<!--
    Expose datasource to use by application code (like Camel, Spring, ...)
-->
<service interface="javax.sql.DataSource" ref="pool">
    <service-properties>
        <entry key="osgi.jndi.service.name" value="jdbc/postgresql" />
    </service-properties>
</service>

以上蓝图 XML 片段与 规范 DataSource 示例 匹配。以下是显示如何使用它的 shell 命令：

karaf@root()> install -s mvn:org.postgresql/postgresql/42.2.5
Bundle ID: 233
karaf@root()> install -s mvn:org.apache.commons/commons-pool2/2.5.0
Bundle ID: 224
karaf@root()> install -s mvn:org.apache.commons/commons-dbcp2/2.1.1
Bundle ID: 225
karaf@root()> install -s blueprint:file://$PQ_HOME/databases/blueprints/postgresql-manual.xml
Bundle ID: 226

karaf@root()> bundle:services -p 226

Bundle 226 provides:
--------------------
objectClass = [javax.sql.DataSource]
osgi.jndi.service.name = jdbc/postgresql
osgi.service.blueprint.compname = pool
service.bundleid = 226
service.id = 242
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = postgresql-manual.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 226
service.id = 243
service.scope = singleton

karaf@root()> feature:install jdbc

karaf@root()> jdbc:ds-list
Name            │ Product    │ Version                       │ URL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           │ Status
────────────────┼────────────┼───────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼───────
jdbc/postgresql │ PostgreSQL │ 10.3 (Debian 10.3-1.pgdg90+1) │ jdbc:postgresql://localhost:5432/reportdb?prepareThreshold=5&preparedStatementCacheQueries=256&preparedStatementCacheSizeMiB=5&databaseMetadataCacheFields=65536&databaseMetadataCacheFieldsMiB=5&defaultRowFetchSize=0&binaryTransfer=true&readOnly=false&binaryTransferEnable=&binaryTransferDisable=&unknownLength=2147483647&logUnclosedConnections=false&disableColumnSanitiser=false&tcpKeepAlive=false&loginTimeout=0&connectTimeout=5&socketTimeout=0&cancelSignalTimeout=10&receiveBufferSize=-1&sendBufferSize=-1&ApplicationName=PostgreSQL JDBC Driver&jaasLogin=true&useSpnego=false&gsslib=auto&sspiServiceClass=POSTGRES&allowEncodingChanges=false&currentSchema=report&targetServerType=any&loadBalanceHosts=false&hostRecheckSeconds=10&preferQueryMode=extended&autosave=never&reWriteBatchedInserts=false │ OK

karaf@root()> jdbc:query jdbc/postgresql 'select * from incident';
date                │ summary    │ name   │ details                       │ id │ email
────────────────────┼────────────┼────────┼───────────────────────────────┼────┼─────────────────
2018-02-20 08:00:00 │ Incident 1 │ User 1 │ This is a report incident 001 │ 1  │ user1@redhat.com
2018-02-20 08:10:00 │ Incident 2 │ User 2 │ This is a report incident 002 │ 2  │ user2@redhat.com
2018-02-20 08:20:00 │ Incident 3 │ User 3 │ This is a report incident 003 │ 3  │ user3@redhat.com
2018-02-20 08:30:00 │ Incident 4 │ User 4 │ This is a report incident 004 │ 4  │ user4@redhat.com

如上方列表所示，Bartner 捆绑包将导出 javax.sql.DataSource 服务，该服务是一个通用、非特定于数据库的连接池。特定于数据库的 javax.sql.XADataSource 捆绑包 没有 作为 OSGi 服务注册，因为 Blueprint XML 没有明确的 < service ref="postgresql"> 声明。

数据源的工厂部署使用 pax-jdbc-config 捆绑包以规范的方式部署。这与 Fuse 6.x 中推荐的方法有点不同，它要求将配置用作服务属性。

下面是蓝图 XML 示例：

<!--
    A database-specific org.osgi.service.jdbc.DataSourceFactory that can create DataSource/XADataSource/
    /ConnectionPoolDataSource/Driver using properties. It is registered by pax-jdbc-* or for example
    mvn:org.postgresql/postgresql/42.2.5 bundle natively.
-->
<reference id="dataSourceFactory"
        interface="org.osgi.service.jdbc.DataSourceFactory"
        filter="(osgi.jdbc.driver.class=org.postgresql.Driver)" />

<!--
    Non database-specific org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory that can create
    pooled data sources using some org.osgi.service.jdbc.DataSourceFactory. dbcp2 pool is registered
    by pax-jdbc-pool-dbcp2 bundle.
-->
<reference id="pooledDataSourceFactory"
        interface="org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory"
        filter="(&amp;(pool=dbcp2)(xa=true))" />

<!--
    Finally, use both factories to expose pooled, xa-aware data source.
-->
<bean id="pool" factory-ref="pooledDataSourceFactory" factory-method="create">
    <argument ref="dataSourceFactory" />
    <argument>
        <props>
            <!--
                Properties needed by postgresql-specific org.osgi.service.jdbc.DataSourceFactory.
                Cannot prepend them with 'jdbc.' prefix as the DataSourceFactory is implemented directly
                by PostgreSQL driver, not by pax-jdbc-* bundle.
            -->
            <prop key="url" value="jdbc:postgresql://localhost:5432/reportdb" />
            <prop key="user" value="fuse" />
            <prop key="password" value="fuse" />
            <prop key="currentSchema" value="report" />
            <prop key="connectTimeout" value="5" />
            <!-- Properties needed by dbcp2-specific org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory -->
            <prop key="pool.minIdle" value="2" />
            <prop key="pool.maxTotal" value="10" />
            <prop key="pool.blockWhenExhausted" value="true" />
            <prop key="pool.maxWaitMillis" value="2000" />
            <prop key="pool.testOnBorrow" value="true" />
            <prop key="pool.testWhileIdle" value="false" />
            <prop key="factory.validationQuery" value="select schema_name from information_schema.schemata" />
            <prop key="factory.validationQueryTimeout" value="2" />
        </props>
    </argument>
</bean>

<!--
    Expose data source for use by application code (such as  Camel, Spring, ...).
-->
<service interface="javax.sql.DataSource" ref="pool">
    <service-properties>
        <entry key="osgi.jndi.service.name" value="jdbc/postgresql" />
    </service-properties>
</service>

本例使用 factory an 使用数据源创建数据源。您不需要显式引用 javax.transaction.TransactionManager 服务，因为它由 XA-aware PooledDataSourceFactory 内部跟踪。

以下示例在 Fuse/Karaf shell 中相同。

karaf@root()> feature:install jdbc pax-jdbc-config pax-jdbc-pool-dbcp2
karaf@root()> install -s mvn:org.postgresql/postgresql/42.2.5
Bundle ID: 232
karaf@root()> install -s blueprint:file://$PQ_HOME/databases/blueprints/postgresql-pax-jdbc-factory-dbcp2.xml
Bundle ID: 233
karaf@root()> bundle:services -p 233

Bundle 233 provides:
--------------------
objectClass = [javax.sql.DataSource]
osgi.jndi.service.name = jdbc/postgresql
osgi.service.blueprint.compname = pool
service.bundleid = 233
service.id = 336
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = postgresql-pax-jdbc-factory-dbcp2.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 233
service.id = 337
service.scope = singleton

karaf@root()> jdbc:ds-list
Name            │ Product    │ Version                       │ URL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           │ Status
────────────────┼────────────┼───────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼───────
jdbc/postgresql │ PostgreSQL │ 10.3 (Debian 10.3-1.pgdg90+1) │ jdbc:postgresql://localhost:5432/reportdb?prepareThreshold=5&preparedStatementCacheQueries=256&preparedStatementCacheSizeMiB=5&databaseMetadataCacheFields=65536&databaseMetadataCacheFieldsMiB=5&defaultRowFetchSize=0&binaryTransfer=true&readOnly=false&binaryTransferEnable=&binaryTransferDisable=&unknownLength=2147483647&logUnclosedConnections=false&disableColumnSanitiser=false&tcpKeepAlive=false&loginTimeout=0&connectTimeout=5&socketTimeout=0&cancelSignalTimeout=10&receiveBufferSize=-1&sendBufferSize=-1&ApplicationName=PostgreSQL JDBC Driver&jaasLogin=true&useSpnego=false&gsslib=auto&sspiServiceClass=POSTGRES&allowEncodingChanges=false&currentSchema=report&targetServerType=any&loadBalanceHosts=false&hostRecheckSeconds=10&preferQueryMode=extended&autosave=never&reWriteBatchedInserts=false │ OK

karaf@root()> jdbc:query jdbc/postgresql 'select * from incident';
date                │ summary    │ name   │ details                       │ id │ email
────────────────────┼────────────┼────────┼───────────────────────────────┼────┼─────────────────
2018-02-20 08:00:00 │ Incident 1 │ User 1 │ This is a report incident 001 │ 1  │ user1@redhat.com
2018-02-20 08:10:00 │ Incident 2 │ User 2 │ This is a report incident 002 │ 2  │ user2@redhat.com
2018-02-20 08:20:00 │ Incident 3 │ User 3 │ This is a report incident 003 │ 3  │ user3@redhat.com
2018-02-20 08:30:00 │ Incident 4 │ User 4 │ This is a report incident 004 │ 4  │ user4@redhat.com

如上方列表所示，Bartner 捆绑包将导出 javax.sql.DataSource 服务，该服务是一个通用、非特定于数据库的连接池。特定于数据库的 javax.sql.XADataSource 没有 注册为 OSGi 服务，因为 Blueprint XML 没有明确的 < service ref="postgresql"> 声明。

在混合数据源部署中，pax-jdbc-config 1.3.0 捆绑包增加了使用服务属性将特定于数据库数据源嵌套在数据源中的另一方式。此方法与 Fuse 6.x 中的工作方式一致。

以下是 Blueprint XML 示例：

<!--
    Database-specific, non-pooling, non-enlisting javax.sql.XADataSource
-->
<bean id="postgresql" class="org.postgresql.xa.PGXADataSource">
    <property name="url" value="jdbc:postgresql://localhost:5432/reportdb" />
    <property name="user" value="fuse" />
    <property name="password" value="fuse" />
    <property name="currentSchema" value="report" />
    <property name="connectTimeout" value="5" />
</bean>

<!--
    Expose database-specific data source with service properties.
    No need to expose pooling, enlisting, non database-specific javax.sql.DataSource. It is registered
    automatically by pax-jdbc-config with the same properties as this <service>, but with higher service.ranking.
-->
<service id="pool" ref="postgresql" interface="javax.sql.XADataSource">
    <service-properties>
        <!-- "pool" key is needed for pax-jdbc-config to wrap database-specific data source inside connection pool -->
        <entry key="pool" value="dbcp2" />
        <entry key="osgi.jndi.service.name" value="jdbc/postgresql" />
        <!-- Other properties that configure given connection pool, as indicated by pool=dbcp2 -->
        <entry key="pool.minIdle" value="2" />
        <entry key="pool.maxTotal" value="10" />
        <entry key="pool.blockWhenExhausted" value="true" />
        <entry key="pool.maxWaitMillis" value="2000" />
        <entry key="pool.testOnBorrow" value="true" />
        <entry key="pool.testWhileIdle" value="false" />
        <entry key="factory.validationQuery" value="select schema_name from information_schema.schemata" />
        <entry key="factory.validationQueryTimeout" value="2" />
    </service-properties>
</service>

在上例中，只有数据库特定的数据源会被手动注册。pool=dbcp2 service 属性是数据源跟踪器的提示，它由 pax-jdbc-config 捆绑包管理。带有这个服务属性的数据源服务嵌套在池数据源内，本例中为 pax-jdbc-pool-dbcp2。

以下是 Fuse/Karaf shell 中的相同示例：

karaf@root()> feature:install jdbc pax-jdbc-config pax-jdbc-pool-dbcp2
karaf@root()> install -s mvn:org.postgresql/postgresql/42.2.5
Bundle ID: 232
karaf@root()> install -s blueprint:file://$PQ_HOME/databases/blueprints/postgresql-pax-jdbc-discovery.xml
Bundle ID: 233
karaf@root()> bundle:services -p 233

Bundle 233 provides:
--------------------
factory.validationQuery = select schema_name from information_schema.schemata
factory.validationQueryTimeout = 2
objectClass = [javax.sql.XADataSource]
osgi.jndi.service.name = jdbc/postgresql
osgi.service.blueprint.compname = postgresql
pool = dbcp2
pool.blockWhenExhausted = true
pool.maxTotal = 10
pool.maxWaitMillis = 2000
pool.minIdle = 2
pool.testOnBorrow = true
pool.testWhileIdle = false
service.bundleid = 233
service.id = 336
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = postgresql-pax-jdbc-discovery.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 233
service.id = 338
service.scope = singleton

karaf@root()> service:list javax.sql.XADataSource
[javax.sql.XADataSource]
------------------------
 factory.validationQuery = select schema_name from information_schema.schemata
 factory.validationQueryTimeout = 2
 osgi.jndi.service.name = jdbc/postgresql
 osgi.service.blueprint.compname = postgresql
 pool = dbcp2
 pool.blockWhenExhausted = true
 pool.maxTotal = 10
 pool.maxWaitMillis = 2000
 pool.minIdle = 2
 pool.testOnBorrow = true
 pool.testWhileIdle = false
 service.bundleid = 233
 service.id = 336
 service.scope = bundle
Provided by :
 Bundle 233
Used by:
 OPS4J Pax JDBC Config (224)

karaf@root()> service:list javax.sql.DataSource
[javax.sql.DataSource]
----------------------
 factory.validationQuery = select schema_name from information_schema.schemata
 factory.validationQueryTimeout = 2
 osgi.jndi.service.name = jdbc/postgresql
 osgi.service.blueprint.compname = postgresql
 pax.jdbc.managed = true
 pax.jdbc.service.id.ref = 336
 pool.blockWhenExhausted = true
 pool.maxTotal = 10
 pool.maxWaitMillis = 2000
 pool.minIdle = 2
 pool.testOnBorrow = true
 pool.testWhileIdle = false
 service.bundleid = 224
 service.id = 337
 service.ranking = 1000
 service.scope = singleton
Provided by :
 OPS4J Pax JDBC Config (224)

karaf@root()> jdbc:ds-list
Name            │ Product    │ Version                       │ URL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           │ Status
────────────────┼────────────┼───────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼───────
jdbc/postgresql │ PostgreSQL │ 10.3 (Debian 10.3-1.pgdg90+1) │ jdbc:postgresql://localhost:5432/reportdb?prepareThreshold=5&preparedStatementCacheQueries=256&preparedStatementCacheSizeMiB=5&databaseMetadataCacheFields=65536&databaseMetadataCacheFieldsMiB=5&defaultRowFetchSize=0&binaryTransfer=true&readOnly=false&binaryTransferEnable=&binaryTransferDisable=&unknownLength=2147483647&logUnclosedConnections=false&disableColumnSanitiser=false&tcpKeepAlive=false&loginTimeout=0&connectTimeout=5&socketTimeout=0&cancelSignalTimeout=10&receiveBufferSize=-1&sendBufferSize=-1&ApplicationName=PostgreSQL JDBC Driver&jaasLogin=true&useSpnego=false&gsslib=auto&sspiServiceClass=POSTGRES&allowEncodingChanges=false&currentSchema=report&targetServerType=any&loadBalanceHosts=false&hostRecheckSeconds=10&preferQueryMode=extended&autosave=never&reWriteBatchedInserts=false │ OK
jdbc/postgresql │ PostgreSQL │ 10.3 (Debian 10.3-1.pgdg90+1) │ jdbc:postgresql://localhost:5432/reportdb?prepareThreshold=5&preparedStatementCacheQueries=256&preparedStatementCacheSizeMiB=5&databaseMetadataCacheFields=65536&databaseMetadataCacheFieldsMiB=5&defaultRowFetchSize=0&binaryTransfer=true&readOnly=false&binaryTransferEnable=&binaryTransferDisable=&unknownLength=2147483647&logUnclosedConnections=false&disableColumnSanitiser=false&tcpKeepAlive=false&loginTimeout=0&connectTimeout=5&socketTimeout=0&cancelSignalTimeout=10&receiveBufferSize=-1&sendBufferSize=-1&ApplicationName=PostgreSQL JDBC Driver&jaasLogin=true&useSpnego=false&gsslib=auto&sspiServiceClass=POSTGRES&allowEncodingChanges=false&currentSchema=report&targetServerType=any&loadBalanceHosts=false&hostRecheckSeconds=10&preferQueryMode=extended&autosave=never&reWriteBatchedInserts=false │ OK

karaf@root()> jdbc:query jdbc/postgresql 'select * from incident'
date                │ summary    │ name   │ details                       │ id │ email
────────────────────┼────────────┼────────┼───────────────────────────────┼────┼─────────────────
2018-02-20 08:00:00 │ Incident 1 │ User 1 │ This is a report incident 001 │ 1  │ user1@redhat.com
2018-02-20 08:10:00 │ Incident 2 │ User 2 │ This is a report incident 002 │ 2  │ user2@redhat.com
2018-02-20 08:20:00 │ Incident 3 │ User 3 │ This is a report incident 003 │ 3  │ user3@redhat.com
2018-02-20 08:30:00 │ Incident 4 │ User 4 │ This is a report incident 004 │ 4  │ user4@redhat.com

在本列表中，如您在 jdbc:ds-list 输出中看到的一样，有两个 数据源，即原始数据源和 wrapper 数据源。

javax.sql.XADataSource 从 Blueprint 捆绑包中注册，并且具有 pool = dbcp2 属性声明。

javax.sql.DataSource 在 pax-jdbc-config 捆绑包中注册，并且：

META-INF/persistence.xml 描述符（请参阅 JPA 2.1 规格 8.2.1.5 jta-data-source）定义两种数据源引用：

这两个数据源与 javax.sql.DataSource 或 javax.sql.XADataSource 无关！这是开发 JPA 应用程序时常见的误解。两个 JNDI 名称都必须引用 JNDI 绑定 javax.sql.DataSource 服务。

当您使用 osgi.jndi.service.name 属性注册 OSGi 服务时，它已在 OSGi JNDI 服务中 绑定。在 OSGi 运行时（如 Fuse/Karaf）中，JNDI 不是 name → value 对的简单字典。通过 OSGi 中的 JNDI 名称引用对象，涉及服务查找和其他更复杂的 OSGi 机制，如服务 hook。

在全新的 Fuse 安装中，以下列表显示了在 JNDI 中注册数据源的方式：

karaf@root()> install -s mvn:mysql/mysql-connector-java/5.1.34
Bundle ID: 223
karaf@root()> install -s mvn:org.osgi/org.osgi.service.jdbc/1.0.0
Bundle ID: 224
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-mysql/1.3.0
Bundle ID: 225
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc/1.3.0
Bundle ID: 226
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-pool-common/1.3.0
Bundle ID: 227
karaf@root()> install -s mvn:org.ops4j.pax.jdbc/pax-jdbc-config/1.3.0
Bundle ID: 228

karaf@root()> config:edit --factory --alias mysql org.ops4j.datasource
karaf@root()> config:property-set osgi.jdbc.driver.name mysql
karaf@root()> config:property-set dataSourceName mysqlds
karaf@root()> config:property-set osgi.jndi.service.name jdbc/mysqlds
karaf@root()> config:property-set dataSourceType DataSource
karaf@root()> config:property-set jdbc.url jdbc:mysql://localhost:3306/reportdb
karaf@root()> config:property-set jdbc.user fuse
karaf@root()> config:property-set jdbc.password fuse
karaf@root()> config:property-set jdbc.useSSL false
karaf@root()> config:update

karaf@root()> feature:install jndi

karaf@root()> jndi:names
JNDI Name                 │ Class Name
──────────────────────────┼───────────────────────────────────────────────
osgi:service/jndi         │ org.apache.karaf.jndi.internal.JndiServiceImpl
osgi:service/jdbc/mysqlds │ com.mysql.jdbc.jdbc2.optional.MysqlDataSource

如您所见，数据源位于 osgi:service/jdbc/mysqlds JNDI 名称下。

但是，如果 OSGi 中的 JPA，您必须使用 完整的 JNDI 名称。以下是指定数据源参考的 META-INF/persistence.xml 片段示例：

<jta-data-source>
    osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=jdbc/mysqlds)
</jta-data-source>
<non-jta-data-source>
    osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=jdbc/mysqlds)
</non-jta-data-source>

如果没有上述配置，您可能会得到这个错误：

Persistence unit "pu-name" refers to a non OSGi service DataSource

下面是一本例行的、规范、分步指南，用于创建一个对 runc 代理的连接因子。

现在，您有特定于代理（没有池）连接工厂，您可以在需要时注入。例如，您可以使用 jms 功能中的 Karaf 命令：

karaf@root()> feature:install -v jms
Adding features: jms/[4.2.0.fuse-000237-redhat-1,4.2.0.fuse-000237-redhat-1]
...
karaf@root()> jms:connectionfactories
JMS Connection Factory
──────────────────────
jms/artemis

karaf@root()> jms:info -u admin -p admin jms/artemis
Property │ Value
─────────┼──────────────────────────
product  │ ActiveMQ
version  │ 2.4.0.amq-711002-redhat-1

karaf@root()> jms:send -u admin -p admin jms/artemis DEV.QUEUE.1 "Hello Artemis"

karaf@root()> jms:browse -u admin -p admin jms/artemis DEV.QUEUE.1
Message ID                              │ Content       │ Charset │ Type │ Correlation ID │ Delivery Mode │ Destination                │ Expiration │ Priority │ Redelivered │ ReplyTo │ Timestamp
────────────────────────────────────────┼───────────────┼─────────┼──────┼────────────────┼───────────────┼────────────────────────────┼────────────┼──────────┼─────────────┼─────────┼──────────────────────────────
ID:2b6ea56d-574d-11e8-971a-7ee9ecc029d4 │ Hello Artemis │ UTF-8   │      │                │ Persistent    │ ActiveMQQueue[DEV.QUEUE.1] │ Never      │ 4        │ false       │         │ Mon May 14 10:02:38 CEST 2018

以下列表显示了切换协议时会发生什么：

karaf@root()> config:list '(service.factoryPid=org.ops4j.connectionfactory)'
----------------------------------------------------------------
Pid:            org.ops4j.connectionfactory.965d4eac-f5a7-4f65-ba1a-15caa4c72703
FactoryPid:     org.ops4j.connectionfactory
BundleLocation: ?
Properties:
   connectionFactoryType = ConnectionFactory
   felix.fileinstall.filename = file:${karaf.etc}/org.ops4j.connectionfactory-artemis.cfg
   jms.consumerMaxRate = 1234
   jms.password = fuse
   jms.url = tcp://localhost:61616
   jms.user = fuse
   osgi.jndi.service.name = jms/artemis
   service.factoryPid = org.ops4j.connectionfactory
   service.pid = org.ops4j.connectionfactory.965d4eac-f5a7-4f65-ba1a-15caa4c72703
   type = artemis

karaf@root()> config:edit org.ops4j.connectionfactory.312eb09a-d686-4229-b7e1-2ea38a77bb0f
karaf@root()> config:property-set protocol amqp
karaf@root()> config:property-delete user
karaf@root()> config:property-set username admin # mind the difference between artemis-jms-client and qpid-jms-client
karaf@root()> config:property-set jms.url amqp://localhost:61616
karaf@root()> config:update

karaf@root()> jms:info -u admin -p admin jms/artemis
Property │ Value
─────────┼────────────────
product  │ QpidJMS
version  │ 0.30.0.redhat-1

karaf@root()> jms:browse -u admin -p admin jms/artemis DEV.QUEUE.1
Message ID │ Content       │ Charset │ Type │ Correlation ID │ Delivery Mode │ Destination │ Expiration │ Priority │ Redelivered │ ReplyTo │ Timestamp
───────────┼───────────────┼─────────┼──────┼────────────────┼───────────────┼─────────────┼────────────┼──────────┼─────────────┼─────────┼──────────────────────────────
           │ Hello Artemis │ UTF-8   │      │                │ Persistent    │ DEV.QUEUE.1 │ Never      │ 4        │ false       │         │ Mon May 14 10:02:38 CEST 2018

本节演示了如何连接到 IBM MQ 8 和 IBM MQ 9。尽管 pax-jms-ibmmq 安装相关的 pax-jms 捆绑包，但由于许可原因，也不会安装 IBM MQ 驱动程序。

您还可以检查信息是否已从 IBM MQ Explorer 或 web 控制台发送。

您可以从 Fuse Software Downloads 页面下载 Fuse 快速入门。

将快速入门 zip 文件的内容提取到本地文件夹，如名为 Quickstart 的文件夹。

您可以将 快速入门/camel/camel-jms 示例作为 OSGi 捆绑包来构建并安装。此捆绑包包含 Camel 路由的蓝图 XML 定义，用于将消息发送到 JBoss A-MQ 6.3 JMS 队列。为 JBoss A-MQ 6.3 代理创建连接工厂的步骤如下：

Configuration Admin factory PID 中的属性传递到相关的 org.ops4j.pax.jms.service.ConnectionFactoryonnectionFactoryy 实施。

目前，您已注册了特定于代理的 连接工厂。由于 连接工厂 本身是连接工厂的工厂，因此 org.ops4j.pax.jms.service.ConnectionFactoryonnectionFactory y 服务可以被视为元数据 工厂。它应该可以生成两种连接工厂：

pax-jms-pool-* 捆绑包可以与 org.ops4j.pax.jms.service.ConnectionFactoryonnectionFactoryy 服务一起正常工作。这些捆绑包提供了 org.ops4j.pax.jms.service.PooledConnectionFactoryonnectionFactory y 的实施，它通过使用一组属性和原始 org.ops4j.pax.jms.service.ConnectionFactor yy 来创建池连接工厂。例如：

public interface PooledConnectionFactoryFactory {

    ConnectionFactory create(ConnectionFactoryFactory cff, Map<String, Object> props);

}

下表显示了哪些捆绑包注册了池连接工厂。在表格中，o.o.p.j.p 代表 org.ops4j.pax.jms.pool。

以上捆绑包只安装连接工厂。要安装的捆绑包本身不安装连接。因此，需要调用 javax.jms.ConnectionFactory org.ops4j.pax.jms.service.PooledConnectionFactoryonnectionFactoryy.create（） 方法所需要的内容。

了解如何使用 pax-jms-pool-pooledjms 捆绑包可帮助您仅使用 pax-jms-pool-pooledjms 捆绑包，但 pax-jms-pool-narayna bundle 几乎都是 pax-jms-pool-pooledjms。

pax-jms-config 捆绑包会跟踪以下内容：

如果 工厂配置 包含 pool 属性，则由 pax-jms-config 捆绑包注册的最终连接工厂为代理特定的连接工厂。如果 pool=pooledjms，则连接工厂将在以下之一内换行：

除了 池 属性（以及布尔值 xa 属性外，它选择非 xa/xa 连接工厂之一），org.ops4j.connection factory PID 可能包含以 pool. 前缀的属性。

对于 pooled-jms 库，这些前缀属性被使用（删除前缀后）来配置实例：

以下列表是 池ed-jms 池（org.ops4j.connectionfactory-artemis factory PID工厂）的真实配置，它使用带有 jms.-prefixed 的便捷语法：

# configuration for pax-jms-config to choose and configure specific org.ops4j.pax.jms.service.ConnectionFactoryFactory
name = jms/artemis
connectionFactoryType = ConnectionFactory
jms.url = tcp://localhost:61616
jms.user = fuse
jms.password = fuse
# org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory specific coniguration
jms.callTimeout = 12000
# ...

# hints for pax-jms-config to use selected org.ops4j.pax.jms.service.PooledConnectionFactoryFactory
pool = pooledjms
xa = false

# pooled-jms specific configuration of org.messaginghub.pooled.jms.JmsPoolConnectionFactory
pool.idleTimeout = 10
pool.maxConnections = 100
pool.blockIfSessionPoolIsFull = true
# ...

在上述配置中，池和 xa 键是 提示 （服务过滤器属性）用于选择其中一个注册的 org.ops4j.pax.jms.service.PooledConnectionFactoryonnectionFactoryy 服务。如果是 pooled-jms 库，这是：

karaf@root()> feature:install pax-jms-pool-pooledjms

karaf@root()> bundle:services -p org.ops4j.pax.jms.pax-jms-pool-pooledjms

OPS4J Pax JMS MessagingHub JMS Pool implementation (252) provides:
------------------------------------------------------------------
objectClass = [org.ops4j.pax.jms.service.PooledConnectionFactoryFactory]
pool = pooledjms
service.bundleid = 252
service.id = 331
service.scope = singleton
xa = false
-----
objectClass = [org.ops4j.pax.jms.service.PooledConnectionFactoryFactory]
pool = pooledjms
service.bundleid = 252
service.id = 335
service.scope = singleton
xa = true

以下是创建和配置连接池的完整示例：

pax-jms-pool-narayna 模块几乎都有 pax-jms-pool-pooledjms 的所有内容。它安装特定于 pooled-jms 的 org.ops4j.pax.jms.service.PooledConnectionFactoryonnectionFactory y，它们适用于 XA 和非 XA 场景。唯一的 区别是在 XA 方案中，有一个额外的集成点。org.jboss.tm.XAResourceRecovery OSGi 服务由 com.arjuna.ats.arjuna.recoveryManager 获取。

pax-jms-pool-transx 模块提供了一个 org.ops4j.pax.jms.service.PooledConnectionFactoryonnectionFactoryy 服务（基于 pax-transx-jms 捆绑包）的实施。pax-transx-jms 捆绑包通过使用 org .ops4j.pax.transx.ManagedConnectionFactory 功能来创建 java x.jms.jms.ConnectionFactoryBuilder 池。这是 第 8.3 节 “关于 pax-transx 项目” 中讨论的 JCA（Java™ 连接器架构）解决方案。

在此方法中，不需要 pax-jms-config 捆绑包。应用程序代码负责注册特定于代理和通用连接池。

<!--
    Broker-specific, non-pooling, non-enlisting javax.jms.XAConnectionFactory
-->
<bean id="artemis" class="org.apache.activemq.artemis.jms.client.ActiveMQXAConnectionFactory">
    <argument value="tcp://localhost:61616" />
    <property name="callTimeout" value="2000" />
    <property name="initialConnectAttempts" value="3" />
</bean>

<!--
    Fuse exports this service from fuse-pax-transx-tm-narayana bundle.
-->
<reference id="tm" interface="javax.transaction.TransactionManager" />

<!--
    Non broker-specific, generic, pooling, enlisting javax.jms.ConnectionFactory
-->
<bean id="pool" class="org.messaginghub.pooled.jms.JmsPoolXAConnectionFactory">
    <property name="connectionFactory" ref="artemis" />
    <property name="transactionManager" ref="tm" />
    <property name="maxConnections" value="10" />
    <property name="idleTimeout" value="10000" />
</bean>

<!--
    Expose connection factory for use by application code (such as Camel, Spring, ...)
-->
<service interface="javax.jms.ConnectionFactory" ref="pool">
    <service-properties>
        <!-- Giving connection factory a name using one of these properties makes identification easier in jms:connectionfactories: -->
        <entry key="osgi.jndi.service.name" value="jms/artemis" />
        <!--<entry key="name" value="jms/artemis" />-->
        <!-- Without any of the above, name will fall back to "service.id" -->
    </service-properties>
</service>

以下是显示如何使用它的 shell 命令：

karaf@root()> feature:install artemis-core-client artemis-jms-client
karaf@root()> install -s mvn:org.apache.commons/commons-pool2/2.5.0
Bundle ID: 244
karaf@root()> install -s mvn:org.messaginghub/pooled-jms/0.3.0
Bundle ID: 245
karaf@root()> install -s blueprint:file://$PQ_HOME/message-brokers/blueprints/artemis-manual.xml
Bundle ID: 246

karaf@root()> bundle:services -p 246

Bundle 246 provides:
--------------------
objectClass = [javax.jms.ConnectionFactory]
osgi.jndi.service.name = jms/artemis
osgi.service.blueprint.compname = pool
service.bundleid = 246
service.id = 340
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = artemis-manual.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 246
service.id = 341
service.scope = singleton

karaf@root()> feature:install jms

karaf@root()> jms:connectionfactories
JMS Connection Factory
──────────────────────
jms/artemis

karaf@root()> jms:info -u admin -p admin jms/artemis
Property │ Value
─────────┼──────────────────────────
product  │ ActiveMQ
version  │ 2.4.0.amq-711002-redhat-1

如上方列表所示，Bartner 捆绑包将导出 javax.jms.ConnectionFactory 服务，该服务是一个通用、非特定于代理的连接池。特定于代理的 javax.jms.XAConnectionFactory 没有 注册为 OSGi 服务，因为 Blueprint XML 没有明确的 < service ref="artemis"> 声明。

此方法以 规范 的方式显示使用 pax-jms-config。这与 Fuse 6.x 推荐的方法稍有不同，因为要求将配置指定为服务属性。

下面是蓝图 XML 示例：

<!--
    A broker-specific org.ops4j.pax.jms.service.ConnectionFactoryFactory that can create (XA)ConnectionFactory
    using properties. It is registered by pax-jms-* bundles
-->
<reference id="connectionFactoryFactory"
        interface="org.ops4j.pax.jms.service.ConnectionFactoryFactory"
        filter="(type=artemis)" />

<!--
    Non broker-specific org.ops4j.pax.jms.service.PooledConnectionFactoryFactory that can create
    pooled connection factories with the help of org.ops4j.pax.jms.service.ConnectionFactoryFactory

    For example, pax-jms-pool-pooledjms bundle registers org.ops4j.pax.jms.service.PooledConnectionFactoryFactory
    with these properties:
     - pool = pooledjms
     - xa = true|false (both are registered)
-->
<reference id="pooledConnectionFactoryFactory"
        interface="org.ops4j.pax.jms.service.PooledConnectionFactoryFactory"
        filter="(&amp;(pool=pooledjms)(xa=true))" />

<!--
    When using XA connection factories, javax.transaction.TransactionManager service is not needed here.
    It is used internally by xa-aware pooledConnectionFactoryFactory.
-->
<!--<reference id="tm" interface="javax.transaction.TransactionManager" />-->

<!--
    Finally, use both factories to expose the pooled, xa-aware, connection factory.
-->
<bean id="pool" factory-ref="pooledConnectionFactoryFactory" factory-method="create">
    <argument ref="connectionFactoryFactory" />
    <argument>
        <props>
            <!--
                Properties needed by artemis-specific org.ops4j.pax.jms.service.ConnectionFactoryFactory
            -->
            <prop key="jms.url" value="tcp://localhost:61616" />
            <prop key="jms.callTimeout" value="2000" />
            <prop key="jms.initialConnectAttempts" value="3" />
            <!-- Properties needed by pooled-jms-specific org.ops4j.pax.jms.service.PooledConnectionFactoryFactory -->
            <prop key="pool.maxConnections" value="10" />
            <prop key="pool.idleTimeout" value="10000" />
        </props>
    </argument>
</bean>

<!--
    Expose connection factory for use by application code (such as Camel, Spring, ...)
-->
<service interface="javax.jms.ConnectionFactory" ref="pool">
    <service-properties>
        <!-- Giving connection factory a name using one of these properties makes identification easier in jms:connectionfactories: -->
        <entry key="osgi.jndi.service.name" value="jms/artemis" />
        <!--<entry key="name" value="jms/artemis" />-->
        <!-- Without any of the above, name will fall back to "service.id" -->
    </service-properties>
</service>

上例使用 factory an 使用 connection factory factories(…​)创建连接工厂。不需要明确引用 javax.transaction.TransactionManager 服务，因为它由 XA 感知池ed ConnectionFactoryonnectionFactoryy 内部跟踪。

以下是它在 Fuse/Karaf shell 中查找的方式：

karaf@root()> feature:install jms pax-jms-artemis pax-jms-pool-pooledjms

karaf@root()> install -s blueprint:file://$PQ_HOME/message-brokers/blueprints/artemis-pax-jms-factory-pooledjms.xml
Bundle ID: 253
karaf@root()> bundle:services -p 253

Bundle 253 provides:
--------------------
objectClass = [javax.jms.ConnectionFactory]
osgi.jndi.service.name = jms/artemis
osgi.service.blueprint.compname = pool
service.bundleid = 253
service.id = 347
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = artemis-pax-jms-factory-pooledjms.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 253
service.id = 348
service.scope = singleton

karaf@root()> jms:connectionfactories
JMS Connection Factory
──────────────────────
jms/artemis

karaf@root()> jms:info -u admin -p admin jms/artemis
Property │ Value
─────────┼──────────────────────────
product  │ ActiveMQ
version  │ 2.4.0.amq-711002-redhat-1

如上方列表所示，Bartner 捆绑包将导出 javax.jms.ConnectionFactory 服务，该服务是一个通用、非特定于代理的连接池。代理特定 javax.jms.XAConnectionFactory 没有 注册为 OSGi 服务，因为 Blueprint XML 没有明确的 < service ref="artemis"> 声明。

pax-jms-config 1.0.0 bundle 使用服务属性添加了另一种 嵌套 代理特定连接工厂中的一种方式。此方法与在 Fuse 6.x 中工作的方式匹配。

下面是蓝图 XML 示例：

<!--
    Broker-specific, non-pooling, non-enlisting javax.jms.XAConnectionFactory
-->
<bean id="artemis" class="org.apache.activemq.artemis.jms.client.ActiveMQXAConnectionFactory">
    <argument value="tcp://localhost:61616" />
    <property name="callTimeout" value="2000" />
    <property name="initialConnectAttempts" value="3" />
</bean>

<!--
    Expose broker-specific connection factory with service properties.
    No need to expose pooling, enlisting, non broker-specific javax.jms.XAConnectionFactory. It will be registered
    automatically by pax-jms-config with the same properties as this <service>, but with a higher service.ranking
-->
<service id="pool" ref="artemis" interface="javax.jms.XAConnectionFactory">
    <service-properties>
        <!-- "pool" key is needed for pax-jms-config to wrap broker-specific connection factory inside connection pool -->
        <entry key="pool" value="pooledjms" />
        <!-- <service>/@id attribute does not propagate, but name of the connection factory is required using one of: -->
        <entry key="osgi.jndi.service.name" value="jms/artemis" />
        <!-- or: -->
        <!--<entry key="name" value="jms/artemis" />-->
        <!-- Other properties, that normally by e.g., pax-jms-pool-pooledjms -->
        <entry key="pool.maxConnections" value="10" />
        <entry key="pool.idleTimeout" value="10000" />
    </service-properties>
</service>

在上例中，您可以看到仅手动注册代理特定连接工厂。pool=pooledjms 服务属性是连接工厂跟踪器的提示，它由 pax-jms-config 捆绑包管理。带有这个 service 属性的连接工厂服务封装在池工厂内，在本示例中，pax-jms-pool-pooledjms。

以下是它在 Fuse/Karaf shell 中查找的方式：

karaf@root()> feature:install jms pax-jms-config pax-jms-artemis pax-jms-pool-pooledjms

karaf@root()> install -s blueprint:file://$PQ_HOME/message-brokers/blueprints/artemis-pax-jms-discovery.xml
Bundle ID: 254

karaf@root()> bundle:services -p 254

Bundle 254 provides:
--------------------
objectClass = [javax.jms.XAConnectionFactory]
osgi.jndi.service.name = jms/artemis
osgi.service.blueprint.compname = artemis
pool = pooledjms
pool.idleTimeout = 10000
pool.maxConnections = 10
service.bundleid = 254
service.id = 349
service.scope = bundle
-----
objectClass = [org.osgi.service.blueprint.container.BlueprintContainer]
osgi.blueprint.container.symbolicname = artemis-pax-jms-discovery.xml
osgi.blueprint.container.version = 0.0.0
service.bundleid = 254
service.id = 351
service.scope = singleton

karaf@root()> service:list javax.jms.XAConnectionFactory
[javax.jms.XAConnectionFactory]
-------------------------------
 osgi.jndi.service.name = jms/artemis
 osgi.service.blueprint.compname = artemis
 pool = pooledjms
 pool.idleTimeout = 10000
 pool.maxConnections = 10
 service.bundleid = 254
 service.id = 349
 service.scope = bundle
Provided by :
 Bundle 254
Used by:
 OPS4J Pax JMS Config (251)

karaf@root()> service:list javax.jms.ConnectionFactory
[javax.jms.ConnectionFactory]
-----------------------------
 osgi.jndi.service.name = jms/artemis
 osgi.service.blueprint.compname = artemis
 pax.jms.managed = true
 pax.jms.service.id.ref = 349
 pool.idleTimeout = 10000
 pool.maxConnections = 10
 service.bundleid = 251
 service.id = 350
 service.ranking = 1000
 service.scope = singleton
Provided by :
 OPS4J Pax JMS Config (251)

karaf@root()> jms:connectionfactories
JMS Connection Factory
──────────────────────
jms/artemis

karaf@root()> jms:info -u admin -p admin jms/artemis
Property │ Value
─────────┼──────────────────────────
product  │ ActiveMQ
version  │ 2.4.0.amq-711002-redhat-1

在上例中，jms:connectionfactories 仅显示一个服务，因为此命令会删除重复的名称。jdbc:ds-list 在数据源混合部署中介绍了两种服务。

javax.jms.XAConnectionFactory 从 Blueprint 捆绑包注册，它含有 pool = pooledjms 属性。

javax.jms.ConnectionFactory 从 pax-jms-config 捆绑包中注册，并且：

图 9.1 “Marking the Route 来分离” 显示了一个路由示例，它通过将 transed（） DSL 命令添加到路由来实现事务。所有遵循 transacted（） 节点的路由节点都包含在事务范围内。在本例中，两个节点访问 JDBC 资源。

以下 Java DSL 示例演示了如何通过使用 transacted（） DSL 命令标记路由来定义事务路由：

import org.apache.camel.builder.RouteBuilder;

class MyRouteBuilder extends RouteBuilder {
    public void configure() {
        from("file:src/data?noop=true")
                .transacted()
                .bean("accountService","credit")
                .bean("accountService","debit");
    }
}

在本例中，文件端点读取一些 XML 格式文件，它们描述了从一个帐户到另一个帐户的资金传输。第一个 bean（） 调用会给受益辅助帐户指定资金总和，然后第二 bean（） 调用会从发送者帐户中减去指定资金总和。两个 bean（） 调用都会导致对数据库资源进行更新。假设数据库资源通过事务管理器绑定到事务，例如： 第 6 章 使用 JDBC 数据源。

以上路由也可以在 Blueprint XML 中表示。& lt;transacted /> 标签将路由标记为事务，如以下 XML 所示：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ...>

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <route>
            <from uri="file:src/data?noop=true" />
            <transacted />
            <bean ref="accountService" method="credit" />
            <bean ref="accountService" method="debit" />
        </route>
    </camelContext>

</blueprint>

要分离事务，传输的处理器必须与特定的事务管理器实例关联。为了便于您每次调用 transacted（） 时指定事务管理器，转换的处理器会自动选择可识别的默认值。例如，如果您的配置中只有一个事务管理器实例，则转换处理器隐式选取此事务管理器，并使用它来分离事务。

一个翻译的处理器还可使用转换策略（ TransactedPolicy 类型）配置，它封装了传播策略和事务管理器（详情请参阅 第 9.4 节 “事务传播策略” ）。以下规则用于选择默认事务管理器或事务策略：

您还可以通过为 transacted（） 提供 bean ID 作为参数来明确指定 bean。请参阅 第 9.4.4 节 “Java DSL 中带有 PROPAGATION_NEVER 策略的示例”。

如果您将转换处理器插入到路由中，则事务管理器每次通过此节点交换时会创建一个新的事务。事务的范围定义如下：

任何在转换处理器前的路由节点都不在事务中。但是，如果路由从事务端点开始，则路由中的所有节点都位于事务中。请参阅 第 9.2.5 节 “路由开始时的事务端点”。

考虑以下路由：它不正确，因为 transacted（） DSL 命令错误地出现在第一个 bean（） 调用后，它访问数据库资源：

// Java
import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {
    ...
    public void configure() {
        from("file:src/data?noop=true")
                .bean("accountService", "credit")
                .transacted()  // <-- WARNING: Transaction started in the wrong place!
                .bean("accountService", "debit");
    }
}

务必要清楚，给定的事务仅与当前线程关联。您不能在事务路由的中间创建线程池，因为新线程中的处理不会参与当前的事务。例如，以下路由绑定到造成问题：

// Java
import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {
    ...
    public void configure() {
        from("file:src/data?noop=true")
                .transacted()
                .threads(3)  // WARNING: Subthreads are not in transaction scope!
                .bean("accountService", "credit")
                .bean("accountService", "debit");
    }
}

上一个路由（如前面的路由）被损坏数据库，因为 thread（） DSL 命令与转换路由不兼容。即使 thread （） 调用前面是 transacted（） 调用，路由也不会如预期的行为。

如果要将路由分成碎片，并让每个路由片段参与到当前事务中，您可以使用 direct: endpoint。例如，要发送交换来分隔路由片段，具体取决于传输量是否大（请求大于 100）还是小（不等于 100），您可以使用 choice（） DSL 命令和直接端点，如下所示：

// Java
import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {
    ...
    public void configure() {
        from("file:src/data?noop=true")
                .transacted()
                .bean("accountService", "credit")
                .choice().when(xpath("/transaction/transfer[amount > 100]"))
                .to("direct:txbig")
                .otherwise()
                .to("direct:txsmall");

        from("direct:txbig")
                .bean("accountService", "debit")
                .bean("accountService", "dumpTable")
                .to("file:target/messages/big");

        from("direct:txsmall")
                .bean("accountService", "debit")
                .bean("accountService", "dumpTable")
                .to("file:target/messages/small");
    }
}

以 direct:tx small 开头的片段开头是 direct:txsmall，参与当前的事务，因为直接端点是同步的。这意味着片段在与第一个路由片段相同的线程中执行，因此它们会包含在相同的事务范围内。

以下 Apache Camel 组件在显示为路由目的地时用作资源端点，例如，如果它们出现在 to（） DSL 命令中。也就是说，这些端点可以访问事务的资源，如数据库或持久队列。资源端点可以参与当前的事务，只要它们与启动当前事务的转换处理器相同的事务管理器相关联。

以下示例显示了包含资源端点的路由。这会将资金转让的顺序发送到两个不同的 JMS 队列。信贷 队列处理订单以对接收方的帐户进行计分。解除队列 处理顺序以分离发送者的帐户。只有在有相应的 debit 时才应有一个分数。因此，您要将 enqueueing 操作包含在一个事务中。如果事务成功，则订单和解除顺序都将排队。如果发生错误，则任何顺序都不会排队。

from("file:src/data?noop=true")
        .transacted()
        .to("jmstx:queue:credits")
        .to("jmstx:queue:debits");

第 9.2 节 “通过事务端点划分” 显示了一个路由示例，它通过路由开头的事务端点（在 from（） 命令中）存在事务端点进行事务。所有路由节点都包含在事务范围内。在本例中，路由中的所有端点都访问 JMS 资源。

以下 Java DSL 示例演示了如何通过启动事务端点的路由来定义事务路由：

from("jmstx:queue:giro")
        .to("jmstx:queue:credits")
        .to("jmstx:queue:debits");

在前面的示例中，事务范围包含端点、jmstx:queue:giro、jmstx:queue:credits 和 jmstx:queue:debits。如果事务成功，则从 giro 队列永久移除交换，并推送到 信 队列和 debits 队列。如果事务失败，则交易不会转向贡献度和分 位 队列，并将交换重新推送到 giro 队列。默认情况下，JMS 会自动尝试重新传送消息。JMS 组件 bean 和 jmstx 必须明确配置为使用事务，如下所示：

<blueprint ...>
    <bean id="jmstx" class="org.apache.camel.component.jms.JmsComponent">
        <property name="configuration" ref="jmsConfig" />
    </bean>

    <bean id="jmsConfig" class="org.apache.camel.component.jms.JmsConfiguration">
        <property name="connectionFactory" ref="jmsConnectionFactory" />
        <property name="transactionManager" ref="jmsTransactionManager" />
        <property name="transacted" value="true" />
    </bean>
    ...
</blueprint>

在上例中，transaction manager 实例( jmsTransactionManager )与 JMS 组件关联，而 transacted 属性设为 true，以启用对 InOnly 交换的事务解包。

前面的路由可以等效在 Blueprint XML 中，如下所示：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <route>
            <from uri="jmstx:queue:giro" />
            <to uri="jmstx:queue:credits" />
            <to uri="jmstx:queue:debits" />
        </route>
    </camelContext>

</blueprint>

在以事务性端点开头的路由中不需要 transacted（） DSL 命令。然而，假设默认事务策略是 PROPAGATION_REQUIRED （请参阅 第 9.4 节 “事务传播策略”），通常会损害包含 transacted（） 命令，如下例所示：

from("jmstx:queue:giro")
        .transacted()
        .to("jmstx:queue:credits")
        .to("jmstx:queue:debits");

但是，此路由可能会以意外的方式工作，例如，如果一个 TransactedPolicy 有一个有非默认传播策略在 Blueprint XML 中创建。请参阅 第 9.1.4 节 “默认事务管理器和转换策略”。因此，通常最好不要将 transacted（） DSL 命令包含在开头事务端点的路由中。

以下 Apache Camel 组件在路由开始时显示为事务端点（例如，如果它们出现在 from（） DSL 命令中）。也就是说，这些端点可以配置为作为事务客户端的行为，也可以访问事务的资源。

要在 bean 级别声明事务策略，插入 tx:transaction 元素作为 bean 元素的子项，如下所示：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
        xmlns:tx="http://aries.apache.org/xmlns/transactions/v1.1.0">

    <bean id="accountFoo" class="org.jboss.fuse.example.Account">
        <tx:transaction method="*" value="Required" />
        <property name="accountName" value="Foo" />
    </bean>

    <bean id="accountBar" class="org.jboss.fuse.example.Account">
        <tx:transaction method="*" value="Required" />
        <property name="accountName" value="Bar" />
    </bean>

</blueprint>

在前面的示例中，所需的事务策略应用于 accountFoo bean 和 accountBar bean 的所有方法，其中 method 属性指定通配符 ：* 以匹配所有 bean 方法。

要在顶层声明事务策略，在 tx:transaction 元素中插入 tx:transaction 元素作为 蓝图 元素的子项，如下所示：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
        xmlns:tx="http://aries.apache.org/xmlns/transactions/v1.1.0">

    <tx:transaction bean="account*" value="Required" />

    <bean id="accountFoo" class="org.jboss.fuse.example.Account">
        <property name="accountName" value="Foo" />
    </bean>

    <bean id="accountBar" class="org.jboss.fuse.example.Account">
        <property name="accountName" value="Bar" />
    </bean>

</blueprint>

在前面的示例中，Required 事务策略应用于 ID 与模式匹配的所有 bean 的所有方法。

tx:transaction 元素支持以下属性：

Apache Camel 可让您使用 org.apache.camel.spring.spi.spring.spi.SpringTransactionPolicy 类来定义 Spring 事务策略，它基本上是一个围绕原生 Spring 类的打包程序。SpringTransactionPolicy 类封装了两部分数据：

例如，您可以使用 PROPAGATION_MANDATORY 行为实例化 Spring transaction 策略，如下所示：

<blueprint ...>
  <bean id="PROPAGATION_MANDATORY "class="org.apache.camel.spring.spi.SpringTransactionPolicy">
    <property name="transactionManager" ref="txManager" />
    <property name="propagationBehaviorName" value="PROPAGATION_MANDATORY" />
  </bean>
  ...
</blueprint>

Spring 支持以下传播行为。这些值最初基于 JavaeEE 支持的传播行为：

以下示例演示了如何为所有支持的传播行为定义事务策略 Bean。为方便起见，每个 bean ID 都与传播行为值的指定的值匹配，但在实践中，您可以使用您喜欢该 bean ID 的任何值。

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <bean id="PROPAGATION_MANDATORY " class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_MANDATORY" />
    </bean>

    <bean id="PROPAGATION_NESTED" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_NESTED" />
    </bean>

    <bean id="PROPAGATION_NEVER" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_NEVER" />
    </bean>

    <bean id="PROPAGATION_NOT_SUPPORTED" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_NOT_SUPPORTED" />
    </bean>

    <!-- This is the default behavior. -->
    <bean id="PROPAGATION_REQUIRED" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
    </bean>

    <bean id="PROPAGATION_REQUIRES_NEW" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRES_NEW" />
    </bean>

    <bean id="PROPAGATION_SUPPORTS" class="org.apache.camel.spring.spi.SpringTransactionPolicy">
        <property name="transactionManager" ref="txManager" />
        <property name="propagationBehaviorName" value="PROPAGATION_SUPPORTS" />
    </bean>

</blueprint>

演示该事务策略对事务的影响的简单方法是将 PROPAGATION_NEVER 策略插入到现有事务中，如以下路由所示：

from("file:src/data?noop=true")
        .transacted()
        .bean("accountService","credit")
        .transacted("PROPAGATION_NEVER")
        .bean("accountService","debit");

使用这种方法时，PR OPAGATION_NEVER 策略不可避免地中止每个事务，从而导致事务回滚。您应该能轻松查看这对应用程序的影响。

以上路由可以在 Blueprint XML 中定义，如下所示：

<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <camelContext xmlns="http://camel.apache.org/schema/blueprint">
        <route>
            <from uri="file:src/data?noop=true" />
            <transacted />
            <bean ref="accountService" method="credit" />
            <transacted ref="PROPAGATION_NEVER" />
            <bean ref="accountService" method="debit" />
        </route>
    </camelContext>

</blueprint>

您可以使用以下方法之一来回滚事务：

9.5.1.1. 使用运行时例外来触发回滚

回滚 Spring 事务的最常见方法是抛出运行时（未检查）异常。换句话说，异常是 java.lang.RuntimeException 的一个实例或子类。java.lang.Error 类型的 Java 错误也会触发事务回滚。另一方面，检查异常不会触发回滚。

下图总结了触发回滚的灰色类如何影响事务的 Java 错误和例外。

注意

Spring 框架也提供 XML 注解系统，您可以指定哪些例外，或者不应触发回滚。详情请查看 Spring 参考指南中的"回滚"。

警告

如果在事务中处理运行时异常，即在异常的几率前，与交易分离的代码不同，则不会回滚事务。详情请查看 第 9.5.2 节 “如何定义死信队列”。

from("file:src/data?noop=true")
    .transacted()
    .bean("accountService","credit")
    .choice().when(xpath("/transaction/transfer[amount > 100]"))
        .rollback()
    .otherwise()
        .to("direct:txsmall");

from("direct:txsmall")
    .bean("accountService","debit")
    .bean("accountService","dumpTable")
    .to("file:target/messages/small");

from("file:src/data?noop=true")
    .transacted()
    .bean("accountService","credit")
    .choice().when(xpath("/transaction/transfer[amount > 100]"))
        .markRollbackOnly()
    .otherwise()
        .to("direct:txsmall");
...

要跟踪失败的事务，您可以定义 onException（） 子句，它可让您将相关交换对象重新放入一个死信队列。但是，在事务上下文中使用时，您需要仔细了解如何定义 onException（） 子句，因为异常处理和事务处理间的潜在的交互。下例演示了定义 onException（） 子句的正确方法，假设您需要阻止重新行异常。

// Java
import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {
    ...
    public void configure() {
        onException(IllegalArgumentException.class)
            .maximumRedeliveries(1)
            .handled(true)
            .to("file:target/messages?fileName=deadLetters.xml&fileExist=Append")
            .markRollbackOnly();  // NB: Must come *after* the dead letter endpoint.

        from("file:src/data?noop=true")
            .transacted()
            .bean("accountService","credit")
            .bean("accountService","debit")
            .bean("accountService","dumpTable")
            .to("file:target/messages");
    }
}

在前面的示例中，对Exception（） 配置为捕获 IllegalArgumentException 异常，并将出错交换发送到死信文件 deadLetters.xml。当然，您可以更改此定义，以捕获应用程序中出现的任何异常。异常 rethrow 行为和事务回滚行为由 onException（） 中的以下特殊设置控制：

在事务路由中使用 doTry（） 和 doCatch（） 子句，不使用 onException（） 处理异常的简单方法。例如，以下代码显示了在事务路由中如何捕获和处理 IllegalArgumentException，而不考虑陷入无限循环的风险。

// Java
import org.apache.camel.builder.RouteBuilder;

public class MyRouteBuilder extends RouteBuilder {
    ...
    public void configure() {
        from("file:src/data?noop=true")
            .doTry()
                .to("direct:split")
            .doCatch(IllegalArgumentException.class)
                .to("file:target/messages?fileName=deadLetters.xml&fileExist=Append")
            .end();

        from("direct:split")
            .transacted()
            .bean("accountService","credit")
            .bean("accountService","debit")
            .bean("accountService","dumpTable")
            .to("file:target/messages");
    }
}

在本例中，路由被分成两个片段。第一个网段（来自 file:src/data 端点）接收传入的交换，并使用 doTry（） 和 doCatch（） 执行异常处理。第二段（来自 direct:split 端点）执行所有事务的工作。如果这个事务段中发生异常，它将第一个都传播到 transacted（） 命令，从而导致回滚当前事务，然后然后由第一个路由网段中的 doCatch（） 子句进行接收。doCatch（） 子句不会重新定义异常，因此文件端点不会进行任何重试，避免无限循环。