package org.jbpm.pvm.internal.wire.descriptor;
|
|
import java.lang.reflect.Constructor;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Method;
|
import java.lang.reflect.Modifier;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
|
import org.jbpm.api.JbpmException;
|
import org.jbpm.internal.log.Log;
|
import org.jbpm.pvm.internal.env.EnvironmentImpl;
|
import org.jbpm.pvm.internal.script.ScriptManager;
|
import org.jbpm.pvm.internal.util.ReflectUtil;
|
import org.jbpm.pvm.internal.wire.Descriptor;
|
import org.jbpm.pvm.internal.wire.JbpmClassNotFoundException;
|
import org.jbpm.pvm.internal.wire.WireContext;
|
import org.jbpm.pvm.internal.wire.WireDefinition;
|
import org.jbpm.pvm.internal.wire.WireException;
|
import org.jbpm.pvm.internal.wire.operation.FieldOperation;
|
import org.jbpm.pvm.internal.wire.operation.Operation;
|
import org.jbpm.pvm.internal.wire.operation.PropertyOperation;
|
|
/**
|
* <p>This {@link Descriptor} creates and initializes an object.
|
* Objects can be instantiated from a constructor or from a method invocation.</p>
|
*
|
* <p>The way to create an object is specified one of these methods (see <a href='#createTime'>creating objects</a>):
|
* <ul>
|
* <li>className ({@link #setClassName(String)})</li>
|
* <li>factoryObjectName ({@link #setFactoryObjectName(String)})</li>
|
* <li>factoryDescriptor ({@link #setFactoryDescriptor(Descriptor)})</li>
|
* </ul>
|
* Only one of these methods can be used.
|
* </p>
|
*
|
* <h3 id='createTime'>Creating objects</h3>
|
* <h4>Creating object from a constructor</h4>
|
*
|
* <p>This method is used when <code>{@link #getClassName()}!=null && {@link #getMethodName()}==null</code>.</p>
|
*
|
* <p>The {@link #construct(WireContext)} method creates a new object
|
* from a constructor matching the given arguments
|
* (specified with {@link #setArgDescriptors(List)}).</p>
|
*
|
*
|
* <h4>Creating an object from a method invocation</h4>
|
*
|
* <p>The name of the method to call is specified by the method attribute.</p>
|
* <ul>
|
* <li>If the method is <i>static</i>, the related class is {@link #getClassName()}.</li>
|
* <li>If the method is an object method, the object to which the method will be applied is defined by:
|
* <ul>
|
* <li>If <code>{@link #getFactoryObjectName()}!=null</code>: the object with the name factoryObjectName will be fetched from the context.</li>
|
* <li>if <code>{@link #getFactoryDescriptor()}!=null</code>: the object will be created from the factory descriptor.</li>
|
* </ul>
|
* </li>
|
* </ul>
|
* <p>The object returned by {@link #construct(WireContext)} is the object returned by the method invocation.</p>
|
*
|
*
|
* <h3>Initializing Objects</h3>
|
* <h4>Auto Wiring</h4>
|
* <p>If the auto wiring is enabled for the object (<code>{@link #isAutoWireEnabled()}==true</code>),
|
* the WireContext will try to look for objects with the same name as the fields in the class.
|
* If it finds an object with that name, and if it is assignable to the field's type, it is automatically injected,
|
* without the need for explicit {@link FieldOperation} that specifies the injection in the wiring xml.</p>
|
* <p>If the auto wiring is enabled and the WireContext finds an object with the name of a field, but not assignable to this field,
|
* a warning message is generated.</p>
|
*
|
* <p>Auto-wiring is disabled by default.</p>
|
*
|
* <h4>Operations</h4>
|
* <p>Field injection or property injection are done after the auto-wiring. For more information, see {@link Operation}.</p>
|
*
|
* <p>If a field was injected by auto-wiring, its value can be overridden by specifying
|
* a {@link FieldOperation} or {@link PropertyOperation} operation.</p>
|
*
|
* @author Tom Baeyens
|
* @author Guillaume Porcher (documentation)
|
*
|
*/
|
public class ObjectDescriptor extends AbstractDescriptor implements Descriptor {
|
|
private static final long serialVersionUID = 1L;
|
private static Log log = Log.getLog(ObjectDescriptor.class.getName());
|
|
protected String className = null;
|
|
/** specifies the object reference on which the method will be invoked.
|
* Either className, objectName or a descriptor has to be specified.
|
*
|
* TODO check if this member can be replaced by a RefDescriptor in the factoryDescriptor member.
|
*
|
* */
|
String factoryObjectName = null;
|
|
protected String expr;
|
|
protected String lang;
|
|
/** specifies the object on which to invoke the method.
|
* Either className, objectName or a descriptor has to be specified. */
|
protected Descriptor factoryDescriptor = null;
|
|
protected String methodName = null;
|
|
/** map to db as a component */
|
protected List<ArgDescriptor> argDescriptors = null;
|
/** list of operations to perform during initialization. */
|
protected List<Operation> operations = null;
|
|
/** True if autowiring is enabled. */
|
protected boolean isAutoWireEnabled = false;
|
|
public ObjectDescriptor() {
|
}
|
|
public ObjectDescriptor(String className) {
|
this.className = className;
|
}
|
|
public ObjectDescriptor(Class<?> clazz) {
|
this.className = clazz.getName();
|
}
|
|
/**
|
* This method constructs a new Object from the ObjectDefinition.
|
* This object will be created from a class constructor or from a method invocation.
|
* @throws WireException one of the following exception occurred:
|
* <ul><li>if the object cannot be created (unable to load the specified class or no matching constructor found)</li>
|
* <li>if the invocation of the specified method failed</li>
|
* </ul>
|
* @see ObjectDescriptor
|
*/
|
public Object construct(WireContext wireContext) {
|
Object object = null;
|
Class<?> clazz = null;
|
|
if (className!=null) {
|
try {
|
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
|
clazz = Class.forName(className, true, classLoader);
|
} catch (Exception e) {
|
throw new JbpmClassNotFoundException("couldn't load class "+className, e);
|
}
|
|
if (methodName==null) {
|
// plain instantiation
|
try {
|
Object[] args = getArgs(wireContext, argDescriptors);
|
Constructor<?> constructor = ReflectUtil.findConstructor(clazz, argDescriptors, args);
|
if (constructor==null) {
|
throw new WireException("couldn't find constructor "+clazz.getName()+" with args "+Arrays.toString(args));
|
}
|
object = constructor.newInstance(args);
|
} catch (WireException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new WireException("couldn't create object '"+(name!=null ? name : className)+"': "+e.getMessage(), e);
|
}
|
}
|
|
} else if (factoryObjectName!=null) {
|
// referenced factory object
|
object = wireContext.get(factoryObjectName, false);
|
if (object==null) {
|
throw new WireException("can't invoke method '"+methodName+"' on null, resulted from fetching object '"+factoryObjectName+"' from this wiring environment");
|
}
|
|
} else if (factoryDescriptor!=null) {
|
// factory object descriptor
|
object = wireContext.create(factoryDescriptor, false);
|
if (object==null) {
|
throw new WireException("created factory object is null, can't invoke method '"+methodName+"' on it");
|
}
|
} else if (expr!=null) {
|
ScriptManager scriptManager = ScriptManager.getScriptManager();
|
object = scriptManager.evaluateExpression(expr, lang);
|
}
|
|
if (methodName!=null) {
|
try {
|
object = invokeMethod(methodName, argDescriptors, wireContext, object, clazz);
|
|
} catch (WireException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new WireException("couldn't invoke factory method "+methodName+": "+e.getMessage(), e);
|
}
|
}
|
|
return object;
|
}
|
|
public static Object invokeMethod(String methodName, List<ArgDescriptor> argDescriptors, WireContext wireContext, Object object, Class< ? > clazz) throws Exception {
|
// method invocation on object or static method invocation in case object is null
|
if (object!=null) {
|
clazz = object.getClass();
|
}
|
Object[] args = ObjectDescriptor.getArgs(wireContext, argDescriptors);
|
Method method = ReflectUtil.findMethod(clazz, methodName, argDescriptors, args);
|
if (method==null) {
|
// throw exception but first, generate decent message
|
throw new WireException("method "+ReflectUtil.getSignature(methodName, argDescriptors, args)+" is not available on "+
|
(object!=null ? "object "+object+" ("+clazz.getName()+")" : "class "+clazz.getName()));
|
}
|
if (object == null && (!Modifier.isStatic(method.getModifiers()))) {
|
// A non static method is invoked on a null object
|
throw new WireException("method "+ clazz.getName() + "." + ReflectUtil.getSignature(methodName, argDescriptors, args)+" is not static. It cannot be called on a null object.");
|
}
|
object = ReflectUtil.invoke(method, object, args);
|
return object;
|
}
|
|
/**
|
* Initializes the specified object.
|
* If auto-wiring was set to <code>true</code>, auto-wiring is performed (see {@link #autoWire(Object, WireContext)}). Fields and properties injections are then performed.
|
*
|
*/
|
public void initialize(Object object, WireContext wireContext) {
|
try {
|
// specified operations takes precedence over auto-wiring.
|
// e.g. in case there is a collision between
|
// a field or property injection and an autowired value,
|
// the field or property injections should win.
|
// That is why autowiring is done first
|
if (isAutoWireEnabled) {
|
autoWire(object, wireContext);
|
}
|
if (operations!=null) {
|
for(Operation operation: operations) {
|
operation.apply(object, wireContext);
|
}
|
}
|
} catch (Exception e) {
|
throw new WireException("couldn't initialize object '"+(name!=null ? name : className)+"': "+e.getMessage(), e);
|
}
|
}
|
|
public Class<?> getType(WireDefinition wireDefinition) {
|
if (className!=null) {
|
try {
|
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
|
return Class.forName(className, true, classLoader);
|
} catch (Exception e) {
|
throw new WireException("couldn't load class '"+className+"'", e);
|
}
|
}
|
|
Descriptor descriptor = null;
|
if (factoryDescriptor!=null) {
|
descriptor = factoryDescriptor;
|
} else if (factoryObjectName!=null) {
|
descriptor = wireDefinition.getDescriptor(factoryObjectName);
|
}
|
|
if (descriptor!=null) {
|
Class<?> factoryClass = descriptor.getType(wireDefinition);
|
if (factoryClass!=null) {
|
Method method = ReflectUtil.findMethod(factoryClass, methodName, argDescriptors, null);
|
if (method!=null) {
|
return method.getReturnType();
|
}
|
}
|
}
|
|
return null;
|
}
|
|
/**
|
* Auto wire object present in the context and the specified object's fields.
|
* @param object object on which auto-wiring is performed.
|
* @param wireContext context in which the wiring objects are searched.
|
*/
|
protected void autoWire(Object object, WireContext wireContext) {
|
Class<?> clazz = object.getClass();
|
while (clazz!=null) {
|
Field[] declaredFields = clazz.getDeclaredFields();
|
if (declaredFields!=null) {
|
for (Field field: declaredFields) {
|
if (! Modifier.isStatic(field.getModifiers())) {
|
String fieldName = field.getName();
|
Class<?> fieldType = field.getType();
|
|
Object autoWireValue = null;
|
if ("environment".equals(fieldName)) {
|
autoWireValue = EnvironmentImpl.getCurrent();
|
|
} else if ( ("context".equals(fieldName))
|
|| ("wireContext".equals(fieldName))
|
) {
|
autoWireValue = wireContext;
|
|
} else if (wireContext.has(fieldName)) {
|
autoWireValue = wireContext.get(fieldName);
|
|
} else {
|
autoWireValue = wireContext.get(fieldType);
|
}
|
// if auto wire value has not been found in current context,
|
// search in environment
|
if (autoWireValue == null) {
|
EnvironmentImpl currentEnvironment = EnvironmentImpl.getCurrent();
|
if (currentEnvironment != null) {
|
autoWireValue = currentEnvironment.get(fieldName);
|
if (autoWireValue == null) {
|
autoWireValue = currentEnvironment.get(fieldType);
|
}
|
}
|
}
|
|
if (autoWireValue!=null) {
|
try {
|
if (log.isTraceEnabled()) log.trace("auto wiring field "+fieldName+" in "+name);
|
ReflectUtil.set(field, object, autoWireValue);
|
} catch (JbpmException e) {
|
if(e.getCause() instanceof IllegalArgumentException) {
|
log.info("WARNING: couldn't auto wire "+fieldName+" (of type "+fieldType.getName()+") " +
|
"with value "+autoWireValue + " (of type "+autoWireValue.getClass().getName()+")");
|
} else {
|
log.info("WARNING: couldn't auto wire "+fieldName+" with value "+autoWireValue);
|
}
|
}
|
}
|
}
|
}
|
}
|
clazz = clazz.getSuperclass();
|
}
|
}
|
|
/**
|
* Creates a list of arguments (objects) from a list of argument descriptors.
|
* @param wireContext context used to create objects.
|
* @param argDescriptors list of argument descriptors.
|
* @return a list of object created from the descriptors.
|
* @throws Exception
|
*/
|
public static Object[] getArgs(WireContext wireContext, List<ArgDescriptor> argDescriptors) throws Exception {
|
Object[] args = null;
|
if (argDescriptors!=null) {
|
args = new Object[argDescriptors.size()];
|
for(int i=0; i<argDescriptors.size(); i++) {
|
ArgDescriptor argDescriptor = argDescriptors.get(i);
|
Object arg;
|
try {
|
arg = wireContext.create(argDescriptor.getDescriptor(), true);
|
args[i] = arg;
|
} catch (RuntimeException e) {
|
// i have made sure that the runtime exception is caught everywhere the getArgs method
|
// is used so that a better descriptive exception can be rethrown
|
throw new Exception("couldn't create argument "+i+": "+e.getMessage(), e);
|
}
|
}
|
}
|
return args;
|
}
|
|
/**
|
* Adds a argument descriptor to the list of arguments descriptor to used when invoking the specified method.
|
* @param argDescriptor argument descriptor to add.
|
*/
|
public void addArgDescriptor(ArgDescriptor argDescriptor) {
|
if (argDescriptors==null) {
|
argDescriptors = new ArrayList<ArgDescriptor>();
|
}
|
argDescriptors.add(argDescriptor);
|
}
|
|
/**
|
* Adds an operation to perform during initialization.
|
* @param operation operation to add.
|
*/
|
public void addOperation(Operation operation) {
|
if (operations==null) {
|
operations = new ArrayList<Operation>();
|
}
|
operations.add(operation);
|
}
|
|
/** convenience method to add a type based field injection */
|
public void addTypedInjection(String fieldName, Class<?> type) {
|
addInjection(fieldName, new EnvDescriptor(type));
|
}
|
|
/** add a field injection based on a descriptor */
|
public void addInjection(String fieldName, Descriptor descriptor) {
|
FieldOperation injectionOperation = new FieldOperation();
|
injectionOperation.setFieldName(fieldName);
|
injectionOperation.setDescriptor(descriptor);
|
addOperation(injectionOperation);
|
}
|
|
/** add a property injection based on a descriptor */
|
public void addPropertyInjection(String propertyName,
|
Descriptor valueDescriptor) {
|
PropertyOperation operation = new PropertyOperation();
|
operation.setPropertyName(propertyName);
|
operation.setDescriptor(valueDescriptor);
|
addOperation(operation);
|
}
|
|
|
// getters and setters //////////////////////////////////////////////////////
|
|
public String getClassName() {
|
return className;
|
}
|
public void setClassName(String className) {
|
this.className = className;
|
}
|
public List<ArgDescriptor> getArgDescriptors() {
|
return argDescriptors;
|
}
|
public void setArgDescriptors(List<ArgDescriptor> argDescriptors) {
|
this.argDescriptors = argDescriptors;
|
}
|
public List<Operation> getOperations() {
|
return operations;
|
}
|
public void setOperations(List<Operation> operations) {
|
this.operations = operations;
|
}
|
public Descriptor getFactoryDescriptor() {
|
return factoryDescriptor;
|
}
|
public void setFactoryDescriptor(Descriptor factoryDescriptor) {
|
this.factoryDescriptor = factoryDescriptor;
|
}
|
public String getFactoryObjectName() {
|
return factoryObjectName;
|
}
|
public void setFactoryObjectName(String factoryObjectName) {
|
this.factoryObjectName = factoryObjectName;
|
}
|
public String getMethodName() {
|
return methodName;
|
}
|
public void setMethodName(String methodName) {
|
this.methodName = methodName;
|
}
|
public boolean isAutoWireEnabled() {
|
return isAutoWireEnabled;
|
}
|
public void setAutoWireEnabled(boolean isAutoWireEnabled) {
|
this.isAutoWireEnabled = isAutoWireEnabled;
|
}
|
public String getExpr() {
|
return expr;
|
}
|
public void setExpr(String expr) {
|
this.expr = expr;
|
}
|
public String getLang() {
|
return lang;
|
}
|
public void setLang(String lang) {
|
this.lang = lang;
|
}
|
}
|
