Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polish MethodReference

Browse Source 
Polish MethodReference code formatting and remove duplicate code.
This commit is contained in:
Phillip Webb
2013-06-28 16:24:14 -07:00
parent bf4563e204
commit 3157b68e4a
1 changed files with 140 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

318
spring-expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java
View File

@@ -42,122 +42,173 @@ import org.springframework.expression.spel.SpelMessage;
*/ */
public class MethodReference extends SpelNodeImpl { public class MethodReference extends SpelNodeImpl {
private final String name;
private final boolean nullSafe; private final boolean nullSafe;
private final String name;
private volatile CachedMethodExecutor cachedExecutor; private volatile CachedMethodExecutor cachedExecutor;
public MethodReference(boolean nullSafe, String methodName, int pos, SpelNodeImpl... arguments) {
public MethodReference(boolean nullSafe, String methodName, int pos,
SpelNodeImpl... arguments) {
super(pos, arguments); super(pos, arguments);
this.name = methodName;
this.nullSafe = nullSafe; this.nullSafe = nullSafe;
this.name = methodName;
} }
public final String getName() { public final String getName() {
return this.name; return this.name;
} }
@Override @Override
protected ValueRef getValueRef(ExpressionState state) throws EvaluationException { protected ValueRef getValueRef(ExpressionState state) throws EvaluationException {
TypedValue currentContext = state.getActiveContextObject(); Object[] arguments = getArguments(state);
Object[] arguments = new Object[getChildCount()]; if (state.getActiveContextObject().getValue() == null) {
for (int i = 0; i < arguments.length; i++) { throwIfNotNullSafe(getArgumentTypes(arguments));
// Make the root object the active context again for evaluating the parameter return ValueRef.NullValueRef.instance;
// expressions
try {
state.pushActiveContextObject(state.getRootContextObject());
arguments[i] = this.children[i].getValueInternal(state).getValue();
}
finally {
state.popActiveContextObject();
}
} }
if (currentContext.getValue() == null) { return new MethodValueRef(state);
if (this.nullSafe) {
return ValueRef.NullValueRef.instance;
}
else {
throw new SpelEvaluationException(getStartPosition(), SpelMessage.METHOD_CALL_ON_NULL_OBJECT_NOT_ALLOWED,
FormatHelper.formatMethodForMessage(this.name, getTypes(arguments)));
}
}
return new MethodValueRef(state,state.getEvaluationContext(),state.getActiveContextObject().getValue(),arguments);
} }
@Override @Override
public TypedValue getValueInternal(ExpressionState state) throws EvaluationException { public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
TypedValue currentContext = state.getActiveContextObject(); EvaluationContext evaluationContext = state.getEvaluationContext();
Object[] arguments = new Object[getChildCount()]; Object value = state.getActiveContextObject().getValue();
for (int i = 0; i < arguments.length; i++) { TypeDescriptor targetType = state.getActiveContextObject().getTypeDescriptor();
// Make the root object the active context again for evaluating the parameter Object[] arguments = getArguments(state);
// expressions return getValueInternal(evaluationContext, value, arguments, targetType);
try { }
state.pushActiveContextObject(state.getRootContextObject());
arguments[i] = this.children[i].getValueInternal(state).getValue(); private TypedValue getValueInternal(EvaluationContext evaluationContext,
} Object value, Object[] arguments, TypeDescriptor targetType) {
finally { List<TypeDescriptor> argumentTypes = getArgumentTypes(arguments);
state.popActiveContextObject();
} if (value == null) {
} throwIfNotNullSafe(argumentTypes);
TypedValue activeContextObject = state.getActiveContextObject(); return TypedValue.NULL;
TypeDescriptor target = (activeContextObject == null ? null
: activeContextObject.getTypeDescriptor());
List<TypeDescriptor> argumentTypes = getTypes(arguments);
if (currentContext.getValue() == null) {
if (this.nullSafe) {
return TypedValue.NULL;
}
else {
throw new SpelEvaluationException(getStartPosition(), SpelMessage.METHOD_CALL_ON_NULL_OBJECT_NOT_ALLOWED,
FormatHelper.formatMethodForMessage(this.name, argumentTypes));
}
} }
MethodExecutor executorToUse = getCachedExecutor(target, argumentTypes); MethodExecutor executorToUse = getCachedExecutor(targetType, argumentTypes);
if (executorToUse != null) { if (executorToUse != null) {
try { try {
return executorToUse.execute(state.getEvaluationContext(), return executorToUse.execute(evaluationContext, value, arguments);
state.getActiveContextObject().getValue(), arguments);
} }
catch (AccessException ae) { catch (AccessException ae) {
// Two reasons this can occur: // Two reasons this can occur:
// 1. the method invoked actually threw a real exception // 1. the method invoked actually threw a real exception
// 2. the method invoked was not passed the arguments it expected and has become 'stale' // 2. the method invoked was not passed the arguments it expected and
// has become 'stale'
// In the first case we should not retry, in the second case we should see if there is a // In the first case we should not retry, in the second case we should see
// better suited method. // if there is a better suited method.
// To determine which situation it is, the AccessException will contain a cause. // To determine the situation, the AccessException will contain a cause.
// If the cause is an InvocationTargetException, a user exception was thrown inside the method. // If the cause is an InvocationTargetException, a user exception was
// thrown inside the method.
// Otherwise the method could not be invoked. // Otherwise the method could not be invoked.
throwSimpleExceptionIfPossible(state, ae); throwSimpleExceptionIfPossible(value, ae);
// at this point we know it wasn't a user problem so worth a retry if a better candidate can be found // at this point we know it wasn't a user problem so worth a retry if a
// better candidate can be found
this.cachedExecutor = null; this.cachedExecutor = null;
} }
} }
// either there was no accessor or it no longer existed // either there was no accessor or it no longer existed
executorToUse = findAccessorForMethod(this.name, argumentTypes, state); executorToUse = findAccessorForMethod(this.name, argumentTypes, value, evaluationContext);
this.cachedExecutor = new CachedMethodExecutor(executorToUse, target, argumentTypes); this.cachedExecutor = new CachedMethodExecutor(executorToUse, targetType,
argumentTypes);
try { try {
return executorToUse.execute(state.getEvaluationContext(), return executorToUse.execute(evaluationContext,
state.getActiveContextObject().getValue(), arguments); value, arguments);
} }
catch (AccessException ae) { catch (AccessException ex) {
// Same unwrapping exception handling as above in above catch block // Same unwrapping exception handling as above in above catch block
throwSimpleExceptionIfPossible(state, ae); throwSimpleExceptionIfPossible(value, ex);
throw new SpelEvaluationException( getStartPosition(), ae, SpelMessage.EXCEPTION_DURING_METHOD_INVOCATION, throw new SpelEvaluationException(getStartPosition(), ex,
this.name, state.getActiveContextObject().getValue().getClass().getName(), ae.getMessage()); SpelMessage.EXCEPTION_DURING_METHOD_INVOCATION, this.name,
value.getClass().getName(),
ex.getMessage());
} }
} }
private void throwIfNotNullSafe(List<TypeDescriptor> argumentTypes) {
if (!this.nullSafe) {
throw new SpelEvaluationException(getStartPosition(),
SpelMessage.METHOD_CALL_ON_NULL_OBJECT_NOT_ALLOWED,
FormatHelper.formatMethodForMessage(this.name, argumentTypes));
}
}
private Object[] getArguments(ExpressionState state) {
Object[] arguments = new Object[getChildCount()];
for (int i = 0; i < arguments.length; i++) {
// Make the root object the active context again for evaluating the parameter
// expressions
try {
state.pushActiveContextObject(state.getRootContextObject());
arguments[i] = this.children[i].getValueInternal(state).getValue();
}
finally {
state.popActiveContextObject();
}
}
return arguments;
}
private List<TypeDescriptor> getArgumentTypes(Object... arguments) {
List<TypeDescriptor> descriptors = new ArrayList<TypeDescriptor>(arguments.length);
for (Object argument : arguments) {
descriptors.add(TypeDescriptor.forObject(argument));
}
return Collections.unmodifiableList(descriptors);
}
private MethodExecutor getCachedExecutor(TypeDescriptor target,
List<TypeDescriptor> argumentTypes) {
if (this.cachedExecutor != null && this.cachedExecutor.isSuitable(target, argumentTypes)) {
return this.cachedExecutor.get();
}
this.cachedExecutor = null;
return null;
}
private MethodExecutor findAccessorForMethod(String name,
List<TypeDescriptor> argumentTypes, Object contextObject,
EvaluationContext evaluationContext) throws SpelEvaluationException {
List<MethodResolver> methodResolvers = evaluationContext.getMethodResolvers();
if (methodResolvers != null) {
for (MethodResolver methodResolver : methodResolvers) {
try {
MethodExecutor methodExecutor = methodResolver.resolve(
evaluationContext, contextObject, name, argumentTypes);
if (methodExecutor != null) {
return methodExecutor;
}
}
catch (AccessException ex) {
throw new SpelEvaluationException(getStartPosition(), ex,
SpelMessage.PROBLEM_LOCATING_METHOD, name,
contextObject.getClass());
}
}
}
throw new SpelEvaluationException(getStartPosition(), SpelMessage.METHOD_NOT_FOUND,
FormatHelper.formatMethodForMessage(name, argumentTypes),
FormatHelper.formatClassNameForMessage(
contextObject instanceof Class ? ((Class<?>) contextObject)
: contextObject.getClass()));
}
/** /**
* Decode the AccessException, throwing a lightweight evaluation exception or, if the cause was a RuntimeException, * Decode the AccessException, throwing a lightweight evaluation exception or, if the
* throw the RuntimeException directly. * cause was a RuntimeException, throw the RuntimeException directly.
*/ */
private void throwSimpleExceptionIfPossible(ExpressionState state, AccessException ae) { private void throwSimpleExceptionIfPossible(Object value, AccessException ae) {
if (ae.getCause() instanceof InvocationTargetException) { if (ae.getCause() instanceof InvocationTargetException) {
Throwable rootCause = ae.getCause().getCause(); Throwable rootCause = ae.getCause().getCause();
if (rootCause instanceof RuntimeException) { if (rootCause instanceof RuntimeException) {
@@ -165,19 +216,12 @@ public class MethodReference extends SpelNodeImpl {
} }
throw new ExpressionInvocationTargetException(getStartPosition(), throw new ExpressionInvocationTargetException(getStartPosition(),
"A problem occurred when trying to execute method '" + this.name + "A problem occurred when trying to execute method '" + this.name +
"' on object of type '" + state.getActiveContextObject().getValue().getClass().getName() + "'", "' on object of type '" +
value.getClass().getName() + "'",
rootCause); rootCause);
} }
} }
private List<TypeDescriptor> getTypes(Object... arguments) {
List<TypeDescriptor> descriptors = new ArrayList<TypeDescriptor>(arguments.length);
for (Object argument : arguments) {
descriptors.add(TypeDescriptor.forObject(argument));
}
return Collections.unmodifiableList(descriptors);
}
@Override @Override
public String toStringAST() { public String toStringAST() {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
@@ -192,117 +236,31 @@ public class MethodReference extends SpelNodeImpl {
return sb.toString(); return sb.toString();
} }
private MethodExecutor findAccessorForMethod(String name,
List<TypeDescriptor> argumentTypes, ExpressionState state)
throws SpelEvaluationException {
return findAccessorForMethod(name, argumentTypes,
state.getActiveContextObject().getValue(), state.getEvaluationContext());
}
private MethodExecutor findAccessorForMethod(String name,
List<TypeDescriptor> argumentTypes, Object contextObject, EvaluationContext eContext)
throws SpelEvaluationException {
List<MethodResolver> methodResolvers = eContext.getMethodResolvers();
if (methodResolvers != null) {
for (MethodResolver methodResolver : methodResolvers) {
try {
MethodExecutor methodExecutor = methodResolver.resolve(eContext,
contextObject, name, argumentTypes);
if (methodExecutor != null) {
return methodExecutor;
}
}
catch (AccessException ex) {
throw new SpelEvaluationException(getStartPosition(), ex,
SpelMessage.PROBLEM_LOCATING_METHOD, name,
contextObject.getClass());
}
}
}
throw new SpelEvaluationException(
getStartPosition(),
SpelMessage.METHOD_NOT_FOUND,
FormatHelper.formatMethodForMessage(name, argumentTypes),
FormatHelper.formatClassNameForMessage(contextObject instanceof Class ? ((Class<?>) contextObject)
: contextObject.getClass()));
}
private MethodExecutor getCachedExecutor(TypeDescriptor target,
List<TypeDescriptor> argumentTypes) {
if (this.cachedExecutor == null || !this.cachedExecutor.isSuitable(target, argumentTypes)) {
this.cachedExecutor = null;
return null;
}
return this.cachedExecutor.get();
}
private class MethodValueRef implements ValueRef { private class MethodValueRef implements ValueRef {
private final ExpressionState state;
private final EvaluationContext evaluationContext; private EvaluationContext evaluationContext;
private final Object target; private Object value;
private TypeDescriptor targetType; private TypeDescriptor targetType;
private final Object[] arguments; private Object[] arguments;
private List<TypeDescriptor> argumentTypes;
MethodValueRef(ExpressionState state, EvaluationContext evaluationContext, MethodValueRef(ExpressionState state) {
Object object, Object[] arguments) { this.evaluationContext = state.getEvaluationContext();
this.state = state; this.value = state.getActiveContextObject().getValue();
this.evaluationContext = evaluationContext; this.targetType = state.getActiveContextObject().getTypeDescriptor();
this.target = object; this.arguments = getArguments(state);
this.targetType = TypeDescriptor.valueOf(target.getClass());
this.arguments = arguments;
this.argumentTypes = getTypes(this.arguments);
} }
@Override @Override
public TypedValue getValue() { public TypedValue getValue() {
MethodExecutor executorToUse = getCachedExecutor(this.targetType, return MethodReference.this.getValueInternal(this.evaluationContext,
this.argumentTypes); this.value, this.arguments, this.targetType);
if (executorToUse != null) {
try {
return executorToUse.execute(this.evaluationContext, this.target, this.arguments);
}
catch (AccessException ae) {
// Two reasons this can occur:
// 1. the method invoked actually threw a real exception
// 2. the method invoked was not passed the arguments it expected and has become 'stale'
// In the first case we should not retry, in the second case we should see if there is a
// better suited method.
// To determine which situation it is, the AccessException will contain a cause.
// If the cause is an InvocationTargetException, a user exception was thrown inside the method.
// Otherwise the method could not be invoked.
throwSimpleExceptionIfPossible(this.state, ae);
// at this point we know it wasn't a user problem so worth a retry if a better candidate can be found
MethodReference.this.cachedExecutor = null;
}
}
// either there was no accessor or it no longer existed
executorToUse = findAccessorForMethod(MethodReference.this.name, argumentTypes, this.target, this.evaluationContext);
MethodReference.this.cachedExecutor = new CachedMethodExecutor(executorToUse, this.targetType, this.argumentTypes);
try {
return executorToUse.execute(this.evaluationContext, this.target, this.arguments);
}
catch (AccessException ex) {
// Same unwrapping exception handling as above in above catch block
throwSimpleExceptionIfPossible(this.state, ex);
throw new SpelEvaluationException(getStartPosition(), ex,
SpelMessage.EXCEPTION_DURING_METHOD_INVOCATION,
MethodReference.this.name, this.state.getActiveContextObject().getValue().getClass().getName(),
ex.getMessage());
}
} }
@Override @Override
@@ -316,6 +274,7 @@ public class MethodReference extends SpelNodeImpl {
} }
} }
private static class CachedMethodExecutor { private static class CachedMethodExecutor {
private final MethodExecutor methodExecutor; private final MethodExecutor methodExecutor;
@@ -324,6 +283,7 @@ public class MethodReference extends SpelNodeImpl {
private final List<TypeDescriptor> argumentTypes; private final List<TypeDescriptor> argumentTypes;
public CachedMethodExecutor(MethodExecutor methodExecutor, TypeDescriptor target, public CachedMethodExecutor(MethodExecutor methodExecutor, TypeDescriptor target,
List<TypeDescriptor> argumentTypes) { List<TypeDescriptor> argumentTypes) {
this.methodExecutor = methodExecutor; this.methodExecutor = methodExecutor;
@@ -331,7 +291,9 @@ public class MethodReference extends SpelNodeImpl {
this.argumentTypes = argumentTypes; this.argumentTypes = argumentTypes;
} }
public boolean isSuitable(TypeDescriptor target, List<TypeDescriptor> argumentTypes) {
public boolean isSuitable(TypeDescriptor target,
List<TypeDescriptor> argumentTypes) {
return (this.methodExecutor != null && this.target != null return (this.methodExecutor != null && this.target != null
&& this.target.equals(target) && this.argumentTypes.equals(argumentTypes)); && this.target.equals(target) && this.argumentTypes.equals(argumentTypes));
} }