import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private Method findFactoryMethod(String beanName) {
    if (!this.beans.containsKey(beanName)) {
        return null;
    }
    final AtomicReference<Method> found = new AtomicReference<Method>(null);
    MetaData meta = this.beans.get(beanName);
    final String factory = meta.getMethod();
    Class<?> type = this.beanFactory.getType(meta.getBean());
    ReflectionUtils.doWithMethods(type, new MethodCallback() {
        @Override
        public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
            if (method.getName().equals(factory)) {
                found.compareAndSet(null, method);
            }
        }
    });
    return found.get();
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private Method findFactoryMethod(String beanName) {
	if (!this.beans.containsKey(beanName)) {
		return null;
	}
	final AtomicReference<Method> found = new AtomicReference<Method>(null);
	MetaData meta = this.beans.get(beanName);
	final String factory = meta.getMethod();
	Class<?> type = this.beanFactory.getType(meta.getBean());
	ReflectionUtils.doWithMethods(type, new MethodCallback() {
		@Override
		public void doWith(Method method)
				throws IllegalArgumentException, IllegalAccessException {
			if (method.getName().equals(factory)) {
				found.compareAndSet(null, method);
			}
		}
	});
	return found.get();
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private void addDeducedBeanTypeForBeanMethod(ConditionContext context,
		AnnotatedTypeMetadata metadata, final List<String> beanTypes,
		final MethodMetadata methodMetadata) {
	try {
		// We should be safe to load at this point since we are in the
		// REGISTER_BEAN phase
		Class<?> configClass = ClassUtils.forName(
				methodMetadata.getDeclaringClassName(), context.getClassLoader());
		ReflectionUtils.doWithMethods(configClass, new MethodCallback() {
			@Override
			public void doWith(Method method)
					throws IllegalArgumentException, IllegalAccessException {
				if (methodMetadata.getMethodName().equals(method.getName())) {
					beanTypes.add(method.getReturnType().getName());
				}
			}
		});
	}
	catch (Throwable ex) {
		throw new BeanTypeDeductionException(
				methodMetadata.getDeclaringClassName(),
				methodMetadata.getMethodName(), ex);
	}
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
public DynamoDBHashAndRangeKeyExtractingEntityMetadataImpl(final Class<T> domainType) {
	super(domainType);
	this.hashAndRangeKeyMethodExtractor = new DynamoDBHashAndRangeKeyMethodExtractorImpl<T>(getJavaType());
	ReflectionUtils.doWithMethods(domainType, new MethodCallback() {
		public void doWith(Method method) {
			if (method.getAnnotation(DynamoDBHashKey.class) != null) {
				String setterMethodName = toSetterMethodNameFromAccessorMethod(method);
				if (setterMethodName != null) {
					hashKeySetterMethod = ReflectionUtils.findMethod(domainType, setterMethodName, method.getReturnType());
				}
			}
		}
	});
	ReflectionUtils.doWithFields(domainType, new FieldCallback() {
		public void doWith(Field field) {
			if (field.getAnnotation(DynamoDBHashKey.class) != null) {
				
				hashKeyField = ReflectionUtils.findField(domainType, field.getName());
				
			}
		}
	});
	Assert.isTrue(hashKeySetterMethod != null || hashKeyField != null, "Unable to find hash key field or setter method on " + domainType + "!");
	Assert.isTrue(hashKeySetterMethod == null || hashKeyField == null, "Found both hash key field and setter method on " + domainType + "!");

}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(final Object bean, String beanName) {
	Class<?> targetClass = AopUtils.getTargetClass(bean);
	ReflectionUtils.doWithMethods(targetClass, new MethodCallback() {
		@Override
		public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
			for (Scheduled scheduled : AnnotationUtils.getRepeatableAnnotation(method, Schedules.class, Scheduled.class)) {
				processScheduled(scheduled, method, bean);
			}
		}
	});
	return bean;
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private Map<Integer, Set<Interceptor>> getInterceptors0(final Object bean, final Class<? extends Annotation> annotationClass) {
	final Map<Integer, Set<Interceptor>> interceptorMap = Maps.newTreeMap();

	ReflectionUtils.doWithMethods(bean.getClass(), new MethodCallback() {
		private Set<Class<? extends Annotation>> getAnnotations(Class<? extends Annotation>[] annotations) {
			if (ArrayUtils.isEmpty(annotations)) {
				return null;
			}

			Set<Class<? extends Annotation>> set = Sets.newLinkedHashSetWithExpectedSize(annotations.length);
			Collections.addAll(set, annotations);
			return set;
		}

		@Override
		@SuppressWarnings("unchecked")
		public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
			Annotation annotation = method.getAnnotation(annotationClass);
			Map<String, Object> annotationAttributes = AnnotationUtils.getAnnotationAttributes(annotation);

			int priority = MapUtils.getIntValue(annotationAttributes, "priority", 0);
			Set<Class<? extends Annotation>> only = getAnnotations((Class<? extends Annotation>[]) annotationAttributes.get("only"));
			Set<Class<? extends Annotation>> unless = getAnnotations((Class<? extends Annotation>[]) annotationAttributes.get("unless"));

			Set<Interceptor> interceptors = interceptorMap.get(priority);

			if (interceptors == null) {
				interceptors = Sets.newLinkedHashSet();
			}

			interceptors.add(new Interceptor(bean, method, only, unless));
			interceptorMap.put(priority, interceptors);
		}
	}, method -> method.isAnnotationPresent(annotationClass));

	return interceptorMap;
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private void assertHasNoBeanMethods(Class<?> testClass) {
	ReflectionUtils.doWithMethods(testClass, new MethodCallback() {

		@Override
		public void doWith(Method method) {
			Assert.state(!AnnotatedElementUtils.isAnnotated(method, Bean.class),
					"Test classes cannot include @Bean methods");
		}

	});

}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
private void addDeducedBeanTypeForBeanMethod(ConditionContext context,
		AnnotatedTypeMetadata metadata, final List<String> beanTypes,
		final MethodMetadata methodMetadata) {
	try {
		// We should be safe to load at this point since we are in the
		// REGISTER_BEAN phase
		Class<?> configClass = ClassUtils.forName(
				methodMetadata.getDeclaringClassName(), context.getClassLoader());
		ReflectionUtils.doWithMethods(configClass, new MethodCallback() {
			@Override
			public void doWith(Method method)
					throws IllegalArgumentException, IllegalAccessException {
				if (methodMetadata.getMethodName().equals(method.getName())) {
					beanTypes.add(method.getReturnType().getName());
				}
			}
		});
	}
	catch (Throwable ex) {
		// swallow exception and continue
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to deduce bean type for "
					+ methodMetadata.getDeclaringClassName() + "."
					+ methodMetadata.getMethodName(), ex);
		}
	}
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
@Override
public Set<String> getIndexRangeKeyPropertyNames() {
	final Set<String> propertyNames = new HashSet<String>();
	ReflectionUtils.doWithMethods(getJavaType(), new MethodCallback() {
		public void doWith(Method method) {
			if (method.getAnnotation(DynamoDBIndexRangeKey.class) != null) {
				if ((method.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexName() != null && method
						.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexName().trim().length() > 0)
						|| (method.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexNames() != null && method
								.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexNames().length > 0)) {
					propertyNames.add(getPropertyNameForAccessorMethod(method));
				}
			}
		}
	});
	ReflectionUtils.doWithFields(getJavaType(), new FieldCallback() {
		public void doWith(Field field) {
			if (field.getAnnotation(DynamoDBIndexRangeKey.class) != null) {
				if ((field.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexName() != null && field
						.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexName().trim().length() > 0)
						|| (field.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexNames() != null && field
								.getAnnotation(DynamoDBIndexRangeKey.class).localSecondaryIndexNames().length > 0)) {
					propertyNames.add(getPropertyNameForField(field));
				}
			}
		}
	});
	return propertyNames;
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
/**
 * Creates a new {@link FieldAndGetterReflectionEntityInformation} inspecting the
 * given domain class for a getter carrying the given annotation.
 * 
 * @param domainClass
 *            must not be {@literal null}.
 * @param annotation
 *            must not be {@literal null}.
 */
public FieldAndGetterReflectionEntityInformation(Class<T> domainClass, final Class<? extends Annotation> annotation) {

	super(domainClass);
	Assert.notNull(annotation);

	ReflectionUtils.doWithMethods(domainClass, new MethodCallback() {
		public void doWith(Method method) {
			if (method.getAnnotation(annotation) != null) {
				FieldAndGetterReflectionEntityInformation.this.method = method;
				return;
			}
		}
	});
	
	if (method == null)
	{
		ReflectionUtils.doWithFields(domainClass, new FieldCallback() {
			public void doWith(Field field) {
				if (field.getAnnotation(annotation) != null) {
					FieldAndGetterReflectionEntityInformation.this.field = field;
					return;
				}
			}
		});
	}

	Assert.isTrue(this.method != null || this.field != null, String.format("No field or method annotated with %s found!", annotation.toString()));
	Assert.isTrue(this.method == null || this.field == null, String.format("Both field and method annotated with %s found!", annotation.toString()));

	if (method != null)
	{
		ReflectionUtils.makeAccessible(method);
	}
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
/**
 * Find annotated elements on types
 * @param ann annotation to search
 * @param clazz class to search on.
 * @return List with annotated elements
 */
public static List<AnnotatedElement> findAnnotatedElements(final Class<? extends Annotation> annotationType, Class<?> clazz) {
	final ArrayList<AnnotatedElement> elements = new ArrayList<AnnotatedElement>();
	// Lookup fields
	ReflectionUtils.doWithFields(clazz, new FieldCallback() {
		
		@Override
		public void doWith(Field field) throws IllegalArgumentException,
				IllegalAccessException {
			if (field.getAnnotation(annotationType) != null) {
				elements.add(field);
			}
			
		}
	});
	// Lookup methods
	ReflectionUtils.doWithMethods(clazz, new MethodCallback() {
		
		@Override
		public void doWith(Method method) throws IllegalArgumentException,
				IllegalAccessException {
			
			if (org.springframework.core.annotation.AnnotationUtils.getAnnotation(method, annotationType) != null)
				elements.add(method);
		}
	});
	
	return elements;
}
 

import org.springframework.util.ReflectionUtils.MethodCallback; //导入依赖的package包/类
@Test
public void restOperationsAreAvailable() throws Exception {
	RestTemplate delegate = mock(RestTemplate.class);
	final TestRestTemplate restTemplate = new TestRestTemplate(delegate);
	ReflectionUtils.doWithMethods(RestOperations.class, new MethodCallback() {

		@Override
		public void doWith(Method method)
				throws IllegalArgumentException, IllegalAccessException {
			Method equivalent = ReflectionUtils.findMethod(TestRestTemplate.class,
					method.getName(), method.getParameterTypes());
			try {
				equivalent.invoke(restTemplate,
						mockArguments(method.getParameterTypes()));
			}
			catch (Exception ex) {
				throw new IllegalStateException(ex);
			}
		}

		private Object[] mockArguments(Class<?>[] parameterTypes) throws Exception {
			Object[] arguments = new Object[parameterTypes.length];
			for (int i = 0; i < parameterTypes.length; i++) {
				arguments[i] = mockArgument(parameterTypes[i]);
			}
			return arguments;
		}

		private Object mockArgument(Class<?> type) throws Exception {
			if (String.class.equals(type)) {
				return "String";
			}
			if (Object[].class.equals(type)) {
				return new Object[0];
			}
			if (URI.class.equals(type)) {
				return new URI("http://localhost");
			}
			if (HttpMethod.class.equals(type)) {
				return HttpMethod.GET;
			}
			if (Class.class.equals(type)) {
				return Object.class;
			}
			return mock(type);
		}

	});

}