org.springframework.expression.spel.support.StandardEvaluationContext Maven / Gradle / Ivy

/*
 * Copyright 2002-2009 the original author or authors.
 *
 * 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.springframework.expression.spel.support;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.core.convert.TypeDescriptor;
import org.springframework.expression.BeanResolver;
import org.springframework.expression.ConstructorResolver;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.MethodFilter;
import org.springframework.expression.MethodResolver;
import org.springframework.expression.OperatorOverloader;
import org.springframework.expression.PropertyAccessor;
import org.springframework.expression.TypeComparator;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.TypeLocator;
import org.springframework.expression.TypedValue;
import org.springframework.util.Assert;

/**
 * Provides a default EvaluationContext implementation.
 *
 * To resolve properties/methods/fields this context uses a reflection mechanism.
 *
 * @author Andy Clement
 * @author Juergen Hoeller
 * @since 3.0
 */
public class StandardEvaluationContext implements EvaluationContext {
	
	private TypedValue rootObject;

	private List constructorResolvers;

	private List methodResolvers;
	
	private ReflectiveMethodResolver reflectiveMethodResolver;

	private List propertyAccessors;

	private TypeLocator typeLocator;

	private TypeConverter typeConverter;

	private TypeComparator typeComparator = new StandardTypeComparator();

	private OperatorOverloader operatorOverloader = new StandardOperatorOverloader();

	private final Map variables = new HashMap();
	
	private BeanResolver beanResolver;


	public StandardEvaluationContext() {
		setRootObject(null);
	}
	
	public StandardEvaluationContext(Object rootObject) {
		this();
		setRootObject(rootObject);
	}


	public void setRootObject(Object rootObject) {
		if (this.rootObject == null) {
			this.rootObject = TypedValue.NULL;
		} else {
			this.rootObject = new TypedValue(rootObject);//, TypeDescriptor.forObject(rootObject));
		}
	}

	public void setRootObject(Object rootObject, TypeDescriptor typeDescriptor) {
		this.rootObject = new TypedValue(rootObject, typeDescriptor);
	}

	public TypedValue getRootObject() {
		return this.rootObject;
	}

	public void addConstructorResolver(ConstructorResolver resolver) {
		ensureConstructorResolversInitialized();
		this.constructorResolvers.add(this.constructorResolvers.size() - 1, resolver);
	}

	public boolean removeConstructorResolver(ConstructorResolver resolver) {
		ensureConstructorResolversInitialized();
		return this.constructorResolvers.remove(resolver);
	}
	
	public List getConstructorResolvers() {
		ensureConstructorResolversInitialized();
		return this.constructorResolvers;
	}
	
	public void setConstructorResolvers(List constructorResolvers) {
		this.constructorResolvers = constructorResolvers;
	}


	public void addMethodResolver(MethodResolver resolver) {
		ensureMethodResolversInitialized();
		this.methodResolvers.add(this.methodResolvers.size() - 1, resolver);
	}
	
	public boolean removeMethodResolver(MethodResolver methodResolver) {
		ensureMethodResolversInitialized();
		return this.methodResolvers.remove(methodResolver);
	}

	public List getMethodResolvers() {
		ensureMethodResolversInitialized();
		return this.methodResolvers;
	}

	public void setBeanResolver(BeanResolver beanResolver) {
		this.beanResolver = beanResolver;
	}
	
	public BeanResolver getBeanResolver() {
		return this.beanResolver;
	}
	
	public void setMethodResolvers(List methodResolvers) {
		this.methodResolvers = methodResolvers;
	}
	

	public void addPropertyAccessor(PropertyAccessor accessor) {
		ensurePropertyAccessorsInitialized();
		this.propertyAccessors.add(this.propertyAccessors.size() - 1, accessor);
	}
	
	public boolean removePropertyAccessor(PropertyAccessor accessor) {
		return this.propertyAccessors.remove(accessor);
	}

	public List getPropertyAccessors() {
		ensurePropertyAccessorsInitialized();
		return this.propertyAccessors;
	}
	
	public void setPropertyAccessors(List propertyAccessors) {
		this.propertyAccessors = propertyAccessors;
	}


	public void setTypeLocator(TypeLocator typeLocator) {
		Assert.notNull(typeLocator, "TypeLocator must not be null");
		this.typeLocator = typeLocator;
	}

	public TypeLocator getTypeLocator() {
		if (this.typeLocator == null) {
			 this.typeLocator = new StandardTypeLocator();
		}
		return this.typeLocator;
	}

	public void setTypeConverter(TypeConverter typeConverter) {
		Assert.notNull(typeConverter, "TypeConverter must not be null");
		this.typeConverter = typeConverter;
	}

	public TypeConverter getTypeConverter() {
		if (this.typeConverter == null) {
			 this.typeConverter = new StandardTypeConverter();
		}
		return this.typeConverter;
	}

	public void setTypeComparator(TypeComparator typeComparator) {
		Assert.notNull(typeComparator, "TypeComparator must not be null");
		this.typeComparator = typeComparator;
	}

	public TypeComparator getTypeComparator() {
		return this.typeComparator;
	}

	public void setOperatorOverloader(OperatorOverloader operatorOverloader) {
		Assert.notNull(operatorOverloader, "OperatorOverloader must not be null");
		this.operatorOverloader = operatorOverloader;
	}

	public OperatorOverloader getOperatorOverloader() {
		return this.operatorOverloader;
	}

	public void setVariable(String name, Object value) {
		this.variables.put(name, value);
	}

	public void setVariables(Map variables) {
		this.variables.putAll(variables);
	}

	public void registerFunction(String name, Method method) {
		this.variables.put(name, method);
	}

	public Object lookupVariable(String name) {
		return this.variables.get(name);
	}

	/**
	 * 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.
	 * 
	 * @param type the type for which the filter should be called
	 * @param filter a MethodFilter, or NULL to deregister a filter for the type
	 */
	public void registerMethodFilter(Class type, MethodFilter filter) {
		ensureMethodResolversInitialized();
		reflectiveMethodResolver.registerMethodFilter(type,filter);
	}

	private void ensurePropertyAccessorsInitialized() {
		if (this.propertyAccessors == null) {
			initializePropertyAccessors();
		}
	}

	private synchronized void initializePropertyAccessors() {
		if (this.propertyAccessors == null) {
			List defaultAccessors = new ArrayList();
			defaultAccessors.add(new ReflectivePropertyAccessor());
			this.propertyAccessors = defaultAccessors;
		}
	}

	private void ensureMethodResolversInitialized() {
		if (this.methodResolvers == null) {
			initializeMethodResolvers();
		}
	}

	private synchronized void initializeMethodResolvers() {
		if (this.methodResolvers == null) {
			List defaultResolvers = new ArrayList();
			defaultResolvers.add(reflectiveMethodResolver = new ReflectiveMethodResolver());
			this.methodResolvers = defaultResolvers;
		}
	}

	private void ensureConstructorResolversInitialized() {
		if (this.constructorResolvers == null) {
			initializeConstructorResolvers();
		}
	}

	private synchronized void initializeConstructorResolvers() {
		if (this.constructorResolvers == null) {
			List defaultResolvers = new ArrayList();
			defaultResolvers.add(new ReflectiveConstructorResolver());
			this.constructorResolvers = defaultResolvers;
		}
	}

}