Java/J2EE应用在JBoss EAP 6.x.x/Spring Boot中连接Oracle Tuxedo配置咨询

Hey there! I’ve helped several teams nail down this exact integration, so let’s walk through the step-by-step config for both JBoss EAP 6.x and Spring Boot. I’ll also quickly clarify XMLink vs JOLT to make sure you’re picking the right tool for your use case.

First: XMLink vs JOLT Quick Breakdown #

• XMLink: Oracle’s JCA-compliant adapter for Tuxedo—this is the standard J2EE approach, perfect for containerized apps (like JBoss EAP) since it leverages JCA’s built-in connection pooling, transaction management, and security integration. This is what we’ll focus on for your JCA/J2C requirement.
• JOLT: A lighter-weight Java client from Oracle that doesn’t need a JCA container. Great for standalone apps, but it misses out on the full J2EE container feature set.

1. JBoss EAP 6.x Configuration #

Step 1: Grab the Tuxedo JCA Adapter #

First, locate the tuxedo-jca.rar file in your Oracle Tuxedo installation directory—it lives under $TUXDIR/udataobj/jca. This is the resource adapter that bridges JBoss to Tuxedo.

Deploy it to JBoss:

• Drop the .rar file into JBoss’s standalone/deployments directory (or domain/deployments for domain mode).
• Or use the JBoss Management Console: Go to Deployments > Add > Upload a deployment and select the .rar file.

Step 2: Configure JCA Connection Pool & Resource #

You can set this up via the JBoss CLI, management console, or directly editing standalone.xml/domain.xml. Here’s the XML snippet to add to the <subsystem xmlns="urn:jboss:domain:resource-adapters:1.1"> section:

<resource-adapters>
    <resource-adapter id="tuxedo-jca">
        <archive>tuxedo-jca.rar</archive>
        <transaction-support>NoTransaction</transaction-support> <!-- Use XATransaction for distributed tx -->
        <config-property name="TUXDIR">/path/to/your/tuxedo/install</config-property>
        <config-property name="TUXCONFIG">/path/to/your/tuxedo/config/tuxconfig</config-property>
        <connection-definitions>
            <connection-definition
                class-name="weblogic.jca.adapter.tuxedo.cci.TuxedoConnectionFactory"
                jndi-name="java:/TuxedoConnectionFactory"
                pool-name="TuxedoPool">
                <config-property name="APP_PW">your-tuxedo-app-password</config-property>
                <security>
                    <application/>
                </security>
                <validation>
                    <valid-connection-checker class-name="org.jboss.jca.adapters.jdbc.extensions.oracle.OracleValidConnectionChecker"/>
                </validation>
            </connection-definition>
        </connection-definitions>
    </resource-adapter>
</resource-adapters>

Key adjustments to make:

• TUXDIR: Path to your Tuxedo installation on the JBoss server.
• TUXCONFIG: Path to your Tuxedo domain’s tuxconfig file.
• APP_PW: Application password for your Tuxedo domain (if required).
• transaction-support: Switch to XATransaction if you need distributed transactions between JBoss and Tuxedo.

Step 3: Code to Call Tuxedo Services #

Inject the connection factory into your EJB/Servlet and invoke Tuxedo services:

import javax.annotation.Resource;
import javax.resource.cci.Connection;
import javax.resource.cci.ConnectionFactory;
import javax.resource.cci.Interaction;
import javax.resource.cci.Record;
import weblogic.jca.adapter.tuxedo.cci.TuxedoRecordFactory;

public class TuxedoServiceClient {

    @Resource(lookup = "java:/TuxedoConnectionFactory")
    private ConnectionFactory tuxedoConnFactory;

    public String callTuxedoService(String serviceName, String inputData) throws Exception {
        try (Connection conn = tuxedoConnFactory.getConnection();
             Interaction interaction = conn.createInteraction()) {

            // Create input/output records (adjust based on your Tuxedo service's data format)
            TuxedoRecordFactory recordFactory = new TuxedoRecordFactory();
            Record inputRecord = recordFactory.createStringRecord(inputData);
            Record outputRecord = recordFactory.createStringRecord("");

            // Invoke the Tuxedo service
            interaction.execute(null, inputRecord, outputRecord);

            return outputRecord.toString();
        }
    }
}

2. Spring Boot Configuration #

Spring Boot doesn’t have out-of-the-box Tuxedo JCA support, but we can integrate it manually with a few steps.

Step 1: Add the Tuxedo JCA Dependency #

First, add the tuxedo-jca.rar to your project. If using Maven, you can use a system scope dependency (or install it to your local Maven repo):

<dependency>
    <groupId>com.oracle.tuxedo</groupId>
    <artifactId>tuxedo-jca</artifactId>
    <version>your-tuxedo-version</version>
    <type>rar</type>
    <scope>system</scope>
    <systemPath>${project.basedir}/lib/tuxedo-jca.rar</systemPath>
</dependency>

Alternatively, extract the .jar files from the .rar and add them directly to your classpath.

Step 2: Configure JCA Connection Factory in Spring #

Create a @Configuration class to set up the Tuxedo connection factory:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import weblogic.jca.adapter.tuxedo.cci.TuxedoConnectionFactory;

@Configuration
public class TuxedoConfig {

    @Bean
    public TuxedoConnectionFactory tuxedoConnectionFactory() {
        TuxedoConnectionFactory factory = new TuxedoConnectionFactory();
        factory.setTUXDIR("/path/to/your/tuxedo/install");
        factory.setTUXCONFIG("/path/to/your/tuxedo/config/tuxconfig");
        factory.setAPP_PW("your-tuxedo-app-password");
        return factory;
    }
}

Step 3: Code to Invoke Tuxedo Services #

Inject the connection factory into your Spring service and call the Tuxedo service (similar to the JBoss example):

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.resource.cci.Connection;
import javax.resource.cci.Interaction;
import javax.resource.cci.Record;
import weblogic.jca.adapter.tuxedo.cci.TuxedoRecordFactory;

@Service
public class TuxedoClientService {

    @Autowired
    private TuxedoConnectionFactory tuxedoConnFactory;

    public String invokeTuxedoService(String serviceName, String input) throws Exception {
        try (Connection conn = tuxedoConnFactory.getConnection();
             Interaction interaction = conn.createInteraction()) {

            TuxedoRecordFactory recordFactory = new TuxedoRecordFactory();
            Record inputRecord = recordFactory.createStringRecord(input);
            Record outputRecord = recordFactory.createStringRecord("");

            interaction.execute(null, inputRecord, outputRecord);
            return outputRecord.toString();
        }
    }
}

Common Pitfalls to Avoid #

• Version Compatibility: Ensure your tuxedo-jca.rar version matches your Tuxedo server version—mismatches cause hard-to-debug connection errors.
• Environment Variables: On the server running your app, confirm TUXDIR and TUXCONFIG are set correctly (or explicitly configure them in the adapter as we did).
• File Permissions: The app server process needs read access to the Tuxedo tuxconfig file and installation directory.
• Transaction Settings: If you need distributed transactions, double-check that Tuxedo is configured for XA support and set transaction-support to XATransaction in JBoss.

内容的提问来源于stack exchange，提问作者Jay