Integration of unified EL into spring-binding. See SWF-287.
This commit is contained in:
Jeremy Grelle
@@ -0,0 +1,77 @@
|
||||
package org.springframework.binding.expression.support;
|
||||
|
||||
import javax.el.ArrayELResolver;
|
||||
import javax.el.BeanELResolver;
|
||||
import javax.el.CompositeELResolver;
|
||||
import javax.el.ELContext;
|
||||
import javax.el.ListELResolver;
|
||||
import javax.el.MapELResolver;
|
||||
import javax.el.ResourceBundleELResolver;
|
||||
|
||||
import org.springframework.binding.collection.MapAdaptable;
|
||||
import org.springframework.util.Assert;
|
||||
|
||||
/**
|
||||
* A generic ELResolver to be used as a default when no other ELResolvers have been
|
||||
* configured by the client application.
|
||||
*
|
||||
* This implementation will resolve the first part of the expression to
|
||||
* the pre-configured base object, and will then delegate through the
|
||||
* chain of standard resolvers for the rest of the expression.
|
||||
*
|
||||
* Note - Requires Java 5 or higher due to the use of generics in the API's basic resolvers.
|
||||
*
|
||||
* @author Jeremy Grelle
|
||||
*
|
||||
*/
|
||||
public class DefaultELResolver extends CompositeELResolver {
|
||||
|
||||
private Object target;
|
||||
|
||||
public DefaultELResolver() {
|
||||
configureResolvers();
|
||||
}
|
||||
|
||||
public Class getType(ELContext context, Object base, Object property) {
|
||||
return super.getType(context, adaptIfNecessary(base), property);
|
||||
}
|
||||
|
||||
public Object getValue(ELContext context, Object base, Object property) {
|
||||
Assert.notNull(target,"The DefaultELResolver must have a target base property set.");
|
||||
if (base == null) {
|
||||
return super.getValue(context, target, property);
|
||||
}
|
||||
return super.getValue(context, adaptIfNecessary(base), property);
|
||||
}
|
||||
|
||||
public void setValue(ELContext context, Object base, Object property, Object val) {
|
||||
Assert.notNull(target,"The DefaultELResolver must have a target base property set.");
|
||||
if (base == null)
|
||||
super.setValue(context, target, property, val);
|
||||
else
|
||||
super.setValue(context, adaptIfNecessary(base), property, val);
|
||||
}
|
||||
|
||||
public Object getTarget() {
|
||||
return target;
|
||||
}
|
||||
|
||||
public void setTarget(Object target) {
|
||||
this.target = adaptIfNecessary(target);
|
||||
}
|
||||
|
||||
private Object adaptIfNecessary(Object base) {
|
||||
if (base instanceof MapAdaptable)
|
||||
return ((MapAdaptable)base).asMap();
|
||||
return base;
|
||||
}
|
||||
|
||||
private void configureResolvers() {
|
||||
add(new ArrayELResolver());
|
||||
add(new ListELResolver());
|
||||
add(new MapELResolver());
|
||||
add(new ResourceBundleELResolver());
|
||||
add(new BeanELResolver());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package org.springframework.binding.expression.support;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import javax.el.CompositeELResolver;
|
||||
import javax.el.ELContext;
|
||||
import javax.el.ELResolver;
|
||||
import javax.el.FunctionMapper;
|
||||
import javax.el.VariableMapper;
|
||||
|
||||
/**
|
||||
* An {@link ELContext} implementation that is meant to aggregate the {@link ELResolver}s of
|
||||
* pre-existing {@link ELContext}s. Can also be used standalone if no other {@link ELContext}
|
||||
* exists in the current environment.
|
||||
*
|
||||
* Note - Using this context standalone requires Java 5 or higher.
|
||||
*
|
||||
* @author Jeremy Grelle
|
||||
*
|
||||
*/
|
||||
public class DelegatingELContext extends ELContext {
|
||||
|
||||
private ELResolver resolver;
|
||||
|
||||
private FunctionMapper functionMapper;
|
||||
|
||||
private VariableMapper variableMapper;
|
||||
|
||||
private List delegates = new ArrayList();
|
||||
|
||||
public ELResolver getELResolver() {
|
||||
return resolver;
|
||||
}
|
||||
|
||||
public void setELResolver(ELResolver resolver) {
|
||||
this.resolver = resolver;
|
||||
}
|
||||
|
||||
public FunctionMapper getFunctionMapper() {
|
||||
return functionMapper;
|
||||
}
|
||||
|
||||
public void setFunctionMapper(FunctionMapper functionMapper) {
|
||||
this.functionMapper = functionMapper;
|
||||
}
|
||||
|
||||
public VariableMapper getVariableMapper() {
|
||||
return variableMapper;
|
||||
}
|
||||
|
||||
public void setVariableMapper(VariableMapper variableMapper) {
|
||||
this.variableMapper = variableMapper;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a delegate {@link ELContext}.
|
||||
*
|
||||
* If this context is currently configured with the {@link DefaultELResolver}, that resolver
|
||||
* instance will be replaced with a new {@link CompositeELResolver}.
|
||||
*
|
||||
* The delegate's base {@link ELResolver} will be added to this context's base {@link CompositeELResolver}.
|
||||
*
|
||||
* @param context The {@link ELContext} whose base {@link ELResolver} needs to be included in this
|
||||
* context's base {@link CompositeELResolver}.
|
||||
*/
|
||||
public void addDelegate(ELContext context) {
|
||||
delegates.add(context);
|
||||
if (getELResolver() == null || getELResolver() instanceof DefaultELResolver) {
|
||||
CompositeELResolver composite = new CompositeELResolver();
|
||||
composite.add(context.getELResolver());
|
||||
setELResolver(composite);
|
||||
}
|
||||
else if (getELResolver() instanceof CompositeELResolver) {
|
||||
((CompositeELResolver) getELResolver()).add(context.getELResolver());
|
||||
}
|
||||
}
|
||||
|
||||
public Object getContext(Class key) {
|
||||
Object context = super.getContext(key);
|
||||
if (context != null)
|
||||
return context;
|
||||
|
||||
Iterator i = delegates.iterator();
|
||||
while(i.hasNext())
|
||||
{
|
||||
ELContext delegate = (ELContext) i.next();
|
||||
context = delegate.getContext(key);
|
||||
if (context != null)
|
||||
return context;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* The <code>ThreadLocal</code> variable used to record the
|
||||
* {@link ELContext} instance for each processing thread.
|
||||
*/
|
||||
private static ThreadLocal instance = new ThreadLocal() {
|
||||
protected Object initialValue() {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the {@link ELContext} instance for the request that is
|
||||
* being processed by the current thread, if any.
|
||||
*/
|
||||
public static DelegatingELContext getCurrentInstance() {
|
||||
if (instance.get() == null)
|
||||
setCurrentInstance(defaultInstance());
|
||||
return ((DelegatingELContext) instance.get());
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the {@link ELContext} instance for the request that is
|
||||
* being processed by the current thread.
|
||||
*
|
||||
* @param context The {@link ELContext} instance for the current
|
||||
* thread, or <code>null</code> if this thread no longer has an
|
||||
* <code>ELContext</code> instance.
|
||||
*
|
||||
*/
|
||||
public static void setCurrentInstance(DelegatingELContext context) {
|
||||
instance.set(context);
|
||||
}
|
||||
|
||||
private static DelegatingELContext defaultInstance() {
|
||||
return new DelegatingELContext();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package org.springframework.binding.expression.support;
|
||||
|
||||
import javax.el.ELContext;
|
||||
import javax.el.ELException;
|
||||
import javax.el.ValueExpression;
|
||||
|
||||
import org.springframework.binding.expression.EvaluationAttempt;
|
||||
import org.springframework.binding.expression.EvaluationContext;
|
||||
import org.springframework.binding.expression.EvaluationException;
|
||||
import org.springframework.binding.expression.SettableExpression;
|
||||
|
||||
/**
|
||||
* Evaluates a parsed EL expression.
|
||||
*
|
||||
* @author Jeremy Grelle
|
||||
*/
|
||||
public class ELExpression implements SettableExpression {
|
||||
|
||||
ValueExpression expression;
|
||||
|
||||
public ELExpression(ValueExpression expression) {
|
||||
this.expression = expression;
|
||||
}
|
||||
|
||||
public void evaluateToSet(Object target, Object value, EvaluationContext context) throws EvaluationException {
|
||||
ELContext ctx = getELContext(target);
|
||||
try {
|
||||
expression.setValue(ctx, value);
|
||||
}
|
||||
catch (ELException ex) {
|
||||
throw new EvaluationException(new EvaluationAttempt(this, target, context), ex);
|
||||
}
|
||||
}
|
||||
|
||||
public Object evaluate(Object target, EvaluationContext context) throws EvaluationException {
|
||||
ELContext ctx = getELContext(target);
|
||||
try {
|
||||
return expression.getValue(ctx);
|
||||
}
|
||||
catch (ELException ex) {
|
||||
throw new EvaluationException(new EvaluationAttempt(this, target, context), ex);
|
||||
}
|
||||
}
|
||||
|
||||
protected Class getType(Object target, EvaluationContext context) throws EvaluationException{
|
||||
ELContext ctx = getELContext(target);
|
||||
try {
|
||||
return expression.getType(ctx);
|
||||
}
|
||||
catch (ELException ex) {
|
||||
throw new EvaluationException(new EvaluationAttempt(this, target, context), ex);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the thread-bound {@link ELContext} instance, configured with a DefaultELResolver if
|
||||
* no other resolvers have been configured.
|
||||
*
|
||||
* @return {@link ELContext} The thread-bound {@link ELContext} instance.
|
||||
*/
|
||||
private ELContext getELContext(Object target) {
|
||||
ELContext ctx = DelegatingELContext.getCurrentInstance();
|
||||
if (ctx.getELResolver() == null)
|
||||
((DelegatingELContext)ctx).setELResolver(new DefaultELResolver());
|
||||
if (ctx.getELResolver() instanceof DefaultELResolver)
|
||||
((DefaultELResolver)ctx.getELResolver()).setTarget(target);
|
||||
return ctx;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return expression.hashCode();
|
||||
}
|
||||
|
||||
public boolean equals(Object o) {
|
||||
if (!(o instanceof ELExpression)) {
|
||||
return false;
|
||||
}
|
||||
ELExpression other = (ELExpression) o;
|
||||
return expression.equals(other.expression);
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return expression.getExpressionString();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package org.springframework.binding.expression.support;
|
||||
|
||||
import javax.el.ELContext;
|
||||
import javax.el.ELException;
|
||||
import javax.el.ExpressionFactory;
|
||||
|
||||
import org.jboss.el.ExpressionFactoryImpl;
|
||||
import org.springframework.binding.expression.Expression;
|
||||
import org.springframework.binding.expression.ExpressionParser;
|
||||
import org.springframework.binding.expression.ParserException;
|
||||
import org.springframework.binding.expression.SettableExpression;
|
||||
|
||||
/**
|
||||
* An expression parser that parses EL expressions. Beyond standard EL expression parsing, it
|
||||
* makes use of the ability of the JBoss-EL implementation to parse dynamic method invocations
|
||||
* such as foo.bar() (the EL spec currently only provides out-of-the-box support for functions).
|
||||
*
|
||||
* @author Jeremy Grelle
|
||||
*/
|
||||
public class ELExpressionParser implements ExpressionParser {
|
||||
|
||||
/**
|
||||
* The expression prefix for deferred EL expressions.
|
||||
*/
|
||||
private static final String DEFERRED_EL_EXPRESSION_PREFIX = "#{";
|
||||
|
||||
/**
|
||||
* The expression suffix for deferred EL expressions.
|
||||
*/
|
||||
private static final String DEFERRED_EL_EXPRESSION_SUFFIX = "}";
|
||||
|
||||
/**
|
||||
* The marked expression delimiter prefix.
|
||||
*/
|
||||
private String expressionPrefix = DEFERRED_EL_EXPRESSION_PREFIX;
|
||||
|
||||
/**
|
||||
* The marked expression delimiter suffix.
|
||||
*/
|
||||
private String expressionSuffix = DEFERRED_EL_EXPRESSION_SUFFIX;
|
||||
|
||||
/**
|
||||
* The ExpressionFactory for constructing EL expressions
|
||||
*/
|
||||
private ExpressionFactory factory = new ExpressionFactoryImpl();
|
||||
|
||||
public String getExpressionPrefix() {
|
||||
return expressionPrefix;
|
||||
}
|
||||
|
||||
public String getExpressionSuffix() {
|
||||
return expressionSuffix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether or not given criteria are expressed as an expression.
|
||||
*/
|
||||
public boolean isDelimitedExpression(String expressionString) {
|
||||
int prefixIndex = expressionString.indexOf(getExpressionPrefix());
|
||||
if (prefixIndex == -1) {
|
||||
return false;
|
||||
}
|
||||
int suffixIndex = expressionString.indexOf(getExpressionSuffix(), prefixIndex);
|
||||
if (suffixIndex == -1) {
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
if (suffixIndex == prefixIndex + getExpressionPrefix().length()) {
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Expression parseExpression(String expressionString) throws ParserException {
|
||||
if (!isDelimitedExpression(expressionString)) {
|
||||
expressionString = getExpressionPrefix() + expressionString + getExpressionSuffix();
|
||||
}
|
||||
return doParseExpression(expressionString);
|
||||
}
|
||||
|
||||
public SettableExpression parseSettableExpression(String expressionString) throws ParserException,
|
||||
UnsupportedOperationException {
|
||||
if (!isDelimitedExpression(expressionString)) {
|
||||
expressionString = getExpressionPrefix() + expressionString + getExpressionSuffix();
|
||||
}
|
||||
return doParseSettableExpression(expressionString);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the expression string into an EL value expression.
|
||||
* @param expressionString
|
||||
* @throws ParserException
|
||||
*/
|
||||
protected Expression doParseExpression(String expressionString) throws ParserException {
|
||||
return doParseSettableExpression(expressionString);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the expression string into an EL value expression.
|
||||
* @param expressionString
|
||||
* @throws ParserException
|
||||
*/
|
||||
protected SettableExpression doParseSettableExpression(String expressionString) throws ParserException {
|
||||
ELContext ctx = getELContext();
|
||||
try {
|
||||
return new ELExpression(factory.createValueExpression(ctx, expressionString, Object.class));
|
||||
}
|
||||
catch (ELException ex) {
|
||||
throw new ParserException(expressionString, ex);
|
||||
}
|
||||
}
|
||||
|
||||
private ELContext getELContext() {
|
||||
return DelegatingELContext.getCurrentInstance();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user