@Before
public void setup() {
	@SuppressWarnings("resource")
	GenericApplicationContext cxt = new GenericApplicationContext();
	cxt.refresh();
	this.resolver = new HeaderMethodArgumentResolver(new DefaultConversionService(), cxt.getBeanFactory());

	Method method = ReflectionUtils.findMethod(getClass(), "handleMessage", (Class<?>[]) null);
	this.paramRequired = new SynthesizingMethodParameter(method, 0);
	this.paramNamedDefaultValueStringHeader = new SynthesizingMethodParameter(method, 1);
	this.paramSystemPropertyDefaultValue = new SynthesizingMethodParameter(method, 2);
	this.paramSystemPropertyName = new SynthesizingMethodParameter(method, 3);
	this.paramNotAnnotated = new SynthesizingMethodParameter(method, 4);
	this.paramOptional = new SynthesizingMethodParameter(method, 5);
	this.paramNativeHeader = new SynthesizingMethodParameter(method, 6);

	this.paramRequired.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramRequired, HeaderMethodArgumentResolver.class);
}
 

/**
 * DefaultParameterNameDiscoverer is supported spring 4.0
 * @return
 */
private String[] getParameterNames(Method method) {
    if (notSupportParameterNameDiscoverer) {
        return null;
    } else {
        try {
            ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();// only support
            // from spring4
            String[] strs = parameterNameDiscoverer.getParameterNames(method);
            if (strs == null) {
                notSupportParameterNameDiscoverer = true;
            }
            return strs;
        } catch (NoClassDefFoundError e) {
            notSupportParameterNameDiscoverer = true;
            return null;
        }
    }
}
 

@Before
public void setup() throws Exception {
	@SuppressWarnings("resource")
	GenericApplicationContext cxt = new GenericApplicationContext();
	cxt.refresh();
	this.resolver = new HeaderMethodArgumentResolver(new DefaultConversionService(), cxt.getBeanFactory());

	Method method = getClass().getDeclaredMethod("handleMessage",
			String.class, String.class, String.class, String.class, String.class);
	this.paramRequired = new SynthesizingMethodParameter(method, 0);
	this.paramNamedDefaultValueStringHeader = new SynthesizingMethodParameter(method, 1);
	this.paramSystemProperty = new SynthesizingMethodParameter(method, 2);
	this.paramNotAnnotated = new SynthesizingMethodParameter(method, 3);
	this.paramNativeHeader = new SynthesizingMethodParameter(method, 4);

	this.paramRequired.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramRequired, HeaderMethodArgumentResolver.class);
}
 

/**
 * Create a ParameterNameDiscoverer to be used for argument binding.
 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
 */
protected ParameterNameDiscoverer createParameterNameDiscoverer() {
	// We need to discover them, or if that fails, guess,
	// and if we can't guess with 100% accuracy, fail.
	DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
	AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
			new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
	adviceParameterNameDiscoverer.setReturningName(this.returningName);
	adviceParameterNameDiscoverer.setThrowingName(this.throwingName);
	// Last in chain, so if we're called and we fail, that's bad...
	adviceParameterNameDiscoverer.setRaiseExceptions(true);
	discoverer.addDiscoverer(adviceParameterNameDiscoverer);
	return discoverer;
}
 

public static void addVerify(List<Verify> list, Method method, List<String> parmsType, List<String> parmsName, List<Object> verifyGroup) {
    // 校验组
    verifyGroup.addAll(Arrays.asList(method.getAnnotationsByType(Validation.class)[0].value()));
    // 设置参数名
    DefaultParameterNameDiscoverer defaultParameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    parmsName.addAll(Arrays.asList(defaultParameterNameDiscoverer.getParameterNames(method)));

    Parameter[] parameters = method.getParameters();
    for (int i = 0; i < parameters.length; i++) {
        parmsType.add(parameters[i].getType().getName());
        if (parameters[i].isAnnotationPresent(Verify.class)) list.add(i, parameters[i].getAnnotationsByType(Verify.class)[0]);
        else list.add(null);
    }
}
 

@Before
public void setup() throws Exception {
	this.resolver = new DestinationVariableMethodArgumentResolver(new DefaultConversionService());

	Method method = getClass().getDeclaredMethod("handleMessage", String.class, String.class, String.class);
	this.paramAnnotated = new MethodParameter(method, 0);
	this.paramAnnotatedValue = new MethodParameter(method, 1);
	this.paramNotAnnotated = new MethodParameter(method, 2);

	this.paramAnnotated.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramAnnotated, DestinationVariableMethodArgumentResolver.class);
	this.paramAnnotatedValue.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramAnnotatedValue, DestinationVariableMethodArgumentResolver.class);
}
 

/**
 * Create a ParameterNameDiscoverer to be used for argument binding.
 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
 */
protected ParameterNameDiscoverer createParameterNameDiscoverer() {
	// We need to discover them, or if that fails, guess,
	// and if we can't guess with 100% accuracy, fail.
	DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
	AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
			new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
	adviceParameterNameDiscoverer.setReturningName(this.returningName);
	adviceParameterNameDiscoverer.setThrowingName(this.throwingName);
	// Last in chain, so if we're called and we fail, that's bad...
	adviceParameterNameDiscoverer.setRaiseExceptions(true);
	discoverer.addDiscoverer(adviceParameterNameDiscoverer);
	return discoverer;
}
 

/**
 * Create a ParameterNameDiscoverer to be used for argument binding.
 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
 */
protected ParameterNameDiscoverer createParameterNameDiscoverer() {
	// We need to discover them, or if that fails, guess,
	// and if we can't guess with 100% accuracy, fail.
	DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
	AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
			new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
	adviceParameterNameDiscoverer.setReturningName(this.returningName);
	adviceParameterNameDiscoverer.setThrowingName(this.throwingName);
	// Last in chain, so if we're called and we fail, that's bad...
	adviceParameterNameDiscoverer.setRaiseExceptions(true);
	discoverer.addDiscoverer(adviceParameterNameDiscoverer);
	return discoverer;
}
 

@Before
public void setup() throws Exception {
	this.resolver = new DestinationVariableMethodArgumentResolver(new DefaultConversionService());

	Method method = getClass().getDeclaredMethod("handleMessage", String.class, String.class, String.class);
	this.paramAnnotated = new MethodParameter(method, 0);
	this.paramAnnotatedValue = new MethodParameter(method, 1);
	this.paramNotAnnotated = new MethodParameter(method, 2);

	this.paramAnnotated.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramAnnotated, DestinationVariableMethodArgumentResolver.class);
	this.paramAnnotatedValue.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(this.paramAnnotatedValue, DestinationVariableMethodArgumentResolver.class);
}
 

/**
 * Create a ParameterNameDiscoverer to be used for argument binding.
 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
 */
protected ParameterNameDiscoverer createParameterNameDiscoverer() {
	// We need to discover them, or if that fails, guess,
	// and if we can't guess with 100% accuracy, fail.
	DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
	AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
			new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
	adviceParameterNameDiscoverer.setReturningName(this.returningName);
	adviceParameterNameDiscoverer.setThrowingName(this.throwingName);
	// Last in chain, so if we're called and we fail, that's bad...
	adviceParameterNameDiscoverer.setRaiseExceptions(true);
	discoverer.addDiscoverer(adviceParameterNameDiscoverer);
	return discoverer;
}
 

private MethodParameter initMethodParameter(int parameterIndex) {
	MethodParameter param = new SynthesizingMethodParameter(this.handleMethod, parameterIndex);
	param.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(param, this.resolver.getClass());
	return param;
}
 

private MethodParameter initMethodParameter(int parameterIndex) {
	MethodParameter param = new SynthesizingMethodParameter(this.handleMethod, parameterIndex);
	param.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(param, this.resolver.getClass());
	return param;
}
 

@Bean
public ParameterNameDiscoverer parameterNameDiscoverer() {
    return new DefaultParameterNameDiscoverer();
}
 

private MethodParameter initMethodParameter(int parameterIndex) {
	MethodParameter param = new SynthesizingMethodParameter(this.handleMethod, parameterIndex);
	param.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(param, this.resolver.getClass());
	return param;
}
 

private MethodParameter initMethodParameter(int parameterIndex) {
	MethodParameter param = new SynthesizingMethodParameter(this.handleMethod, parameterIndex);
	param.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
	GenericTypeResolver.resolveParameterType(param, this.resolver.getClass());
	return param;
}
 

private void initParameters(HandlerMethod handlerMethod) {
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
    }
}
 

private void initParameters(HandlerMethod handlerMethod) {
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
    }
}
 

private void initParameters(HandlerMethod handlerMethod) {
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
    }
}
 

/**
 * To maximize the caching feature in name discoverer, inject as a bean instead of creating every time.
 */
@Bean
public ParameterNameDiscoverer parameterNameDiscoverer() {
	return new DefaultParameterNameDiscoverer();
}
 

public ReflectionAdapterImpl() {
    this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    this.cacheBeans = new ConcurrentHashMap<>();
    this.cacheMethods = new ConcurrentHashMap<>();
    this.cacheParamNames = new ConcurrentHashMap<>();
}