org.springframework.expression.spel.support

## Class StandardEvaluationContext

- java.lang.Object
- - org.springframework.expression.spel.support.StandardEvaluationContext

- All Implemented Interfaces:
    EvaluationContext

      public class StandardEvaluationContext
      extends Object
      implements EvaluationContext

  Provides a default EvaluationContext implementation.

  To resolve properties/methods/fields this context uses a reflection mechanism.

  Since:
    3.0
  Author:
    Andy Clement, Juergen Hoeller, Sam Brannen

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `StandardEvaluationContext()`
    `StandardEvaluationContext(Object rootObject)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addConstructorResolver(ConstructorResolver resolver)`
    `void` | `addMethodResolver(MethodResolver resolver)`
    `void` | `addPropertyAccessor(PropertyAccessor accessor)`
    `BeanResolver` | `getBeanResolver()`
    `List<ConstructorResolver>` | `getConstructorResolvers()`
    `List<MethodResolver>` | `getMethodResolvers()`
    `OperatorOverloader` | `getOperatorOverloader()`
    `List<PropertyAccessor>` | `getPropertyAccessors()`
    `TypedValue` | `getRootObject()`
    `TypeComparator` | `getTypeComparator()`
    `TypeConverter` | `getTypeConverter()`
    `TypeLocator` | `getTypeLocator()`
    `Object` | `lookupVariable(String name)` Look up a named variable within this evaluation context.
    `void` | `registerFunction(String name, Method method)`
    `void` | `registerMethodFilter(Class<?> type, MethodFilter filter)` Register a `MethodFilter` which will be called during method resolution for the specified type.
    `boolean` | `removeConstructorResolver(ConstructorResolver resolver)`
    `boolean` | `removeMethodResolver(MethodResolver methodResolver)`
    `boolean` | `removePropertyAccessor(PropertyAccessor accessor)`
    `void` | `setBeanResolver(BeanResolver beanResolver)`
    `void` | `setConstructorResolvers(List<ConstructorResolver> constructorResolvers)`
    `void` | `setMethodResolvers(List<MethodResolver> methodResolvers)`
    `void` | `setOperatorOverloader(OperatorOverloader operatorOverloader)`
    `void` | `setPropertyAccessors(List<PropertyAccessor> propertyAccessors)`
    `void` | `setRootObject(Object rootObject)`
    `void` | `setRootObject(Object rootObject, TypeDescriptor typeDescriptor)`
    `void` | `setTypeComparator(TypeComparator typeComparator)`
    `void` | `setTypeConverter(TypeConverter typeConverter)`
    `void` | `setTypeLocator(TypeLocator typeLocator)`
    `void` | `setVariable(String name, Object value)` Set a named variable within this evaluation context to a specified value.
    `void` | `setVariables(Map<String,Object> variables)`

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

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

- - ### Constructor Detail

    - #### StandardEvaluationContext

          public StandardEvaluationContext()

    - #### StandardEvaluationContext

          public StandardEvaluationContext(Object rootObject)

  - ### Method Detail

    - #### setRootObject

          public void setRootObject(Object rootObject,
                           TypeDescriptor typeDescriptor)

    - #### setRootObject

          public void setRootObject(Object rootObject)

    - #### getRootObject

          public TypedValue getRootObject()

      Specified by:
        `getRootObject` in interface `EvaluationContext`
      Returns:
        the default root context object against which unqualified properties/methods/etc should be resolved. This can be overridden when evaluating an expression.

    - #### addConstructorResolver

          public void addConstructorResolver(ConstructorResolver resolver)

    - #### removeConstructorResolver

          public boolean removeConstructorResolver(ConstructorResolver resolver)

    - #### getConstructorResolvers

          public List<ConstructorResolver> getConstructorResolvers()

      Specified by:
        `getConstructorResolvers` in interface `EvaluationContext`
      Returns:
        a list of resolvers that will be asked in turn to locate a constructor

    - #### setConstructorResolvers

          public void setConstructorResolvers(List<ConstructorResolver> constructorResolvers)

    - #### addMethodResolver

          public void addMethodResolver(MethodResolver resolver)

    - #### removeMethodResolver

          public boolean removeMethodResolver(MethodResolver methodResolver)

    - #### getMethodResolvers

          public List<MethodResolver> getMethodResolvers()

      Specified by:
        `getMethodResolvers` in interface `EvaluationContext`
      Returns:
        a list of resolvers that will be asked in turn to locate a method

    - #### setBeanResolver

          public void setBeanResolver(BeanResolver beanResolver)

    - #### getBeanResolver

          public BeanResolver getBeanResolver()

      Specified by:
        `getBeanResolver` in interface `EvaluationContext`
      Returns:
        a bean resolver that can look up beans by name

    - #### setMethodResolvers

          public void setMethodResolvers(List<MethodResolver> methodResolvers)

    - #### addPropertyAccessor

          public void addPropertyAccessor(PropertyAccessor accessor)

    - #### removePropertyAccessor

          public boolean removePropertyAccessor(PropertyAccessor accessor)

    - #### getPropertyAccessors

          public List<PropertyAccessor> getPropertyAccessors()

      Specified by:
        `getPropertyAccessors` in interface `EvaluationContext`
      Returns:
        a list of accessors that will be asked in turn to read/write a property

    - #### setPropertyAccessors

          public void setPropertyAccessors(List<PropertyAccessor> propertyAccessors)

    - #### setTypeLocator

          public void setTypeLocator(TypeLocator typeLocator)

    - #### getTypeLocator

          public TypeLocator getTypeLocator()

      Specified by:
        `getTypeLocator` in interface `EvaluationContext`
      Returns:
        a type locator that can be used to find types, either by short or fully qualified name.

    - #### setTypeConverter

          public void setTypeConverter(TypeConverter typeConverter)

    - #### getTypeConverter

          public TypeConverter getTypeConverter()

      Specified by:
        `getTypeConverter` in interface `EvaluationContext`
      Returns:
        a type converter that can convert (or coerce) a value from one type to another.

    - #### setTypeComparator

          public void setTypeComparator(TypeComparator typeComparator)

    - #### getTypeComparator

          public TypeComparator getTypeComparator()

      Specified by:
        `getTypeComparator` in interface `EvaluationContext`
      Returns:
        a type comparator for comparing pairs of objects for equality.

    - #### setOperatorOverloader

          public void setOperatorOverloader(OperatorOverloader operatorOverloader)

    - #### getOperatorOverloader

          public OperatorOverloader getOperatorOverloader()

      Specified by:
        `getOperatorOverloader` in interface `EvaluationContext`
      Returns:
        an operator overloader that may support mathematical operations between more than the standard set of types

    - #### setVariable

          public void setVariable(String name,
                         Object value)

      Description copied from interface: `EvaluationContext`
      Set a named variable within this evaluation context to a specified value.
      Specified by:
        `setVariable` in interface `EvaluationContext`
      Parameters:
        `name` - variable to set
        `value` - value to be placed in the variable

    - #### setVariables

          public void setVariables(Map<String,Object> variables)

    - #### registerFunction

          public void registerFunction(String name,
                              Method method)

    - #### lookupVariable

          public Object lookupVariable(String name)

      Description copied from interface: `EvaluationContext`
      Look up a named variable within this evaluation context.
      Specified by:
        `lookupVariable` in interface `EvaluationContext`
      Parameters:
        `name` - variable to lookup
      Returns:
        the value of the variable

    - #### registerMethodFilter

          public void registerMethodFilter(Class<?> type,
                                  MethodFilter filter)
                                    throws IllegalStateException

      Register a `MethodFilter` which will be called during method resolution for the specified type.

      The `MethodFilter` may remove methods and/or sort the methods which will then be used by SpEL as the candidates to look through for a match.

      Parameters:
        `type` - the type for which the filter should be called
        `filter` - a `MethodFilter`, or `null` to unregister a filter for the type
      Throws:
        `IllegalStateException` - if the `ReflectiveMethodResolver` is not in use