CallMethodRule (Apache Tomcat 7.0.104 API Documentation)

org.apache.tomcat.util.digester

## Class CallMethodRule

- java.lang.Object
- - org.apache.tomcat.util.digester.Rule
  - - org.apache.tomcat.util.digester.CallMethodRule

-     public class CallMethodRule
      extends Rule

  Rule implementation that calls a method on an object on the stack (normally the top/parent object), passing arguments collected from subsequent `CallParamRule` rules or from the body of this element.

  By using `CallMethodRule(String methodName)` a method call can be made to a method which accepts no arguments.

  Incompatible method parameter types are converted using `org.apache.commons.beanutils.ConvertUtils`.

  This rule now uses org.apache.commons.beanutils.MethodUtils#invokeMethod by default. This increases the kinds of methods successfully and allows primitives to be matched by passing in wrapper classes. There are rare cases when org.apache.commons.beanutils.MethodUtils#invokeExactMethod (the old default) is required. This method is much stricter in its reflection. Setting the `UseExactMatch` to true reverts to the use of this method.

  Note that the target method is invoked when the end of the tag the CallMethodRule fired on is encountered, not when the last parameter becomes available. This implies that rules which fire on tags nested within the one associated with the CallMethodRule will fire before the CallMethodRule invokes the target method. This behaviour is not configurable.

  Note also that if a CallMethodRule is expecting exactly one parameter and that parameter is not available (eg CallParamRule is used with an attribute name but the attribute does not exist) then the method will not be invoked. If a CallMethodRule is expecting more than one parameter, then it is always invoked, regardless of whether the parameters were available or not (missing parameters are passed as null values).

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected String` | `bodyText` The body text collected from this element.
    `protected String` | `methodName` The method name to call on the parent object.
    `protected String[]` | `paramClassNames` The names of the classes of the parameters to be collected.
    `protected int` | `paramCount` The number of parameters to collect from `MethodParam` rules.
    `protected Class<?>[]` | `paramTypes` The parameter types of the parameters to be collected.
    `protected int` | `targetOffset` location of the target object for the call, relative to the top of the digester object stack.
    `protected boolean` | `useExactMatch` Should `MethodUtils.invokeExactMethod` be used for reflection.

    - ### Fields inherited from class org.apache.tomcat.util.digester.Rule

      `digester, namespaceURI`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CallMethodRule(int targetOffset, String methodName)` Construct a "call method" rule with the specified method name.
    `CallMethodRule(int targetOffset, String methodName, int paramCount)` Construct a "call method" rule with the specified method name.
    `CallMethodRule(int targetOffset, String methodName, int paramCount, Class<?>[] paramTypes)` Construct a "call method" rule with the specified method name and parameter types.
    `CallMethodRule(int targetOffset, String methodName, int paramCount, String[] paramTypes)` Construct a "call method" rule with the specified method name and parameter types.
    `CallMethodRule(String methodName)` Construct a "call method" rule with the specified method name.
    `CallMethodRule(String methodName, int paramCount)` Construct a "call method" rule with the specified method name.
    `CallMethodRule(String methodName, int paramCount, Class<?>[] paramTypes)` Construct a "call method" rule with the specified method name and parameter types.
    `CallMethodRule(String methodName, int paramCount, String[] paramTypes)` Construct a "call method" rule with the specified method name and parameter types.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `begin(String namespace, String name, Attributes attributes)` Process the start of this element.
    `void` | `body(String namespace, String name, String bodyText)` Process the body text of this element.
    `void` | `end(String namespace, String name)` Process the end of this element.
    `void` | `finish()` Clean up after parsing is complete.
    `boolean` | `getUseExactMatch()` Should `MethodUtils.invokeExactMethod` be used for the reflection.
    `protected void` | `processMethodCallResult(Object result)` Subclasses may override this method to perform additional processing of the invoked method's result.
    `void` | `setDigester(Digester digester)` Set the associated digester.
    `void` | `setUseExactMatch(boolean useExactMatch)` Set whether `MethodUtils.invokeExactMethod` should be used for the reflection.
    `String` | `toString()` Render a printable version of this Rule.

    - ### Methods inherited from class org.apache.tomcat.util.digester.Rule

      `begin, body, end, getDigester, getNamespaceURI, setNamespaceURI`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### bodyText

          protected String bodyText

      The body text collected from this element.

    - #### targetOffset

          protected int targetOffset

      location of the target object for the call, relative to the top of the digester object stack. The default value of zero means the target object is the one on top of the stack.

    - #### methodName

          protected String methodName

      The method name to call on the parent object.

    - #### paramCount

          protected int paramCount

      The number of parameters to collect from `MethodParam` rules. If this value is zero, a single parameter will be collected from the body of this element.

    - #### paramTypes

          protected Class<?>[] paramTypes

      The parameter types of the parameters to be collected.

    - #### paramClassNames

          protected String[] paramClassNames

      The names of the classes of the parameters to be collected. This attribute allows creation of the classes to be postponed until the digester is set.

    - #### useExactMatch

          protected boolean useExactMatch

      Should `MethodUtils.invokeExactMethod` be used for reflection.

  - ### Constructor Detail

    - #### CallMethodRule

          public CallMethodRule(String methodName,
                        int paramCount)

      Construct a "call method" rule with the specified method name. The parameter types (if any) default to java.lang.String.
      Parameters:
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element.

    - #### CallMethodRule

          public CallMethodRule(int targetOffset,
                        String methodName,
                        int paramCount)

      Construct a "call method" rule with the specified method name. The parameter types (if any) default to java.lang.String.
      Parameters:
        `targetOffset` - location of the target object. Positive numbers are relative to the top of the digester object stack. Negative numbers are relative to the bottom of the stack. Zero implies the top object on the stack.
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element.

    - #### CallMethodRule

          public CallMethodRule(String methodName)

      Construct a "call method" rule with the specified method name. The method should accept no parameters.
      Parameters:
        `methodName` - Method name of the parent method to call

    - #### CallMethodRule

          public CallMethodRule(int targetOffset,
                        String methodName)

      Construct a "call method" rule with the specified method name. The method should accept no parameters.
      Parameters:
        `targetOffset` - location of the target object. Positive numbers are relative to the top of the digester object stack. Negative numbers are relative to the bottom of the stack. Zero implies the top object on the stack.
        `methodName` - Method name of the parent method to call

    - #### CallMethodRule

          public CallMethodRule(String methodName,
                        int paramCount,
                        String[] paramTypes)

      Construct a "call method" rule with the specified method name and parameter types. If `paramCount` is set to zero the rule will use the body of this element as the single argument of the method, unless `paramTypes` is null or empty, in this case the rule will call the specified method with no arguments.
      Parameters:
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element
        `paramTypes` - The Java class names of the arguments (if you wish to use a primitive type, specify the corresponding Java wrapper class instead, such as `java.lang.Boolean` for a `boolean` parameter)

    - #### CallMethodRule

          public CallMethodRule(int targetOffset,
                        String methodName,
                        int paramCount,
                        String[] paramTypes)

      Construct a "call method" rule with the specified method name and parameter types. If `paramCount` is set to zero the rule will use the body of this element as the single argument of the method, unless `paramTypes` is null or empty, in this case the rule will call the specified method with no arguments.
      Parameters:
        `targetOffset` - location of the target object. Positive numbers are relative to the top of the digester object stack. Negative numbers are relative to the bottom of the stack. Zero implies the top object on the stack.
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element
        `paramTypes` - The Java class names of the arguments (if you wish to use a primitive type, specify the corresponding Java wrapper class instead, such as `java.lang.Boolean` for a `boolean` parameter)

    - #### CallMethodRule

          public CallMethodRule(String methodName,
                        int paramCount,
                        Class<?>[] paramTypes)

      Construct a "call method" rule with the specified method name and parameter types. If `paramCount` is set to zero the rule will use the body of this element as the single argument of the method, unless `paramTypes` is null or empty, in this case the rule will call the specified method with no arguments.
      Parameters:
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element
        `paramTypes` - The Java classes that represent the parameter types of the method arguments (if you wish to use a primitive type, specify the corresponding Java wrapper class instead, such as `java.lang.Boolean.TYPE` for a `boolean` parameter)

    - #### CallMethodRule

          public CallMethodRule(int targetOffset,
                        String methodName,
                        int paramCount,
                        Class<?>[] paramTypes)

      Construct a "call method" rule with the specified method name and parameter types. If `paramCount` is set to zero the rule will use the body of this element as the single argument of the method, unless `paramTypes` is null or empty, in this case the rule will call the specified method with no arguments.
      Parameters:
        `targetOffset` - location of the target object. Positive numbers are relative to the top of the digester object stack. Negative numbers are relative to the bottom of the stack. Zero implies the top object on the stack.
        `methodName` - Method name of the parent method to call
        `paramCount` - The number of parameters to collect, or zero for a single argument from the body of this element
        `paramTypes` - The Java classes that represent the parameter types of the method arguments (if you wish to use a primitive type, specify the corresponding Java wrapper class instead, such as `java.lang.Boolean.TYPE` for a `boolean` parameter)

  - ### Method Detail

    - #### getUseExactMatch

          public boolean getUseExactMatch()

      Should `MethodUtils.invokeExactMethod` be used for the reflection.

    - #### setUseExactMatch

          public void setUseExactMatch(boolean useExactMatch)

      Set whether `MethodUtils.invokeExactMethod` should be used for the reflection.

    - #### setDigester

          public void setDigester(Digester digester)

      Set the associated digester. If needed, this class loads the parameter classes from their names.
      Overrides:
        `setDigester` in class `Rule`

    - #### begin

          public void begin(String namespace,
                   String name,
                   Attributes attributes)
                     throws Exception

      Process the start of this element.
      Overrides:
        `begin` in class `Rule`
      Parameters:
        `namespace` - the namespace URI of the matching element, or an empty string if the parser is not namespace aware or the element has no namespace
        `name` - the local name if the parser is namespace aware, or just the element name otherwise
        `attributes` - The attribute list for this element
      Throws:
        `Exception`

    - #### body

          public void body(String namespace,
                  String name,
                  String bodyText)
                    throws Exception

      Process the body text of this element.
      Overrides:
        `body` in class `Rule`
      Parameters:
        `namespace` - the namespace URI of the matching element, or an empty string if the parser is not namespace aware or the element has no namespace
        `name` - the local name if the parser is namespace aware, or just the element name otherwise
        `bodyText` - The body text of this element
      Throws:
        `Exception`

    - #### end

          public void end(String namespace,
                 String name)
                   throws Exception

      Process the end of this element.
      Overrides:
        `end` in class `Rule`
      Parameters:
        `namespace` - the namespace URI of the matching element, or an empty string if the parser is not namespace aware or the element has no namespace
        `name` - the local name if the parser is namespace aware, or just the element name otherwise
      Throws:
        `Exception`

    - #### finish

          public void finish()
                      throws Exception

      Clean up after parsing is complete.
      Overrides:
        `finish` in class `Rule`
      Throws:
        `Exception`

    - #### processMethodCallResult

          protected void processMethodCallResult(Object result)

      Subclasses may override this method to perform additional processing of the invoked method's result.
      Parameters:
        `result` - the Object returned by the method invoked, possibly null

    - #### toString

          public String toString()

      Render a printable version of this Rule.
      Overrides:
        `toString` in class `Object`

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.