1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.springframework.expression.spel.support;
18
19 import java.lang.reflect.Method;
20 import java.util.ArrayList;
21 import java.util.HashMap;
22 import java.util.List;
23 import java.util.Map;
24
25 import org.springframework.core.convert.TypeDescriptor;
26 import org.springframework.expression.BeanResolver;
27 import org.springframework.expression.ConstructorResolver;
28 import org.springframework.expression.EvaluationContext;
29 import org.springframework.expression.MethodFilter;
30 import org.springframework.expression.MethodResolver;
31 import org.springframework.expression.OperatorOverloader;
32 import org.springframework.expression.PropertyAccessor;
33 import org.springframework.expression.TypeComparator;
34 import org.springframework.expression.TypeConverter;
35 import org.springframework.expression.TypeLocator;
36 import org.springframework.expression.TypedValue;
37 import org.springframework.util.Assert;
38
39
40
41
42
43
44
45
46
47
48
49 public class StandardEvaluationContext implements EvaluationContext {
50
51 private TypedValue rootObject;
52
53 private List<ConstructorResolver> constructorResolvers;
54
55 private List<MethodResolver> methodResolvers;
56
57 private BeanResolver beanResolver;
58
59 private ReflectiveMethodResolver reflectiveMethodResolver;
60
61 private List<PropertyAccessor> propertyAccessors;
62
63 private TypeLocator typeLocator;
64
65 private TypeConverter typeConverter;
66
67 private TypeComparator typeComparator = new StandardTypeComparator();
68
69 private OperatorOverloader operatorOverloader = new StandardOperatorOverloader();
70
71 private final Map<String, Object> variables = new HashMap<String, Object>();
72
73
74 public StandardEvaluationContext() {
75 setRootObject(null);
76 }
77
78 public StandardEvaluationContext(Object rootObject) {
79 setRootObject(rootObject);
80 }
81
82
83 public void setRootObject(Object rootObject, TypeDescriptor typeDescriptor) {
84 this.rootObject = new TypedValue(rootObject, typeDescriptor);
85 }
86
87 public void setRootObject(Object rootObject) {
88 this.rootObject = (rootObject != null ? new TypedValue(rootObject) : TypedValue.NULL);
89 }
90
91 @Override
92 public TypedValue getRootObject() {
93 return this.rootObject;
94 }
95
96 public void addConstructorResolver(ConstructorResolver resolver) {
97 ensureConstructorResolversInitialized();
98 this.constructorResolvers.add(this.constructorResolvers.size() - 1, resolver);
99 }
100
101 public boolean removeConstructorResolver(ConstructorResolver resolver) {
102 ensureConstructorResolversInitialized();
103 return this.constructorResolvers.remove(resolver);
104 }
105
106 public void setConstructorResolvers(List<ConstructorResolver> constructorResolvers) {
107 this.constructorResolvers = constructorResolvers;
108 }
109
110 @Override
111 public List<ConstructorResolver> getConstructorResolvers() {
112 ensureConstructorResolversInitialized();
113 return this.constructorResolvers;
114 }
115
116 public void addMethodResolver(MethodResolver resolver) {
117 ensureMethodResolversInitialized();
118 this.methodResolvers.add(this.methodResolvers.size() - 1, resolver);
119 }
120
121 public boolean removeMethodResolver(MethodResolver methodResolver) {
122 ensureMethodResolversInitialized();
123 return this.methodResolvers.remove(methodResolver);
124 }
125
126 public void setMethodResolvers(List<MethodResolver> methodResolvers) {
127 this.methodResolvers = methodResolvers;
128 }
129
130 @Override
131 public List<MethodResolver> getMethodResolvers() {
132 ensureMethodResolversInitialized();
133 return this.methodResolvers;
134 }
135
136 public void setBeanResolver(BeanResolver beanResolver) {
137 this.beanResolver = beanResolver;
138 }
139
140 @Override
141 public BeanResolver getBeanResolver() {
142 return this.beanResolver;
143 }
144
145 public void addPropertyAccessor(PropertyAccessor accessor) {
146 ensurePropertyAccessorsInitialized();
147 this.propertyAccessors.add(this.propertyAccessors.size() - 1, accessor);
148 }
149
150 public boolean removePropertyAccessor(PropertyAccessor accessor) {
151 return this.propertyAccessors.remove(accessor);
152 }
153
154 public void setPropertyAccessors(List<PropertyAccessor> propertyAccessors) {
155 this.propertyAccessors = propertyAccessors;
156 }
157
158 @Override
159 public List<PropertyAccessor> getPropertyAccessors() {
160 ensurePropertyAccessorsInitialized();
161 return this.propertyAccessors;
162 }
163
164 public void setTypeLocator(TypeLocator typeLocator) {
165 Assert.notNull(typeLocator, "TypeLocator must not be null");
166 this.typeLocator = typeLocator;
167 }
168
169 @Override
170 public TypeLocator getTypeLocator() {
171 if (this.typeLocator == null) {
172 this.typeLocator = new StandardTypeLocator();
173 }
174 return this.typeLocator;
175 }
176
177 public void setTypeConverter(TypeConverter typeConverter) {
178 Assert.notNull(typeConverter, "TypeConverter must not be null");
179 this.typeConverter = typeConverter;
180 }
181
182 @Override
183 public TypeConverter getTypeConverter() {
184 if (this.typeConverter == null) {
185 this.typeConverter = new StandardTypeConverter();
186 }
187 return this.typeConverter;
188 }
189
190 public void setTypeComparator(TypeComparator typeComparator) {
191 Assert.notNull(typeComparator, "TypeComparator must not be null");
192 this.typeComparator = typeComparator;
193 }
194
195 @Override
196 public TypeComparator getTypeComparator() {
197 return this.typeComparator;
198 }
199
200 public void setOperatorOverloader(OperatorOverloader operatorOverloader) {
201 Assert.notNull(operatorOverloader, "OperatorOverloader must not be null");
202 this.operatorOverloader = operatorOverloader;
203 }
204
205 @Override
206 public OperatorOverloader getOperatorOverloader() {
207 return this.operatorOverloader;
208 }
209
210 @Override
211 public void setVariable(String name, Object value) {
212 this.variables.put(name, value);
213 }
214
215 public void setVariables(Map<String,Object> variables) {
216 this.variables.putAll(variables);
217 }
218
219 public void registerFunction(String name, Method method) {
220 this.variables.put(name, method);
221 }
222
223 @Override
224 public Object lookupVariable(String name) {
225 return this.variables.get(name);
226 }
227
228
229
230
231
232
233
234
235
236
237 public void registerMethodFilter(Class<?> type, MethodFilter filter) throws IllegalStateException {
238 ensureMethodResolversInitialized();
239 if (this.reflectiveMethodResolver != null) {
240 this.reflectiveMethodResolver.registerMethodFilter(type, filter);
241 }
242 else {
243 throw new IllegalStateException("Method filter cannot be set as the reflective method resolver is not in use");
244 }
245 }
246
247 private void ensurePropertyAccessorsInitialized() {
248 if (this.propertyAccessors == null) {
249 initializePropertyAccessors();
250 }
251 }
252
253 private synchronized void initializePropertyAccessors() {
254 if (this.propertyAccessors == null) {
255 List<PropertyAccessor> defaultAccessors = new ArrayList<PropertyAccessor>();
256 defaultAccessors.add(new ReflectivePropertyAccessor());
257 this.propertyAccessors = defaultAccessors;
258 }
259 }
260
261 private void ensureMethodResolversInitialized() {
262 if (this.methodResolvers == null) {
263 initializeMethodResolvers();
264 }
265 }
266
267 private synchronized void initializeMethodResolvers() {
268 if (this.methodResolvers == null) {
269 List<MethodResolver> defaultResolvers = new ArrayList<MethodResolver>();
270 this.reflectiveMethodResolver = new ReflectiveMethodResolver();
271 defaultResolvers.add(this.reflectiveMethodResolver);
272 this.methodResolvers = defaultResolvers;
273 }
274 }
275
276 private void ensureConstructorResolversInitialized() {
277 if (this.constructorResolvers == null) {
278 initializeConstructorResolvers();
279 }
280 }
281
282 private synchronized void initializeConstructorResolvers() {
283 if (this.constructorResolvers == null) {
284 List<ConstructorResolver> defaultResolvers = new ArrayList<ConstructorResolver>();
285 defaultResolvers.add(new ReflectiveConstructorResolver());
286 this.constructorResolvers = defaultResolvers;
287 }
288 }
289
290 }