Apache Karaf 트랜잭션 가이드

다음 기능에 따라 리소스의 서비스 품질이 결정됩니다.

다음 기능은 트랜잭션 관리자의 서비스 품질을 결정합니다.

로컬 트랜잭션 관리자는 단일 리소스에 대해서만 트랜잭션을 조정할 수 있는 트랜잭션 관리자입니다. 로컬 트랜잭션 관리자의 구현은 일반적으로 리소스 자체에 포함되어 있으며 애플리케이션에서 사용하는 트랜잭션 관리자는 이 기본 제공 트랜잭션 관리자에 대한 씬 래퍼입니다.

예를 들어 Oracle 데이터베이스에는 중복 작업(SQL BEGIN,COMMIT 또는 ROLLBACK 문을 사용하거나 네이티브 Oracle API를 사용하여) 및 다양한 트랜잭션 격리 수준을 지원하는 기본 제공 트랜잭션 관리자가 있습니다. Oracle 트랜잭션 관리자에 대한 제어는 JDBC를 통해 내보낼 수 있으며, 이 JDBC API는 애플리케이션에서 트랜잭션을 위임하는 데 사용됩니다.

이 컨텍스트에서 리소스를 구성하는 사항을 이해하는 것이 중요합니다. 예를 들어 JMS 제품을 사용하는 경우 JMS 리소스는 개별 대기열과 주제가 아닌 JMS 제품의 단일 실행 인스턴스입니다. 또한 동일한 기본 리소스에 다른 방식으로 액세스하면 여러 리소스가 실제로 단일 리소스일 수 있습니다. 예를 들어 애플리케이션은 관계형 데이터베이스에 직접(DBC를 통해) 직접 및 간접적으로( Hibernate와 같은 객체 관계형 매핑 툴을 통해)에 액세스할 수 있습니다. 이 경우 동일한 기본 트랜잭션 관리자가 관련되므로 두 코드 조각을 동일한 트랜잭션에 등록할 수 있어야 합니다.

애플리케이션에는 서로 독립적으로 작동하는 다양한 로컬 트랜잭션 관리자가 있을 수 있습니다. 예를 들어 JMS 끝점이 JMS 트랜잭션 관리자를 참조하는 JMS 대기열 및 주제를 조작하는 Camel 경로가 한 개 있을 수 있습니다. 다른 경로는 JDBC를 통해 관계형 데이터베이스에 액세스할 수 있습니다. 그러나 JDBC 및 JMS 액세스를 동일한 경로에 결합하고 둘 다 동일한 트랜잭션에 참여하도록 할 수 없습니다.

글로벌 트랜잭션 관리자는 여러 리소스에 대해 트랜잭션을 조정할 수 있는 트랜잭션 관리자입니다. 이는 리소스 자체에 빌드된 트랜잭션 관리자를 사용할 수 없는 경우 필요합니다. 트랜잭션 처리 모니터(TP 모니터)라고도 하는 외부 시스템은 다양한 리소스 간에 트랜잭션을 조정할 수 있습니다.

다음은 여러 리소스에서 작동하는 트랜잭션에 대한 사전 요구 사항입니다.

일반적으로 서버는 트랜잭션과 관련된 리소스에 직접 연결합니다. 그러나 분산 시스템에서는 웹 서비스를 통해 간접적으로 노출되는 리소스에만 연결해야 합니다. 이 경우 분산 트랜잭션을 지원할 수 있는 TP 모니터가 필요합니다. 다양한 분산 프로토콜에 대한 트랜잭션을 지원하는 방법을 설명하는 여러 표준을 사용할 수 있습니다(예: 웹 서비스에 대한 WS-AtomicTransactions 사양).

앞서 언급했듯이 javax. Cryostat.UserTransaction 은 일반적으로 Cryostat 애플리케이션의 JNDI에서 가져옵니다. 그러나 Spring은 많은 시나리오에서 이 인터페이스를 명시적으로 구현합니다. 항상 전체 JTA 시나리오가 필요하지는 않으며 애플리케이션에서 단일 리소스(예: JDBC)에 액세스해야 하는 경우가 있습니다.

일반적으로 org.springframework.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 오브젝트는 현재 트랜잭션을 검색한 다음 트랜잭션 오브젝트에서 해당 메서드를 호출하는 편리한 래퍼입니다.

또한 트랜잭션 인터페이스는 UserTransaction 인터페이스에 해당하지 않는 다음 메서드를 정의합니다.

트랜잭션을 사용하여 XA 리소스를 등록하려면 트랜잭션 인터페이스에서 enlistResource() 메서드를 호출해야 합니다. 예를 들어 TransactionManager 개체와 XAResource 개체가 지정되면 다음과 같이 XAResource 개체를 등록할 수 있습니다.For example, given a TransactionManager object and an XAResource object, you could enlist the XAResource object as follows:

// 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() 호출을 사용하여 리터링된 오류-prone 코드로 끝날 수 있습니다. 또한 적절한 위치에서 enlistResource() 를 호출하기 어려울 수 있습니다. 예를 들어 일부 트랜잭션 세부 정보를 숨기는 프레임워크를 사용하는 경우입니다.

XA 리소스를 명시적으로 등록하지 않고 XA 리소스의 자동 목록을 지원하는 기능을 사용하는 것이 더 쉽고 안전합니다. 예를 들어 JMS 및 JDBC 리소스 사용 컨텍스트에서 표준 기술은 자동 목록을 지원하는 래퍼 클래스를 사용하는 것입니다.

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.cpds adapter.DriverAdapterCPDS 어댑터의 도움을 받아 직접 또는 DBCP2는 다음과 같은 애플리케이션 서버 계약을 구현합니다.

두 풀 모두 구성 단계에서 javax.sql.ConnectionPoolDataSource 의 인스턴스를 사용합니다.

DBCP2에서 가장 중요하고 흥미로운 부분입니다.

다음은 DBCP2의 일반 데이터 소스 목록입니다.

여기에는 두 개의 축이 있습니다.

두 종류의 데이터 소스 모두 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

admin 팩토리 PID 구성의 속성은 관련 org.osgi.service.jdbc.DataSourceFactory 구현으로 전달됩니다.

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.8.0.fuse-780038-redhat-00001/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.DataSourceFactory.createDataSourceSource(properties) 로 전달됩니다. 그러나 이러한 속성은 접두사가 제거되지 않고 (예: javax.sql.DataSource OSGi 서비스) 속성으로 추가됩니다.

이전 예제에서는 데이터베이스별 데이터 소스 팩토리 를 등록하는 방법을 보여줍니다. 데이터 소스 자체는 연결에 대한 팩토리이기 때문에 org.osgi.service.jdbc.DataSourceFactory 는 세 가지 종류의 데이터 소스를 생성할 수 있어야 하는 메타 팩토리 로 취급될 수 있으며, 보너스로 java.sql.Driver:

예를 들어 pax-jdbc-mysql 은 org.ops4j.pax.jdbc.mysql.impl.MysqlDataSourceFactory 를 생성합니다.

PostgreSQL 드라이버 자체는 OSGi JDBC 서비스를 구현하고 다음을 생성합니다.

표준 데이터 소스 예 에 표시된 것처럼 모든 풀링 (일반 데이터 소스)이 JTA 환경에서 작동하려면 실제로 (XA) 연결을 얻으려면 데이터베이스별 데이터 소스가 필요합니다.

우리는 이미 후자를 보유하고 있으며 실제적이고 일반적인 신뢰할 수 있는 연결 풀이 필요합니다.

표준 데이터 소스 예 는 데이터베이스별 데이터 소스를 사용하여 일반 풀을 구성하는 방법을 보여줍니다. 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)

}

이 인터페이스는 이전에 제시된 중요한 참고 사항에 완벽하게 부합하며 반복할 가치가 있습니다.

이 인터페이스는 데이터베이스별 비풀링 데이터에서 간단히 풀링 데이터 소스를 생성합니다. 또는 보다 정확하게는 데이터베이스별 데이터 소스의 팩토리 를 데이터 소스 풀링 팩토리로 변환하는 데이터 소스 팩토리(meta factory)입니다.

다음 표에서는 풀링된 데이터 소스 팩토리를 등록하는 번들을 보여줍니다. 표에서 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 구성 서비스” 번들을 고려하십시오. 다음을 추적하는 것 외에도 다음을 수행하십시오.

또한 번들은 pax-jc -pool-* 번들 중 하나에서 등록한 org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory 의 인스턴스도 추적합니다.

팩토리 구성에 pool 속성이 포함된 경우 pax-jdbc-config 번들에 의해 등록된 궁극적인 데이터 소스는 데이터베이스별 데이터이며 데이터베이스별 데이터입니다. 그러나 pool=dbcp2인 경우 다음 중 하나로 래핑됩니다.

이는 일반 데이터 소스 예와 일치합니다. pool 속성 및 비xa 또는 xa 데이터 소스를 선택하는 부울 xa 속성 외에도 org.ops4j.datasource 팩토리 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-specific org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory 를 설치합니다. 유일한 차이점은 XA 시나리오에서 추가 통합 포인트가 있다는 것입니다. org.jboss.tm.XAResourceRecovery OSGi 서비스는 Narayana 트랜잭션 관리자의 일부인 com.arjuna.ats.arjuna.recovery.RecoveryManager 에서 선택하도록 등록됩니다.

pax-jdbc-pool-transx 번들에서는 pax- transx-jc-jdbc bundle에서 org.ops4j.pax.jdbc.pool.common.PooledDataSourceFactory 서비스를 기반으로 합니다. pax-transx-jdbc 번들에서는 org.ops4j.pax.transx.jdbc.ManagedDataSourceBuilder 기능을 사용하여 javax.sql.DataSource Sourcec 풀을 생성합니다. JCA(Java™ Connector Architecture) 솔루션이며 나중에 설명합니다.

데이터 소스의 수동 배포 예에서는 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 조각은 표준 데이터 소스 예 과 일치합니다. 다음은 사용 방법을 보여주는 쉘 명령은 다음과 같습니다.

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

위 목록에 표시된 것처럼 블루프린트 번은 일반적인 데이터베이스 별 연결 풀인 javax.sql.DataSource 서비스를 내보냅니다. 블루프린트 XML에는 명시적인 <service ref="postgresql" > 선언이 없기 때문에 데이터베이스별 javax.sql.XADataSource 번들은 OSGi 서비스로 등록되지 않습니다.

데이터 소스의 팩토리 배포는 표준 방식으로 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>

이 예에서는 데이터 소스 팩토리 를 사용하여 데이터 소스를 생성하는 팩토리 빈을 사용합니다. XA 인식 PooledDataSourceFactory 에서 내부적으로 추적하므로 javax. Cryostat.TransactionManager 서비스를 명시적으로 참조할 필요가 없습니다.

다음은 동일한 예이지만 Fuse/Karaf 쉘에서는 다음과 같습니다.

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

위 목록에 표시된 것처럼 블루프린트 번은 일반적인 데이터베이스 별 연결 풀인 javax.sql.DataSource 서비스를 내보냅니다. 블루프린트 XML에는 명시적인 <service ref="postgresql" > 선언이 없기 때문에 데이터베이스별 javax.sql.XADataSource 는 OSGi 서비스로 등록되지 않습니다.

데이터 소스 혼합 배포에서 pax-jdbc-config 1.3.0 번들은 서비스 속성을 사용하여 데이터베이스별 데이터 소스를 풀링 데이터 소스 내에 래핑 하는 또 다른 방법을 추가합니다. 이 방법은 Fuse 6.x에서 작동하는 방식과 일치합니다.

블루프린트 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 쉘의 예는 다음과 같습니다.

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 출력에서 볼 수 있듯이 두 개의 데이터 소스, 원래 데이터 소스 및 래퍼 데이터 소스가 있습니다.

javax.sql.XADataSource 는 블루프린트 번들에서 등록되며 pool = dbcp2 속성이 선언되어 있습니다.

javax.sql.DataSource 는 pax-jdbc-config 번들에서 등록되어 있습니다.

META-INF/persistence.xml 설명자( JPA 2.1 사양 참조, 8.2.1.5 jta-data-source, non-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는 이름 → 값 쌍으로 구성된 간단한 사전이 아닙니다. OSGi의 JNDI 이름을 사용하여 오브젝트를 참조하려면 서비스 조회 및 서비스 후크와 같은 기타 더 복잡한 OSGi 메커니즘이 포함됩니다.

다음 목록에서는 새로운 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

다음은 Artemis 브로커에 대한 연결 요소를 만들기 위한 세부적이고 표준 적인 단계별 가이드입니다.

이제 필요한 경우 삽입할 수 있는 브로커별(아직 풀링 없음) 연결 팩토리가 있습니다. 예를 들어 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 또는 웹 콘솔에서 메시지가 전송되었는지 확인할 수도 있습니다.

Fuse 소프트웨어 다운로드 페이지에서 Fuse 빠른 시작을 다운로드할 수 있습니다.

빠른 시작 zip 파일의 내용을 로컬 폴더(예: quickstarts 라는 폴더 )로 추출합니다.

OSGi 번들로 퀵스타트/camel/camel-jms 예제를 빌드하고 설치할 수 있습니다. 이 번들에는 JBoss A-MQ 6.3 JMS 큐로 메시지를 전송하는 Camel 경로에 대한 블루프린트 XML 정의가 포함되어 있습니다. JBoss A-MQ 6.3 브로커를 위한 연결 팩토리를 생성하는 절차는 다음과 같습니다.

구성 관리 팩토리 PID 의 속성은 관련 org.ops4j.pax.jms.service.ConnectionFactoryFactory 구현으로 전달됩니다.

지금까지 브로커별 연결 팩토리 를 등록했습니다. 연결 팩토리 자체는 연결 팩토리 의 팩토리이기 때문에 org.ops4j.pax.jms.service.ConnectionFactoryFactory 서비스는 메타 팩토리 로 취급될 수 있습니다. 두 종류의 연결 팩토리를 생성할 수 있어야 합니다.

pax-jms-pool-* 번들은 org.ops4j.pax.jms.service.ConnectionFactoryFactory 서비스와 원활하게 작동합니다. 이러한 번들은 속성 세트와 원래 org.ops4j.pax.service.ConnectionFactoryfactory를 사용하여 풀링된 연결 팩토리를 생성하는 데 사용할 수 있는 org.ops4j.pax.pax.jms.service.service.service.service.service.Pooled ConnectionFactory factory의 구현을 제공합니다. 예를 들면 다음과 같습니다.

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.PooledConnectionFactoryFactory.create() 메서드를 호출하는 데 필요한 것이 있습니다.

pax-jms-pooledjms 번들을 사용하는 방법을 이해하면 pax-jms-pool-pooledjms 번들뿐만 아니라 pax-jms-pool-pool - narayna 번들도 사용할 수 있습니다.

pax-jms-config 번들은 다음을 추적합니다.

팩토리 구성에 pool 속성이 포함된 경우 pax-jms-config 번들에 의해 등록된 궁극적인 연결 팩토리는 브로커별 연결 팩토리입니다. pool=pooledjms 인 경우 연결 팩토리는 다음 중 하나로 래핑됩니다.

pool 속성(및 비xa/xa 연결 팩토리 중 하나를 선택하는 부울 xa 속성 외에도 org.ops4j.connectionfactory factory PID 에는 풀 접두사가 있는 속성이 포함될 수 있습니다. .

pooled-jms 라이브러리의 경우 다음과 같은 접두사가 지정된 속성이 ( 접두사를 제거한 후) 사용하여 인스턴스를 구성합니다.

다음 목록은 jms와 함께 편리한 구문을 사용하는 pooled-jms 풀(org.ops4j.connectionfactory-artemis factory PID)의 비현실적 구성입니다.-prefixed properties:

# 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
# ...

위의 구성에서 pool 및 xa 키는 등록된 org.ops4j.pax.jms.service.PooledConnectionFactoryfactory 서비스 중 하나를 선택하는 힌트 (서비스 필터 속성)입니다. 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 로 거의 모든 작업을 수행합니다. XA 및 비 XA 시나리오에 대해 pooled-jms-specific org.ops4j.pax.jms.service.PooledConnectionFactoryFactory 를 설치합니다. 유일한 차이점은 XA 시나리오에서는 추가 통합 포인트가 있다는 것입니다. org.jboss.tm.XAResourceRecovery OSGi 서비스는 com.arjuna.ats.arjuna.recovery.Recovery.RecoveryManager 에서 선택할 수 있도록 등록되었습니다.

pax-jms-pool-transx 모듈은 pax-transx-jms 번들을 기반으로 하는 org.ops4j.pax.service.PooledConnectionFactoryFactory 서비스의 구현을 제공합니다. pax-transx-jms 번들은 org.ops4j.pax.transx.jms.ManagedConnectionFactoryBuilder 기능을 사용하여 javax.jms.ConnectionFactory 풀을 생성합니다. 이는 8.3절. “pax-transx 프로젝트 정보” 에서 설명하는 JCA(Java™ Connector Architecture) 솔루션입니다.

이 방법에서는 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>

다음은 사용 방법을 보여주는 쉘 명령은 다음과 같습니다.

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

위 목록에 표시된 것처럼 블루프린트 번은 일반적인 브로커별 연결 풀인 javax.jms.ConnectionFactory 서비스를 내보냅니다. 블루프린트 XML에는 명시적인 <service ref="artemis" > 선언이 없기 때문에 브로커별 javax.jms.XAConnectionFactory 는 OSGi 서비스로 등록되지 않습니다.

이 방법은 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>

이전 예제에서는 연결 팩토리 (…​)를 사용하여 연결 팩토리를 생성하는 팩토리 빈을 사용합니다. XA 인식 PooledConnectionFactoryFactory 에서 내부적으로 추적하므로 javax. Cryostat.TransactionManager 서비스에 대한 명시적 참조가 필요하지 않습니다.

Fuse/Karaf 쉘의 예는 다음과 같습니다.

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

위 목록에 표시된 것처럼 블루프린트 번은 일반적인 브로커별 연결 풀인 javax.jms.ConnectionFactory 서비스를 내보냅니다. 블루프린트 XML에는 명시적인 <service ref="artemis" > 선언이 없기 때문에 브로커별 javax.jms.XAConnectionFactory 는 OSGi 서비스로 등록되지 않습니다.

pax-jms-config 1.0.0 번에서는 서비스 속성을 사용하여 풀링 연결 팩토리 내의 브로커별 연결 팩토리를 래핑 하는 다른 방법을 추가합니다. 이 방법은 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 service 속성은 pax-jms-config 번들에서 관리하는 연결 팩토리 추적기에 대한 힌트입니다. 이 서비스 속성을 사용하는 연결 팩토리 서비스는 풀링 연결 팩토리(이 예에서는 pax-jms-pool-pooledjms ) 내에서 래핑됩니다.

Fuse/Karaf 쉘의 예는 다음과 같습니다.

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 는 블루프린트 번들에서 등록되며, 선언된 pool = pooledjms 속성이 있습니다.

javax.jms.ConnectionFactory 는 pax-jms-config 번들 및에서 등록됩니다.

그림 9.1. “경로를 표시하여 분리” 경로에 transacted() 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 형식 파일을 읽습니다. 첫 번째 Cryostat () 호출 크레딧은 수혜자의 계정에 지정된 합계를 제공한 다음 두 번째 blank () 호출에서 지정된 양의 비용을 보낸 사람의 계정에서 뺀 값입니다. 둘 다 useful() 호출을 수행하면 데이터베이스 리소스에 대한 업데이트가 수행됩니다. 데이터베이스 리소스가 트랜잭션 관리자를 통해 트랜잭션에 바인딩되는 것으로 가정합니다(예: 6장. JDBC 데이터 소스 사용 ).

이전 경로는 블루프린트 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>

트랜잭션을 분리하려면 트랜잭션된 프로세서가 특정 트랜잭션 관리자 인스턴스와 연결되어야 합니다. Transact ed() 를 호출할 때마다 트랜잭션 관리자를 지정해야 합니다. 변환된 프로세서는 합리적인 기본값을 자동으로 선택합니다. 예를 들어 구성에 트랜잭션 관리자 인스턴스가 하나만 있는 경우 거래된 프로세서는 암시적으로 이 트랜잭션 관리자를 선택하여 트랜잭션을 위임합니다.

트랜잭션된 프로세서는 전파 정책 및 트랜잭션 관리자를 캡슐화하는 TransactedPolicy 유형의 트랜잭션 정책으로 구성할 수도 있습니다(자세한 내용은 9.4절. “트랜잭션 전파 정책” 참조). 다음 규칙은 기본 트랜잭션 관리자 또는 트랜잭션 정책을 선택하는 데 사용됩니다.

또한 빈 ID를 transacted() 의 인수로 제공하여 8080을 명시적으로 지정하는 옵션도 있습니다. 9.4.4절. “Java DSL의 PROPAGATION_NEVER 정책이 포함된 샘플 경로”을 참조하십시오.

트랜잭션 프로세서를 경로에 삽입하면 트랜잭션 관리자는 교환이 이 노드를 통과할 때마다 새 트랜잭션을 생성합니다. 트랜잭션 범위는 다음과 같이 정의됩니다.

트랜잭션된 프로세서 앞에 있는 경로 노드는 트랜잭션에 없습니다. 그러나 경로가 트랜잭션 끝점으로 시작되면 경로의 모든 노드가 트랜잭션에 있습니다. 9.2.5절. “경로 시작 시 트랜잭션 끝점”을 참조하십시오.

다음 경로를 고려하십시오. transacted() DSL 명령이 데이터베이스 리소스에 액세스하는 첫 번째 8080 () 호출 뒤에 실수로 표시되기 때문에 올바르지 않습니다.

// 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");
    }
}

이전과 같은 경로는 threads() DSL 명령이 트랜잭션된 경로와 호환되지 않기 때문에 데이터베이스가 손상될 수 있습니다. threads() 호출이 transacted() 호출보다 우선하더라도 경로가 예상대로 작동하지 않습니다.

경로를 조각으로 분할하고 각 경로 조각이 현재 트랜잭션에 참여하도록 하려면 직접 엔드포인트를 사용할 수 있습니다. 예를 들어, 전송 양이 큰지(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:txbig 와 direct:tx windows로 시작하는 조각과 현재 트랜잭션에 모두 참여합니다. 즉, 조각은 첫 번째 경로 조각과 동일한 스레드에서 실행되므로 동일한 트랜잭션 범위에 포함됩니다.

다음 Apache Camel 구성 요소는 경로의 대상으로 표시될 때 리소스 끝점 역할을 합니다(예: to() DSL 명령에 표시되는 경우). 즉, 이러한 끝점은 데이터베이스 또는 영구 큐와 같은 트랜잭션 리소스에 액세스할 수 있습니다. 리소스 끝점은 현재 트랜잭션을 시작한 트랜잭션 프로세서와 동일한 트랜잭션 관리자와 연결된 경우 현재 트랜잭션에 참여할 수 있습니다.

다음 예제에서는 리소스 끝점이 있는 경로를 보여줍니다. 이렇게 하면 두 개의 다른 JMS 큐로 금전 전송 순서를 보냅니다. 크레딧 대기열은 주문을 처리하여 수신자의 계정을 계산합니다. 직불 큐는 발신자의 계정을 끌기 위해 주문을 처리합니다. 해당 직불이 있는 경우에만 크레딧이 있어야 합니다. 결과적으로 큐에 있는 작업을 단일 트랜잭션으로 묶어야 합니다. 트랜잭션이 성공하면 신용 주문과 직불 순서가 모두 큐에 추가됩니다. 오류가 발생하면 주문이 큐에 추가되지 않습니다.

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 를 포함합니다. 트랜잭션이 성공하면 기프트 큐에서 교환이 영구적으로 제거되고 신용 큐 및 직불 큐 로 푸시됩니다. 트랜잭션이 실패하면 교환이 신용 및 직불 큐에 배치되지 않고 교환이 기가 큐로 다시 푸시 됩니다. 기본적으로 JMS는 메시지를 자동으로 다시 전달하려고 시도합니다. jmstx 인 JMS 구성 요소 빈은 다음과 같이 트랜잭션을 사용하도록 명시적으로 구성해야 합니다.

<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>

이전 예에서 트랜잭션 관리자 인스턴스 jmsTransactionManager 는 JMS 구성 요소와 연결되고 트랜잭션 된 속성이 true 로 설정되어 InOnly 교환에 대한 트랜잭션 요약을 활성화합니다.

앞의 경로는 다음과 같이 블루프린트 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절. “트랜잭션 전파 정책”참조)라고 가정하면 일반적으로 다음 예제와 같이 Transact ed() 명령을 포함하는 것은 무해합니다.

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

그러나 이 경로는 예기치 않은 방식으로 작동할 수 있습니다(예: 블루프린트 XML에서 기본이 아닌 전파 정책이 있는 single Cryostated Policy VLAN). 9.1.4절. “기본 트랜잭션 관리자 및 트랜잭션 정책”을 참조하십시오. 따라서 일반적으로 트랜잭션 끝점으로 시작하는 경로에 transacted() DSL 명령을 포함하지 않는 것이 좋습니다.

다음 Apache Camel 구성 요소는 경로 시작 시 표시되는 경우 트랜잭션 끝점 역할을 합니다(예: from() DSL 명령에 표시되는 경우). 즉, 이러한 끝점은 트랜잭션 클라이언트로 작동하도록 구성할 수 있으며 트랜잭션 리소스에도 액세스할 수 있습니다.

8080 수준에서 트랜잭션 정책을 선언하려면 다음과 같이 tx: Cryostat 요소를^2 요소의 자식으로 삽입합니다.

<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 콩 및 accountBar 8080의 모든 메서드에 적용됩니다. 여기서 메서드 속성은 모든 Cryostat 메서드를 일치시키기 위해 와일드카드 * 를 지정합니다.

최상위 수준에서 트랜잭션 정책을 선언하려면 다음과 같이 tx: Cryostat 요소를 블루프린트 요소의 자식으로 삽입합니다.

<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 가 패턴인 account* 와 일치하는 모든 빈의 모든 메서드에 적용됩니다.

tx: Cryostat 요소는 다음 특성을 지원합니다.

Apache Camel을 사용하면 org.apache.camel.spring.spi.SpringTransactionPolicy 클래스를 사용하여 Spring 트랜잭션 정책을 정의할 수 있습니다. 이 정책은 기본적으로 네이티브 Spring 클래스와 관련된 래퍼입니다. SpringTransactionPolicy 클래스는 다음 두 가지 데이터를 캡슐화합니다.

예를 들어 다음과 같이 PROPAGATION_MANDATORY 동작을 사용하여 Spring 트랜잭션 정책 metrics을 인스턴스화할 수 있습니다.

<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에서 지원하는 전파 동작에 따라 모델링되었습니다.

다음 예제에서는 지원되는 모든 전파 동작에 대해 트랜잭션 정책 빈을 정의하는 방법을 보여줍니다. 편의를 위해 각 빈 ID는 전파 동작 값의 지정된 값과 일치하지만 실제로는 빈 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");

이러한 방식으로 사용되는 PROPAGATION_NEVER 정책은 모든 트랜잭션을 필연적으로 중단하여 트랜잭션 롤백을 생성합니다. 애플리케이션에 미치는 영향을 쉽게 확인할 수 있습니다.

이전 경로는 블루프린트 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 트랜잭션을 롤백하는 가장 일반적인 방법은 런타임(확인되지 않음) 예외를 throw하는 것입니다. 즉, 예외는 java.lang.RuntimeException 의 인스턴스 또는 하위 클래스입니다. java.lang.Error 유형의 Java 오류도 트랜잭션 롤백을 트리거합니다. 반면 검사된 예외는 롤백을 트리거하지 않습니다.

다음 그림은 Java 오류 및 예외가 트랜잭션에 미치는 영향을 요약한 것으로, 롤백을 트리거하는 클래스는 회색으로 표시됩니다.

참고

Spring 프레임워크는 롤백을 트리거하거나 트리거하지 않아야 하는 예외를 지정할 수 있는 XML 주석 시스템도 제공합니다. 자세한 내용은 Spring Reference Guide의 "Rolling back"를 참조하십시오.

주의

트랜잭션 내에서 런타임 예외가 처리되는 경우, 즉 예외가 트랜잭션 분리를 수행하는 코드로 대체될 가능성이 있기 전에 트랜잭션이 롤백되지 않습니다. 자세한 내용은 9.5.2절. “dead letter queue를 정의하는 방법”의 내용을 참조하십시오.

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");
...

실패한 트랜잭션을 추적하기 위해 관련 교환 개체를 dead-letter queue로 전환할 수 있는 onException() 절을 정의할 수 있습니다. 그러나 트랜잭션 컨텍스트에서 사용하는 경우 예외 처리와 트랜잭션 처리 간의 잠재적인 상호 작용으로 인해 onException() 절을 정의하는 방법에 대해 주의해야 합니다. 다음 예제에서는 rethrown 예외를 억제해야 한다고 가정하면 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");
    }
}

이전 예에서 onException() 은 IllegalArgumentException 예외를 catch하고 잘못된 교환을 dead letter file dead letter file, deadLet Cryostat.xml 로 전송하도록 구성되어 있습니다. 물론 이 정의를 변경하여 애플리케이션에서 발생하는 모든 종류의 예외를 파악할 수 있습니다. 예외 다시 화살표 동작 및 트랜잭션 롤백 동작은 onException() 절의 다음과 같은 특수 설정으로 제어됩니다.

onException() 을 사용하는 대신 트랜잭션 경로에서 예외를 처리하는 간단한 방법은 경로 주위에 doTry() 및 doCatch() 절을 사용하는 것입니다. 예를 들어 다음 코드는 무한 루프에 갇혀 있을 위험 없이 트랜잭션 경로에서 IllegalArgumentException 을 catch하고 처리하는 방법을 보여줍니다.

// 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");
    }
}

이 예에서 경로는 두 세그먼트로 나뉩니다. 첫 번째 세그먼트( 파일:src/data 끝점)는 들어오는 교환을 수신하고 doTry() 및 doCatch() 를 사용하여 예외 처리를 수행합니다. 두 번째 세그먼트( 직접:split 끝점)는 모든 트랜잭션 작업을 수행합니다. 이 트랜잭션 세그먼트 내에서 예외가 발생하면 먼저 transacted() 명령으로 전파되므로 현재 트랜잭션이 롤백되고 첫 번째 경로 세그먼트의 doCatch() 절에 의해 catch됩니다. doCatch() 절은 예외를 다시 가져오지 않으므로 파일 끝점에서 재시도를 수행하지 않고 무한 루프를 방지할 수 있습니다.