import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
private MethodExecutor getCachedExecutor(EvaluationContext evaluationContext, Object value,
		TypeDescriptor target, List<TypeDescriptor> argumentTypes) {

	List<MethodResolver> methodResolvers = evaluationContext.getMethodResolvers();
	if (methodResolvers == null || methodResolvers.size() != 1 ||
			!(methodResolvers.get(0) instanceof ReflectiveMethodResolver)) {
		// Not a default ReflectiveMethodResolver - don't know whether caching is valid
		return null;
	}

	CachedMethodExecutor executorToCheck = this.cachedExecutor;
	if (executorToCheck != null && executorToCheck.isSuitable(value, target, argumentTypes)) {
		return executorToCheck.get();
	}
	this.cachedExecutor = null;
	return null;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
private MethodExecutor findAccessorForMethod(String name, List<TypeDescriptor> argumentTypes,
		Object targetObject, EvaluationContext evaluationContext) throws SpelEvaluationException {

	List<MethodResolver> methodResolvers = evaluationContext.getMethodResolvers();
	if (methodResolvers != null) {
		for (MethodResolver methodResolver : methodResolvers) {
			try {
				MethodExecutor methodExecutor = methodResolver.resolve(
						evaluationContext, targetObject, name, argumentTypes);
				if (methodExecutor != null) {
					return methodExecutor;
				}
			}
			catch (AccessException ex) {
				throw new SpelEvaluationException(getStartPosition(), ex,
						SpelMessage.PROBLEM_LOCATING_METHOD, name, targetObject.getClass());
			}
		}
	}

	throw new SpelEvaluationException(getStartPosition(), SpelMessage.METHOD_NOT_FOUND,
			FormatHelper.formatMethodForMessage(name, argumentTypes),
			FormatHelper.formatClassNameForMessage(
					targetObject instanceof Class ? ((Class<?>) targetObject) : targetObject.getClass()));
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
/**
 * Test whether {@link ReflectiveMethodResolver} handles Widening Primitive Conversion. That's passing an 'int' to a
 * method accepting 'long' is ok.
 */
@Test
public void wideningPrimitiveConversion_8224() throws Exception {

	class WideningPrimitiveConversion {
		public int getX(long i) {
			return 10;
		}
	}

	final Integer INTEGER_VALUE = Integer.valueOf(7);
	WideningPrimitiveConversion target = new WideningPrimitiveConversion();
	EvaluationContext emptyEvalContext = new StandardEvaluationContext();

	List<TypeDescriptor> args = new ArrayList<TypeDescriptor>();
	args.add(TypeDescriptor.forObject(INTEGER_VALUE));

	MethodExecutor me = new ReflectiveMethodResolver(true).resolve(emptyEvalContext, target, "getX", args);
	final int actual = (Integer) me.execute(emptyEvalContext, target, INTEGER_VALUE).getValue();

	final int compiler = target.getX(INTEGER_VALUE);
	assertEquals(compiler, actual);
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Ignore @Test
public void repro() throws Exception {
	AlwaysTrueReleaseStrategy target = new AlwaysTrueReleaseStrategy();
	BeanFactoryTypeConverter converter = new BeanFactoryTypeConverter();

	StandardEvaluationContext context = new StandardEvaluationContext();
	context.setTypeConverter(converter);

	List<Foo> arguments = new ArrayList<Foo>();

	// !!!! With the below line commented you'll get NPE. Uncomment and everything is OK!
	//arguments.add(new Foo());

	List<TypeDescriptor> paramDescriptors = new ArrayList<TypeDescriptor>();
	Method method = AlwaysTrueReleaseStrategy.class.getMethod("checkCompleteness", List.class);
	paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, 0)));


	List<TypeDescriptor> argumentTypes = new ArrayList<TypeDescriptor>();
	argumentTypes.add(TypeDescriptor.forObject(arguments));
	ReflectiveMethodResolver resolver = new ReflectiveMethodResolver();
	MethodExecutor executor = resolver.resolve(context, target, "checkCompleteness", argumentTypes);

	Object result = executor.execute(context, target, arguments);
	System.out.println("Result: " + result);
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
public CachedMethodExecutor(MethodExecutor methodExecutor, Class<?> staticClass,
		TypeDescriptor target, List<TypeDescriptor> argumentTypes) {
	this.methodExecutor = methodExecutor;
	this.staticClass = staticClass;
	this.target = target;
	this.argumentTypes = argumentTypes;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Override
public MethodExecutor resolve(
	EvaluationContext context,
	Object targetObject,
	String name,
	List<TypeDescriptor> argumentTypes
) throws AccessException {
	return Martini.class.isInstance(targetObject) ? resolve(name, argumentTypes) : null;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Override
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> arguments)
		throws AccessException {
	if (name.equals("hasRole")) {
		return new HasRoleExecutor(context.getTypeConverter());
	}
	return null;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
private MethodExecutor range () {
  return (ctx,target,args) -> {
    List<Integer> value = IntStream.rangeClosed((int)args[0], (int)args[1])
                                   .boxed()
                                   .collect(Collectors.toList());
    return new TypedValue(value);
  };
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
		List<TypeDescriptor> argumentTypes) throws AccessException {
	if (targetObject instanceof SecurityExpressionRoot) {
		if ("oauthConsumerHasRole".equals(name) || "oauthConsumerHasAnyRole".equals(name)) {
			return new OAuthClientRoleExecutor();
		} else if ("denyOAuthConsumer".equals(name)) {
			return new DenyOAuthClientRoleExecutor();
		}
	}

	return null;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
private TypedValue getValueInternal(EvaluationContext evaluationContext,
		Object value, TypeDescriptor targetType, Object[] arguments) {

	List<TypeDescriptor> argumentTypes = getArgumentTypes(arguments);
	if (value == null) {
		throwIfNotNullSafe(argumentTypes);
		return TypedValue.NULL;
	}

	MethodExecutor executorToUse = getCachedExecutor(evaluationContext, value, targetType, argumentTypes);
	if (executorToUse != null) {
		try {
			return executorToUse.execute(evaluationContext, value, 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 the situation, 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(value, ae);

			// 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;
		}
	}

	// either there was no accessor or it no longer existed
	executorToUse = findAccessorForMethod(this.name, argumentTypes, value, evaluationContext);
	this.cachedExecutor = new CachedMethodExecutor(
			executorToUse, (value instanceof Class ? (Class<?>) value : null), targetType, argumentTypes);
	try {
		return executorToUse.execute(evaluationContext, value, arguments);
	}
	catch (AccessException ex) {
		// Same unwrapping exception handling as above in above catch block
		throwSimpleExceptionIfPossible(value, ex);
		throw new SpelEvaluationException(getStartPosition(), ex,
				SpelMessage.EXCEPTION_DURING_METHOD_INVOCATION, this.name,
				value.getClass().getName(), ex.getMessage());
	}
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
public MethodExecutor get() {
	return this.methodExecutor;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Override
public MethodExecutor resolve(EvaluationContext context,
		Object targetObject, String name,
		List<TypeDescriptor> argumentTypes) throws AccessException {
	return null;
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Override
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
		List<TypeDescriptor> argumentTypes) throws AccessException {
	throw new UnsupportedOperationException();
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Test
public void varargsAndPrimitives_SPR8174() throws Exception {
	EvaluationContext emptyEvalContext = new StandardEvaluationContext();
	List<TypeDescriptor> args = new ArrayList<TypeDescriptor>();

	args.add(TypeDescriptor.forObject(34L));
	ReflectionUtil<Integer> ru = new ReflectionUtil<Integer>();
	MethodExecutor me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "methodToCall", args);

	args.set(0, TypeDescriptor.forObject(23));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, 45);

	args.set(0, TypeDescriptor.forObject(23f));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, 45f);

	args.set(0, TypeDescriptor.forObject(23d));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, 23d);

	args.set(0, TypeDescriptor.forObject((short) 23));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, (short) 23);

	args.set(0, TypeDescriptor.forObject(23L));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, 23L);

	args.set(0, TypeDescriptor.forObject((char) 65));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, (char) 65);

	args.set(0, TypeDescriptor.forObject((byte) 23));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, (byte) 23);

	args.set(0, TypeDescriptor.forObject(true));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "foo", args);
	me.execute(emptyEvalContext, ru, true);

	// trickier:
	args.set(0, TypeDescriptor.forObject(12));
	args.add(TypeDescriptor.forObject(23f));
	me = new ReflectiveMethodResolver().resolve(emptyEvalContext, ru, "bar", args);
	me.execute(emptyEvalContext, ru, 12, 23f);
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
private <T> MethodExecutor cast(Class<T> type) {
  return (ctx,target,args) -> {
    T value = type.cast(ConvertUtils.convert(args[0], type));
    return new TypedValue(value);
  };
}
 

import org.springframework.expression.MethodExecutor; //导入依赖的package包/类
@Override
public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
		List<TypeDescriptor> argumentTypes) throws AccessException {
	throw new UnsupportedOperationException("Auto-generated method stub");
}