## 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

Constructor Summary
`StandardEvaluationContext()`
`StandardEvaluationContext(Object rootObject)`

Method Summary
`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)

  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 deregister a filter for the type