Java AnnotationAttributes.getClassArray方法代码示例

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
    AnnotationAttributes attributes = AnnotationAttributes
            .fromMap(metadata.getAnnotationAttributes(ServletComponentScan.class.getName()));
    String[] value = attributes.getStringArray("value");
    String[] basePackages = attributes.getStringArray("basePackages");
    Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
    if (!ObjectUtils.isEmpty(value)) {
        Assert.state(ObjectUtils.isEmpty(basePackages),
                "@ServletComponentScan basePackages and value attributes are" + " mutually exclusive");
    }
    Set<String> packagesToScan = new LinkedHashSet<String>();
    packagesToScan.addAll(Arrays.asList(value));
    packagesToScan.addAll(Arrays.asList(basePackages));
    for (Class<?> basePackageClass : basePackageClasses) {
        packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
    }
    if (packagesToScan.isEmpty()) {
        return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
    }
    return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(
			metadata.getAnnotationAttributes(ServletComponentScan.class.getName()));
	String[] basePackages = attributes.getStringArray("basePackages");
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	Set<String> packagesToScan = new LinkedHashSet<String>();
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	if (packagesToScan.isEmpty()) {
		return Collections
				.singleton(ClassUtils.getPackageName(metadata.getClassName()));
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = AnnotationAttributes
			.fromMap(metadata.getAnnotationAttributes(EntityScan.class.getName()));
	String[] basePackages = attributes.getAliasedStringArray("basePackages",
			EntityScan.class, metadata.getClassName());
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	Set<String> packagesToScan = new LinkedHashSet<String>();
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	if (packagesToScan.isEmpty()) {
		return Collections
				.singleton(ClassUtils.getPackageName(metadata.getClassName()));
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(
			metadata.getAnnotationAttributes(EntityScan.class.getName()));
	String[] basePackages = attributes.getStringArray("basePackages");
	Class<?>[] basePackageClasses = attributes
			.getClassArray("basePackageClasses");
	Set<String> packagesToScan = new LinkedHashSet<String>();
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	if (packagesToScan.isEmpty()) {
		String packageName = ClassUtils.getPackageName(metadata.getClassName());
		Assert.state(!StringUtils.isEmpty(packageName),
				"@EntityScan cannot be used with the default package");
		return Collections.singleton(packageName);
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
public static String[] getBasePackages(AnnotationAttributes attributes, String[] defaultPackages) {
	
	String[] value = attributes.getStringArray("value");
	String[] basePackages = attributes.getStringArray(BASE_PACKAGES);
	Class<?>[] basePackageClasses = attributes.getClassArray(BASE_PACKAGE_CLASSES);

	// Default configuration - return package of annotated class
	if (value.length == 0 && basePackages.length == 0 && basePackageClasses.length == 0) {
		return defaultPackages;
	}

	Set<String> packages = new HashSet<String>();
	packages.addAll(Arrays.asList(value));
	packages.addAll(Arrays.asList(basePackages));

	for (Class<?> typeName : basePackageClasses) {
		packages.add(ClassUtils.getPackageName(typeName));
	}

	return packages.toArray(new String[] {});
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(
			metadata.getAnnotationAttributes(ServletComponentScan.class.getName()));
	String[] value = attributes.getStringArray("value");
	String[] basePackages = attributes.getStringArray("basePackages");
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	if (!ObjectUtils.isEmpty(value)) {
		Assert.state(ObjectUtils.isEmpty(basePackages),
				"@ServletComponentScan basePackages and value attributes are"
						+ " mutually exclusive");
	}
	Set<String> packagesToScan = new LinkedHashSet<String>();
	packagesToScan.addAll(Arrays.asList(value));
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	if (packagesToScan.isEmpty()) {
		return Collections
				.singleton(ClassUtils.getPackageName(metadata.getClassName()));
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
protected Set<String> getPackagesToScan(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = AnnotationAttributes
			.fromMap(metadata.getAnnotationAttributes(this.annotationType.getName()));
	String[] value = attributes.getStringArray("value");
	String[] basePackages = attributes.getStringArray("basePackages");
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	if (!ObjectUtils.isEmpty(value)) {
		Assert.state(ObjectUtils.isEmpty(basePackages),
				String.format(
						"@%s basePackages and value attributes are mutually exclusive",
						this.annotationType.getSimpleName()));
	}
	Set<String> packagesToScan = new LinkedHashSet<String>();
	packagesToScan.addAll(Arrays.asList(value));
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	if (packagesToScan.isEmpty()) {
		return Collections
				.singleton(ClassUtils.getPackageName(metadata.getClassName()));
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
public AbstractTemplateProvider(AnnotationAttributes attributes) {
    Assert.notNull(attributes, "AnnotationAttributes must not be null!");
    this.excludeClasses = attributes.getClassArray(getExcludeClasses());
    this.postfix = attributes.getString(getPostfix());
    this.debug = attributes.getBoolean("debug");
    this.overwrite = attributes.getBoolean("overwrite");
    if (excludeClasses.length > 0 && debug) {
        SDLogger.debug(String.format("Exclude %s %s in the %s generator", excludeClasses.length, excludeClasses.length == 1 ? "entity":"entities", postfix));
    }
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private static Set<String> getPackagesToScan(AnnotationAttributes attributes) {
	String[] basePackages = attributes.getStringArray("basePackages");
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	Set<String> packagesToScan = new LinkedHashSet<>();
	packagesToScan.addAll(Arrays.asList(basePackages));
	for (Class<?> basePackageClass : basePackageClasses) {
		packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
	}
	return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(EnableSpringSeedJpa.class.getName()));
		String propertyPrefix = attributes.getString("propertyPrefix");
		String beanNamePrefix =  attributes.getString("beanNamePrefix");
		Class<?>[] entityPackages = attributes.getClassArray("baseEntityClasses");

/*
		//There are two ways to register bean dynamically in Spring.
 		DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory)this.beanFactory;

		DataSource dataSource = JpaBuilderUtil.newDataSource(environment, prefix);
		beanFactory.registerSingleton(prefix + DataSource.class.getSimpleName(), dataSource);

		EntityManagerFactory entityManagerFactory = JpaBuilderUtil.newEntityManagerFactory(dataSource, entityPackages);
		beanFactory.registerSingleton(prefix + "entityManager", entityManagerFactory);

		PlatformTransactionManager platformTransactionManager = JpaBuilderUtil.newPlatformTransactionManager(entityManagerFactory);
		beanFactory.registerSingleton(prefix + "transactionManager", platformTransactionManager);
*/

		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(Dbcp2DataSourceFactoryBean.class)
			.addPropertyValue("prefix", propertyPrefix)
			.addPropertyValue("environment", this.environment)
			.setDestroyMethodName("close");
		String dataSourceName = beanNamePrefix.isEmpty()? "dataSource": beanNamePrefix + "DataSource";
		registry.registerBeanDefinition(dataSourceName, builder.getBeanDefinition());

		BeanDefinitionBuilder builderEntity = BeanDefinitionBuilder.genericBeanDefinition(EntityManagerFactoryFactoryBean.class)
			.addPropertyReference("dataSource", dataSourceName)
			.addPropertyValue("entityPackages", entityPackages);
		String entityManagerFactoryName = beanNamePrefix.isEmpty()? "entityManagerFactory": beanNamePrefix + "EntityManagerFactory";
		registry.registerBeanDefinition(entityManagerFactoryName, builderEntity.getBeanDefinition());

		BeanDefinitionBuilder builderTrans = BeanDefinitionBuilder.genericBeanDefinition(JpaTransactionManagerFactoryBean.class)
			.addPropertyReference("entityManagerFactory",entityManagerFactoryName);
		String transactionManagerName = beanNamePrefix.isEmpty()? "transactionManager": beanNamePrefix + "TransactionManager";
		registry.registerBeanDefinition(transactionManagerName, builderTrans.getBeanDefinition());
	}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private String[] addBasePakcages(AnnotationMetadata metadata,
                                 AnnotationAttributes attrs) {
    List<String> basePkgs = new ArrayList<String>();
    addBasePackages(attrs, basePkgs, "value");
    addBasePackages(attrs, basePkgs, "basePackages");
    for (val clz : attrs.getClassArray("basePackageClasses")) {
        basePkgs.add(ClassUtils.getPackageName(clz));
    }

    if (basePkgs.isEmpty()) {
        basePkgs.add(ClassUtils.getPackageName(metadata.getClassName()));
    }

    return StringUtils.toStringArray(basePkgs);
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Test
public void directlyAnnotatedWithImport() {
	AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
	ctx.register(ImportingConfig.class);
	ctx.refresh();
	assertNotNull(ctx.getBean("importedConfigBean"));

	ImportedConfig importAwareConfig = ctx.getBean(ImportedConfig.class);
	AnnotationMetadata importMetadata = importAwareConfig.importMetadata;
	assertThat("import metadata was not injected", importMetadata, notNullValue());
	assertThat(importMetadata.getClassName(), is(ImportingConfig.class.getName()));
	AnnotationAttributes importAttribs = AnnotationConfigUtils.attributesFor(importMetadata, Import.class);
	Class<?>[] importedClasses = importAttribs.getClassArray("value");
	assertThat(importedClasses[0].getName(), is(ImportedConfig.class.getName()));
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private void assertMetaAnnotationOverrides(AnnotationMetadata metadata) {
	AnnotationAttributes attributes = (AnnotationAttributes) metadata.getAnnotationAttributes(
			TestComponentScan.class.getName(), false);
	String[] basePackages = attributes.getStringArray("basePackages");
	assertThat("length of basePackages[]", basePackages.length, is(1));
	assertThat("basePackages[0]", basePackages[0], is("org.example.componentscan"));
	String[] value = attributes.getStringArray("value");
	assertThat("length of value[]", value.length, is(0));
	Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
	assertThat("length of basePackageClasses[]", basePackageClasses.length, is(0));
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
/**
 * Inspects the packages to be scanned for {@link RetrofitService} interfaces from the {@link RetrofitServiceScan}
 * import annotation.
 *
 * @param metadata the annotation metadata.
 * @return a set of packages to be scanned for {@link RetrofitService} candidates.
 */
private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
    AnnotationAttributes attributes = AnnotationAttributes
            .fromMap(metadata.getAnnotationAttributes(RetrofitServiceScan.class.getName()));

    String[] value = attributes.getStringArray("value");
    String[] basePackages = attributes.getStringArray("basePackages");
    Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");

    if (!ObjectUtils.isEmpty(value)) {
        Assert.state(ObjectUtils.isEmpty(basePackages),
                "@RetrofitServiceScan basePackages and value attributes are mutually exclusive");
    }

    Set<String> packagesToScan = new LinkedHashSet<String>();
    packagesToScan.addAll(Arrays.asList(value));
    packagesToScan.addAll(Arrays.asList(basePackages));

    for (Class<?> basePackageClass : basePackageClasses) {
        packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
    }

    if (packagesToScan.isEmpty()) {
        return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
    }

    return packagesToScan;
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {
	List<TypeFilter> typeFilters = new ArrayList<TypeFilter>();
	FilterType filterType = filterAttributes.getEnum("type");

	for (Class<?> filterClass : filterAttributes.getClassArray("value")) {
		switch (filterType) {
			case ANNOTATION:
				Assert.isAssignable(Annotation.class, filterClass,
						"An error occured while processing a @ComponentScan ANNOTATION type filter: ");
				@SuppressWarnings("unchecked")
				Class<Annotation> annotationType = (Class<Annotation>) filterClass;
				typeFilters.add(new AnnotationTypeFilter(annotationType));
				break;
			case ASSIGNABLE_TYPE:
				typeFilters.add(new AssignableTypeFilter(filterClass));
				break;
			case CUSTOM:
				Assert.isAssignable(TypeFilter.class, filterClass,
						"An error occured while processing a @ComponentScan CUSTOM type filter: ");
				typeFilters.add(BeanUtils.instantiateClass(filterClass, TypeFilter.class));
				break;
			default:
				throw new IllegalArgumentException("Filter type not supported with Class value: " + filterType);
		}
	}

	for (String expression : filterAttributes.getStringArray("pattern")) {
		switch (filterType) {
			case ASPECTJ:
				typeFilters.add(new AspectJTypeFilter(expression, this.resourceLoader.getClassLoader()));
				break;
			case REGEX:
				typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(expression)));
				break;
			default:
				throw new IllegalArgumentException("Filter type not supported with String pattern: " + filterType);
		}
	}

	return typeFilters;
}