Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.fujitsu.iflow.model.workflow
Interface JavaAction

public interface JavaAction

The `JavaAction` interface allows the inclusion of Java methods in a process definition that will be executed during process enactment. JavaActions provide mechanisms through which process instances can interact with applications external to Interstage BPM. In other words, JavaActions can be used to move data into process instances from outside Interstage BPM and out of process instances to applications outside the scope of Interstage BPM.

When data is moved into a process instance, it is usually read from one or more external data sources and copied into User Defined Attributes (UDA). Data is moved out of a process instance by copying the values of UDAs to one or more external data sources. Since UDAs can modify the action of certain nodes, JavaActions can do the same.

JavaActions can be added to the process definition at design-time. They can be added at either the process definition level as Init, Process Owner, or Commit Actions or the activity node level as Role, Prologue, Epilogue, or Timer Actions. The point of execution can be determined by the following list:

- Init Actions and Process Owner Actions. These Actions are executed upon process initialization. These JavaActions initialize UDA data before the first activity is activated.
- Commit Actions. The Commit JavaActions are executed upon process completion. They can be used to clean up or analyze the data of the entire process instance.
- Prologue `JavaAction`s. These JavaActions are evaluated upon activity node activation but before the node performs its task. Therefore, they can be used to initialize UDA values associated with the node before the activity's work items are assigned.
- Set of Epilogue JavaActions. Epilogue JavaActions are executed after completion of the activity but before the process instance moves on to another activity. Therefore, they can be used to clean up or analyze values associated with the activity after the intended work is finished.
- Set of Role JavaActions. A Role JavaAction is evaluated during role resolution and before task assignment. It is therefore used to dynamically compute a list of human assignees for a task in conjunction with the role.
- Timer Actions. These JavaActions are executed when a timer expires.

JavaActions call methods on user defined Java classes.

JavaActions gain access to process workflow information using the `ServerEnactmentContext` API. They use this workflow information during the execution of their Java business methods that are outside the scope of the Interstage BPM server.

The most important attributes of a JavaAction are the actionName, className, classPath, methodName, argumentsUDANames and returnValueUDAName. The actionName is the identifier of the JavaAction and should be unique, short and descriptive. The attributes className, classPath, methodName, argumentsUDANames and returnValueUDAName specify the user defined Java method that will be executed. A JavaAction is normally part of a `JavaActionSet` which can be added at design-time to a process definition at the process defintion (`Plan`) or activity node (`Node`) level.

That is why the standard way of constructing a new `JavaAction` object is to call the method `JavaActionSet.createJavaActions` which creates a `JavaAction` object upon which you can create JavaActions.

`String` parameters of all methods in this class have a length limit. This limit is documented in the Javadoc description for each of its parameters. If the length of a value supplied for such a parameter exceeds this limit or the value is `null`, an exception is thrown. This exception is a subclass of `ModelException`. For future compatibility, only `ModelException` should be caught explicitly.

If the signature of a method does not allow the throwing of exceptions, any value supplied to this method that exceeds the length limit is truncated to the maximum length supported. `null` values are ignored in this case. Any method’s behaviour that differs from the behaviour described above is explained in this method’s Javadoc description.

Sample

This sample will give a short overview of the creation of a new `JavaAction` object.

The user defined class is:
`com.fujitsu.iflow.client.MyJavaActionClass`
The class, located in the (standard) Interstage BPM attachment directory:
`c:\ibpm_attachments\`
The method to call:
`public boolean setCustDetails(String name, String city, boolean isMale, int age, float orderAmt)`

Sample implementation of a JavaAction using the parameters defined above:

     JavaActionSet javaActionSet = WFObjectFactory.getJavaActionSet();
     JavaAction[] javaActions = javaActionSet.createJavaActions(1);
     javaActions[0].setActionDescription("Saving the customer fails");
     javaActions[0].setActionName("set Customer Details");
     javaActions[0].setClassName("com.fujitsu.iflow.client.MyJavaActionClass");
     javaActions[0].setClassPath("c:\\ibpm_attachments\\");
     javaActions[0].setMethodName("setCustDetails(String,String,boolean,int,float)");
     javaActions[0].setArgumentsUDANames("<E>uda.Name</E><E>uda.City</E><E>uda.IsMale</E><E>uda.Age</E><E>uda.Price*uda.Qty</E>");
     javaActions[0].setReturnValueUDAName("Succeeds");
     javaActionSet.setActionSetName("CustomerDetails");
     javaActionSet.setJavaActions(javaActions);

See Also:
  `JavaActionSet`, `ServerEnactmentContext`

Field Summary
`static int` | `MAX_ACTION_DESCRIPTION_LENGTH` Specifies the maximum length of action description; currently 256 characters
`static int` | `MAX_ACTION_NAME_LENGTH` Specifies the maximum length of action name; currently 30 characters

Method Summary
`boolean` | `getAbortSequenceOnError()` Indicates if the sequence of the JavaAction will be aborted in case of an error.
`java.lang.String` | `getActionDescription()` Returns the description of this JavaAction.
`java.lang.String` | `getActionName()` Returns the name of this JavaAction.
`java.lang.String` | `getActionTechDescription()` Returns the detailed technical description of this JavaAction.
`java.lang.String` | `getArgumentsUDANames()` Returns the list of method arguments that are formatted as JavaScript and nested within `<E>` XML tags.
`java.lang.String` | `getBeanMethodArgumentsUDANames()` Returns the list of method arguments that are formatted like described in the `setBeanMethodArgumentsUDANames` method.
`java.lang.String` | `getBeanMethodName()` Returns the name of the method, contained in the EJB, called from this `JavaAction`.
`java.lang.String` | `getBeanName()` Returns a short descriptive name of the input EJB that supplies the method to be called by this JavaAction.
`java.lang.String` | `getClassName()` Returns the name of Java class that contains the method for invocation.
`java.lang.String` | `getClassPath()` Returns the location (fully qualified path) to the Java class that contains the method for invocation.
`java.lang.String` | `getEditorClassName()` Returns the class name of the JavaAction Editor (GUI) used to supply data for this `JavaAction` (if used).
`java.lang.String` | `getFactoryClassName()` Returns the `JavaActionSet` location of the JavaAction that was set up by the `setFactoryClassName` method.
`java.lang.String` | `getMethodName()` Returns the name of the Java method that is invoked when this JavaAction is executed (with parameter types).
`java.lang.String` | `getReturnValueUDAName()` Returns the name of User Defined Attribute (UDA) that will receive the result of the called Java method if there is any.
`void` | `setAbortSequenceOnError(boolean value)` Specifies if the sequence of the JavaAction will be aborted in the case of an error.
`void` | `setActionDescription(java.lang.String description)` Sets the description of this JavaAction.
`void` | `setActionName(java.lang.String name)` Sets the name of this JavaAction.
`void` | `setActionTechDescription(java.lang.String techDescription)` Sets the technical description of this JavaAction.
`void` | `setArgumentsUDANames(java.lang.String inputUDAList)` Defines the arguments that will be passes to the JavaAction Java method during process enactment.
`void` | `setBeanMethodArgumentsUDANames(java.lang.String udaNames)` Defines the arguments that will be passes to the JavaAction Java EJB method during process enactment.
`void` | `setBeanMethodName(java.lang.String methodName)` Sets the name of the method (contained in EJB) called from the this `JavaAction`.
`void` | `setBeanName(java.lang.String beanName)` Sets the JNDI name of the input EJB that supplies the method to be called by this JavaAction.
`void` | `setClassName(java.lang.String className)` Sets the name of the Java class.
`void` | `setClassPath(java.lang.String classPath)` Sets the classpath of this JavaAction.
`void` | `setEditorClassName(java.lang.String editorClassName)` Sets the class name of the JavaAction Editor (GUI) used to supply data for this `JavaAction`.
`void` | `setFactoryClassName(java.lang.String factoryClassName)` Sets the `FactoryClassName`.
`void` | `setMethodName(java.lang.String methodName)` Sets the name of Java method for this JavaAction.
`void` | `setReturnValueUDAName(java.lang.String returnUDA)` Sets the name of the User Defined Attribute (UDA) that will hold the return value.

Field Detail

### MAX_ACTION_NAME_LENGTH

    public static final int MAX_ACTION_NAME_LENGTH

  Specifies the maximum length of action name; currently 30 characters

  See Also:
    Constant Field Values

### MAX_ACTION_DESCRIPTION_LENGTH

    public static final int MAX_ACTION_DESCRIPTION_LENGTH

  Specifies the maximum length of action description; currently 256 characters

  See Also:
    Constant Field Values

Method Detail

### getActionName

    public java.lang.String getActionName()

  Returns the name of this JavaAction. The name of a JavaAction is its identifier.

  Returns an empty `String` if no action name is defined.

  Returns:
    The name of this JavaAction.
  See Also:
    `setActionName(String)`

### getActionDescription

    public java.lang.String getActionDescription()

  Returns the description of this JavaAction.

  Returns an empty `String` if no description is defined.

  Returns:
    The description of this JavaAction.
  See Also:
    `setActionDescription(String)`

### getActionTechDescription

    public java.lang.String getActionTechDescription()

  Returns the detailed technical description of this JavaAction.

  Returns an empty `String` if no technical description is defined.

  Returns:
    A technical description of this JavaAction.
  See Also:
    `setActionTechDescription(String)`

### getMethodName

    public java.lang.String getMethodName()

  Returns the name of the Java method that is invoked when this JavaAction is executed (with parameter types). The method name consists of the name of the JavaAction invoked and the data types of the parameters used in that method.

  ### Example for the returned value:

      setCustDetails(String,String,boolean,int,float)

  Returns:
    Name of method which will be invoked. Returns an empty `String` if no method name is defined.
  See Also:
    `setMethodName(String)`

### getClassName

    public java.lang.String getClassName()

  Returns the name of Java class that contains the method for invocation.

  Returns an empty `String` if no class name is defined.

  Returns:
    The fully qualified name of Java class.
  See Also:
    `setClassName(String)`

### getClassPath

    public java.lang.String getClassPath()

  Returns the location (fully qualified path) to the Java class that contains the method for invocation.

  Returns an empty `String` if no classpath is defined.

  Returns:
    The fully qualified path where the Java class is located.
  See Also:
    `setClassPath(String)`

### getFactoryClassName

    public java.lang.String getFactoryClassName()

  Returns the `JavaActionSet` location of the JavaAction that was set up by the `setFactoryClassName` method.

  However, it is not necessary to use this method or the `setFactoryClassName` method. They are reserved for future usage.

  Returns:
    The fully qualified name of factory class.
  See Also:
    `setFactoryClassName(String)`

### getArgumentsUDANames

    public java.lang.String getArgumentsUDANames()

  Returns the list of method arguments that are formatted as JavaScript and nested within `<E>` XML tags.

  Example (from the interface description):
  `"<E>uda.Name</E><E>uda.City</E><E>uda.IsMale</E><E>uda.Age</E><E>uda.Price*uda.Qty</E>`

  Returns an empty `String` if no argument UDA names are defined.

  Returns:
    List of parameters which are used as method arguments.
  See Also:
    `setArgumentsUDANames(String)`

### getReturnValueUDAName

    public java.lang.String getReturnValueUDAName()

  Returns the name of User Defined Attribute (UDA) that will receive the result of the called Java method if there is any.

  Returns an empty `String` if no return value UDA name is defined.

  Returns:
    The name of the UDA variable that will hold the return value of the Java method.
  See Also:
    `setReturnValueUDAName(String)`

### getAbortSequenceOnError

    public boolean getAbortSequenceOnError()

  Indicates if the sequence of the JavaAction will be aborted in case of an error.

  Returns:
    `true` if sequence will be aborted; `false` otherwise.
  See Also:
    `setAbortSequenceOnError(boolean)`

### getBeanName

    public java.lang.String getBeanName()

  Returns a short descriptive name of the input EJB that supplies the method to be called by this JavaAction.

  Returns:
    A short descriptive name of the EJB JavaAction.

### getBeanMethodName

    public java.lang.String getBeanMethodName()

  Returns the name of the method, contained in the EJB, called from this `JavaAction`.

  Returns:
    The name of bean method that will be invoked.
  See Also:
    `setBeanMethodName(String)`

### getBeanMethodArgumentsUDANames

    public java.lang.String getBeanMethodArgumentsUDANames()

  Returns the list of method arguments that are formatted like described in the `setBeanMethodArgumentsUDANames` method.

  Returns:
    List of parameters that are used as arguments for the method of the Bean JavaAction.
  See Also:
    `setBeanMethodArgumentsUDANames(String)`

### getEditorClassName

    public java.lang.String getEditorClassName()

  Returns the class name of the JavaAction Editor (GUI) used to supply data for this `JavaAction` (if used).

  Returns:
    The class name of JavaAction Editor.

### setActionName

    public void setActionName(java.lang.String name)

  Sets the name of this JavaAction. The name of a JavaAction is the identifier and should be short and descriptive.

  The name is limited to the number of characters specified by `MAX_ACTION_NAME_LENGTH`. If the length exceeds that number of characters, the identifier is truncated to the maximum length. If the supplied value is null, the name will not be changed.

  Parameters:
    `name` - The new name of this JavaAction.

### setActionDescription

    public void setActionDescription(java.lang.String description)

  Sets the description of this JavaAction. The description is a field to store a long string that contains further information about the purpose of this JavaAction.

  The description is limited to the number of characters specified by `MAX_ACTION_DESCRIPTION_LENGTH`. If the length exceeds that number of characters, the identifier is truncated to the maximum length. If the supplied value is `null`, the description will not be changed.

  Parameters:
    `description` - The new description of this JavaAction.

### setActionTechDescription

    public void setActionTechDescription(java.lang.String techDescription)

  Sets the technical description of this JavaAction. The technical description is a field to store a long `String` that contains further technical information about the usage of this JavaAction. For example, this description details the information on the objective/function/behaviour of the associated method.

  The description is limited to the number of characters specified by `MAX_ACTION_DESCRIPTION_LENGTH`. If the length exceeds that number of characters, the identifier is truncated to the maximum length. If the supplied value is `null`, the description will not be changed.

  Parameters:
    `techDescription` - The new technical description of this JavaAction.

### setMethodName

    public void setMethodName(java.lang.String methodName)

  Sets the name of Java method for this JavaAction. The specified method will be invoked when this JavaAction is performed during process enactment.

  The name of method must include the types of parameters.

  - Method with arguments
    The types of target method arguments must be part of the `methodName` value. For example, for the method:

        public void myMethodWithArguments(ServerEnactmentContext, long l, int i, String s) {...}

    the argument must be:

        myMethodWithArguments(ServerEnactmentContext,long,int,String)

  - Method without arguments
    In this case the `methodName` value only consists of the name of target method and of open and close brackets. For example, for the method:

        public void myMethodWithoutArguments() {...}

    the argument must be:

        myMethodWithoutArguments()

  Parameters:
    `methodName` - Name of method which will be invoked.
  See Also:
    `ServerEnactmentContext`

### setClassName

    public void setClassName(java.lang.String className)

  Sets the name of the Java class. The name must be a fully qualified Java class name. For example: `com.fujitsu.iflow.client.MyJavaActionClass`. This Java class will be used to create a Java object, of this type, which will be used to invoke the specified method.

  Parameters:
    `className` - The fully qualified name of the Java class.

### setFactoryClassName

    public void setFactoryClassName(java.lang.String factoryClassName)

  Sets the `FactoryClassName`.

  However, it is unnecessary to use this method. It is reserved for future usage.

  Parameters:
    `factoryClassName` - The fully qualified name of Java class.
  See Also:
    `setClassName(String)`

### setClassPath

    public void setClassPath(java.lang.String classPath)

  Sets the classpath of this JavaAction. The classpath will help Interstage BPM to find and load Java classes that are not in the Interstage BPM Server/Application Server environment's classpath. The given class will be loaded only from the JavaAction's classpath value. If the value is not specified then the class will be loaded from Interstage BPM's classpath. If Interstage BPM can not find a class specified by the method `setClassName`, an error will result, and the JavaAction will not work.

  Parameters:
    `classPath` - The fully qualified path where the specified JavaAction class is located.
  See Also:
    `setClassName(String)`

### setArgumentsUDANames

    public void setArgumentsUDANames(java.lang.String inputUDAList)

  Defines the arguments that will be passes to the JavaAction Java method during process enactment.

  If the Java method has n parameters, the one `String` argument will define all n parameter values one at a time in the same order as the method parameters.

  Each parameter value is a JavaScript expression, nested within XML tags. Each value definition starts with an <E> tag, and ends with </E> tag. The JS expression contained by these tags must, of course, be properly encoded according to XML rules for text.

  To encode String value to a JS literal use method
  `JSConversions.quote4JS(String)`.
  This method expects the String value to encode and returns the proper JS literal.

  Once you have the set of JS expressions, you must combine these together into a single XML document using XML encoding rules like changing any occurrences of "<" to "&lt;" etc. That encoding can be done by using method
  `Utils.combineParametersToXML(String[])`

  The JS expression may use the variables and functions that are normally available in the server enactment context. See documentation on JS in the `ServerEnactmentContext` for details.

  It is possible to use two different kinds of arguments: Fix parameters, and User Defined Attributes (UDA).

  - Fix parameters

    The most common JS expression is the `String` literal expression. If you want to pass a constant `String` value to the Java method, then that `String` value needs to have double quotes around it, and special characters within the `String` need to be escaped with a backslash using the normal Java/JS `String` literal rules. If you want to pass the 'name' of a UDA variable to the java method, so it can use the name to retrieve the value, then this name is again a constant `String` value, and you would put the name in quotes.

  - UDA parameter

    If you want to pass the value of a UDA variable 'foo' to the method, then you can put in an expression like 'uda.foo' which accesses the UDA object in the JS environment, and the result of this expression is the value of the UDA variable.

  If a special type is needed to be passed, you can include a type conversion expression like: 'new Packages.MyObj(uda.foo)'. That expression would construct a new instance of the MyObj class, passing the value of the 'foo' UDA variable to the constructor. All the other normal JS conversions are available.

  Example

  Definition of parameters for following method:

      setCustDetails(String name, String city, boolean isMale, int age, float orderAmt)

  1. Fix parameters:
     Following values shall be passes as arguments: `name`="Bill", `city`="New York", `isMale`="true", `age`="30", `orderAmt`="15.0".
     In this case the `inputUdaList` must have following format:

         <E>"Bill"</E><E>"NewYork"</E><E>true</E><E>30</E><E>15.0</E>

     Note, that only the `String` values are enclosed by double quotes. If you use fix `String` values, remember that the quotes and backslash must be escaped with a backslash, and newline characters must be replaced with a backslash followed by a lower case n.
  2. UDA values:
     Next to define fix values for arguments you can also use the values of UDA's. In this case, the run-time values of defined UDAs will be passed to the method arguments.
     If the process definition contains the UDAs "Name", "City", "IsMail", "Age", "Price" and "Qty" the `inputUdaList` could have following format:

         <E>uda.Name</E><E>uda.City</E><E>uda.IsMale</E><E>uda.Age</E><E>uda.Price*uda.Qty</E>

     In this example the UDA `Name` is passed to the first parameter of method (name), `City` is passed to the second parameter (city), the value of the `IsMail` UDA is passed to the third (isMail), the UDA `Age` is passed to the fourth (age) and the product of UDAs `Price` and `Qty` are passed to the sixth one (orderAmt).
  3. Combination of fix and UDA values:
     Take UDAs for the arguments name, isMale and orderAmt and fix values for city and age:

         <E>uda.Name</E><E>"New York"</E><E>uda.IsMale</E><E>30</E><E>uda.Price*uda.Qty</E>

  Note: When there is more than one parameter to the method, the entire `String` is not valid XML because it does not have a single root node. Instead it is a sequence of n XML values packed into a single `String`. One trick that can be used to easily parse this is to add an open tag before it, and a matching close tag after the `String`, and then parse with a standard XML parser. Similarly, you can make a single DOM tree, convert to `String`, and then strip the tags from the root node off each end in order to generate this value.

  Parameters:
    `inputUDAList` - A list of method arguments formatted as JavaScript expression, which are nested within XML tags.

### setReturnValueUDAName

    public void setReturnValueUDAName(java.lang.String returnUDA)

  Sets the name of the User Defined Attribute (UDA) that will hold the return value. The UDA specified should be of appropriate type to hold the return value of the called Java method. No verification of this types will be done when this method is called. Incompatibility between the return value of the method and the UDA type would result in the failure of JavaAction at process enactment time. If the Java method returns void then this UDA should not be specified.

  The name is limited to the number of characters specified by `DataItemRef.MAX_DATA_REF_NAME_LENGTH`. If the length exceeds that number of characters, the identifier is truncated to the maximum length. If the supplied value is `null`, the name will not be changed.

  Parameters:
    `returnUDA` - The name of UDA varibale that will receive the result of the called Java method if there is any.

### setAbortSequenceOnError

    public void setAbortSequenceOnError(boolean value)

  Specifies if the sequence of the JavaAction will be aborted in the case of an error.

  Parameters:
    `value` - `true` defines that the execution will be aborted. false will not abort sequence on error.

### setBeanName

    public void setBeanName(java.lang.String beanName)

  Sets the JNDI name of the input EJB that supplies the method to be called by this JavaAction. The `beanName` is a short and descriptive name for the associated method.

  Parameters:
    `beanName` - The name of the EJB Java action.

### setBeanMethodName

    public void setBeanMethodName(java.lang.String methodName)

  Sets the name of the method (contained in EJB) called from the this `JavaAction`. This method will be performed during process enactment.

  Parameters:
    `methodName` - Name of method which will be invoked.

### setBeanMethodArgumentsUDANames

    public void setBeanMethodArgumentsUDANames(java.lang.String udaNames)

  Defines the arguments that will be passes to the JavaAction Java EJB method during process enactment. This is similar to setArgumentsUDANames, but it is used in the context of EJBs (EnterpriseJavaBeans).

  If the Java method has n parameters, the one `String` argument will define all n parameter values one at a time in the same order as the method parameters.

  Each parameter value is a JavaScript expression, nested within XML tags. Each value definition starts with an <E> tag, and ends with </E> tag. The JS expression contained by these tags must, of course, be properly encoded according to XML rules for text.

  The JS expression may use the variables and functions that are normally available in the server enactment context. See documentation on JS in the `ServerEnactmentContext` for details.

  It is possible to use two different kinds of arguments: Fix parameters, and User Defined Attributes (UDA).

  - Fix parameters

    The most common JS expression is the `String` literal expression. If you want to pass a constant `String` value to the Java method, then that `String` value needs to have double quotes around it, and special characters within the `String` need to be escaped with a backslash using the normal Java/JS `String` literal rules. If you want to pass the 'name' of a UDA variable to the java method, so it can use the name to retrieve the value, then this name is again a constant `String` value, and you would put the name in quotes.

  - UDA parameter

    If you want to pass the value of a UDA variable 'foo' to the method, then you can put in an expression like 'uda.foo' which accesses the UDA object in the JS environment, and the result of this expression is the value of the UDA variable.

  If a special type is needed to be passed, you can include a type conversion expression like: 'new Packages.MyObj(uda.foo)'. That expression would construct a new instance of the MyObj class, passing the value of the 'foo' UDA variable to the constructor. All the other normal JS conversions are available.

  Example

  Definition of parameters for following method:

      setCustDetails(String name, String city, boolean isMale, int age, float orderAmt)

  1. Fix parameters:
     Following values shall be passes as arguments: `name`="Bill", `city`="New York", `isMale`="true", `age`="30", `orderAmt`="15.0".
     In this case the `inputUdaList` must have following format:

         <E>"Bill"</E><E>"NewYork"</E><E>true</E><E>30</E><E>15.0</E>

     Note, that only the `String` values are enclosed by double quotes. If you use fix `String` values, remember that the quotes and backslash must be escaped with a backslash, and newline characters must be replaced with a backslash followed by a lower case n.
  2. UDA values:
     Next to define fix values for arguments you can also use the values of UDA's. In this case, the run-time values of defined UDAs will be passed to the method arguments.
     If the process definition contains the UDAs "Name", "City", "IsMail", "Age", "Price" and "Qty" the `inputUdaList` could have following format:

         <E>uda.Name</E><E>uda.City</E><E>uda.IsMale</E><E>uda.Age</E><E>uda.Price*uda.Qty</E>

     In this example the UDA `Name` is passed to the first parameter of method (name), `City` is passed to the second parameter (city), the value of the `IsMail` UDA is passed to the third (isMail), the UDA `Age` is passed to the fourth (age) and the product of UDAs `Price` and `Qty` are passed to the sixth one (orderAmt).
  3. Combination of fix and UDA values:
     Take UDAs for the arguments name, isMale and orderAmt and fix values for city and age:

         <E>uda.Name</E><E>"New York"</E><E>uda.IsMale</E><E>30</E><E>uda.Price*uda.Qty</E>

  Note: When there is more than one parameter to the method, the entire `String` is not valid XML because it does not have a single root node. Instead it is a sequence of n XML values packed into a single `String`. One trick that can be used to easily parse this is to add an open tag before it, and a matching close tag after the `String`, and then parse with a standard XML parser. Similarly, you can make a single DOM tree, convert to `String`, and then strip the tags from the root node off each end in order to generate this value.

  Parameters:
    `udaNames` - A list of method arguments formatted as JavaScript expression, which are nested within XML tags.

### setEditorClassName

    public void setEditorClassName(java.lang.String editorClassName)

  Sets the class name of the JavaAction Editor (GUI) used to supply data for this `JavaAction`.

  Parameters:
    `editorClassName` - Fully qualified JNDI name of the editor class used.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD