MicroTx supports the following distributed transaction protocols:

• XA protocol, which is based upon The Open Group’s XA specification. For details about the specification, see https://pubs.opengroup.org/onlinepubs/009680699/toc.pdf.
• Saga protocol, which is based on the Eclipse MicroProfile LRA specification. For details about the specification, see https://download.eclipse.org/microprofile/microprofile-lra-1.0-M1/microprofile-lra-spec.html.
• Try-Confirm/Cancel (TCC) protocol

MicroTx contains two components: the transaction coordinator and the MicroTx library.

MicroTx, a containerized microservice, runs along with your application microservices. The following figure shows how the components of MicroTx interact with your application microservices.

Here's a typical transaction workflow when you use MicroTx. The following figure shows how MicroTx communicates with your application microservices to handle transactions.

To use MicroTx to manage the transactions in your application, you need to make a few changes to your existing application code to integrate the functionality provided by the MicroTx libraries.

Let's use a sample Java application to understand the changes that you, as an application developer need to make. The sample application is a banking teller application which transfers an amount from one department to another. The sample XA application code files are available in the xa folder in the microtx-samples GitHub repository. The MicroTx library is already integrated with the sample application code.

The MicroTx library for Java performs the following functions:

• Enlists the participant service with the Transaction Coordinator in the transaction.
• Injects an XADataSource object for the participant application code to use through dependency injection, and then calls start() on the associated XAResource. Participant microservices, those microservices called in the context of an XA transaction, must use an XA-compliant data source. In Java this means using an XADataSource object.

  The MicroTx libraries automatically inject the configured data source into the participant services, so the application developer must add the @Inject or @Context annotation to the application code. The application code runs the DML using this connection.

• Calls the resource managers to perform operations.

This highlighted code lines, in bold, in the following code snippet of the sample XA application, in Java, show the changes or additions that are typically made.

package com.oracle.mtm.sample.data;
...
/**
 * Include the Transaction Manager for Microservices library files.
 */

import com.oracle.mtm.sample.Configuration;
import com.oracle.mtm.sample.entity.Account;
import oracle.trm.jta.common.TrmSQLConnection;

/**
 * Service that connects to the accounts database and provides methods to interact with the accounts
 */
@RequestScoped
public class AccountsService implements IAccountsService {

    /**
     * The database connection injected by the Transaction Manager for Microservices library.
     * Use this connection object to execute SQLs (DMLs) within the application code.
     */
    @Inject
    @TrmSQLConnection
    private Connection connection;

    @Inject
    private Configuration config;
...
    @Override
    public boolean withdraw(String accountId, double amount) throws SQLException {
        String query = "UPDATE accounts SET amount=amount-? where account_id=?";      
        /**
         * Use the connection object that the Transaction Manager for Microservices library
         * injects in the application code.
         */
       PreparedStatement statement = connection.prepareStatement(query);
        statement.setDouble(1, amount);
        statement.setString(2, accountId);
        return statement.executeUpdate() > 0;
    }
... 
    
}

The sample code has been truncated with … to improve readability. To view the entire sample code, see the sample XA application code files that are available in the installation bundle in the GitHub repository.