Transactions - JBOSS Portal 2.2 API 英文版文档

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.jboss.portal.common.transaction
Class Transactions

java.lang.Object
  org.jboss.portal.common.transaction.Transactions

public class Transactions
extends java.lang.Object

Utility class for managing transactions.

Nested Class Summary

static interface Transactions.Runnable


static class Transactions.Type


Field Summary

static Transactions.Type TYPE_MANDATORY


static Transactions.Type TYPE_NEVER


static Transactions.Type TYPE_NOT_SUPPORTED


static Transactions.Type TYPE_REQUIRED


static Transactions.Type TYPE_REQUIRES_NEW


static Transactions.Type TYPE_SUPPORTS


Constructor Summary

Transactions()


Method Summary

static java.lang.Object apply(Transactions.Type type, javax.transaction.TransactionManager tm, Transactions.Runnable runnable)
          Apply the transaction type around the unit of work.

static void applyAfter(Transactions.Type type, javax.transaction.TransactionManager tm, javax.transaction.Transaction oldTx)
          Apply the transaction type after the unit of work has been done.

static javax.transaction.Transaction applyBefore(Transactions.Type type, javax.transaction.TransactionManager tm)
          Apply the transaction type before the unit of work.

static void begin(javax.transaction.TransactionManager tm)
          Begin a new transaction.

static boolean end(javax.transaction.TransactionManager tm)
          Terminate the active transaction for this thread.

static java.lang.Object mandatory(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static java.lang.Object never(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static java.lang.Object notSupported(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static java.lang.Object required(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static java.lang.Object requiresNew(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static void resume(javax.transaction.TransactionManager tm, javax.transaction.Transaction tx)
          Associate the thread with a transaction

static void safeEnd(javax.transaction.TransactionManager tm)


void safeSetRollbackOnly(javax.transaction.TransactionManager tm)


static void setRollbackOnly(javax.transaction.TransactionManager tm)
          Mark the active transaction for this thread as rollback only

static java.lang.Object supports(javax.transaction.TransactionManager tm, Transactions.Runnable runnable)


static javax.transaction.Transaction suspend(javax.transaction.TransactionManager tm)
          Disassociate the current thread with the active transaction.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TYPE_NOT_SUPPORTED

public static final Transactions.Type TYPE_NOT_SUPPORTED

TYPE_SUPPORTS

public static final Transactions.Type TYPE_SUPPORTS

TYPE_REQUIRED

public static final Transactions.Type TYPE_REQUIRED

TYPE_REQUIRES_NEW

public static final Transactions.Type TYPE_REQUIRES_NEW

TYPE_MANDATORY

public static final Transactions.Type TYPE_MANDATORY

TYPE_NEVER

public static final Transactions.Type TYPE_NEVER

Constructor Detail

Transactions

public Transactions()

Method Detail

applyBefore

public static javax.transaction.Transaction applyBefore(Transactions.Type type,
                                                        javax.transaction.TransactionManager tm)
                                                 throws TransactionException,
                                                        java.lang.IllegalArgumentException

Apply the transaction type before the unit of work.

Parameters:: type - the transaction type; tm - the transaction manager
Returns:: the new transaction if one has been started.
Throws:: TransactionException; IllegalArgumentException - if the type or the transaction manager is null

applyAfter

public static void applyAfter(Transactions.Type type,
                              javax.transaction.TransactionManager tm,
                              javax.transaction.Transaction oldTx)
                       throws TransactionException,
                              java.lang.IllegalArgumentException

Apply the transaction type after the unit of work has been done.

Parameters:: type - the transaction type; tm - the transaction manager; oldTx - the old transaction if it is not null
Throws:: TransactionException; IllegalArgumentException - if the type of the transaction manager is null

apply

public static java.lang.Object apply(Transactions.Type type,
                                     javax.transaction.TransactionManager tm,
                                     Transactions.Runnable runnable)
                              throws NestedException,
                                     TransactionException,
                                     java.lang.IllegalArgumentException

Apply the transaction type around the unit of work.

Parameters:: type - the transaction type; tm - the transaction manager; runnable - the unit of work
Returns:: the object returned by the runnable object
Throws:: NestedException - wraps any exception throws by the runnable object; TransactionException; IllegalArgumentException - if any method argument is null

notSupported

public static java.lang.Object notSupported(javax.transaction.TransactionManager tm,
                                            Transactions.Runnable runnable)
                                     throws NestedException,
                                            TransactionException

Throws:: NestedException; TransactionException

never

public static java.lang.Object never(javax.transaction.TransactionManager tm,
                                     Transactions.Runnable runnable)
                              throws NestedException,
                                     TransactionException

Throws:: NestedException; TransactionException

mandatory

public static java.lang.Object mandatory(javax.transaction.TransactionManager tm,
                                         Transactions.Runnable runnable)
                                  throws NestedException,
                                         TransactionException

Throws:: NestedException; TransactionException

supports

public static java.lang.Object supports(javax.transaction.TransactionManager tm,
                                        Transactions.Runnable runnable)
                                 throws NestedException,
                                        TransactionException

Throws:: NestedException; TransactionException

required

public static java.lang.Object required(javax.transaction.TransactionManager tm,
                                        Transactions.Runnable runnable)
                                 throws NestedException,
                                        TransactionException

Throws:: NestedException; TransactionException

requiresNew

public static java.lang.Object requiresNew(javax.transaction.TransactionManager tm,
                                           Transactions.Runnable runnable)
                                    throws NestedException,
                                           TransactionException

Throws:: NestedException; TransactionException

begin

public static void begin(javax.transaction.TransactionManager tm)
                  throws java.lang.IllegalArgumentException,
                         TransactionException

Begin a new transaction.

Parameters:: tm - the transaction manager
Throws:: IllegalArgumentException - if the tm is null; TransactionException

setRollbackOnly

public static void setRollbackOnly(javax.transaction.TransactionManager tm)
                            throws java.lang.IllegalArgumentException,
                                   TransactionException

Mark the active transaction for this thread as rollback only

Parameters:: tm - the transaction manager
Throws:: IllegalArgumentException - if the tm is null; TransactionException
See Also:: #setRollbackOnly(javax.transaction.Transaction)

safeSetRollbackOnly

public void safeSetRollbackOnly(javax.transaction.TransactionManager tm)

safeEnd

public static void safeEnd(javax.transaction.TransactionManager tm)

end

public static boolean end(javax.transaction.TransactionManager tm)
                   throws java.lang.IllegalArgumentException,
                          TransactionException

Terminate the active transaction for this thread. If the transaction is marked for rollback then it is rollbacked otherwise it is commited.

Parameters:: tm - the transaction manager
Returns:: true if commit happened, false otherwise
Throws:: IllegalArgumentException - if the tm is null; TransactionException

resume

public static void resume(javax.transaction.TransactionManager tm,
                          javax.transaction.Transaction tx)
                   throws java.lang.IllegalArgumentException,
                          TransactionException

Associate the thread with a transaction

Parameters:: tm - the transaction manager; tx - the transaction to associate with the this thread
Throws:: IllegalArgumentException - if any argument is null; TransactionException

suspend

public static javax.transaction.Transaction suspend(javax.transaction.TransactionManager tm)
                                             throws java.lang.IllegalArgumentException,
                                                    TransactionException

Disassociate the current thread with the active transaction.

Parameters:: tm - the transaction manager
Returns:: the transaction previously associated with this thread
Throws:: IllegalArgumentException - if the transaction manager is null; TransactionException