## org.springframework.expression.spel.support
Class ReflectivePropertyAccessor

    java.lang.Object
      org.springframework.expression.spel.support.ReflectivePropertyAccessor

All Implemented Interfaces:
  PropertyAccessor

    public class ReflectivePropertyAccessor

extends Object
implements PropertyAccessor

Simple PropertyAccessor that uses reflection to access properties for reading and writing. A property can be accessed if it is accessible as a field on the object or through a getter (if being read) or a setter (if being written).

Since:
  3.0
Author:
  Andy Clement, Juergen Hoeller

Field Summary
`protected Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,org.springframework.expression.spel.support.ReflectivePropertyAccessor.InvokerPair>` `readerCache`
`protected Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,TypeDescriptor>` `typeDescriptorCache`
`protected Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,Member>` `writerCache`

Constructor Summary
`ReflectivePropertyAccessor()`

Method Summary
`boolean` `canRead(EvaluationContext context, Object target, String name)` Called to determine if a resolver instance is able to access a specified property on a specified target object.
`boolean` `canWrite(EvaluationContext context, Object target, String name)` Called to determine if a resolver instance is able to write to a specified property on a specified target object.
`PropertyAccessor` `createOptimalAccessor(EvaluationContext eContext, Object target, String name)` Attempt to create an optimized property accessor tailored for a property of a particular name on a particular class.
`protected Field` `findField(String name, Class<?> clazz, boolean mustBeStatic)` Find a field of a certain name on a specified class
`protected Method` `findGetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)` Find a getter method for the specified property.
`protected Method` `findSetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)` Find a setter method for the specified property.
`Class<?>[]` `getSpecificTargetClasses()` Return an array of classes for which this resolver should be called.
`TypedValue` `read(EvaluationContext context, Object target, String name)` Called to read a property from a specified target object
`void` `write(EvaluationContext context, Object target, String name, Object newValue)` Called to write to a property on a specified target object.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### readerCache

    protected final Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,org.springframework.expression.spel.support.ReflectivePropertyAccessor.InvokerPair> readerCache

### writerCache

    protected final Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,Member> writerCache

### typeDescriptorCache

    protected final Map<org.springframework.expression.spel.support.ReflectivePropertyAccessor.CacheKey,TypeDescriptor> typeDescriptorCache

Constructor Detail

### ReflectivePropertyAccessor

    public ReflectivePropertyAccessor()

Method Detail

### getSpecificTargetClasses

    public Class<?>[] getSpecificTargetClasses()

  Description copied from interface: `PropertyAccessor`
  Return an array of classes for which this resolver should be called. Returning null indicates this is a general resolver that can be called in an attempt to resolve a property on any type.

  Specified by:
    `getSpecificTargetClasses` in interface `PropertyAccessor`
  Returns:
    null which means this is a general purpose accessor

### canRead

    public boolean canRead(EvaluationContext context,
                           Object target,
                           String name)
                    throws AccessException

  Description copied from interface: `PropertyAccessor`
  Called to determine if a resolver instance is able to access a specified property on a specified target object.

  Specified by:
    `canRead` in interface `PropertyAccessor`
  Parameters:
    `context` - the evaluation context in which the access is being attempted
    `target` - the target object upon which the property is being accessed
    `name` - the name of the property being accessed
  Returns:
    true if this resolver is able to read the property
  Throws:
    `AccessException` - if there is any problem determining whether the property can be read

### read

    public TypedValue read(EvaluationContext context,
                           Object target,
                           String name)
                    throws AccessException

  Description copied from interface: `PropertyAccessor`
  Called to read a property from a specified target object

  Specified by:
    `read` in interface `PropertyAccessor`
  Parameters:
    `context` - the evaluation context in which the access is being attempted
    `target` - the target object upon which the property is being accessed
    `name` - the name of the property being accessed
  Returns:
    a TypedValue object wrapping the property value read and a type descriptor for it
  Throws:
    `AccessException` - if there is any problem accessing the property value

### canWrite

    public boolean canWrite(EvaluationContext context,
                            Object target,
                            String name)
                     throws AccessException

  Description copied from interface: `PropertyAccessor`
  Called to determine if a resolver instance is able to write to a specified property on a specified target object.

  Specified by:
    `canWrite` in interface `PropertyAccessor`
  Parameters:
    `context` - the evaluation context in which the access is being attempted
    `target` - the target object upon which the property is being accessed
    `name` - the name of the property being accessed
  Returns:
    true if this resolver is able to write to the property
  Throws:
    `AccessException` - if there is any problem determining whether the property can be written to

### write

    public void write(EvaluationContext context,
                      Object target,
                      String name,
                      Object newValue)
               throws AccessException

  Description copied from interface: `PropertyAccessor`
  Called to write to a property on a specified target object. Should only succeed if canWrite() also returns true.

  Specified by:
    `write` in interface `PropertyAccessor`
  Parameters:
    `context` - the evaluation context in which the access is being attempted
    `target` - the target object upon which the property is being accessed
    `name` - the name of the property being accessed
    `newValue` - the new value for the property
  Throws:
    `AccessException` - if there is any problem writing to the property value

### findGetterForProperty

    protected Method findGetterForProperty(String propertyName,
                                           Class<?> clazz,
                                           boolean mustBeStatic)

  Find a getter method for the specified property. A getter is defined as a method whose name start with the prefix 'get' and the rest of the name is the same as the property name (with the first character uppercased).

### findSetterForProperty

    protected Method findSetterForProperty(String propertyName,
                                           Class<?> clazz,
                                           boolean mustBeStatic)

  Find a setter method for the specified property.

### findField

    protected Field findField(String name,
                              Class<?> clazz,
                              boolean mustBeStatic)

  Find a field of a certain name on a specified class

### createOptimalAccessor

    public PropertyAccessor createOptimalAccessor(EvaluationContext eContext,
                                                  Object target,
                                                  String name)

  Attempt to create an optimized property accessor tailored for a property of a particular name on a particular class. The general ReflectivePropertyAccessor will always work but is not optimal due to the need to lookup which reflective member (method/field) to use each time read() is called. This method will just return the ReflectivePropertyAccessor instance if it is unable to build something more optimal.