org.ocpsoft.rewrite.spring.SpringExpressionLanguageProvider Maven / Gradle / Ivy
/*
* Copyright 2011 Lincoln Baxter, III
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.ocpsoft.rewrite.spring;
import org.ocpsoft.rewrite.el.spi.ExpressionLanguageProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanExpressionContext;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.expression.BeanExpressionContextAccessor;
import org.springframework.context.expression.BeanFactoryAccessor;
import org.springframework.context.expression.BeanFactoryResolver;
import org.springframework.context.expression.MapAccessor;
import org.springframework.context.expression.StandardBeanExpressionResolver;
import org.springframework.core.convert.ConversionService;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.SpelEvaluationException;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.expression.spel.support.StandardTypeConverter;
import org.springframework.expression.spel.support.StandardTypeLocator;
import org.springframework.web.context.WebApplicationContext;
/**
* Implementation of {@link org.ocpsoft.rewrite.el.spi.ExpressionLanguageProvider} for the Spring Expression Language
* (SpEL)
*
* @author Christian Kaltepoth
*/
public class SpringExpressionLanguageProvider implements ExpressionLanguageProvider
{
/**
* Used to parse the SpEL expressions
*/
private final ExpressionParser parser = new SpelExpressionParser();
@Autowired
private WebApplicationContext applicationContext;
@Override
public int priority()
{
return 20;
}
@Override
public Object retrieveValue(String expression) throws UnsupportedOperationException
{
try {
Expression exp = parser.parseExpression(expression);
return exp.getValue(getEvaluationContext());
}
catch (SpelEvaluationException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public void submitValue(String expression, Object value) throws UnsupportedOperationException
{
try {
Expression exp = parser.parseExpression(expression);
exp.setValue(getEvaluationContext(), value);
}
catch (SpelEvaluationException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public Object evaluateMethodExpression(String expression) throws UnsupportedOperationException
{
try {
// the method expression MUST end with ()
String el = expression;
if (!el.endsWith("()")) {
el = el + "()";
}
// evaluate the expression
Expression exp = parser.parseExpression(el);
return exp.getValue(getEvaluationContext());
}
catch (SpelEvaluationException e) {
throw new UnsupportedOperationException(e);
}
}
@Override
public Object evaluateMethodExpression(String expression, Object... values) throws UnsupportedOperationException
{
throw new UnsupportedOperationException();
}
/**
* Lazily initialized by {@link #getEvaluationContext()}
*/
private EvaluationContext _evaluationContext = null;
/**
* Lazily creates a StandardEvaluationContext. The code has been inspired by
* {@link StandardBeanExpressionResolver#evaluate(String, BeanExpressionContext)}
*/
public EvaluationContext getEvaluationContext()
{
if (_evaluationContext == null) {
// we need a ConfigurableBeanFactory to build the BeanExpressionContext
ConfigurableBeanFactory beanFactory = null;
// the WebApplicationContext MAY implement ConfigurableBeanFactory
if (applicationContext instanceof ConfigurableBeanFactory) {
beanFactory = (ConfigurableBeanFactory) applicationContext;
}
// the AutowireCapableBeanFactory usually implements ConfigurableListableBeanFactory
if (beanFactory == null && applicationContext != null
&& applicationContext.getAutowireCapableBeanFactory() instanceof ConfigurableBeanFactory) {
beanFactory = (ConfigurableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
}
// we cannot continue without a ConfigurableBeanFactory
if (beanFactory == null) {
throw new IllegalStateException("Unable to find a ConfigurableBeanFactory");
}
BeanExpressionContext beanEvaluationContext = new BeanExpressionContext(beanFactory, null);
StandardEvaluationContext sec = new StandardEvaluationContext();
sec.setRootObject(beanEvaluationContext);
sec.addPropertyAccessor(new BeanExpressionContextAccessor());
sec.addPropertyAccessor(new BeanFactoryAccessor());
sec.addPropertyAccessor(new MapAccessor());
sec.setBeanResolver(new BeanFactoryResolver(beanEvaluationContext.getBeanFactory()));
sec.setTypeLocator(new StandardTypeLocator(beanEvaluationContext.getBeanFactory().getBeanClassLoader()));
ConversionService conversionService = beanEvaluationContext.getBeanFactory().getConversionService();
if (conversionService != null) {
sec.setTypeConverter(new StandardTypeConverter(conversionService));
}
_evaluationContext = sec;
}
return _evaluationContext;
}
}