Save This Page
Home » glassfish-v2ur2-b04-src » javax » transaction » [javadoc | source]
    1   /*
    2    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    3    * 
    4    * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
    5    * 
    6    * The contents of this file are subject to the terms of either the GNU
    7    * General Public License Version 2 only ("GPL") or the Common Development
    8    * and Distribution License("CDDL") (collectively, the "License").  You
    9    * may not use this file except in compliance with the License. You can obtain
   10    * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
   11    * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
   12    * language governing permissions and limitations under the License.
   13    * 
   14    * When distributing the software, include this License Header Notice in each
   15    * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
   16    * Sun designates this particular file as subject to the "Classpath" exception
   17    * as provided by Sun in the GPL Version 2 section of the License file that
   18    * accompanied this code.  If applicable, add the following below the License
   19    * Header, with the fields enclosed by brackets [] replaced by your own
   20    * identifying information: "Portions Copyrighted [year]
   21    * [name of copyright owner]"
   22    * 
   23    * Contributor(s):
   24    * 
   25    * If you wish your version of this file to be governed by only the CDDL or
   26    * only the GPL Version 2, indicate your decision by adding "[Contributor]
   27    * elects to include this software in this distribution under the [CDDL or GPL
   28    * Version 2] license."  If you don't indicate a single choice of license, a
   29    * recipient has the option to distribute your version of this file under
   30    * either the CDDL, the GPL Version 2 or to extend the choice of license to
   31    * its licensees as provided above.  However, if you add GPL Version 2 code
   32    * and therefore, elected the GPL Version 2 license, then the option applies
   33    * only if the new code is made subject to such option by the copyright
   34    * holder.
   35    */
   36   
   37   package javax.transaction;
   38   
   39   import java.lang.IllegalArgumentException;
   40   import java.lang.IllegalStateException;
   41   import java.lang.SecurityException;
   42   
   43   /**
   44    * The TransactionManager interface defines the methods that allow an
   45    * application server to manage transaction boundaries.
   46    */
   47   public interface TransactionManager {
   48   
   49       /**
   50        * Create a new transaction and associate it with the current thread.
   51        *
   52        * @exception NotSupportedException Thrown if the thread is already
   53        *    associated with a transaction and the Transaction Manager
   54        *    implementation does not support nested transactions.
   55        *
   56        * @exception SystemException Thrown if the transaction manager
   57        *    encounters an unexpected error condition.
   58        *
   59        */
   60       public void begin() throws NotSupportedException, SystemException;
   61   
   62       /**
   63        * Complete the transaction associated with the current thread. When this
   64        * method completes, the thread is no longer associated with a transaction.
   65        *
   66        * @exception RollbackException Thrown to indicate that
   67        *    the transaction has been rolled back rather than committed.
   68        *
   69        * @exception HeuristicMixedException Thrown to indicate that a heuristic
   70        *    decision was made and that some relevant updates have been committed
   71        *    while others have been rolled back.
   72        *
   73        * @exception HeuristicRollbackException Thrown to indicate that a
   74        *    heuristic decision was made and that all relevant updates have been
   75        *    rolled back.
   76        *
   77        * @exception SecurityException Thrown to indicate that the thread is
   78        *    not allowed to commit the transaction.
   79        *
   80        * @exception IllegalStateException Thrown if the current thread is
   81        *    not associated with a transaction.
   82        *
   83        * @exception SystemException Thrown if the transaction manager
   84        *    encounters an unexpected error condition.
   85        *
   86        */
   87       public void commit() throws RollbackException,
   88   	HeuristicMixedException, HeuristicRollbackException, SecurityException,
   89   	IllegalStateException, SystemException;
   90   
   91       /**
   92        * Obtain the status of the transaction associated with the current thread.
   93        *
   94        * @return The transaction status. If no transaction is associated with
   95        *    the current thread, this method returns the Status.NoTransaction
   96        *    value.
   97        *
   98        * @exception SystemException Thrown if the transaction manager
   99        *    encounters an unexpected error condition.
  100        *
  101        */
  102       public int getStatus() throws SystemException;
  103   
  104       /**
  105        * Get the transaction object that represents the transaction
  106        * context of the calling thread.
  107        *
  108        * @return the <code>Transaction</code> object representing the
  109        *	  transaction associated with the calling thread.
  110        *
  111        * @exception SystemException Thrown if the transaction manager
  112        *    encounters an unexpected error condition.
  113        *
  114        */
  115       public Transaction getTransaction() throws SystemException;
  116   
  117       /**
  118        * Resume the transaction context association of the calling thread
  119        * with the transaction represented by the supplied Transaction object.
  120        * When this method returns, the calling thread is associated with the
  121        * transaction context specified.
  122        *
  123        * @param tobj The <code>Transaction</code> object that represents the
  124        *    transaction to be resumed.
  125        *
  126        * @exception InvalidTransactionException Thrown if the parameter
  127        *    transaction object contains an invalid transaction.
  128        *
  129        * @exception IllegalStateException Thrown if the thread is already
  130        *    associated with another transaction.
  131        *
  132        * @exception SystemException Thrown if the transaction manager
  133        *    encounters an unexpected error condition.
  134        */
  135       public void resume(Transaction tobj)
  136               throws InvalidTransactionException, IllegalStateException,
  137               SystemException;
  138   
  139       /**
  140        * Roll back the transaction associated with the current thread. When this
  141        * method completes, the thread is no longer associated with a
  142        * transaction.
  143        *
  144        * @exception SecurityException Thrown to indicate that the thread is
  145        *    not allowed to roll back the transaction.
  146        *
  147        * @exception IllegalStateException Thrown if the current thread is
  148        *    not associated with a transaction.
  149        *
  150        * @exception SystemException Thrown if the transaction manager
  151        *    encounters an unexpected error condition.
  152        *
  153        */
  154       public void rollback() throws IllegalStateException, SecurityException,
  155                               SystemException;
  156   
  157       /**
  158        * Modify the transaction associated with the current thread such that
  159        * the only possible outcome of the transaction is to roll back the
  160        * transaction.
  161        *
  162        * @exception IllegalStateException Thrown if the current thread is
  163        *    not associated with a transaction.
  164        *
  165        * @exception SystemException Thrown if the transaction manager
  166        *    encounters an unexpected error condition.
  167        *
  168        */
  169       public void setRollbackOnly() throws IllegalStateException, SystemException;
  170   
  171       /**
  172        * Modify the timeout value that is associated with transactions started
  173        * by the current thread with the begin method.
  174        *
  175        * <p> If an application has not called this method, the transaction
  176        * service uses some default value for the transaction timeout.
  177        *
  178        * @param seconds The value of the timeout in seconds. If the value is zero,
  179        *        the transaction service restores the default value. If the value
  180        *        is negative a SystemException is thrown.
  181        *
  182        * @exception SystemException Thrown if the transaction manager
  183        *    encounters an unexpected error condition.
  184        *
  185        */
  186       public void setTransactionTimeout(int seconds) throws SystemException;
  187   
  188       /**
  189        * Suspend the transaction currently associated with the calling
  190        * thread and return a Transaction object that represents the
  191        * transaction context being suspended. If the calling thread is
  192        * not associated with a transaction, the method returns a null
  193        * object reference. When this method returns, the calling thread
  194        * is not associated with a transaction.
  195        *
  196        * @return Transaction object representing the suspended transaction.
  197        *
  198        * @exception SystemException Thrown if the transaction manager
  199        *    encounters an unexpected error condition.
  200        *
  201        */
  202       public Transaction suspend() throws SystemException;
  203   }

Save This Page
Home » glassfish-v2ur2-b04-src » javax » transaction » [javadoc | source]