javax.enterprise.concurrent

## Interface ContextService

-     public interface ContextService

  The ContextService provides methods for creating dynamic proxy objects (as defined by `java.lang.reflect.Proxy`) with the addition of context typically associated with applications executing in a Java™ EE environment. Examples of such context are classloading, namespace, security, etc.

  The proxy objects follow the same rules as defined for the `java.lang.reflect.Proxy` class with the following additions:

  - The proxy instance will retain the context of the creator's thread.
  - The proxy instance will implement all of the interfaces specified on the `createContextualProxy` methods.
  - The object to have a proxy instance created for should not be a component managed by the Java™ EE Product Provider, such as a web component or an EJB.
  - All interface method invocations on a proxy instance run in the creator's context with the exception of `hashCode`, `equals`, `toString` and all other methods declared in `Object`.
  - The proxy instance must implement `Serializable`.
  - The proxied object instance must implement `Serializable` if the proxy instance is serialized.
  - Execution properties can be stored with the proxy instance. Custom property keys must not begin with "javax.enterprise.concurrent.".
  - Execution properties are to be used for controlling how various contextual information is retrieved and applied to the thread. Although application components can store arbitrary property keys and values, it is not recommended. Java™ EE product providers may impose limits to the size of the keys and values.

  Since:
    1.0

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Object` | `createContextualProxy(Object instance, Class<?>... interfaces)` Creates a new contextual object proxy for the input object instance.
    `Object` | `createContextualProxy(Object instance, Map<String,String> executionProperties, Class<?>... interfaces)` Creates a new contextual object proxy for the input object instance.
    `<T> T` | `createContextualProxy(T instance, Class<T> intf)` Creates a new contextual object proxy for the input object instance.
    `<T> T` | `createContextualProxy(T instance, Map<String,String> executionProperties, Class<T> intf)` Creates a new contextual object proxy for the input object instance.
    `Map<String,String>` | `getExecutionProperties(Object contextualProxy)` Gets the current execution properties on the context proxy instance.

- - ### Method Detail

    - #### createContextualProxy

          <T> T createContextualProxy(T instance,
                                    Class<T> intf)

      Creates a new contextual object proxy for the input object instance.

      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);

      Parameters:
        `instance` - the instance of the object to proxy.
        `intf` - the interface that the proxy should implement.
      Returns:
        a proxy for the input object that implements the specified interface.
      Throws:
        `IllegalArgumentException` - - if the `intf` argument is null or the instance does not implement the specified interface.

    - #### createContextualProxy

          Object createContextualProxy(Object instance,
                                     Class<?>... interfaces)

      Creates a new contextual object proxy for the input object instance.

      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);

      Parameters:
        `instance` - the instance of the object to proxy.
        `interfaces` - the interfaces that the proxy should implement.
      Returns:
        a proxy for the input object that implements all of the specified interfaces.
      Throws:
        `IllegalArgumentException` - - if the `interfaces` argument is null or the instance does not implement all the specified interfaces.

    - #### createContextualProxy

          <T> T createContextualProxy(T instance,
                                    Map<String,String> executionProperties,
                                    Class<T> intf)

      Creates a new contextual object proxy for the input object instance.

      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.

                }
            }

      Parameters:
        `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.
      Returns:
        a proxy for the input object that implements the specified interface.
      Throws:
        `IllegalArgumentException` - - if the `intf` argument null or the instance does not implement the specified interface.

    - #### createContextualProxy

          Object createContextualProxy(Object instance,
                                     Map<String,String> executionProperties,
                                     Class<?>... interfaces)

      Creates a new contextual object proxy for the input object instance.

      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.

      Parameters:
        `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.
      Returns:
        a proxy for the input object that implements all of the specified interfaces.
      Throws:
        `IllegalArgumentException` - - if the `interfaces` argument is null or the instance does not implement all the specified interfaces.

    - #### getExecutionProperties

          Map<String,String> getExecutionProperties(Object contextualProxy)

      Gets the current execution properties on the context proxy instance.
      Parameters:
        `contextualProxy` - the contextual proxy instance to retrieve the execution properties.
      Returns:
        A copy of the current contextual object execution properties, or null if the contextualProxy is created without specifying any execution properties.
      Throws:
        `IllegalArgumentException` - thrown if the input contextualProxy is not a valid contextual object proxy created with the `createContextualProxy` method.

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.