Polishing

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/TypeConverterDelegate.java

@@ -220,8 +220,8 @@ else if (convertedValue instanceof Map) {
 				else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
 					if (firstAttemptEx == null && !requiredType.isInterface() && !requiredType.isEnum()) {
 						try {
-							Constructor strCtor = requiredType.getConstructor(String.class);
-							return (T) BeanUtils.instantiateClass(strCtor, convertedValue);
+							Constructor<T> strCtor = requiredType.getConstructor(String.class);
+							return BeanUtils.instantiateClass(strCtor, convertedValue);
 						}
 						catch (NoSuchMethodException ex) {
 							// proceed with field lookup
@@ -331,7 +331,7 @@ private Object attemptToConvertStringToEnum(Class<?> requiredType, String trimme
 	 * @param requiredType the type to find an editor for
 	 * @return the corresponding editor, or {@code null} if none
 	 */
-	private PropertyEditor findDefaultEditor(Class requiredType) {
+	private PropertyEditor findDefaultEditor(Class<?> requiredType) {
 		PropertyEditor editor = null;
 		if (requiredType != null) {
 			// No custom editor -> check BeanWrapperImpl's default editors.
@@ -496,7 +496,7 @@ else if (input.getClass().isArray()) {
 
 	@SuppressWarnings("unchecked")
 	private Collection convertToTypedCollection(
-			Collection original, String propertyName, Class requiredType, TypeDescriptor typeDescriptor) {
+			Collection original, String propertyName, Class<?> requiredType, TypeDescriptor typeDescriptor) {
 
 		if (!Collection.class.isAssignableFrom(requiredType)) {
 			return original;
@@ -578,7 +578,7 @@ private Collection convertToTypedCollection(
 
 	@SuppressWarnings("unchecked")
 	private Map convertToTypedMap(
-			Map original, String propertyName, Class requiredType, TypeDescriptor typeDescriptor) {
+			Map original, String propertyName, Class<?> requiredType, TypeDescriptor typeDescriptor) {
 
 		if (!Map.class.isAssignableFrom(requiredType)) {
 			return original;
@@ -674,7 +674,7 @@ private String buildKeyedPropertyName(String propertyName, Object key) {
 				null);
 	}
 
-	private boolean canCreateCopy(Class requiredType) {
+	private boolean canCreateCopy(Class<?> requiredType) {
 		return (!requiredType.isInterface() && !Modifier.isAbstract(requiredType.getModifiers()) &&
 				Modifier.isPublic(requiredType.getModifiers()) && ClassUtils.hasConstructor(requiredType));
 	}

spring-beans/src/main/java/org/springframework/beans/factory/support/DisposableBeanAdapter.java

@@ -65,7 +65,7 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {
 
 	private static final Log logger = LogFactory.getLog(DisposableBeanAdapter.class);
 
-	private static Class closeableInterface;
+	private static Class<?> closeableInterface;
 
 	static {
 		try {
@@ -86,14 +86,14 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {
 
 	private final boolean nonPublicAccessAllowed;
 
+	private final AccessControlContext acc;
+
 	private String destroyMethodName;
 
 	private transient Method destroyMethod;
 
 	private List<DestructionAwareBeanPostProcessor> beanPostProcessors;
 
-	private final AccessControlContext acc;
-
 
 	/**
 	 * Create a new DisposableBeanAdapter for the given bean.
@@ -150,9 +150,9 @@ private DisposableBeanAdapter(Object bean, String beanName, boolean invokeDispos
 		this.beanName = beanName;
 		this.invokeDisposableBean = invokeDisposableBean;
 		this.nonPublicAccessAllowed = nonPublicAccessAllowed;
+		this.acc = null;
 		this.destroyMethodName = destroyMethodName;
 		this.beanPostProcessors = postProcessors;
-		this.acc = null;
 	}
 
 

spring-context/src/test/java/org/springframework/context/annotation/configuration/Spr10744Tests.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2002-2014 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.configuration;
+
+import org.junit.Test;
+
+import org.springframework.beans.factory.ObjectFactory;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Scope;
+import org.springframework.context.annotation.ScopedProxyMode;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+/**
+ * @author Phillip Webb
+ */
+public class Spr10744Tests {
+
+	private static int createCount = 0;
+
+	private static int scopeCount = 0;
+
+
+	@Test
+	public void testSpr10744() throws Exception {
+		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+		context.getBeanFactory().registerScope("myTestScope", new MyTestScope());
+		context.register(MyTestConfiguration.class);
+		context.refresh();
+
+		Foo bean1 = context.getBean("foo", Foo.class);
+		Foo bean2 = context.getBean("foo", Foo.class);
+		assertThat(bean1, sameInstance(bean2));
+
+		// Should have created a single instance for the proxy
+		assertThat(createCount, equalTo(1));
+		assertThat(scopeCount, equalTo(0));
+
+		// Proxy mode should create new scoped object on each method call
+		bean1.getMessage();
+		assertThat(createCount, equalTo(2));
+		assertThat(scopeCount, equalTo(1));
+		bean1.getMessage();
+		assertThat(createCount, equalTo(3));
+		assertThat(scopeCount, equalTo(2));
+
+		context.close();
+	}
+
+
+	private static class MyTestScope implements org.springframework.beans.factory.config.Scope {
+
+		@Override
+		public Object get(String name, ObjectFactory<?> objectFactory) {
+			scopeCount++;
+			return objectFactory.getObject();
+		}
+
+		@Override
+		public Object remove(String name) {
+			return null;
+		}
+
+		@Override
+		public void registerDestructionCallback(String name, Runnable callback) {
+		}
+
+		@Override
+		public Object resolveContextualObject(String key) {
+			return null;
+		}
+
+		@Override
+		public String getConversationId() {
+			return null;
+		}
+	}
+
+
+	static class Foo {
+
+		public Foo() {
+			createCount++;
+		}
+
+		public String getMessage() {
+			return "Hello";
+		}
+	}
+
+
+	@Configuration
+	static class MyConfiguration {
+
+		@Bean
+		public Foo foo() {
+			return new Foo();
+		}
+	}
+
+
+	@Configuration
+	static class MyTestConfiguration extends MyConfiguration {
+
+		@Bean
+		@Scope(value = "myTestScope",  proxyMode = ScopedProxyMode.TARGET_CLASS)
+		@Override
+		public Foo foo() {
+			return new Foo();
+		}
+	}
+
+}

spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -25,6 +25,7 @@
 
 import org.springframework.core.BridgeMethodResolver;
 import org.springframework.util.Assert;
+import org.springframework.util.ReflectionUtils;
 
 /**
  * General utility methods for working with annotations, handling bridge methods (which the compiler
@@ -60,8 +61,8 @@ public abstract class AnnotationUtils {
 	 * Method, Constructor or Field. Meta-annotations will be searched if the annotation
 	 * is not declared locally on the supplied element.
 	 * @param ae the Method, Constructor or Field from which to get the annotation
-	 * @param annotationType the annotation class to look for, both locally and as a meta-annotation
-	 * @return the matching annotation or {@code null} if not found
+	 * @param annotationType the annotation type to look for, both locally and as a meta-annotation
+	 * @return the matching annotation, or {@code null} if none found
 	 * @since 3.1
 	 */
 	public static <T extends Annotation> T getAnnotation(AnnotatedElement ae, Class<T> annotationType) {
@@ -92,7 +93,7 @@ public static Annotation[] getAnnotations(Method method) {
 	 * Get a single {@link Annotation} of {@code annotationType} from the supplied {@link Method}.
 	 * <p>Correctly handles bridge {@link Method Methods} generated by the compiler.
 	 * @param method the method to look for annotations on
-	 * @param annotationType the annotation class to look for
+	 * @param annotationType the annotation type to look for
 	 * @return the annotations found
 	 * @see org.springframework.core.BridgeMethodResolver#findBridgedMethod(Method)
 	 */
@@ -115,8 +116,8 @@ public static <A extends Annotation> A getAnnotation(Method method, Class<A> ann
 	 * traversing its super methods if no annotation can be found on the given method itself.
 	 * <p>Annotations on methods are not inherited by default, so we need to handle this explicitly.
 	 * @param method the method to look for annotations on
-	 * @param annotationType the annotation class to look for
-	 * @return the annotation found, or {@code null} if none found
+	 * @param annotationType the annotation type to look for
+	 * @return the annotation found, or {@code null} if none
 	 */
 	public static <A extends Annotation> A findAnnotation(Method method, Class<A> annotationType) {
 		A annotation = getAnnotation(method, annotationType);
@@ -192,7 +193,7 @@ private static boolean isInterfaceWithAnnotatedMethods(Class<?> iface) {
 	 * with the interfaces that the superclass declares. Recursing up through the entire superclass
 	 * hierarchy if no match is found.
 	 * @param clazz the class to look for annotations on
-	 * @param annotationType the annotation class to look for
+	 * @param annotationType the annotation type to look for
 	 * @return the annotation found, or {@code null} if none found
 	 */
 	public static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> annotationType) {
@@ -215,11 +216,11 @@ public static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> a
 				}
 			}
 		}
-		Class<?> superClass = clazz.getSuperclass();
-		if (superClass == null || superClass.equals(Object.class)) {
+		Class<?> superclass = clazz.getSuperclass();
+		if (superclass == null || superclass.equals(Object.class)) {
 			return null;
 		}
-		return findAnnotation(superClass, annotationType);
+		return findAnnotation(superclass, annotationType);
 	}
 
 	/**
@@ -232,9 +233,8 @@ public static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> a
 	 * <p>The standard {@link Class} API does not provide a mechanism for determining which class
 	 * in an inheritance hierarchy actually declares an {@link Annotation}, so we need to handle
 	 * this explicitly.
-	 * @param annotationType the Class object corresponding to the annotation type
-	 * @param clazz the Class object corresponding to the class on which to check for the annotation,
-	 * or {@code null}
+	 * @param annotationType the annotation type to look for, both locally and as a meta-annotation
+	 * @param clazz the class on which to check for the annotation (may be {@code null})
 	 * @return the first {@link Class} in the inheritance hierarchy of the specified {@code clazz}
 	 * which declares an annotation for the specified {@code annotationType}, or {@code null}
 	 * if not found
@@ -248,8 +248,10 @@ public static Class<?> findAnnotationDeclaringClass(Class<? extends Annotation>
 		if (clazz == null || clazz.equals(Object.class)) {
 			return null;
 		}
-		return (isAnnotationDeclaredLocally(annotationType, clazz)) ? clazz : findAnnotationDeclaringClass(
-			annotationType, clazz.getSuperclass());
+		if (isAnnotationDeclaredLocally(annotationType, clazz)) {
+			return clazz;
+		}
+		return findAnnotationDeclaringClass(annotationType, clazz.getSuperclass());
 	}
 
 	/**
@@ -413,14 +415,13 @@ else if (value instanceof Class[]) {
 					}
 					if (nestedAnnotationsAsMap && value instanceof Annotation) {
 						attrs.put(method.getName(),
-							getAnnotationAttributes((Annotation) value, classValuesAsString, nestedAnnotationsAsMap));
+							getAnnotationAttributes((Annotation) value, classValuesAsString, true));
 					}
 					else if (nestedAnnotationsAsMap && value instanceof Annotation[]) {
 						Annotation[] realAnnotations = (Annotation[]) value;
 						AnnotationAttributes[] mappedAnnotations = new AnnotationAttributes[realAnnotations.length];
 						for (int i = 0; i < realAnnotations.length; i++) {
-							mappedAnnotations[i] = getAnnotationAttributes(realAnnotations[i], classValuesAsString,
-								nestedAnnotationsAsMap);
+							mappedAnnotations[i] = getAnnotationAttributes(realAnnotations[i], classValuesAsString, true);
 						}
 						attrs.put(method.getName(), mappedAnnotations);
 					}
@@ -456,7 +457,8 @@ public static Object getValue(Annotation annotation) {
 	 */
 	public static Object getValue(Annotation annotation, String attributeName) {
 		try {
-			Method method = annotation.annotationType().getDeclaredMethod(attributeName, new Class[0]);
+			Method method = annotation.annotationType().getDeclaredMethod(attributeName);
+			ReflectionUtils.makeAccessible(method);
 			return method.invoke(annotation);
 		}
 		catch (Exception ex) {
@@ -506,8 +508,7 @@ public static Object getDefaultValue(Class<? extends Annotation> annotationType)
 	 */
 	public static Object getDefaultValue(Class<? extends Annotation> annotationType, String attributeName) {
 		try {
-			Method method = annotationType.getDeclaredMethod(attributeName, new Class[0]);
-			return method.getDefaultValue();
+			return annotationType.getDeclaredMethod(attributeName).getDefaultValue();
 		}
 		catch (Exception ex) {
 			return null;

spring-core/src/main/java/org/springframework/core/env/EnumerablePropertySource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -18,6 +18,7 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.util.Assert;
 
 /**
@@ -53,21 +54,22 @@ public EnumerablePropertySource(String name, T source) {
 		super(name, source);
 	}
 
+
 	/**
-	 * Return the names of all properties contained by the {@linkplain #getSource()
-	 * source} object (never {@code null}).
+	 * Return the names of all properties contained by the
+	 * {@linkplain #getSource() source} object (never {@code null}).
 	 */
 	public abstract String[] getPropertyNames();
 
 	/**
 	 * Return whether this {@code PropertySource} contains a property with the given name.
-	 * <p>This implementation checks for the presence of the given name within
-	 * the {@link #getPropertyNames()} array.
-	 * @param name the property to find
+	 * <p>This implementation checks for the presence of the given name within the
+	 * {@link #getPropertyNames()} array.
+	 * @param name the name of the property to find
 	 */
 	public boolean containsProperty(String name) {
-		Assert.notNull(name, "property name must not be null");
-		for (String candidate : this.getPropertyNames()) {
+		Assert.notNull(name, "Property name must not be null");
+		for (String candidate : getPropertyNames()) {
 			if (candidate.equals(name)) {
 				if (logger.isDebugEnabled()) {
 					logger.debug(String.format("PropertySource [%s] contains '%s'", getName(), name));