Introduced @description annotation for populating BeanDefinition.getDescription()

Issue: SPR-10583

Author: jhoeller

spring-context/src/main/java/org/springframework/context/annotation/AdviceModeImportSelector.java

@@ -1,5 +1,5 @@
  /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,23 +23,20 @@
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.util.Assert;
 
-import static org.springframework.context.annotation.MetadataUtils.*;
-
-/**
+ /**
  * Convenient base class for {@link ImportSelector} implementations that select imports
  * based on an {@link AdviceMode} value from an annotation (such as the {@code @Enable*}
  * annotations).
  *
- * @param <A> Annotation containing {@linkplain #getAdviceModeAttributeName() AdviceMode
- * attribute}
- *
+ * @param <A> Annotation containing {@linkplain #getAdviceModeAttributeName() AdviceMode attribute}
  * @author Chris Beams
  * @since 3.1
  */
 public abstract class AdviceModeImportSelector<A extends Annotation> implements ImportSelector {
 
 	public static final String DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME = "mode";
 
+
 	/**
 	 * The name of the {@link AdviceMode} attribute for the annotation specified by the
 	 * generic type {@code A}. The default is {@value #DEFAULT_ADVICE_MODE_ATTRIBUTE_NAME},
@@ -50,48 +47,38 @@ protected String getAdviceModeAttributeName() {
 	}
 
 	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>This implementation resolves the type of annotation from generic metadata and
+	 * This implementation resolves the type of annotation from generic metadata and
 	 * validates that (a) the annotation is in fact present on the importing
 	 * {@code @Configuration} class and (b) that the given annotation has an
 	 * {@linkplain #getAdviceModeAttributeName() advice mode attribute} of type
 	 * {@link AdviceMode}.
-	 *
 	 * <p>The {@link #selectImports(AdviceMode)} method is then invoked, allowing the
 	 * concrete implementation to choose imports in a safe and convenient fashion.
-	 *
 	 * @throws IllegalArgumentException if expected annotation {@code A} is not present
 	 * on the importing {@code @Configuration} class or if {@link #selectImports(AdviceMode)}
 	 * returns {@code null}
 	 */
 	@Override
 	public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
 		Class<?> annoType = GenericTypeResolver.resolveTypeArgument(this.getClass(), AdviceModeImportSelector.class);
-
-		AnnotationAttributes attributes = attributesFor(importingClassMetadata, annoType);
+		AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
 		Assert.notNull(attributes, String.format(
 				"@%s is not present on importing class '%s' as expected",
 				annoType.getSimpleName(), importingClassMetadata.getClassName()));
 
 		AdviceMode adviceMode = attributes.getEnum(this.getAdviceModeAttributeName());
-
 		String[] imports = selectImports(adviceMode);
 		Assert.notNull(imports, String.format("Unknown AdviceMode: '%s'", adviceMode));
-
 		return imports;
 	}
 
 	/**
 	 * Determine which classes should be imported based on the given {@code AdviceMode}.
-	 *
 	 * <p>Returning {@code null} from this method indicates that the {@code AdviceMode} could
 	 * not be handled or was unknown and that an {@code IllegalArgumentException} should
 	 * be thrown.
-	 *
 	 * @param adviceMode the value of the {@linkplain #getAdviceModeAttributeName()
 	 * advice mode attribute} for the annotation specified via generics.
-	 *
 	 * @return array containing classes to import; empty array if none, {@code null} if
 	 * the given {@code AdviceMode} is unknown.
 	 */

spring-context/src/main/java/org/springframework/context/annotation/AnnotationBeanNameGenerator.java

@@ -87,7 +87,7 @@ protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotat
 		Set<String> types = amd.getAnnotationTypes();
 		String beanName = null;
 		for (String type : types) {
-			AnnotationAttributes attributes = MetadataUtils.attributesFor(amd, type);
+			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
 			if (isStereotypeWithNameValue(type, amd.getMetaAnnotationTypes(type), attributes)) {
 				String value = (String) attributes.get("value");
 				if (StringUtils.hasLength(value)) {

spring-context/src/main/java/org/springframework/context/annotation/AnnotationConfigUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,11 +27,10 @@
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
-import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.core.type.AnnotatedTypeMetadata;
 import org.springframework.util.ClassUtils;
 
-import static org.springframework.context.annotation.MetadataUtils.*;
-
 /**
  * Utility class that allows for convenient registration of common
  * {@link org.springframework.beans.factory.config.BeanPostProcessor} and
@@ -231,20 +230,31 @@ private static BeanDefinitionHolder registerPostProcessor(
 	}
 
 	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
-		AnnotationMetadata metadata = abd.getMetadata();
-		if (metadata.isAnnotated(Primary.class.getName())) {
-			abd.setPrimary(true);
-		}
+		processCommonDefinitionAnnotations(abd, abd.getMetadata());
+	}
+
+	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
 		if (metadata.isAnnotated(Lazy.class.getName())) {
 			abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
 		}
+		else if (abd.getMetadata().isAnnotated(Lazy.class.getName())) {
+			abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
+		}
+
+		if (metadata.isAnnotated(Primary.class.getName())) {
+			abd.setPrimary(true);
+		}
 		if (metadata.isAnnotated(DependsOn.class.getName())) {
 			abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
 		}
+
 		if (abd instanceof AbstractBeanDefinition) {
+			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
 			if (metadata.isAnnotated(Role.class.getName())) {
-				Integer role = attributesFor(metadata, Role.class).getNumber("value");
-				((AbstractBeanDefinition)abd).setRole(role);
+				absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
+			}
+			if (metadata.isAnnotated(Description.class.getName())) {
+				absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
 			}
 		}
 	}
@@ -260,5 +270,12 @@ static BeanDefinitionHolder applyScopedProxyMode(
 		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
 	}
 
+	static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, Class<?> annoClass) {
+		return attributesFor(metadata, annoClass.getName());
+	}
+
+	static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, String annoClassName) {
+		return AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(annoClassName, false));
+	}
 
 }

spring-context/src/main/java/org/springframework/context/annotation/AnnotationScopeMetadataResolver.java

@@ -77,7 +77,7 @@ public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
 		ScopeMetadata metadata = new ScopeMetadata();
 		if (definition instanceof AnnotatedBeanDefinition) {
 			AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
-			AnnotationAttributes attributes = MetadataUtils.attributesFor(annDef.getMetadata(), this.scopeAnnotationType);
+			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(annDef.getMetadata(), this.scopeAnnotationType);
 			if (attributes != null) {
 				metadata.setScopeName(attributes.getString("value"));
 				ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");

spring-context/src/main/java/org/springframework/context/annotation/AspectJAutoProxyRegistrar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,16 +21,14 @@
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.type.AnnotationMetadata;
 
-import static org.springframework.context.annotation.MetadataUtils.*;
-
 /**
  * Registers an {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
  * AnnotationAwareAspectJAutoProxyCreator} against the current {@link BeanDefinitionRegistry}
  * as appropriate based on a given @{@link EnableAspectJAutoProxy} annotation.
  *
  * @author Chris Beams
- * @see EnableAspectJAutoProxy
  * @since 3.1
+ * @see EnableAspectJAutoProxy
  */
 class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
 
@@ -46,7 +44,7 @@ public void registerBeanDefinitions(
 		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
 
 		AnnotationAttributes enableAJAutoProxy =
-				attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
+				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
 		if (enableAJAutoProxy.getBoolean("proxyTargetClass")) {
 			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
 		}

spring-context/src/main/java/org/springframework/context/annotation/AutoProxyRegistrar.java

@@ -1,5 +1,5 @@
  /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,6 @@
 
 package org.springframework.context.annotation;
 
-import static org.springframework.context.annotation.MetadataUtils.attributesFor;
-
 import java.util.Set;
 
 import org.apache.commons.logging.Log;
@@ -61,7 +59,7 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
 		boolean candidateFound = false;
 		Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
 		for (String annoType : annoTypes) {
-			AnnotationAttributes candidate = attributesFor(importingClassMetadata, annoType);
+			AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
 			Object mode = candidate.get("mode");
 			Object proxyTargetClass = candidate.get("proxyTargetClass");
 			if (mode != null && proxyTargetClass != null

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java

@@ -53,8 +53,6 @@
 import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.util.StringUtils;
 
-import static org.springframework.context.annotation.MetadataUtils.*;
-
 /**
  * Reads a given fully-populated set of ConfigurationClass instances, registering bean
  * definitions with the given {@link BeanDefinitionRegistry} based on its contents.
@@ -178,14 +176,13 @@ private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationCl
 	 * with the BeanDefinitionRegistry based on its contents.
 	 */
 	private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
-		if (conditionEvaluator.shouldSkip(beanMethod.getMetadata(),
-				ConfigurationPhase.REGISTER_BEAN)) {
+		if (this.conditionEvaluator.shouldSkip(beanMethod.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
 			return;
 		}
 		ConfigurationClass configClass = beanMethod.getConfigurationClass();
 		MethodMetadata metadata = beanMethod.getMetadata();
 
-		RootBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass);
+		ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass);
 		beanDef.setResource(configClass.getResource());
 		beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
 		if (metadata.isStatic()) {
@@ -201,14 +198,8 @@ private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
 		beanDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
 		beanDef.setAttribute(RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
 
-		// consider role
-		AnnotationAttributes role = attributesFor(metadata, Role.class);
-		if (role != null) {
-			beanDef.setRole(role.<Integer>getNumber("value"));
-		}
-
 		// consider name and any aliases
-		AnnotationAttributes bean = attributesFor(metadata, Bean.class);
+		AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
 		List<String> names = new ArrayList<String>(Arrays.asList(bean.getStringArray("name")));
 		String beanName = (names.size() > 0 ? names.remove(0) : beanMethod.getMetadata().getMethodName());
 		for (String alias : names) {
@@ -230,27 +221,7 @@ private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
 			}
 		}
 
-		if (metadata.isAnnotated(Primary.class.getName())) {
-			beanDef.setPrimary(true);
-		}
-
-		// is this bean to be instantiated lazily?
-		if (metadata.isAnnotated(Lazy.class.getName())) {
-			AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
-			beanDef.setLazyInit(lazy.getBoolean("value"));
-		}
-		else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){
-			AnnotationAttributes lazy = attributesFor(configClass.getMetadata(), Lazy.class);
-			beanDef.setLazyInit(lazy.getBoolean("value"));
-		}
-
-		if (metadata.isAnnotated(DependsOn.class.getName())) {
-			AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
-			String[] otherBeans = dependsOn.getStringArray("value");
-			if (otherBeans.length > 0) {
-				beanDef.setDependsOn(otherBeans);
-			}
-		}
+		AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
 
 		Autowire autowire = bean.getEnum("autowire");
 		if (autowire.isAutowire()) {
@@ -269,7 +240,7 @@ else if (configClass.getMetadata().isAnnotated(Lazy.class.getName())){
 
 		// consider scoping
 		ScopedProxyMode proxyMode = ScopedProxyMode.NO;
-		AnnotationAttributes scope = attributesFor(metadata, Scope.class);
+		AnnotationAttributes scope = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
 		if (scope != null) {
 			beanDef.setScope(scope.getString("value"));
 			proxyMode = scope.getEnum("proxyMode");

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassParser.java

@@ -66,8 +66,6 @@
 import org.springframework.core.type.filter.AssignableTypeFilter;
 import org.springframework.util.StringUtils;
 
-import static org.springframework.context.annotation.MetadataUtils.*;
-
 /**
  * Parses a {@link Configuration} class definition, populating a collection of
  * {@link ConfigurationClass} objects (parsing a single Configuration class may result in
@@ -223,13 +221,13 @@ protected final SourceClass doProcessConfigurationClass(ConfigurationClass confi
 		processMemberClasses(configClass, sourceClass);
 
 		// process any @PropertySource annotations
-		AnnotationAttributes propertySource = attributesFor(sourceClass.getMetadata(), org.springframework.context.annotation.PropertySource.class);
+		AnnotationAttributes propertySource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), org.springframework.context.annotation.PropertySource.class);
 		if (propertySource != null) {
 			processPropertySource(propertySource);
 		}
 
 		// process any @ComponentScan annotations
-		AnnotationAttributes componentScan = attributesFor(sourceClass.getMetadata(), ComponentScan.class);
+		AnnotationAttributes componentScan = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ComponentScan.class);
 		if (componentScan != null) {
 			// the config class is annotated with @ComponentScan -> perform the scan immediately
 			if (!conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
@@ -250,7 +248,7 @@ protected final SourceClass doProcessConfigurationClass(ConfigurationClass confi
 
 		// process any @ImportResource annotations
 		if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
-			AnnotationAttributes importResource = attributesFor(sourceClass.getMetadata(), ImportResource.class);
+			AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
 			String[] resources = importResource.getStringArray("value");
 			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
 			for (String resource : resources) {

spring-context/src/main/java/org/springframework/context/annotation/Description.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.context.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Adds a textual description to bean definitions derived from
+ * {@link org.springframework.stereotype.Component} or {@link Bean}.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0
+ * @see org.springframework.beans.factory.config.BeanDefinition#getDescription()
+ */
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Description {
+
+	/**
+	 * The textual description to associate with the bean definition.
+	 */
+	String value();
+
+}