Introduce FeatureSpecification support

Introduce FeatureSpecification interface and implementations

    FeatureSpecification objects decouple the configuration of
    spring container features from the concern of parsing XML
    namespaces, allowing for reuse in code-based configuration
    (see @feature* annotations below).

    * ComponentScanSpec
    * TxAnnotationDriven
    * MvcAnnotationDriven
    * MvcDefaultServletHandler
    * MvcResources
    * MvcViewControllers

Refactor associated BeanDefinitionParsers to delegate to new impls above

    The following BeanDefinitionParser implementations now deal only
    with the concern of XML parsing.  Validation is handled by their
    corresponding FeatureSpecification object.  Bean definition creation
    and registration is handled by their corresponding
    FeatureSpecificationExecutor type.

    * ComponentScanBeanDefinitionParser
    * AnnotationDrivenBeanDefinitionParser (tx)
    * AnnotationDrivenBeanDefinitionParser (mvc)
    * DefaultServletHandlerBeanDefinitionParser
    * ResourcesBeanDefinitionParser
    * ViewControllerBeanDefinitionParser

Update AopNamespaceUtils to decouple from XML (DOM API)

    Methods necessary for executing TxAnnotationDriven specification
    (and eventually, the AspectJAutoProxy specification) have been
    added that accept boolean arguments for whether to proxy
    target classes and whether to expose the proxy via threadlocal.

    Methods that accepted and introspected DOM Element objects still
    exist but have been deprecated.

Introduce @FeatureConfiguration classes and @feature methods

    Allow for creation and configuration of FeatureSpecification objects
    at the user level.  A companion for @configuration classes allowing
    for completely code-driven configuration of the Spring container.

    See changes in ConfigurationClassPostProcessor for implementation
    details.

    See Feature*Tests for usage examples.

    FeatureTestSuite in .integration-tests is a JUnit test suite designed
    to aggregate all BDP and Feature* related tests for a convenient way
    to confirm that Feature-related changes don't break anything.
    Uncomment this test and execute from Eclipse / IDEA. Due to classpath
    issues, this cannot be compiled by Ant/Ivy at the command line.

Introduce @FeatureAnnotation meta-annotation and @componentscan impl

    @FeatureAnnotation provides an alternate mechanism for creating
    and executing FeatureSpecification objects.  See @componentscan
    and its corresponding ComponentScanAnnotationParser implementation
    for details.  See ComponentScanAnnotationIntegrationTests for usage
    examples

Introduce Default[Formatting]ConversionService implementations

    Allows for convenient instantiation of ConversionService objects
    containing defaults appropriate for most environments.  Replaces
    similar support originally in ConversionServiceFactory (which is now
    deprecated). This change was justified by the need to avoid use
    of FactoryBeans in @configuration classes (such as
    FormattingConversionServiceFactoryBean). It is strongly preferred
    that users simply instantiate and configure the objects that underlie
    our FactoryBeans. In the case of the ConversionService types, the
    easiest way to do this is to create Default* subtypes. This also
    follows convention with the rest of the framework.

Minor updates to util classes

    All in service of changes above. See diffs for self-explanatory
    details.

    * BeanUtils
    * ObjectUtils
    * ReflectionUtils

Author: cbeams

org.springframework.aop/src/main/java/org/springframework/aop/config/AopNamespaceUtils.java

@@ -16,12 +16,12 @@
 
 package org.springframework.aop.config;
 
-import org.w3c.dom.Element;
-
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.parsing.ComponentRegistrar;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.xml.ParserContext;
+import org.w3c.dom.Element;
 
 /**
  * Utility class for handling registration of auto-proxy creators used internally
@@ -52,6 +52,11 @@ public abstract class AopNamespaceUtils {
 	private static final String EXPOSE_PROXY_ATTRIBUTE = "expose-proxy";
 
 
+	/**
+	 * @deprecated since Spring 3.1 in favor of
+	 * {@link #registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry, ComponentRegistrar, Object, Boolean, Boolean)}
+	 */
+	@Deprecated
 	public static void registerAutoProxyCreatorIfNecessary(
 			ParserContext parserContext, Element sourceElement) {
 
@@ -61,6 +66,20 @@ public static void registerAutoProxyCreatorIfNecessary(
 		registerComponentIfNecessary(beanDefinition, parserContext);
 	}
 
+	public static void registerAutoProxyCreatorIfNecessary(
+			BeanDefinitionRegistry registry, ComponentRegistrar parserContext, Object source, Boolean proxyTargetClass, Boolean exposeProxy) {
+
+		BeanDefinition beanDefinition =
+			AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry, source);
+		useClassProxyingIfNecessary(registry, proxyTargetClass, exposeProxy);
+		registerComponentIfNecessary(beanDefinition, parserContext);
+	}
+
+	public static void registerAutoProxyCreatorIfNecessary(
+			BeanDefinitionRegistry registry, ComponentRegistrar parserContext, Object source, Boolean proxyTargetClass) {
+		registerAutoProxyCreatorIfNecessary(registry, parserContext, source, proxyTargetClass, false);
+	}
+
 	public static void registerAspectJAutoProxyCreatorIfNecessary(
 			ParserContext parserContext, Element sourceElement) {
 
@@ -101,6 +120,12 @@ public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistr
 	}
 
 
+	/**
+	 * @deprecated since Spring 3.1 in favor of
+	 * {@link #useClassProxyingIfNecessary(BeanDefinitionRegistry, Boolean, Boolean)}
+	 * which does not require a parameter of type org.w3c.dom.Element
+	 */
+	@Deprecated
 	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
 		if (sourceElement != null) {
 			boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
@@ -114,11 +139,20 @@ private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry,
 		}
 	}
 
-	private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
+	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Boolean proxyTargetClass, Boolean exposeProxy) {
+		if (proxyTargetClass) {
+			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
+		}
+		if (exposeProxy) {
+			AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
+		}
+	}
+
+	private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ComponentRegistrar componentRegistrar) {
 		if (beanDefinition != null) {
 			BeanComponentDefinition componentDefinition =
 					new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
-			parserContext.registerComponent(componentDefinition);
+			componentRegistrar.registerComponent(componentDefinition);
 		}
 	}
 

org.springframework.beans/src/main/java/org/springframework/beans/BeanUtils.java

@@ -86,7 +86,7 @@ public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationExceptio
 	}
 
 	/**
-	 * Convenience method to instantiate a class using its no-arg constructor.
+	 * Instantiate a class using its no-arg constructor.
 	 * As this method doesn't try to load classes by name, it should avoid
 	 * class-loading issues.
 	 * <p>Note that this method tries to set the constructor accessible
@@ -108,6 +108,27 @@ public static <T> T instantiateClass(Class<T> clazz) throws BeanInstantiationExc
 		}
 	}
 
+	/**
+	 * Instantiate a class using its no-arg constructor and return the new instance
+	 * as the the specified assignable type.
+	 * <p>Useful in cases where
+	 * the type of the class to instantiate (clazz) is not available, but the type
+	 * desired (assignableTo) is known.
+	 * <p>As this method doesn't try to load classes by name, it should avoid
+	 * class-loading issues.
+	 * <p>Note that this method tries to set the constructor accessible
+	 * if given a non-accessible (that is, non-public) constructor.
+	 * @param clazz class to instantiate
+	 * @param assignableTo type that clazz must be assignableTo
+	 * @return the new instance
+	 * @throws BeanInstantiationException if the bean cannot be instantiated
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> T instantiateClass(Class<?> clazz, Class<T> assignableTo) throws BeanInstantiationException {
+		Assert.isAssignable(assignableTo, clazz);
+		return (T)instantiateClass(clazz);
+	}
+
 	/**
 	 * Convenience method to instantiate a class using the given constructor.
 	 * As this method doesn't try to load classes by name, it should avoid

org.springframework.beans/src/main/java/org/springframework/beans/factory/parsing/BeanDefinitionRegistrar.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.parsing;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+
+public interface BeanDefinitionRegistrar {
+
+	String registerWithGeneratedName(BeanDefinition beanDefinition);
+
+}

org.springframework.beans/src/main/java/org/springframework/beans/factory/parsing/ComponentRegistrar.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.parsing;
+
+public interface ComponentRegistrar extends BeanDefinitionRegistrar {
+
+	void registerBeanComponent(BeanComponentDefinition component);
+
+	void registerComponent(ComponentDefinition component);
+}

org.springframework.beans/src/main/java/org/springframework/beans/factory/parsing/ReaderContext.java

@@ -30,12 +30,13 @@ public class ReaderContext {
 
 	private final Resource resource;
 
-	private final ProblemReporter problemReporter;
-
 	private final ReaderEventListener eventListener;
 
 	private final SourceExtractor sourceExtractor;
 
+	// TODO SPR-7420: review exposing problem reporter
+	protected final ProblemReporter problemReporter;
+
 
 	public ReaderContext(Resource resource, ProblemReporter problemReporter,
 			ReaderEventListener eventListener, SourceExtractor sourceExtractor) {

org.springframework.beans/src/main/java/org/springframework/beans/factory/parsing/SimpleProblemCollector.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2002-2011 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.beans.factory.parsing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.core.io.DescriptiveResource;
+
+/**
+ * TODO SPR-7420: document
+ *
+ * @author Chris Beams
+ * @since 3.1
+ */
+public class SimpleProblemCollector {
+
+	private Location location = null;
+	private List<Problem> errors = new ArrayList<Problem>();
+
+	public SimpleProblemCollector(Object location) {
+		if (location != null) {
+			this.location = new Location(new DescriptiveResource(location.toString()));
+		}
+	}
+
+	public void error(String message) {
+		this.errors.add(new Problem(message, this.location));
+	}
+
+	public void error(String message, Throwable cause) {
+		this.errors.add(new Problem(message, this.location, null, cause));
+	}
+
+	public void reportProblems(ProblemReporter reporter) {
+		for (Problem error : errors) {
+			reporter.error(error);
+		}
+	}
+
+	public boolean hasErrors() {
+		return this.errors.size() > 0;
+	}
+
+}

org.springframework.beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2011 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.

org.springframework.beans/src/main/java/org/springframework/beans/factory/support/BeanDefinitionReaderUtils.java

@@ -166,7 +166,7 @@ public static void registerBeanDefinition(
 	 * for the given bean definition or the definition cannot be registered
 	 */
 	public static String registerWithGeneratedName(
-			AbstractBeanDefinition definition, BeanDefinitionRegistry registry)
+			BeanDefinition definition, BeanDefinitionRegistry registry)
 			throws BeanDefinitionStoreException {
 
 		String generatedName = generateBeanName(definition, registry, false);

org.springframework.beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2011 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,21 +21,28 @@
 import org.springframework.beans.factory.config.BeanDefinition;
 
 /**
- * Interface used by the
- * {@link org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader} to
- * handle custom, top-level (directly under <code>&lt;beans&gt;</code>) tags.
+ * Interface used by the {@link DefaultBeanDefinitionDocumentReader} to handle custom,
+ * top-level (directly under {@code <beans>}) tags.
  *
  * <p>Implementations are free to turn the metadata in the custom tag into as many
  * {@link BeanDefinition BeanDefinitions} as required.
  *
  * <p>The parser locates a {@link BeanDefinitionParser} from the associated
  * {@link NamespaceHandler} for the namespace in which the custom tag resides.
  *
+ * <p>Implementations are encouraged to decouple XML parsing from bean registration by
+ * parsing element(s) into a {@link org.springframework.context.FeatureSpecification
+ * FeatureSpecification} object and subsequently executing that specification.
+ * Doing so allows for maximum reuse between XML-based and annotation-based
+ * configuration options.
+ *
  * @author Rob Harrop
  * @since 2.0
  * @see NamespaceHandler
- * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator
  * @see AbstractBeanDefinitionParser
+ * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator
+ * @see org.springframework.context.FeatureSpecification
+ * @see org.springframework.context.AbstractSpecificationExecutor
  */
 public interface BeanDefinitionParser {
 

org.springframework.beans/src/main/java/org/springframework/beans/factory/xml/ParserContext.java

@@ -21,6 +21,7 @@
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
 import org.springframework.beans.factory.parsing.ComponentDefinition;
+import org.springframework.beans.factory.parsing.ComponentRegistrar;
 import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
@@ -36,7 +37,7 @@
  * @see XmlReaderContext
  * @see BeanDefinitionParserDelegate
  */
-public final class ParserContext {
+public final class ParserContext implements ComponentRegistrar {
 
 	private final XmlReaderContext readerContext;
 
@@ -121,4 +122,8 @@ public void registerBeanComponent(BeanComponentDefinition component) {
 		registerComponent(component);
 	}
 
+	public String registerWithGeneratedName(BeanDefinition beanDefinition) {
+		return this.readerContext.registerWithGeneratedName(beanDefinition);
+	}
+
 }