public class ContextServiceImpl extends java.lang.Object implements ContextService
Constructor and Description |
---|
ContextServiceImpl() |
Modifier and Type | Method and Description |
---|---|
java.lang.Object |
createContextualProxy(java.lang.Object instance,
java.lang.Class<?>... interfaces)
Creates a new contextual object proxy for the input object instance.
|
java.lang.Object |
createContextualProxy(java.lang.Object instance,
java.util.Map<java.lang.String,java.lang.String> executionProperties,
java.lang.Class<?>... interfaces)
Creates a new contextual object proxy for the input object instance.
|
<T> T |
createContextualProxy(T instance,
java.lang.Class<T> intf)
Creates a new contextual object proxy for the input object instance.
|
<T> T |
createContextualProxy(T instance,
java.util.Map<java.lang.String,java.lang.String> executionProperties,
java.lang.Class<T> intf)
Creates a new contextual object proxy for the input object instance.
|
java.util.Map<java.lang.String,java.lang.String> |
getExecutionProperties(java.lang.Object contextualProxy)
Gets the current execution properties on the context proxy instance.
|
public <T> T createContextualProxy(T instance, java.lang.Class<T> intf)
ContextService
Each method invocation will have the context of the application component instance that created the contextual object proxy.
The contextual object is useful when developing or using Java™ SE threading mechanisms propagating events to other component instances.
If the application component that created the proxy is not started or
deployed, all methods on reflected interfaces may throw an
IllegalStateException
.
For example, to execute a Runnable which is contextualized with the creator's context using a Java™ SE ExecutorService:
public class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable.run with Java EE Context available."); } } InitialContext ctx = new InitialContext(); ThreadFactory threadFactory = (ThreadFactory) ctx .lookup("java:comp/env/concurrent/ThreadFactory"); ContextService ctxService = (ContextService) ctx .lookup("java:comp/env/concurrent/ContextService"); MyRunnable myRunnableInstance = ...; Runnable rProxy = ctxService.createContextualProxy(myRunnableInstance, Runnable.class); ExecutorService exSvc = Executors.newThreadPool(10, threadFactory); Future f = exSvc.submit(rProxy);
createContextualProxy
in interface ContextService
instance
- the instance of the object to proxy.intf
- the interface that the proxy should implement.public java.lang.Object createContextualProxy(java.lang.Object instance, java.lang.Class<?>... interfaces)
ContextService
This method is similar to <T> T createContextualProxy(T instance, Class<T> intf)
except that this method can be used if the proxy has to support multiple
interfaces.
Example:
public class MyRunnableWork implements Runnable, SomeWorkInterface { public void run() { System.out.println("MyRunnableWork.run with Java EE Context available."); } public void someWorkInterfaceMethod() { ... } } ThreadFactory threadFactory = ...; ContextService ctxService = ...; MyRunnableWork myRunnableWorkInstance = ...; Object proxy = ctxService.createContextualProxy(myRunnableWorkInstance, Runnable.class, SomeWorkInterface.class); // call SomeWorkInterface method on the proxy ((SomeWorkInterface) proxy).someWorkInterfaceMethod(); ExecutorService exSvc = Executors.newThreadPool(10, threadFactory); // submit the proxy as a Runnable to the ExecutorService Future f = exSvc.submit( (Runnable)proxy);
createContextualProxy
in interface ContextService
instance
- the instance of the object to proxy.interfaces
- the interfaces that the proxy should implement.public <T> T createContextualProxy(T instance, java.util.Map<java.lang.String,java.lang.String> executionProperties, java.lang.Class<T> intf)
ContextService
The contextual object is useful when developing or using Java™ SE threading mechanisms propagating events to other component instances.
If the application component that created the proxy is not started or
deployed, all methods on reflected interfaces may throw an
IllegalStateException
.
This method accepts a Map
object which allows the
contextual object creator to define what contexts or behaviors to capture
when creating the contextual object. The specified properties will remain
with the contextual object.
For example, to call a Message Driven Bean (MDB) with the sender's context, but within the MDB's transaction:
public class MyServlet ... { public void doPost() throws NamingException, JMSException { InitialContext ctx = new InitialContext(); // Get the ContextService that only propagates // security context. ContextService ctxSvc = (ContextService) ctx.lookup("java:comp/env/SecurityContext"); // Set any custom context data through execution properties Map<String, String> execProps = new HashMap<>(); execProps.put("vendor_a.security.tokenexpiration", "15000"); // Specify that contextual object should run inside the current // transaction. If we have a failure, we don't want to consume // the message. execProps.put(ManagedTask.TRANSACTION, "USE_TRANSACTION_OF_EXECUTION_THREAD"); ProcessMessage msgProcessor = ctxSvc.createContextualProxy(new MessageProcessor(), execProps, ProcessMessage.class); ConnectionFactory cf = (ConnectionFactory) ctx.lookup("java:comp/env/MyTopicConnectionFactory"); Destination dest = (Destination) ctx.lookup("java:comp/env/MyTopic"); Connection con = cf.createConnection(); Session session = con.createSession(true, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(dest); Message msg = session.createObjectMessage((Serializable)msgProcessor); producer.send(dest, msg); ... } public class MyMDB ... { public void onMessage(Message msg) { // Get the ProcessMessage contextual object from the message. ObjectMessage omsg = (ObjectMessage)msg; ProcessMessage msgProcessor = (ProcessMessage)omsg.getObject(); // Process the message in the specified context. msgProcessor.processMessage(msg); } } public interface ProcessMessage { public void processMessage(Message msg); } public class MessageProcessor implements ProcessMessage, Serializable { public void processMessage(Message msg) { // Process the message with the application container // context that sent the message. } }
createContextualProxy
in interface ContextService
instance
- the instance of the object to proxy.executionProperties
- the properties to use when creating and running the context
object.intf
- the interface that the proxy should implement.public java.lang.Object createContextualProxy(java.lang.Object instance, java.util.Map<java.lang.String,java.lang.String> executionProperties, java.lang.Class<?>... interfaces)
ContextService
This method is similar to <T> T createContextualProxy(T instance, Map<String, String> executionProperties, Class<T> intf)
except that this method can be used if the proxy has to support multiple
interfaces.
createContextualProxy
in interface ContextService
instance
- the instance of the object to proxy.executionProperties
- the properties to use when creating and running the context
object.interfaces
- the interfaces that the proxy should implement.public java.util.Map<java.lang.String,java.lang.String> getExecutionProperties(java.lang.Object contextualProxy)
ContextService
getExecutionProperties
in interface ContextService
contextualProxy
- the contextual proxy instance to retrieve the execution properties.