web server - Borland Technical Publications

Managing transactions
Managing transactions
After the client creates a bean instance, it can use the getHandle() method to obtain a
handle to this instance. Once it has the handle, it can write it to a serialized file. Later,
the client program can read the serialized file, casting the object that it reads in to a
Handle type. Then, it calls the getEJBObject() method on the handle to obtain the bean
reference, casting the results of getEJBObject() to the correct type for the bean.
To illustrate, the CartClient program might do the following to utilize a handle to the
CartBean session bean:
import java.io;
import javax.ejb.Handle;
...
Cart cart;
...
cart = home.create(cardHolderName, creditCardNumber, expirationDate);
// call getHandle on the cart object to get its handle
cartHandle = cart.getHandle();
// write the handle to serialized file
FileOutputStream f = new FileOutputStream ("carthandle.ser");
ObjectOutputStream o = new ObjectOutputStream(f);
o.writeObject(myHandle);
o.flush();
o.close();
...
// read handle from file at later time
FileInputStream fi = new FileInputStream ("carthandle.ser");
ObjectInputStream oi = new ObjectInputStream(fi);
//read the object from the file and cast it to a Handle
cartHandle = (Handle)oi.readObject();
oi.close();
...
// Use the handle to reference the bean instance
try {
Object ref = context.lookup("cart");
Cart cart1 = (Cart) javax.rmi.PortableRemoteObject.narrow(ref, Cart.class);
...
} catch (RemoteException e) {
...
}
...
When finished with the session bean handle, the client can remove it with the
javax.ejb.EJBHome.remove(Handle handle) method.
A client program can manage its own transactions rather than letting the enterprise
bean (or container) manage the transaction. A client that manages its own transaction
does so in exactly the same manner as a session bean than manages its own
transaction.
When a client manages its own transactions, it is responsible for delimiting the
transaction boundaries. That is, it must explicitly start the transaction and end (commit
or roll back) the transaction.
A client uses the javax.transaction.UserTransaction interface to manage its own
transactions. It must first obtain a reference to the UserTransaction interface, using
JNDI to do so. Once it has the UserTransaction context, the client uses the
UserTransaction.begin() method to start the transaction, followed later by the
UserTransaction.commit() method to commit and end the transaction (or
90 BES Developer’s Guide