Java MethodMetadata.getDeclaringClassName方法代码示例

import org.springframework.core.type.MethodMetadata; //导入方法依赖的package包/类
private static <T> boolean hasCustomBeanDefinition(
		ConfigurableListableBeanFactory beanFactory, Class<T> type,
		Class<?> configClass) {
	String[] names = beanFactory.getBeanNamesForType(type, true, false);
	if (names == null || names.length != 1) {
		return false;
	}
	BeanDefinition definition = beanFactory.getBeanDefinition(names[0]);
	if (definition instanceof AnnotatedBeanDefinition) {
		MethodMetadata factoryMethodMetadata = ((AnnotatedBeanDefinition) definition)
				.getFactoryMethodMetadata();
		if (factoryMethodMetadata != null) {
			String className = factoryMethodMetadata.getDeclaringClassName();
			return !configClass.getName().equals(className);
		}
	}
	return true;
}
 

import org.springframework.core.type.MethodMetadata; //导入方法依赖的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.core.type.MethodMetadata; //导入方法依赖的package包/类
private void addDeducedBeanTypeForBeanMethod(ConditionContext context,
                                             MethodMetadata metadata, final List<String> beanTypes) {
    try {
        // We should be safe to load at this point since we are in the
        // REGISTER_BEAN phase
        Class<?> returnType = ClassUtils.forName(metadata.getReturnTypeName(), context.getClassLoader());
        beanTypes.add(returnType.getName());
    } catch (Throwable ex) {
        throw new BeanTypeDeductionException(metadata.getDeclaringClassName(), metadata.getMethodName(), ex);
    }
}
 

import org.springframework.core.type.MethodMetadata; //导入方法依赖的package包/类
private void addDeducedBeanTypeForBeanMethod(ConditionContext context,
		MethodMetadata metadata, final List<String> beanTypes) {
	try {
		// We should be safe to load at this point since we are in the
		// REGISTER_BEAN phase
		Class<?> returnType = ClassUtils.forName(metadata.getReturnTypeName(),
				context.getClassLoader());
		beanTypes.add(returnType.getName());
	}
	catch (Throwable ex) {
		throw new BeanTypeDeductionException(metadata.getDeclaringClassName(),
				metadata.getMethodName(), ex);
	}
}
 

import org.springframework.core.type.MethodMetadata; //导入方法依赖的package包/类
private String getName(AnnotatedTypeMetadata metadata) {
	if (metadata instanceof AnnotationMetadata) {
		return ((AnnotationMetadata) metadata).getClassName();
	}
	if (metadata instanceof MethodMetadata) {
		MethodMetadata methodMetadata = (MethodMetadata) metadata;
		return methodMetadata.getDeclaringClassName() + "."
				+ methodMetadata.getMethodName();
	}
	return metadata.toString();
}
 

import org.springframework.core.type.MethodMetadata; //导入方法依赖的package包/类
private static String getClassOrMethodName(AnnotatedTypeMetadata metadata) {
	if (metadata instanceof ClassMetadata) {
		ClassMetadata classMetadata = (ClassMetadata) metadata;
		return classMetadata.getClassName();
	}
	MethodMetadata methodMetadata = (MethodMetadata) metadata;
	return methodMetadata.getDeclaringClassName() + "#"
			+ methodMetadata.getMethodName();
}
 

import org.springframework.core.type.MethodMetadata; //导入方法依赖的package包/类
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
    try {
        Class<?> beanClazz = null;
        String beanClassName = beanDefinition.getBeanClassName();

        // Fix for @Bean annotations in @Configuration will return a "null" beanClassName. This
        // finds the class anyway:
        if (beanClassName == null && beanDefinition instanceof AnnotatedBeanDefinition) {
            MethodMetadata factoryMethodMetadata =
                    ((AnnotatedBeanDefinition) beanDefinition).getFactoryMethodMetadata();
            if (factoryMethodMetadata instanceof StandardMethodMetadata) {
                StandardMethodMetadata methodMetaData = (StandardMethodMetadata) factoryMethodMetadata;
                beanClazz = methodMetaData.getIntrospectedMethod().getReturnType();
            } else {
                // Try to find the method directly from the defining class/method
                String declaringClassName = factoryMethodMetadata.getDeclaringClassName();
                Class<?> factoryClazz = Class.forName(declaringClassName);

                // Note that MethodMetadata does not give us the exact method, we have to loop through to find
                // one which matches the name -- this is not optimal. But it should not matter much, the only thing
                // which may trip this up is having two classes with same name but different return values which is
                // not something we would expect in (sane) @Configuration classes.
                for (Method m : factoryClazz.getDeclaredMethods()) {
                    if (factoryMethodMetadata.getMethodName().equals(m.getName())) {
                        beanClazz = m.getReturnType();
                    }
                }
            }
        }

        if (beanClassName != null) {
            beanClazz = Class.forName(beanClassName);
        }
        if (beanClazz != null && isBeanRejected(beanName, beanClazz)) {
            log.info("Rejected bean [{}] with definiton [{}]", beanName, beanDefinition);
        } else {
            if (beanClazz == null) {
                log.warn("Unable to find beanclass for bean [{}] with definition [{}]", beanName, beanDefinition);
            }
            if (remockConfig.getEagerBeanClasses().contains(beanClazz)
                    || remockConfig.getEagerBeanNames().contains(beanName)) {
                beanDefinition.setLazyInit(false);
            } else if (!remockConfig.disableLazyInit()) {
                beanDefinition.setLazyInit(true);
            }
            super.registerBeanDefinition(beanName, beanDefinition);
        }
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
}