Java StandardAnnotationMetadata类代码示例

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
private AnnotationRepositoryConfigurationSource getConfigurationSource(
    BeanDefinitionRegistry registry) {
  StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(
      getConfiguration(), true);
  return new MybatisAnnotationRepositoryConfigurationSource(metadata, getAnnotation(),
      resourceLoader, this.environment, registry) {
    @Override
    public String[] getMapperLocations() {
      return MybatisRepositoriesAutoConfigureRegistrar.this.getMapperLocations();
    }

    @Override
    public Iterable<String> getBasePackages() {
      return MybatisRepositoriesAutoConfigureRegistrar.this.getBasePackages();
    }
  };
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
@Test
public void testViewScopedClass() {
	GenericApplicationContext acx = new GenericApplicationContext();
	AnnotationConfigUtils.registerAnnotationConfigProcessors(acx);

	acx.registerBeanDefinition("viewScopedClass", new AnnotatedGenericBeanDefinition(
		new StandardAnnotationMetadata(ViewScopedClass.class)));
	acx.registerBeanDefinition("scopedBeansConfiguration", new RootBeanDefinition(
		ScopedBeansConfiguration.class));
	acx.addBeanFactoryPostProcessor(JsfScopeAnnotationsAutoConfiguration.jsfScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.addBeanFactoryPostProcessor(CdiScopeAnnotationsAutoConfiguration.cdiScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.refresh();

	assertThat(acx.getBeanDefinition("viewScopedClass").getScope())
		.isEqualTo(ViewScope.SCOPE_VIEW);
	assertThat(acx.getBeanDefinition("viewScopedBean").getScope())
		.isEqualTo(ViewScope.SCOPE_VIEW);
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
@Test
public void testSessionScopedClass() {
	GenericApplicationContext acx = new GenericApplicationContext();
	AnnotationConfigUtils.registerAnnotationConfigProcessors(acx);

	acx.registerBeanDefinition("sessionScopedClass", new AnnotatedGenericBeanDefinition(
		new StandardAnnotationMetadata(SessionScopedClass.class)));
	acx.registerBeanDefinition("scopedBeansConfiguration", new RootBeanDefinition(
		ScopedBeansConfiguration.class));
	acx.addBeanFactoryPostProcessor(JsfScopeAnnotationsAutoConfiguration.jsfScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.addBeanFactoryPostProcessor(CdiScopeAnnotationsAutoConfiguration.cdiScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.refresh();

	assertThat(acx.getBeanDefinition("sessionScopedClass").getScope())
		.isEqualTo(WebApplicationContext.SCOPE_SESSION);
	assertThat(acx.getBeanDefinition("sessionScopedBean").getScope())
		.isEqualTo(WebApplicationContext.SCOPE_SESSION);
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
@Test
public void testNoScopedClass() {
	GenericApplicationContext acx = new GenericApplicationContext();
	AnnotationConfigUtils.registerAnnotationConfigProcessors(acx);

	acx.registerBeanDefinition("noScopedClass", new AnnotatedGenericBeanDefinition(
		new StandardAnnotationMetadata(NoScopedClass.class)));
	acx.registerBeanDefinition("scopedBeansConfiguration", new RootBeanDefinition(
		ScopedBeansConfiguration.class));
	acx.addBeanFactoryPostProcessor(JsfScopeAnnotationsAutoConfiguration.jsfScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.addBeanFactoryPostProcessor(CdiScopeAnnotationsAutoConfiguration.cdiScopeAnnotationsConfigurer(acx.getEnvironment()));
	acx.refresh();

	assertThat(acx.getBeanDefinition("noScopedClass").getScope())
		.isEqualTo("");
	assertThat(acx.getBeanDefinition("noScopedBean").getScope())
		.isEqualTo("");

}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Register member (nested) classes that happen to be configuration classes themselves.
 * @param metadata the metadata representation of the containing class
 * @throws IOException if there is any problem reading metadata from a member class
 */
private void processMemberClasses(AnnotationMetadata metadata) throws IOException {
	if (metadata instanceof StandardAnnotationMetadata) {
		for (Class<?> memberClass : ((StandardAnnotationMetadata) metadata).getIntrospectedClass().getDeclaredClasses()) {
			if (ConfigurationClassUtils.isConfigurationCandidate(new StandardAnnotationMetadata(memberClass))) {
				processConfigurationClass(new ConfigurationClass(memberClass, true));
			}
		}
	}
	else {
		for (String memberClassName : metadata.getMemberClassNames()) {
			MetadataReader reader = this.metadataReaderFactory.getMetadataReader(memberClassName);
			AnnotationMetadata memberClassMetadata = reader.getAnnotationMetadata();
			if (ConfigurationClassUtils.isConfigurationCandidate(memberClassMetadata)) {
				processConfigurationClass(new ConfigurationClass(reader, true));
			}
		}
	}
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
public static boolean matches(ConditionContext context) {
	Class<AuthorizationServerEndpointsConfigurationBeanCondition> type = AuthorizationServerEndpointsConfigurationBeanCondition.class;
	Conditional conditional = AnnotationUtils.findAnnotation(type,
			Conditional.class);
	StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(type);
	for (Class<? extends Condition> conditionType : conditional.value()) {
		Condition condition = BeanUtils.instantiateClass(conditionType);
		if (condition.matches(context, metadata)) {
			return true;
		}
	}
	return false;
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Factory method to obtain a {@link SourceClass} from a {@link ConfigurationClass}.
 */
public SourceClass asSourceClass(ConfigurationClass configurationClass) throws IOException {
	try {
		AnnotationMetadata metadata = configurationClass.getMetadata();
		if (metadata instanceof StandardAnnotationMetadata) {
			return asSourceClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
		}
		return asSourceClass(configurationClass.getMetadata().getClassName());
	}
	catch (ClassNotFoundException ex) {
		throw new IllegalStateException(ex);
	}
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
public SourceClass(Object source) {
	this.source = source;
	if (source instanceof Class<?>) {
		this.metadata = new StandardAnnotationMetadata((Class<?>) source, true);
	}
	else {
		this.metadata = ((MetadataReader) source).getAnnotationMetadata();
	}
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Create a new AnnotatedGenericBeanDefinition for the given annotation metadata,
 * allowing for ASM-based processing and avoidance of early loading of the bean class.
 * Note that this constructor is functionally equivalent to
 * {@link org.springframework.context.annotation.ScannedGenericBeanDefinition
 * ScannedGenericBeanDefinition}, however the semantics of the latter indicate that a
 * bean was discovered specifically via component-scanning as opposed to other means.
 * @param metadata the annotation metadata for the bean class in question
 * @since 3.1.1
 */
public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata) {
	Assert.notNull(metadata, "AnnotationMetadata must not be null");
	if (metadata instanceof StandardAnnotationMetadata) {
		setBeanClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
	}
	else {
		setBeanClassName(metadata.getClassName());
	}
	this.metadata = metadata;
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Factory method to obtain a {@link SourceClass} from a {@link ConfigurationClass}.
 */
public SourceClass asSourceClass(ConfigurationClass configurationClass) throws IOException {
	AnnotationMetadata metadata = configurationClass.getMetadata();
	if (metadata instanceof StandardAnnotationMetadata) {
		return asSourceClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
	}
	return asSourceClass(configurationClass.getMetadata().getClassName());
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Create a new {@link ConfigurationClass} with the given name.
 * @param clazz the underlying {@link Class} to represent
 * @param beanName name of the {@code @Configuration} class bean
 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
 */
public ConfigurationClass(Class<?> clazz, String beanName) {
	Assert.hasText(beanName, "Bean name must not be null");
	this.metadata = new StandardAnnotationMetadata(clazz, true);
	this.resource = new DescriptiveResource(clazz.toString());
	this.beanName = beanName;
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
@Test
public void metadataFromImportsOneThenTwo() {
	AnnotationMetadata importMetadata = new AnnotationConfigApplicationContext(
			ConfigurationOne.class, ConfigurationTwo.class)
			.getBean(MetadataHolder.class).importMetadata;
	assertEquals(ConfigurationOne.class,
			((StandardAnnotationMetadata) importMetadata).getIntrospectedClass());
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
@Test
public void metadataFromImportsTwoThenOne() {
	AnnotationMetadata importMetadata = new AnnotationConfigApplicationContext(
			ConfigurationTwo.class, ConfigurationOne.class)
			.getBean(MetadataHolder.class).importMetadata;
	assertEquals(ConfigurationOne.class,
			((StandardAnnotationMetadata) importMetadata).getIntrospectedClass());
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
/**
 * Create a new {@link ConfigurationClass} with the given name.
 * @param clazz the underlying {@link Class} to represent
 * @param beanName name of the {@code @Configuration} class bean
 * @throws IllegalArgumentException if beanName is null (as of Spring 3.1.1)
 * @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
 */
public ConfigurationClass(Class<?> clazz, String beanName) {
	Assert.hasText(beanName, "Bean name must not be null");
	this.metadata = new StandardAnnotationMetadata(clazz, true);
	this.resource = new DescriptiveResource(clazz.toString());
	this.beanName = beanName;
	this.importedBy = null;
}
 

import org.springframework.core.type.StandardAnnotationMetadata; //导入依赖的package包/类
private AnnotationRepositoryConfigurationSource getConfigurationSource() {
	StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(
			getConfiguration(), true);
	return new AnnotationRepositoryConfigurationSource(metadata, getAnnotation(),
			this.resourceLoader, this.environment) {
		@Override
		public java.lang.Iterable<String> getBasePackages() {
			return AbstractRepositoryConfigurationSourceSupport.this
					.getBasePackages();
		}
	};
}