import java.lang.reflect.Proxy;
/**
+ * <p>
* Thread-specific proxy is used to create implementations of interfaces that
* delegate to a thread-specific implementation of the service.
+ * </p>
*
+ * <p>
* It can be used for instance to create a contextual reference to an entity
* manager that delegates to a thread-specific instance.
+ * </p>
*
+ * <p>
* The {@link #set(Object)} method sets the current service instance for the
* current thread. The {@link #get()} method gets the current service instance
* for the current thread. The {@link #getProxy()} method gets a proxy that will
* delegate at runtime to the thread-specific instance. The result from this
* method can be passed at construction of an object that will be used by
* multiple threads.
+ * </p>
*
+ * <p>
* This class is mostly used by infrastructure code (utilities) and test tools.
+ * </p>
*
+ * <p>
* Care has been taken so that the invocation handler is serializable. However,
* it is only serializable within one virtual machine. It cannot be used in a
* distributed context where it can be sent to another JVM.
+ * </p>
+ *
+ * <p>
+ * This class currently does not do any cleanup. So it should not be used in production code
+ * but only in test utilities.
+ * </p>
*
* @param T
* Interface to proxy.
}
/**
- * Constructs the factory with a callback to create thread-specific objects
- * automatically.
+ * Constructs the factory with a callback to create thread-specific objects
+ * automatically.
*
* @param aClass
* Interface class of the service to proxy.
svc = new ThreadLocal<T>() {
@Override
protected T initialValue() {
- if ( aCallback != null ) {
+ if (aCallback != null) {
return aCallback.create();
}
- return null;
+ return null;
}
};
clazz = aClass;