Oracle8i Enterprise JavaBeans Developer's Guide and Reference Release 3 (8.1.7) Part Number A83725-01 |
Library | Service | Contents | Index

## JTA Server-Side Demarcation

Server-side demarcation can occur either implicitly through container-managed transaction or explicitly through bean-managed transactions. A container-managed transaction is specified within the EJB deployment descriptor for the bean. Most EJBs use container-managed transactions as it requires no transaction implementation within the application.

No matter which way that the server object decides to demarcate transactions, the enlistment of the database is the same for both container and bean-managed transactions.

- Container-Managed Transactions

- Bean-Managed Transactions

- Enlisting Resources on the Server-side

### Container-Managed Transactions

You can declare that the container manages the transaction for the bean within the EJB deployment descriptor. This requires that you specify "`Container`" within the `<transaction-type>` element and the container-managed transaction attribute (see Table 7-1) within the `<container-transaction>` element. See "Defining Transactions" for full instructions.

Based upon the transaction attribute you specify within the EJB deployment descriptor, the container will begin, commit, or rollback global transactions when a method in the bean instance is invoked. Each bean can be specified with different transaction attributes. The transaction attributes specify how the transaction demarcation is handled. This means that your bean does not retrieve the `UserTransaction` object, nor invokes any of its methods. The container does this for you.

The container does not enlist the database resources for you. Bind each `DataSource` within the namespace as indicated within Table 7-5. Your code enlists each database by retrieving the database connection through one of the methods listed in Table 7-2. A full example using container-managed transactional beans and database enlistment is shown in the section "Configuring Two-Phase Commit Engine".

### Bean-Managed Transactions

Only session beans have the option to use bean-managed transactions. This means that only session beans can demarcate the transaction with the `begin`, `commit`, and `rollback` methods. In order to specify that this session bean is going to programmatically demarcate its transaction, it must specify the following in its EJB deployment descriptor:

    <enterprise-beans>
     <session>
      . . .
      <transaction-type>Bean</transaction-type>
     </session>
    </enterprise-beans>

Note: See "Defining Transactions" for a full description of defining transaction management in the EJB deployment descriptor.

The session bean implementation demarcates transactions in the same manner as a client would. It invokes the `begin`, `commit`, and `rollback` methods off of the `UserTransaction` object. The only difference is how the `UserTransaction` object is retrieved. There are two methods for retrieving the `UserTransaction` object on the server side in a bean-managed transactional bean:

- SessionContext getUserTransaction method

- JNDI lookup

#### ``SessionContext getUserTransaction method

The bean retrieves the `UserTransaction` object from the `SessionContext` object, which was set within the `setSessionContext` method. This is the EJB 1.0 methodology for retrieving the `UserTransaction` object and can only be used in a single-phase commit environment.

The container has already retrieved the `UserTransaction` object for you. The following shows that the session context is saved in the `ctx` variable.

    public void setSessionContext (SessionContext ctx) {
        this.ctx = ctx;
    }

Within the bean implementation, retrieve the `UserTransaction` from the session context and begin the transaction.

    UserTransaction ut = ctx.getUserTransaction();
    ut.begin();
    ...
    ut.commit();

#### JNDI lookup

The EJB 1.1 method retrieves the `UserTransaction` object by performing an in-session lookup with the following JNDI name: "`java:comp/UserTransaction`". In a single-phase commit environment, the container will create the `UserTransaction` object for you; in a two-phase environment, you must have already bound a `UserTransaction` object with the two-phase commit information (username, password, and two-phase commit URL) into the namespace. After retrieval, you use this object to demarcate your global transaction.

The following demonstrates retrieving a `UserTransaction` object from the namespace:

    ic = new InitialContext ( );

    // lookup the usertransaction
    UserTransaction ut = (UserTransaction)ic.lookup ("java:comp/UserTransaction");
    ut.begin ();
    ...
    ut.commit();

| Copyright © 1996-2000, Oracle Corporation. All Rights Reserved. |
Library | Service | Contents | Index