public abstract class ExpressionFactory extends Object
ValueExpression
or MethodExpression
instance for later evaluation. Classes that implement the EL expression language expose their functionality via this
abstract class. There is no concrete implementation of this API available in this package. Technologies such as JavaServer Pages and JavaServer Faces provide access to an implementation via factory
methods. The createValueExpression(ELContext, String, Class)
method is used to parse expressions that evaluate to values (both l-values and r-values are supported). The
createMethodExpression(ELContext, String, Class, Class[])
method is used to parse expressions that evaluate to a reference to a method on an object. Unlike previous incarnations of this
API, there is no way to parse and evaluate an expression in one single step. The expression needs to first be parsed, and then evaluated. Resolution of model objects is performed at evaluation
time, via the ELResolver
associated with the ELContext
passed to the ValueExpression or MethodExpression. The ELContext object also provides access to the FunctionMapper
and
VariableMapper
to be used when parsing the expression. EL function and variable mapping is performed at parse-time, and the results are bound to the expression. Therefore, the
ELContext
, FunctionMapper
, and VariableMapper
are not stored for future use and do not have to be Serializable. The createValueExpression and createMethodExpression methods
must be thread-safe. That is, multiple threads may call these methods on the same ExpressionFactory object simultaneously. Implementations should synchronize access if they depend on transient
state. Implementations should not, however, assume that only one object of each ExpressionFactory type will be instantiated; global caching should therefore be static. The ExpressionFactory must be
able to handle the following types of input for the expression parameter:
ELException
to be thrown:
Constructor and Description |
---|
ExpressionFactory() |
Modifier and Type | Method and Description |
---|---|
abstract Object |
coerceToType(Object obj,
Class<?> targetType)
Coerces an object to a specific type according to the EL type conversion rules.
|
abstract MethodExpression |
createMethodExpression(ELContext context,
String expression,
Class<?> expectedReturnType,
Class<?>[] expectedParamTypes)
Parses an expression into a
MethodExpression for later evaluation. |
abstract ValueExpression |
createValueExpression(ELContext context,
String expression,
Class<?> expectedType)
Parses an expression into a
ValueExpression for later evaluation. |
abstract ValueExpression |
createValueExpression(Object instance,
Class<?> expectedType)
Creates a ValueExpression that wraps an object instance.
|
static ExpressionFactory |
newInstance()
Creates a new instance of a ExpressionFactory.
|
static ExpressionFactory |
newInstance(Properties properties)
Create a new instance of a ExpressionFactory, with optional properties.
|
public static ExpressionFactory newInstance()
ELException
- if a factory class cannot be found or instantiation fails.public static ExpressionFactory newInstance(Properties properties)
properties
- Properties passed to the constructor of the implementation.ELException
- if a factory class cannot be found or instantiation fails.public abstract Object coerceToType(Object obj, Class<?> targetType)
ELException
is thrown if an error results from applying the conversion rules.obj
- The object to coerce.targetType
- The target type for the coercion.ELException
- if an error results from applying the conversion rules.public abstract MethodExpression createMethodExpression(ELContext context, String expression, Class<?> expectedReturnType, Class<?>[] expectedParamTypes)
MethodExpression
for later evaluation. Use this method for expressions that refer to methods. If the expression is a String literal, a MethodExpression is
created, which when invoked, returns the String literal, coerced to expectedReturnType. An ELException is thrown if expectedReturnType is void or if the coercion of the String literal to the
expectedReturnType yields an error (see Section "1.16 Type Conversion"). This method should perform syntactic validation of the expression. If in doing so it detects errors, it should raise an
ELException.context
- The EL context used to parse the expression. The FunctionMapper and VariableMapper stored in the ELContext are used to resolve functions and variables found in the expression. They can
be null, in which case functions or variables are not supported for this expression. The object returned must invoke the same functions and access the same variable mappings regardless
of whether the mappings in the provided FunctionMapper and VariableMapper instances change between calling ExpressionFactory.createMethodExpression() and any method on MethodExpression.
Note that within the EL, the ${} and #{} syntaxes are treated identically. This includes the use of VariableMapper and FunctionMapper at expression creation time. Each is invoked if not
null, independent of whether the #{} or ${} syntax is used for the expression.expression
- The expression to parseexpectedReturnType
- The expected return type for the method to be found. After evaluating the expression, the MethodExpression must check that the return type of the actual method matches this type. Passing
in a value of null indicates the caller does not care what the return type is, and the check is disabled.expectedParamTypes
- The expected parameter types for the method to be found. Must be an array with no elements if there are no parameters expected. It is illegal to pass null.ELException
- Thrown if there are syntactical errors in the provided expression.NullPointerException
- if paramTypes is null.public abstract ValueExpression createValueExpression(ELContext context, String expression, Class<?> expectedType)
ValueExpression
for later evaluation. Use this method for expressions that refer to values. This method should perform syntactic validation of the expression.
If in doing so it detects errors, it should raise an ELException.context
- The EL context used to parse the expression. The FunctionMapper and VariableMapper stored in the ELContext are used to resolve functions and variables found in the expression. They can
be null, in which case functions or variables are not supported for this expression. The object returned must invoke the same functions and access the same variable mappings regardless
of whether the mappings in the provided FunctionMapper and VariableMapper instances change between calling ExpressionFactory.createValueExpression() and any method on ValueExpression.
Note that within the EL, the ${} and #{} syntaxes are treated identically. This includes the use of VariableMapper and FunctionMapper at expression creation time. Each is invoked if not
null, independent of whether the #{} or ${} syntax is used for the expression.expression
- The expression to parseexpectedType
- The type the result of the expression will be coerced to after evaluation.ELException
- Thrown if there are syntactical errors in the provided expression.NullPointerException
- if paramTypes is null.public abstract ValueExpression createValueExpression(Object instance, Class<?> expectedType)
instance
- The object instance to be wrapped.expectedType
- The type the result of the expression will be coerced to after evaluation. There will be no coercion if it is Object.class,Copyright © 2015 Alfresco. All rights reserved.