81127009e4a6afc09993800789637a0001c78ce0
[utils] / support / general / src / main / java / org / wamblee / general / ThreadSpecificProxyFactory.java
1 /*
2  * Copyright 2005-2010 the original author or authors.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.wamblee.general;
17
18 import java.lang.reflect.InvocationHandler;
19 import java.lang.reflect.Proxy;
20
21 /**
22  * <p>
23  * Thread-specific proxy is used to create implementations of interfaces that
24  * delegate to a thread-specific implementation of the service.
25  * </p>
26  * 
27  * <p>
28  * It can be used for instance to create a contextual reference to an entity
29  * manager that delegates to a thread-specific instance.
30  * </p>
31  * 
32  * <p>
33  * The {@link #set(Object)} method sets the current service instance for the
34  * current thread. The {@link #get()} method gets the current service instance
35  * for the current thread. The {@link #getProxy()} method gets a proxy that will
36  * delegate at runtime to the thread-specific instance. The result from this
37  * method can be passed at construction of an object that will be used by
38  * multiple threads.
39  * </p>
40  *
41  * <p>
42  * This class is mostly used by infrastructure code (utilities) and test tools.
43  * </p>
44  * 
45  * <p>
46  * Care has been taken so that the invocation handler is serializable. However,
47  * it is only serializable within one virtual machine. It cannot be used in a
48  * distributed context where it can be sent to another JVM.
49  * </p>
50  * 
51  * @param T
52  *            Interface to proxy.
53  * @author Erik Brakkee
54  * 
55  */
56 public class ThreadSpecificProxyFactory<T> {
57
58     /**
59      * Optional callback invoked to create the thread-specific object when there
60      * is no object yet associated with the current thread.
61      * 
62      * @author Erik Brakkee
63      * 
64      */
65     public static interface CreationCallback<T> {
66         /**
67          * Creates the object.
68          * 
69          * @return Object.
70          */
71         T create();
72     }
73
74     private ThreadLocal<T> svc;
75     private Class clazz;
76     private T proxy;
77
78     /**
79      * Constructs the factory.
80      * 
81      * @param aClass
82      *            Interface class of the service to proxy.
83      */
84     public ThreadSpecificProxyFactory(Class<T> aClass) {
85         this(aClass, null);
86     }
87
88     /**
89      * Constructs the factory with a callback to create thread-specific objects 
90      * automatically. 
91      * 
92      * @param aClass
93      *            Interface class of the service to proxy.
94      * @param aCallback
95      *            Callback to create the object if it does not exist. When null,
96      *            then no initialization is done.
97      */
98     public ThreadSpecificProxyFactory(Class<T> aClass,
99         final CreationCallback<T> aCallback) {
100         if (!aClass.isInterface()) {
101             throw new IllegalArgumentException("Class " + aClass.getName() +
102                 " is not an interface");
103         }
104         svc = new ThreadLocal<T>() {
105             @Override
106             protected T initialValue() {
107                 if ( aCallback != null ) { 
108                     return aCallback.create();
109                 }
110                 return null; 
111             }
112         };
113         clazz = aClass;
114         proxy = createProxy();
115
116     }
117
118     /**
119      * Sets the thread-specific service.
120      * 
121      * @param aService
122      *            Service, use null value to reset.
123      */
124     public void set(T aService) {
125         svc.set(aService);
126     }
127
128     /**
129      * Gets the current thread-specific service. To get a contextual reference
130      * that can be used by any thread but delegates to a thread-specific
131      * instance, use {@link #getProxy()}.
132      * 
133      * @return Service.
134      */
135     public T get() {
136         return svc.get();
137     }
138
139     /**
140      * Gets the proxy that delegates to the thread-specific instance set by
141      * {@link #set(Object)}
142      * 
143      * @return Proxy.
144      */
145     public T getProxy() {
146         return proxy;
147     }
148
149     private T createProxy() {
150         InvocationHandler handler = new ThreadSpecificInvocationHandler(svc,
151             clazz);
152         Class proxyClass = Proxy.getProxyClass(clazz.getClassLoader(),
153             new Class[] { clazz });
154         T proxyObj;
155         try {
156             proxyObj = (T) proxyClass.getConstructor(
157                 new Class[] { InvocationHandler.class }).newInstance(
158                 new Object[] { handler });
159             return proxyObj;
160         } catch (Exception e) {
161             throw new RuntimeException("Could not create proxy for " +
162                 clazz.getName(), e);
163         }
164     }
165 }