Examples of org.jbpm.pvm.internal.wire.WireContext

org.jbpm.pvm.internal.wire.WireContext
object factory that creates, initializes, wires and caches objects based on {@link Descriptor descriptors} (aka IoC container).
General principle

As input, a WireContext takes a {@link WireDefinition}. The WireDefinition contains named {@link Descriptor}s that know how to create objects and wire them together. Each object has a name. The WireContext will maintain a cache (map) of the created objects. So that upon subsequent requests, the same object can be given from the cache.

Purpose

A WireContext is used often in combination with {@link Environment} to decouple the processDefinition virtual machine from its environment. In the {@link JbpmConfiguration}, both the process-engine context and the environment contexts are WireContexts. The PVM will use the persistence service, asynchronous message service, timer service and other services through specified abstractions in the environment.

Another usage of the WireContext is construction and configuration of user code objects in a persistable way. {@link ActivityBehaviour}s and {@link org.jbpm.api.activity.ExternalActivityBehaviour}and other user code can be instantiated with a WireContext. That way, they can be persisted in a fixed schema.

Each {@link ProcessElementImpl} has configuration properties.Consider this extra metadata that can be associated to elements in a processDefinition definition. In that respect, it's somewhat similar to what annotations are in Java. Because of the wire persistence, all these configuration properties fit into the same process model and in its database schema.

Xml

Mostly often, {@link Descriptor}s and WireContext's are not used directly. Instead, the wire XML is used in a configuration file. The {@link WireParser wire XML parser} contains the documentation onthe XML grammer. The {@link WireParser} will produce a {@link WireDefinition}with a bunch of {@link Descriptor}s in it.
Object lifecycle

Objects are build in 2 phases: construction and initialization. The motivation for splitting these phases is to resolve many of the circular dependencies. Imagine 2 objects that have a bidirectional reference. By splitting the construction from the initialization phase, the objects can both be constructed first, and then during initialization, they will be injected into each other.

Construction

Construction of the object is all that needs to be done until a reference to the object is available.

In the case of dynamically created objects ( {@link ObjectDescriptor}), the simplest case this is accomplished with a constructor. But also static or non-static factory methods can be used to obtain a reference to an object.

In case of immutable objects, the descriptor can just provide a reference to a singleton object.

Initialization

Initialization is optional and it is comprised of everything that needs to be done with an object after a reference to the object is available. {@link AbstractDescriptor} contains an empty default initialization method.

For objects {@link ObjectDescriptor}s, this means that a a sequence of {@link Operation}s can be applied to the object. Following operations implementations are already available and can be applied to an object during initialization:
- {@link FieldOperation}: injects another object into a field
- {@link PropertyOperation}: injects another object with a setter method.
- {@link InvokeOperation}: invokes a method.
- {@link SubscribeOperation}: subscribes to an {@link Observable observable}.
Environment

When an environment is injected into a WireContext, lookup of all referenced object names will be done first in this WireContext, but if the object name is not defined there, the environment will be searched in the environment's default search order.

Events

Several objects will fire events to which can be subscribed:

The WireContext itself fires the {@link #EVENT_OPEN} and {@link #EVENT_OPEN}events.

The {@link Descriptor}s will fire the events {@link Descriptor#EVENT_CONSTRUCTING}, {@link Descriptor#EVENT_INITIALIZING}, {@link Descriptor#EVENT_CONSTRUCTED}, {@link Descriptor#EVENT_SET} and {@link Descriptor#EVENT_REMOVE}.

And last but not least, the objects created by the WireContext can be {@link Observable} themselves.

Eager initialization

By default, all objects in a WireContext are lazily constructued and initialized. Eager initialization is specified on a named object and it means that the object is constructed and initialized during construction of the WireContext. You an only specify eager initialization when the object has a name.

Specifying how an object should be initialized.

The initialization can be specified with the {@link AbstractDescriptor#setInit(char)} method.
The possible value for init parameter is one of :
- {@link AbstractDescriptor#INIT_LAZY}: for lazy creation and delayed initialization
- {@link AbstractDescriptor#INIT_REQUIRED}: for lazy creation and immediate initialization
- {@link AbstractDescriptor#INIT_EAGER}: for eager creation and delayed initialization
- {@link AbstractDescriptor#INIT_IMMEDIATE}: for eager creation and immediate initialization
@author Tom Baeyens @author Guillaume Porcher (documentation)

          "</objects>"
        )
        .execute()
        .getDocumentObject();
  
      WireContext wireContext = new WireContext(wireDefinition);
      defaultScriptManager = wireContext.get(ScriptManager.class);
    }
    return defaultScriptManager;
  }

View Full Code Here

        if (txWireObjects != null) {
            usedWireDefinition = new WireDefinition(transactionWireDefinition,
                    txWireObjects);
        }


        WireContext transactionContext = new WireContext(usedWireDefinition,
                Context.CONTEXTNAME_TRANSACTION, environment, true);
        // add the environment block context to the environment
        environment.setContext(transactionContext);


        Environment.pushEnvironment(environment);
        try {
            // finish the creation of the environment wire context
            transactionContext.create();


        } catch (RuntimeException e) {
            Environment.popEnvironment();
            throw e;
        }

View Full Code Here

    WireDefinition usedWireDefinition = transactionWireDefinition;
    if (txWireObjects!=null) {
      usedWireDefinition = new WireDefinition(transactionWireDefinition, txWireObjects);
    }
    
    WireContext transactionContext = new WireContext(usedWireDefinition, Context.CONTEXTNAME_TRANSACTION, environment, true);
    // add the environment block context to the environment
    environment.setContext(transactionContext);


    Environment.pushEnvironment(environment);
    try {
      // finish the creation of the environment wire context
      transactionContext.create();


    } catch (RuntimeException e) {
      Environment.popEnvironment();
      throw e;
    }

View Full Code Here

    return wireContext.keys();
  }
  
  public void add(Descriptor descriptor) {
    if (wireContext==null) {
      wireContext = new WireContext(new WireDefinition());
    }
    wireContext.getWireDefinition().addDescriptor(descriptor);
  }

View Full Code Here

       ) {
      listener = new FilterListener(listener, eventNames);
    }


    // identify the wireContext
    WireContext wireContext = null;
    if (contextName!=null) {
      Environment environment = Environment.getCurrent();
      if (environment!=null) {
        try {
          wireContext = (WireContext) environment.getContext(contextName);
          if (wireContext==null) {
            throw new WireException("couldn't subscribe because context "+contextName+" doesn't exist");
          }
        } catch (ClassCastException e) {
          throw new WireException("couldn't subscribe because context "+contextName+" is not a WireContext", e);
        }
      } else {
        throw new WireException("couldn't get context "+contextName+" for subscribe because no environment available in context "+targetWireContext);
      }
    } else {
      wireContext = targetWireContext;
    }


    if (wireEvents) {
      WireDefinition wireDefinition = wireContext.getWireDefinition();
      
      // if there are objectNames specified
      if (objectNames!=null) {
        // subscribe to the descriptors for the all objectNames
        for (String objectName: objectNames) {
          Descriptor descriptor = wireDefinition.getDescriptor(objectName);
          subscribe(listener, descriptor);
        }
        
      // if no objectNames are specified, subscribe to all the descriptors
      } else { 
        Set<Descriptor> descriptors = new HashSet<Descriptor>(wireDefinition.getDescriptors().values());
        for(Descriptor descriptor: descriptors) {
          subscribe(listener, descriptor);
        }
      }


    } else if ( (objectNames!=null)
                && (!objectNames.isEmpty())
              ) {
      // for every objectName
      for (String objectName: objectNames) {
        // subscribe to the objects themselves
        Object object = wireContext.get(objectName);
        if (object==null) {
          throw new WireException("couldn't subscribe to object in context "+wireContext.getName()+": object "+objectName+" unavailable");
        }
        if (! (object instanceof Observable)) {
          throw new WireException("couldn't subscribe to object in context "+wireContext.getName()+": object "+objectName+" ("+object.getClass().getName()+") isn't "+Observable.class.getName());
        }
        subscribe(listener, (Observable)object);
      }


    } else {

View Full Code Here

      authenticatedUserIdThreadLocal.set(null);
    }
  }


  protected void installTransactionContext(PvmEnvironment environment) {
    WireContext transactionContext = new WireContext(transactionWireDefinition, Context.CONTEXTNAME_TRANSACTION, true);
    // add the environment block context to the environment
    environment.setContext(transactionContext);


    EnvironmentImpl.pushEnvironment(environment);
    try {
      // finish the creation of the environment wire context
      transactionContext.create();


    } catch (RuntimeException e) {
      EnvironmentImpl.popEnvironment();
      throw e;
    }

View Full Code Here

  
  public void perform(OpenExecution execution) throws Exception {
    
    Object invocationTarget = null;


    WireContext wireContext = new WireContext();


    if (target!=null) {
      invocationTarget = target;


    } else if (targetExpression!=null) {

View Full Code Here

       ) {
      listener = new FilterListener(listener, eventNames);
    }


    // identify the wireContext
    WireContext wireContext = null;
    if (contextName!=null) {
      EnvironmentImpl environment = EnvironmentImpl.getCurrent();
      if (environment!=null) {
        try {
          wireContext = (WireContext) environment.getContext(contextName);
          if (wireContext==null) {
            throw new WireException("couldn't subscribe because context "+contextName+" doesn't exist");
          }
        } catch (ClassCastException e) {
          throw new WireException("couldn't subscribe because context "+contextName+" is not a WireContext", e);
        }
      } else {
        throw new WireException("couldn't get context "+contextName+" for subscribe because no environment available in context "+targetWireContext);
      }
    } else {
      wireContext = targetWireContext;
    }


    if (wireEvents) {
      WireDefinition wireDefinition = wireContext.getWireDefinition();
      
      // if there are objectNames specified
      if (objectNames!=null) {
        // subscribe to the descriptors for the all objectNames
        for (String objectName: objectNames) {
          Descriptor descriptor = wireDefinition.getDescriptor(objectName);
          subscribe(listener, descriptor);
        }
        
      // if no objectNames are specified, subscribe to all the descriptors
      } else { 
        Set<Descriptor> descriptors = new HashSet<Descriptor>(wireDefinition.getDescriptors().values());
        for(Descriptor descriptor: descriptors) {
          subscribe(listener, descriptor);
        }
      }


    } else if ( (objectNames!=null)
                && (!objectNames.isEmpty())
              ) {
      // for every objectName
      for (String objectName: objectNames) {
        // subscribe to the objects themselves
        Object object = wireContext.get(objectName);
        if (object==null) {
          throw new WireException("couldn't subscribe to object in context "+wireContext.getName()+": object "+objectName+" unavailable");
        }
        if (! (object instanceof Observable)) {
          throw new WireException("couldn't subscribe to object in context "+wireContext.getName()+": object "+objectName+" ("+object.getClass().getName()+") isn't "+Observable.class.getName());
        }
        subscribe(listener, (Observable)object);
      }


    } else {

View Full Code Here

          "</objects>"
        )
        .execute()
        .getDocumentObject();
  
      WireContext wireContext = new WireContext(wireDefinition);
      defaultScriptManager = wireContext.get(ScriptManager.class);
    }
    return defaultScriptManager;
  }

View Full Code Here

      String className = objectDescriptor.getClassName();
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      clazz = Class.forName(className, true, classLoader);  
    }
    
    WireContext wireContext = new WireContext(new WireDefinition());
    Object returnValue = ObjectDescriptor.invokeMethod(methodName, argDescriptors, wireContext, target, clazz);
    
    if (variableName!=null) {
      execution.setVariable(variableName, returnValue);
    }

View Full Code Here

TOP

Related Classes of org.jbpm.pvm.internal.wire.WireContext

org.jbpm.jpdl.internal.activity.JavaActivity

org.jbpm.pvm.internal.cfg.JbpmConfiguration

org.jbpm.pvm.internal.cfg.SpringConfiguration

org.jbpm.pvm.internal.env.Environment

org.jbpm.pvm.internal.env.EnvironmentImpl

org.jbpm.pvm.internal.model.WireProperties

org.jbpm.pvm.internal.processengine.ProcessEngineImpl

org.jbpm.pvm.internal.script.ScriptManager

org.jbpm.pvm.internal.wire.operation.SubscribeOperation

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of org.jbpm.pvm.internal.wire.WireContext

General principle

Purpose

Xml

Object lifecycle

Construction

Initialization

Environment

Events

Eager initialization

Specifying how an object should be initialized.

Related Classes of org.jbpm.pvm.internal.wire.WireContext