Java AnnotationAttributes.getBoolean方法代码示例

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包/类
/**
 * Register, escalate, and configure the AspectJ auto proxy creator based on the value
 * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
 * {@code @Configuration} class.
 */
@Override
public void registerBeanDefinitions(
		AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

	AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

	AnnotationAttributes enableAJAutoProxy =
			AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
	if (enableAJAutoProxy.getBoolean("proxyTargetClass")) {
		AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
	}
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
public void setImportMetadata(AnnotationMetadata importMetadata) {
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableSpringSeedRestApiMvc.class.getName()));
	this.disableCors =  attributes.getBoolean("disableCors");
	this.parseAuthorizationHeader = attributes.getBoolean("parseAuthorizationHeader");
	AnnotationAttributes jwt = attributes.getAnnotation("enableJwtConfig");
	this.jwtValue = jwt.getBoolean("value");
	this.jwtSecretPropertyName = jwt.getString("secretPropertyName");
	this.expiration = jwt.getNumber("expiration").longValue();

	this.enableSwagger2 = attributes.getBoolean("enableSwagger2");
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
public void setImportMetadata(AnnotationMetadata importMetadata) {
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableSpringSeedRedis.class.getName()));
	this.defaultExpiration =  attributes.getNumber("defaultExpiration").longValue();
	this.propertyPrefix = attributes.getString("propertyPrefix");
	AnnotationAttributes[] annotationAttributes = attributes.getAnnotationArray("cacheExpirations");
	for(AnnotationAttributes a: annotationAttributes){
		expiresMap.put(a.getString("value"), a.getNumber("expiration").longValue());
	}
	this.clearBeforeStart = attributes.getBoolean("clearBeforeStart");
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
private MyBatisConfigurationBuilder(AnnotationMetadata metadata) {
    this.metadata = metadata;

    AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(EnableMyBatis.class.getName(), false));
    Assert.notNull(attributes, String.format("@%s is not present on importing class '%s' as expected", EnableMyBatis.class.getName(), metadata.getClassName()));
    this.attributes = attributes;
    this.useFlyway = attributes.getBoolean(Constant.USE_FLYWAY_ATTRIBUTE_NAME);
    this.migration = attributes.getString(Constant.MIGRATION_ATTRIBUTE_NAME);
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    List<String> imports = new ArrayList<>();
    imports.add(MyBatisBeanDefinitionRegistrar.class.getName());
    imports.add(MyBatisConfiguration.class.getName());

    AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(EnableMyBatis.class.getName(), false));
    boolean supportTransaction = attributes.getBoolean(Constant.SUPPORT_TRANSACTION_ATTRIBUTE_NAME);
    if (supportTransaction) {
        imports.add(DataSourceTransactionManagementConfiguration.class.getName());
    }

    return imports.toArray(new String[imports.size()]);
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context,
		AnnotatedTypeMetadata metadata) {
	AnnotationAttributes annotationAttributes = AnnotationAttributes
			.fromMap(metadata.getAnnotationAttributes(ANNOTATION_CLASS));
	String endpointName = annotationAttributes.getString("value");
	boolean enabledByDefault = annotationAttributes.getBoolean("enabledByDefault");
	ConditionOutcome outcome = determineEndpointOutcome(endpointName,
			enabledByDefault, context);
	if (outcome != null) {
		return outcome;
	}
	return determineAllEndpointsOutcome(context);
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
@Override
public void setImportMetadata(AnnotationMetadata importMetadata) {
    AnnotationAttributes annotationAttributes = AnnotationAttributes.fromMap(
            importMetadata.getAnnotationAttributes(EnableWxMvc.class.getName(), false));
    this.menuAutoCreate = annotationAttributes.getBoolean("menuAutoCreate");
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
protected boolean determineRequiredStatus(AnnotationAttributes ann) {
	return (!ann.containsKey(this.requiredParameterName) || this.requiredParameterValue == ann.getBoolean(this.requiredParameterName));
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
/**
 * Construct a new {@link ContextConfigurationAttributes} instance for the
 * supplied {@link AnnotationAttributes} (parsed from a
 * {@link ContextConfiguration @ContextConfiguration} annotation) and
 * the {@linkplain Class test class} that declared them.
 * @param declaringClass the test class that declared {@code @ContextConfiguration}
 * @param annAttrs the annotation attributes from which to retrieve the attributes
 */
@SuppressWarnings("unchecked")
public ContextConfigurationAttributes(Class<?> declaringClass, AnnotationAttributes annAttrs) {
	this(declaringClass, annAttrs.getStringArray("locations"), annAttrs.getClassArray("classes"), annAttrs.getBoolean("inheritLocations"),
		(Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>[]) annAttrs.getClassArray("initializers"),
		annAttrs.getBoolean("inheritInitializers"), annAttrs.getString("name"), (Class<? extends ContextLoader>) annAttrs.getClass("loader"));
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
/**
 * Determine if the annotated field or method requires its dependency.
 * <p>A 'required' dependency means that autowiring should fail when no beans
 * are found. Otherwise, the autowiring process will simply bypass the field
 * or method when no beans are found.
 * @param annotation the Autowired annotation
 * @return whether the annotation indicates that a dependency is required
 */
protected boolean determineRequiredStatus(AnnotationAttributes annotation) {
	return (!annotation.containsKey(this.requiredParameterName) ||
			this.requiredParameterValue == annotation.getBoolean(this.requiredParameterName));
}
 

import org.springframework.core.annotation.AnnotationAttributes; //导入方法依赖的package包/类
/**
 * Determine if the annotated field or method requires its dependency.
 * <p>A 'required' dependency means that autowiring should fail when no beans
 * are found. Otherwise, the autowiring process will simply bypass the field
 * or method when no beans are found.
 * @param ann the Autowired annotation
 * @return whether the annotation indicates that a dependency is required
 */
protected boolean determineRequiredStatus(AnnotationAttributes ann) {
	return (!ann.containsKey(this.requiredParameterName) ||
			this.requiredParameterValue == ann.getBoolean(this.requiredParameterName));
}