TransManager

2. final
3. public class TransManager {
4.     
5.     private final static Log log = LogUtil.getLog(TransManager.class);
6.     
7.     private final static ThreadLocal<Map<String,Object>> cache = new ThreadLocal<Map<String,Object>>(){
8.         @Override
9.         protected Map<String,Object> initialValue() {
10.             return new HashMap<String,Object>();
11.         }
12.     };
13.     
14.     
15.     //--------------------------------------
16.     
17.     private static List<TransListener> listenerLst = new CopyOnWriteArrayList<TransListener>();
18.     
19.     public static void addListener(TransListener listener){
20.         if(listener == null){
21.             throw new java.lang.NullPointerException();
22.         }
23.         listenerLst.add(listener);
24.     }
25.     
26.     public static void remove(TransListener listener){
27.         if(listener == null){
28.             throw new java.lang.NullPointerException();
29.         }
30.         listenerLst.remove(listener);
31.     }
32.     
33.     //--------------------------------------
34.     
35.     public static <T> T wrap(Class<T> clz) {
36.         return wrap(clz, false , true);
37.     }
38.     
39.     public static <T> T wrap(Class<T> clz , boolean isUseCache) {
40.         return wrap(clz, false , isUseCache);
41.     }
42.     
43.     public static <T> T wrap(Class<T> clz , boolean isReadOnly , boolean isUseCache) {
44.         return wrap(clz, DbSessionFactory.MAIN , isReadOnly , isUseCache);
45.     }
46.     
47.     
48.     @SuppressWarnings("unchecked")
49.     public static <T> T wrap(Class<T> clz , int dbtype , boolean isReadOnly , boolean isUseCache) {
50.         
51.         if(!isUseCache){
52.             return makeObj(clz,dbtype,isReadOnly);
53.         }else{
54.         
55.             String key = clz.getCanonicalName()+"_"+dbtype+"_"+isReadOnly;
56.             
57.             T obj = (T)cache.get().get(key);
58.             
59.             if(obj == null){
60.                 obj = makeObj(clz,dbtype,isReadOnly);
61.                 cache.get().put(key,obj);
62.             }
63.             
64.             return obj;
65.         }
66.     }
67.     
68.     
69.     @SuppressWarnings("unchecked")
70.     private static <T> T makeObj(Class<T> clz,final int dbtype , final boolean isReadOnly){
71.         return (T)Enhancer.create(clz, new MethodInterceptor(){
72.             public Object intercept(Object obj, Method method, Object[] arg,MethodProxy proxy) throws Throwable {
73.                 return execute(dbtype, isReadOnly, obj, null , proxy , arg);
74.             }
75.         });
76.     }
77.     
78.     
79.     //---------------------------------
80.     
81.     public static <T> T doTransaction(Transaction<T> t) throws Exception {
82.         return doTransaction(t , DbSessionFactory.MAIN , false);
83.     }
84.     
85.     
86.     private static Method exeMethod ;
87.     static{
88.         try {
89.             exeMethod = Transaction.class.getMethod("execute");
90.         } catch (Exception e) {
91.             e.printStackTrace();
92.         }
93.     }
94.     @SuppressWarnings("unchecked")
95.     public static <T> T doTransaction(Transaction<T> t , int dbtype , boolean isReadOnly) throws Exception {
96.         return (T)execute(dbtype, isReadOnly, t, exeMethod , null , null);
97.     }
98.     
99.     
100.     //----------------------------------
101.     
102.     private static Object execute(int dbtype , boolean isReadOnly , Object obj , Method method ,MethodProxy proxy,Object[] args) throws Exception {
103.         
104.         try{
105.             
106.             begin(dbtype,isReadOnly);  
107.             
108.             Object res = method==null? proxy.invokeSuper(obj,args) : method.invoke(obj, args);
109.             
110.             commit(dbtype,isReadOnly);
111.             
112.             return res;
113.             
114.         } catch (Throwable dx) {
115.             rollback(dbtype,isReadOnly);
116.             throw new Exception(dx);
117.         }
118.     }
119.     
120.     private static void begin(int dbtype , boolean isReadOnly) throws Exception{
121.         
122.         for(TransListener listerner : listenerLst ){
123.             try{
124.                 listerner.begin(dbtype, isReadOnly);
125.             }catch(Exception dx){
126.                 log.error("TransListener begin err!" , dx);
127.             }
128.         }
129.         
130.         if(isReadOnly){
131.             DbSessionFactory.beginReadOnlyTransaction(dbtype);
132.         }else{
133.             DbSessionFactory.beginTransaction(dbtype);
134.         }
135.         
136.     }
137.     
138.     private static void commit(int dbtype , boolean isReadOnly) throws Exception{
139.         
140.         if(isReadOnly){
141.             DbSessionFactory.commitReadOnlyTransaction(dbtype);
142.         }else{
143.             DbSessionFactory.commitTransaction(dbtype);
144.         }
145.         
146.         for(TransListener listerner : listenerLst ){
147.             try{
148.                 listerner.commit(dbtype, isReadOnly);
149.             }catch(Exception dx){
150.                 log.error("TransListener commit err!" , dx);
151.             }
152.         }
153.     }
155.     private static void rollback(int dbtype , boolean isReadOnly) throws Exception{
156.         
157.         if(isReadOnly){
158.             DbSessionFactory.rollbackReadOnlyTransaction(dbtype);
159.         }else{
160.             DbSessionFactory.rollbackTransaction(dbtype);
161.         }
162.         
163.         for(TransListener listerner : listenerLst ){
164.             try{
165.                 listerner.rollback(dbtype, isReadOnly);
166.             }catch(Exception dx){
167.                 log.error("TransListener rollback err!" , dx);
168.             }
169.         }
170.     }
171.     
172.     
173.     //------------------------------------
174.     
175.     public interface TransListener {
176.         
177.         public void begin(int dbtype , boolean isReadOnly);
178.         
179.         public void commit(int dbtype , boolean isReadOnly);
180.         
181.         public void rollback(int dbtype , boolean isReadOnly);
182.         
183.     }
184.     
185.     
186.     //------------------------------------
187.     
188.     
189.     public interface Transaction<T> {
191.         public T execute() throws Exception;
193.     }
194. }