1interface javax.transaction.TransactionManager
 2{
 3public abstract void begin();
 4public abstract void commit();
 5public abstract int getStatus();
 6public abstract Transaction getTransaction();
 7public void resume(Transaction tobj);
 8public abstract void rollback();
 9public abstract void setRollbackOnly();
10public abstract void setTransactionTimeout(intseconds);
11public abstract Transaction suspend() ;
12}

a JMS provider javax.transaction.xa.XAResource interface, the implements the javax.jms.XAConnection and the javax.jms.XASession interface.

5 Common TransactionManager

5.1 EJB Transaction Options:
NotSupported
    If the method is called within a transaction, this transaction is suspended during the time of the method execution.
Required
    If the method is called within a transaction, the method is executed in the scope of this transaction; otherwise, a new transaction is started for the execution of the method and committed before the method result is sent to the caller.
RequiresNew
    The method will always be executed within the scope of a new transaction. The new transaction is started for the execution of the method, and committed before the method result is sent to the caller. If the method is called within a transaction, this transaction is suspended before the new one is started and resumed when the new transaction has completed.
Mandatory
    The method should always be called within the scope of a transaction, else the container will throw the TransactionRequired exception.
Supports
    The method is invoked within the caller transaction scope; if the caller does not have an associated transaction, the method is invoked without a transaction scope.
Never
    The client is required to call the bean without any transaction context; if it is not the case, a java.rmi.RemoteException is thrown by the container.

5.2 Spring transaction:
      Transaction isolation: The degree of isolation this transaction has from the work of other transactions. For example, can this transaction see uncommitted writes from other transactions? avaliable options:
ISOLATION_DEFAULT
ISOLATION_READ_UNCOMMITTED
ISOLATION_READ_COMMITTED
ISOLATION_REPEATABLE_READ
ISOLATION_SERIALIZABLE

      Transaction propagation: Normally all code executed within a transaction scope will run in that transaction. However, there are several options specifying behavior if a transactional method is executed when a transaction context already exists: For example, simply running in the existing transaction (the most common case); or suspending the existing transaction and creating a new transaction. Spring offers the transaction propagation options familiar from EJB CMT. avaliable options:
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS

      Transaction timeout: How long this transaction may run before timing out (automatically being rolled back by the underlying transaction infrastructure).
      Read-only status: A read-only transaction does not modify any data. Read-only transactions can be a useful optimization in some cases (such as when using Hibernate).

6 transaction for web service
Protocol specifications:
WS-Transaction
OASIS Business Transaction Protocol (BTP)
Java API
JAXTX (JSR-156)

& The bitwise & operator performs a bitwise AND operation.

^ The bitwise ^ operator performs a bitwise exclusive OR operation.

| The bitwise | operator performs a bitwise inclusive OR operation.

• ^ can swap two variables without using an intermediate, temporary variable which is useful if you are short on available RAM or want that sliver of extra speed.

  Usually, when not using ^, you will do:

  temp = a;
  
      
  
      a = b;
  
      
  
      b = temp;

  Using ^, no "temp" is needed:

  a ^= b;
  
      
  
      b ^= a;
  
      
  
      a ^= b;

  This will swap "a" and "b" integers. Both must be integers.

// These are my masks



private static final int MASK_DID_HOMEWORK  = 0x0001;



private static final int MASK_ATE_DINNER    = 0x0002;



private static final int MASK_SLEPT_WELL    = 0x0004; 







// This is my current state



private int m_nCurState;

To set my state, I use the bitwise OR operator:

// Set state for'ate dinner' and 'slept well' to 'on'



m_nCurState = m_nCurState | (MASK_ATE_DINNER | MASK_SLEPT_WELL);

Notice how I 'or' my current state in with the states that I want to turn 'on'. Who knows what my current state is and I don't want to blow it away.

To unset my state, I use the bitwise AND operator with the complement operator:

// Turn off the 'ate dinner' flag



m_nCurState = (m_nCurState & ~MASK_ATE_DINNER);

To check my current state, I use the AND operator:

// Check if I did my homework



if (0 != (m_nCurState & MASK_DID_HOMEWORK)) {



    // yep



} else { 



    // nope...



}

Why do I think this is interesting? Say I'm designing an interface that sets my state. I could write a method that accepts three booleans:

void setState( boolean bDidHomework, boolean bAteDinner, boolean bSleptWell);

Or, I could use a single number to represent all three states and pass a single value:

void setState( int nStateBits);

If you choose the second pattern you'll be very happy when decide to add another state - you won't have to break existing impls of your interface.

Pros:

1, reduce configuration xml files

2, readable by self-documenting

Cons:

1, it adds deployment context to classes, which should be generic enough.

2, interfere with design principles such as IOC and dependency injection, because you need to introduce imports

Usage (annotation works only when handled by related annotation processor):

• Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
• Compiler-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
• Runtime processing — Some annotations are available to be examined at runtime.

  1 import java.io.IOException;
  2 import java.io.PrintStream;
  3 import java.lang.reflect.AnnotatedElement;
  4 import java.lang.annotation.Annotation;
  5 
  6 import java.util.Date;
  7 import java.lang.annotation.Documented;
  8 import java.lang.annotation.Inherited;
  9 import java.lang.annotation.Retention;
 10 import java.lang.annotation.RetentionPolicy;
 11 
 12 public class ReflectionTester {
 13 
 14   public ReflectionTester() {
 15   }
 16 
 17   public void testAnnotationPresent(PrintStream out) throws IOException {
 18     Class c = Super.class;
 19     boolean inProgress = c.isAnnotationPresent(InProgress.class);
 20     if (inProgress) {
 21       out.println("Super is In Progress");
 22     } else {
 23       out.println("Super is not In Progress");
 24     }
 25   }
 26 
 27   public void testInheritedAnnotation(PrintStream out) throws IOException {
 28     Class c = Sub.class;
 29     boolean inProgress = c.isAnnotationPresent(InProgress.class);
 30     if (inProgress) {
 31       out.println("Sub is In Progress");
 32     } else {
 33       out.println("Sub is not In Progress");
 34     }
 35   }
 36 
 37   public void testGetAnnotation(PrintStream out) 
 38     throws IOException, NoSuchMethodException {
 39 
 40     Class c = AnnotationTester.class;
 41     AnnotatedElement element = c.getMethod("calculateInterest", 
 42                                   float.class, float.class);
 43 
 44     GroupTODO groupTodo = element.getAnnotation(GroupTODO.class);
 45     String assignedTo = groupTodo.assignedTo();
 46 
 47     out.println("TODO Item on Annotation Tester is assigned to: '" + 
 48         assignedTo + "'");
 49   }
 50 
 51   public void printAnnotations(AnnotatedElement e, PrintStream out)
 52     throws IOException {
 53 
 54     out.printf("Printing annotations for '%s'%n%n", e.toString());
 55 
 56     Annotation[] annotations = e.getAnnotations();
 57     for (Annotation a : annotations) {
 58       out.printf("    * Annotation '%s' found%n", 
 59         a.annotationType().getName());
 60     }
 61   }
 62 
 63   public static void main(String[] args) {
 64     try {
 65       ReflectionTester tester = new ReflectionTester();
 66 
 67       tester.testAnnotationPresent(System.out);
 68       tester.testInheritedAnnotation(System.out);
 69 
 70       tester.testGetAnnotation(System.out);
 71 
 72       Class c = AnnotationTester.class;
 73       AnnotatedElement element = c.getMethod("calculateInterest", 
 74                                     float.class, float.class);      
 75       tester.printAnnotations(element, System.out);
 76     } catch (Exception e) {
 77       e.printStackTrace();
 78     } 
 79   }
 80 }
 81 
 82 class Sub extends Super {
 83 
 84   public void print(PrintStream out) throws IOException {
 85     out.println("Sub printing");
 86   }
 87 }
 88 
 89 @InProgress class Super {
 90 
 91   public void print(PrintStream out) throws IOException {
 92     out.println("Super printing");
 93   }
 94 }
 95 
 96 @Documented
 97 @Retention(RetentionPolicy.RUNTIME)
 98 @interface GroupTODO {
 99 
100   public enum Severity { CRITICAL, IMPORTANT, TRIVIAL, DOCUMENTATION };
101 
102   Severity severity() default Severity.IMPORTANT;
103   String item();
104   String assignedTo();
105   String dateAssigned();
106 }
107 
108 /**
109  * Marker annotation to indicate that a method or class
110  *   is still in progress.
111  */
112 @Documented
113 @Inherited
114 @Retention(RetentionPolicy.RUNTIME)
115 @interface InProgress { }
116 
117 class AnnotationTester {
118 
119   @InProgress
120   @GroupTODO(
121     severity=GroupTODO.Severity.CRITICAL,
122     item="Figure out the amount of interest per month",
123     assignedTo="Brett McLaughlin",
124     dateAssigned="04-26-2004"
125   )
126   public void calculateInterest(float amount, float rate) {
127     // Need to finish this method later
128   }
129 }
130