root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Refactored support for @Order on @Bean methods as well as @Priority handling 

Issue: SPR-11310
Issue: SPR-10548
This commit is contained in:
Juergen Hoeller 2014-09-04 00:41:13 +02:00
parent 82f8b4330c
commit c6d29f1a31
17 changed files with 284 additions and 664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultDependencyComparator.java
View File

@ -1,61 +0,0 @@
/*
* 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.beans.factory.support;
import java.util.Comparator;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.annotation.DefaultOrderProviderComparator;
/**
* The default {@link Comparator} to use to order dependencies. Extends from
* {@link DefaultOrderProviderComparator} so that the bean factory has the ability
* to provide an {@link org.springframework.core.annotation.OrderProvider} that
* is aware of more bean metadata, if any.
*
* @author Stephane Nicoll
* @since 4.1
* @see org.springframework.core.annotation.OrderProviderComparator
* @see org.springframework.core.annotation.OrderProvider
* @see DefaultListableBeanFactory#setDependencyComparator(java.util.Comparator)
*/
public class DefaultDependencyComparator extends DefaultOrderProviderComparator implements Comparator<Object> {
/**
* Shared default instance of DefaultDependencyComparator.
*/
public static final DefaultDependencyComparator INSTANCE = new DefaultDependencyComparator();
private final Comparator<Object> comparator;
public DefaultDependencyComparator() {
this.comparator = AnnotationAwareOrderComparator.INSTANCE;
}
public DefaultDependencyComparator(Comparator<Object> comparator) {
this.comparator = comparator;
}
@Override
public int compare(Object o1, Object o2) {
return this.comparator.compare(o1, o2);
}
}

77
spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java
View File

@ -24,6 +24,7 @@ import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
@ -62,9 +63,8 @@ import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.core.OrderComparator;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.OrderProviderComparator;
import org.springframework.core.annotation.OrderUtils;
import org.springframework.lang.UsesJava8;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
@ -941,7 +941,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
if (this.dependencyComparator != null && result instanceof Object[]) {
sortArray((Object[]) result, matchingBeans);
Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
}
return result;
}
@ -968,7 +968,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
Object result = converter.convertIfNecessary(matchingBeans.values(), type);
if (this.dependencyComparator != null && result instanceof List) {
sortList((List<?>) result, matchingBeans);
Collections.sort((List<?>) result, adaptDependencyComparator(matchingBeans));
}
return result;
}
@ -1029,32 +1029,22 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
}
}
private void sortArray(Object[] items, Map<String, Object> matchingBeans) {
if (this.dependencyComparator instanceof OrderProviderComparator) {
((OrderProviderComparator) this.dependencyComparator)
.sortArray(items, createFactoryAwareOrderProvider(matchingBeans));
private Comparator<Object> adaptDependencyComparator(Map<String, Object> matchingBeans) {
if (this.dependencyComparator instanceof OrderComparator) {
return ((OrderComparator) this.dependencyComparator).withSourceProvider(
createFactoryAwareOrderSourceProvider(matchingBeans));
}
else {
Arrays.sort(items, this.dependencyComparator);
return this.dependencyComparator;
}
}
private void sortList(List<?> items, Map<String, Object> matchingBeans) {
if (this.dependencyComparator instanceof OrderProviderComparator) {
((OrderProviderComparator) this.dependencyComparator)
.sortList(items, createFactoryAwareOrderProvider(matchingBeans));
}
else {
Collections.sort(items, this.dependencyComparator);
}
}
private FactoryAwareOrderProvider createFactoryAwareOrderProvider(Map<String, Object> beans) {
private FactoryAwareOrderSourceProvider createFactoryAwareOrderSourceProvider(Map<String, Object> beans) {
IdentityHashMap<Object, String> instancesToBeanNames = new IdentityHashMap<Object, String>();
for (Map.Entry<String, Object> entry : beans.entrySet()) {
instancesToBeanNames.put(entry.getValue(), entry.getKey());
}
return new FactoryAwareOrderProvider(instancesToBeanNames, this);
return new FactoryAwareOrderSourceProvider(instancesToBeanNames);
}
/**
@ -1223,13 +1213,18 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
/**
* Return the priority assigned for the given bean instance by
* the {@code javax.annotation.Priority} annotation.
* <p>If the annotation is not present, returns {@code null}.
* @param beanInstance the bean instance to check (can be null)
* <p>The default implementation delegates to the specified
* {@link #setDependencyComparator dependency comparator}, checking its
* {@link OrderComparator#getPriority method} if it is an extension of
* Spring's common {@link OrderComparator} - typically, an
* {@link org.springframework.core.annotation.AnnotationAwareOrderComparator}.
* If no such comparator is present, this implementation returns {@code null}.
* @param beanInstance the bean instance to check (can be {@code null})
* @return the priority assigned to that bean or {@code null} if none is set
*/
protected Integer getPriority(Object beanInstance) {
if (beanInstance != null) {
return OrderUtils.getPriorityValue(beanInstance.getClass());
if (this.dependencyComparator instanceof OrderComparator) {
return ((OrderComparator) this.dependencyComparator).getPriority(beanInstance);
}
return null;
}
@ -1406,4 +1401,36 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
}
}
/**
* An {@link org.springframework.core.OrderComparator.OrderSourceProvider} implementation
* that is aware of the bean metadata of the instances to sort.
* <p>Lookup for the method factory of an instance to sort, if any, and let the
* comparator retrieve the {@link org.springframework.core.annotation.Order}
* value defined on it. This essentially allows for the following construct:
*/
private class FactoryAwareOrderSourceProvider implements OrderComparator.OrderSourceProvider {
private final Map<Object, String> instancesToBeanNames;
public FactoryAwareOrderSourceProvider(Map<Object, String> instancesToBeanNames) {
this.instancesToBeanNames = instancesToBeanNames;
}
@Override
public Object getOrderSource(Object obj) {
return getFactoryMethod(this.instancesToBeanNames.get(obj));
}
private Method getFactoryMethod(String beanName) {
if (beanName != null && containsBeanDefinition(beanName)) {
BeanDefinition bd = getMergedBeanDefinition(beanName);
if (bd instanceof RootBeanDefinition) {
return ((RootBeanDefinition) bd).getResolvedFactoryMethod();
}
}
return null;
}
}
}

87
spring-beans/src/main/java/org/springframework/beans/factory/support/FactoryAwareOrderProvider.java
View File

@ -1,87 +0,0 @@
/*
* 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.beans.factory.support;
import java.lang.reflect.Method;
import java.util.Map;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.core.annotation.OrderProvider;
/**
* An {@link OrderProvider} implementation that is aware of the
* bean metadata of the instances to sort.
*
* <p>Lookup for the method factory of an instance to sort, if
* any and retrieve the {@link Order} value defined on it. This
* essentially allows for the following construct:
*
* <pre class="code">
* &#064;Configuration
* public class AppConfig {
*
* &#064;Bean
* &#064;Order(5)
* public MyService myService() {
* return new MyService();
* }
* }</pre>
*
* @author Stephane Nicoll
* @since 4.1
*/
class FactoryAwareOrderProvider implements OrderProvider {
private final Map<Object, String> instancesToBeanNames;
private final ConfigurableListableBeanFactory beanFactory;
public FactoryAwareOrderProvider(Map<Object, String> instancesToBeanNames,
ConfigurableListableBeanFactory beanFactory) {
this.instancesToBeanNames = instancesToBeanNames;
this.beanFactory = beanFactory;
}
@Override
public Integer getOrder(Object obj) {
Method factoryMethod = getFactoryMethod(this.instancesToBeanNames.get(obj));
if (factoryMethod != null) {
Order order = AnnotationUtils.getAnnotation(factoryMethod, Order.class);
if (order != null) {
return order.value();
}
}
return null;
}
private Method getFactoryMethod(String beanName) {
if (beanName != null && beanFactory.containsBeanDefinition(beanName)) {
BeanDefinition bd = beanFactory.getMergedBeanDefinition(beanName);
if (bd instanceof RootBeanDefinition) {
return ((RootBeanDefinition) bd).getResolvedFactoryMethod();
}
}
return null;
}
}

8
spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java
View File

@ -69,6 +69,7 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.factory.xml.ConstructorDependenciesBean;
import org.springframework.beans.propertyeditors.CustomNumberEditor;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.convert.support.GenericConversionService;
@ -1392,6 +1393,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testGetBeanByTypeWithPriority() throws Exception {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(LowPriorityTestBean.class);
lbf.registerBeanDefinition("bd1", bd1);
@ -1403,6 +1405,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testGetBeanByTypeWithMultiplePriority() throws Exception {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(HighPriorityTestBean.class);
lbf.registerBeanDefinition("bd1", bd1);
@ -1416,6 +1419,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testGetBeanByTypeWithPriorityAndNullInstance() throws Exception {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(NullTestBeanFactoryBean.class);
lbf.registerBeanDefinition("bd1", bd1);
@ -1427,6 +1431,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testGetBeanByTypePrimaryHasPrecedenceOverPriority() throws Exception {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd1 = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(TestBean.class);
bd2.setPrimary(true);
@ -1697,6 +1702,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testAutowireBeanByTypeWithTwoMatchesAndPriority() {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(LowPriorityTestBean.class);
lbf.registerBeanDefinition("test", bd);
@ -1710,6 +1716,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testAutowireBeanByTypeWithIdenticalPriorityCandidates() {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(HighPriorityTestBean.class);
lbf.registerBeanDefinition("test", bd);
@ -1730,6 +1737,7 @@ public class DefaultListableBeanFactoryTests {
@Test
public void testAutowireBeanByTypePrimaryTakesPrecedenceOverPriority() {
DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
RootBeanDefinition bd = new RootBeanDefinition(HighPriorityTestBean.class);
RootBeanDefinition bd2 = new RootBeanDefinition(TestBean.class);
bd2.setPrimary(true);

42
spring-beans/src/test/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessorTests.java
View File

@ -39,11 +39,11 @@ import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.TypedStringValue;
import org.springframework.beans.factory.support.AutowireCandidateQualifier;
import org.springframework.beans.factory.support.DefaultDependencyComparator;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.annotation.Order;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.IndexedTestBean;
@ -354,7 +354,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
@Test
public void testOrderedResourceInjection() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
@ -385,38 +385,10 @@ public class AutowiredAnnotationBeanPostProcessorTests {
bf.destroySingletons();
}
@Test
public void testOrderedResourceInjectionDetectsFactoryAwareComparator() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
DefaultDependencyComparator comparator = mock(DefaultDependencyComparator.class);
bf.setDependencyComparator(comparator);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(OptionalResourceInjectionBean.class));
TestBean tb = new TestBean();
bf.registerSingleton("testBean", tb);
IndexedTestBean itb = new IndexedTestBean();
bf.registerSingleton("indexedTestBean", itb);
final OrderedNestedTestBean ntb1 = new OrderedNestedTestBean();
ntb1.setOrder(2);
bf.registerSingleton("nestedTestBean1", ntb1);
final OrderedNestedTestBean ntb2 = new OrderedNestedTestBean();
ntb2.setOrder(1);
bf.registerSingleton("nestedTestBean2", ntb2);
OptionalResourceInjectionBean bean = (OptionalResourceInjectionBean) bf.getBean("annotatedBean");
verify(comparator, never()).compare(any(), any());
verify(comparator, never()).sortList(any(),any());
verify(comparator, times(2)).sortArray(any(),any());
bf.destroySingletons();
}
@Test
public void testAnnotationOrderedResourceInjection() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
@ -448,7 +420,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
@Test
public void testOrderedCollectionResourceInjection() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
@ -489,7 +461,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
@Test
public void testAnnotationOrderedCollectionResourceInjection() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
@ -607,7 +579,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
@Test
public void testConstructorResourceInjectionWithMultipleOrderedCandidates() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
@ -631,7 +603,7 @@ public class AutowiredAnnotationBeanPostProcessorTests {
@Test
public void testConstructorResourceInjectionWithMultipleCandidatesAsOrderedCollection() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
bf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);

68
spring-beans/src/test/java/org/springframework/beans/factory/support/DependencyComparatorTests.java
View File

@ -1,68 +0,0 @@
/*
* 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.beans.factory.support;
import static org.junit.Assert.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.springframework.core.Ordered;
/**
*
* @author Stephane Nicoll
*/
public class DependencyComparatorTests {
private final DefaultDependencyComparator comparator = new DefaultDependencyComparator();
@Test
public void plainComparator() {
List<Object> items = new ArrayList<Object>();
C c = new C(5);
C c2 = new C(-5);
items.add(c);
items.add(c2);
Collections.sort(items, comparator);
assertOrder(items, c2, c);
}
private void assertOrder(List<?> actual, Object... expected) {
for (int i = 0; i < actual.size(); i++) {
assertSame("Wrong instance at index '" + i + "'", expected[i], actual.get(i));
}
assertEquals("Wrong number of items", expected.length, actual.size());
}
private static class C implements Ordered {
private final int order;
private C(int order) {
this.order = order;
}
@Override
public int getOrder() {
return order;
}
}
}

137
spring-beans/src/test/java/org/springframework/beans/factory/support/FactoryAwareOrderProviderTests.java
View File

@ -1,137 +0,0 @@
/*
* 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.beans.factory.support;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
import java.lang.reflect.Method;
import java.util.HashMap;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.annotation.Order;
import org.springframework.util.ReflectionUtils;
/**
*
* @author Stephane Nicoll
*/
public class FactoryAwareOrderProviderTests {
@Rule
public final TestName name = new TestName();
@Mock
private ConfigurableListableBeanFactory beanFactory;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}
@Test
public void noBeanName() {
FactoryAwareOrderProvider orderProvider = createOrderProvider(new HashMap<Object, String>());
assertNull(orderProvider.getOrder(25));
}
@Test
public void beanNameNotRegistered() {
HashMap<Object, String> beans = new HashMap<>();
beans.put(25, "myBean");
given(beanFactory.containsBeanDefinition("myBean")).willReturn(false);
FactoryAwareOrderProvider orderProvider = createOrderProvider(beans);
assertNull(orderProvider.getOrder(25));
verify(beanFactory).containsBeanDefinition("myBean");
}
@Test
public void beanNameNoRootBeanDefinition() {
HashMap<Object, String> beans = new HashMap<>();
beans.put(25, "myBean");
given(beanFactory.containsBeanDefinition("myBean")).willReturn(true);
given(beanFactory.getMergedBeanDefinition("myBean")).willReturn(mock(BeanDefinition.class));
FactoryAwareOrderProvider orderProvider = createOrderProvider(beans);
assertNull(orderProvider.getOrder(25));
verify(beanFactory).containsBeanDefinition("myBean");
verify(beanFactory).getMergedBeanDefinition("myBean");
}
@Test
public void beanNameNoFactory() {
HashMap<Object, String> beans = new HashMap<>();
beans.put(25, "myBean");
RootBeanDefinition rbd = mock(RootBeanDefinition.class);
given(rbd.getResolvedFactoryMethod()).willReturn(null);
given(beanFactory.containsBeanDefinition("myBean")).willReturn(true);
given(beanFactory.getMergedBeanDefinition("myBean")).willReturn(rbd);
FactoryAwareOrderProvider orderProvider = createOrderProvider(beans);
assertNull(orderProvider.getOrder(25));
verify(beanFactory).containsBeanDefinition("myBean");
verify(beanFactory).getMergedBeanDefinition("myBean");
}
@Test
public void beanNameFactoryNoOrderValue() {
HashMap<Object, String> beans = new HashMap<>();
beans.put(25, "myBean");
Method m = ReflectionUtils.findMethod(getClass(), name.getMethodName());
RootBeanDefinition rbd = mock(RootBeanDefinition.class);
given(rbd.getResolvedFactoryMethod()).willReturn(m);
given(beanFactory.containsBeanDefinition("myBean")).willReturn(true);
given(beanFactory.getMergedBeanDefinition("myBean")).willReturn(rbd);
FactoryAwareOrderProvider orderProvider = createOrderProvider(beans);
assertNull(orderProvider.getOrder(25));
verify(beanFactory).containsBeanDefinition("myBean");
verify(beanFactory).getMergedBeanDefinition("myBean");
}
@Test
@Order(500)
public void beanNameFactoryOrderValue() {
HashMap<Object, String> beans = new HashMap<>();
beans.put(25, "myBean");
Method m = ReflectionUtils.findMethod(getClass(), name.getMethodName());
RootBeanDefinition rbd = mock(RootBeanDefinition.class);
given(rbd.getResolvedFactoryMethod()).willReturn(m);
given(beanFactory.containsBeanDefinition("myBean")).willReturn(true);
given(beanFactory.getMergedBeanDefinition("myBean")).willReturn(rbd);
FactoryAwareOrderProvider orderProvider = createOrderProvider(beans);
assertEquals(Integer.valueOf(500), orderProvider.getOrder(25));
verify(beanFactory).containsBeanDefinition("myBean");
verify(beanFactory).getMergedBeanDefinition("myBean");
}
private FactoryAwareOrderProvider createOrderProvider(HashMap<Object, String> beans) {
return new FactoryAwareOrderProvider(beans, beanFactory);
}
}

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

@ -28,7 +28,6 @@ import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultDependencyComparator;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.support.GenericApplicationContext;
@ -49,7 +48,6 @@ import org.springframework.util.ClassUtils;
* @author Juergen Hoeller
* @author Chris Beams
* @author Phillip Webb
* @author Stephane Nicoll
* @since 2.5
* @see ContextAnnotationAutowireCandidateResolver
* @see CommonAnnotationBeanPostProcessor
@ -136,7 +134,7 @@ public class AnnotationConfigUtils {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(DefaultDependencyComparator.INSTANCE);
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());

3
spring-context/src/test/java/org/springframework/context/annotation/spr11310/Spr11310Tests.java → spring-context/src/test/java/org/springframework/context/annotation/Spr11310Tests.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package org.springframework.context.annotation.spr11310;
package org.springframework.context.annotation;
import static org.junit.Assert.*;
@ -30,7 +30,6 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
/**
*
* @author Stephane Nicoll
*/
public class Spr11310Tests {

91
spring-core/src/main/java/org/springframework/core/OrderComparator.java
View File

@ -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.
@ -43,8 +43,27 @@ public class OrderComparator implements Comparator<Object> {
public static final OrderComparator INSTANCE = new OrderComparator();
/**
* Build an adapted order comparator with the given soruce provider.
* @param sourceProvider the order source provider to use
* @return the adapted comparator
* @since 4.1
*/
public Comparator<Object> withSourceProvider(final OrderSourceProvider sourceProvider) {
return new Comparator<Object>() {
@Override
public int compare(Object o1, Object o2) {
return doCompare(o1, o2, sourceProvider);
}
};
}
@Override
public int compare(Object o1, Object o2) {
return doCompare(o1, o2, null);
}
private int doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider) {
boolean p1 = (o1 instanceof PriorityOrdered);
boolean p2 = (o2 instanceof PriorityOrdered);
if (p1 && !p2) {
@ -55,20 +74,62 @@ public class OrderComparator implements Comparator<Object> {
}
// Direct evaluation instead of Integer.compareTo to avoid unnecessary object creation.
int i1 = getOrder(o1);
int i2 = getOrder(o2);
int i1 = getOrder(o1, sourceProvider);
int i2 = getOrder(o2, sourceProvider);
return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
}
/**
* Determine the order value for the given object.
* <p>The default implementation checks against the {@link Ordered}
* interface. Can be overridden in subclasses.
* <p>The default implementation checks against the given {@link OrderSourceProvider}
* using {@link #findOrder} and falls back to a regular {@link #getOrder(Object)} call.
* @param obj the object to check
* @return the order value, or {@code Ordered.LOWEST_PRECEDENCE} as fallback
*/
private int getOrder(Object obj, OrderSourceProvider sourceProvider) {
Integer order = null;
if (sourceProvider != null) {
order = findOrder(sourceProvider.getOrderSource(obj));
}
return (order != null ? order : getOrder(obj));
}
/**
* Determine the order value for the given object.
* <p>The default implementation checks against the {@link Ordered} interface
* through delegating to {@link #findOrder}. Can be overridden in subclasses.
* @param obj the object to check
* @return the order value, or {@code Ordered.LOWEST_PRECEDENCE} as fallback
*/
protected int getOrder(Object obj) {
return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : Ordered.LOWEST_PRECEDENCE);
Integer order = findOrder(obj);
return (order != null ? order : Ordered.LOWEST_PRECEDENCE);
}
/**
* Find an order value indicated by the given object.
* <p>The default implementation checks against the {@link Ordered} interface.
* Can be overridden in subclasses.
* @param obj the object to check
* @return the order value, or {@code null} if none found
*/
protected Integer findOrder(Object obj) {
return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
}
/**
* Determine a priority value for the given object, if any.
* <p>The default implementation always returns {@code null}.
* Subclasses may override this to give specific kinds of values a
* 'priority' characteristic, in addition to their 'order' semantics.
* A priority indicates that it may be used for selecting one object over
* another, in addition to serving for ordering purposes in a list/array.
* @param obj the object to check
* @return the priority value, or {@code null} if none
* @since 4.1
*/
public Integer getPriority(Object obj) {
return null;
}
@ -115,4 +176,22 @@ public class OrderComparator implements Comparator<Object> {
}
}
/**
* Strategy interface to provide an order source for a given object.
* @since 4.1
*/
public static interface OrderSourceProvider {
/**
* Return an order source for the specified object, i.e. an object that
* should be checked for an order value as a replacement to the given object.
* <p>If the returned object does not indicate any order, the comparator
* will fall back to checking the original object.
* @param obj the object to find an order source for
* @return the order source for that object, or {@code null} if none found
*/
Object getOrderSource(Object obj);
}
}

69
spring-core/src/main/java/org/springframework/core/annotation/AnnotationAwareOrderComparator.java
View File

@ -16,19 +16,20 @@
package org.springframework.core.annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.springframework.core.OrderComparator;
import org.springframework.core.Ordered;
/**
* {@link java.util.Comparator} implementation that checks
* {@link org.springframework.core.Ordered} as well as the
* {@link Order} annotation, with an order value provided by an
* {@code Ordered} instance overriding a statically defined
* annotation value (if any).
* {@link java.util.Comparator} implementation that checks Spring's
* {@link org.springframework.core.Ordered} interface as well as the
* {@link Order} annotation and the {@link javax.annotation.Priority}
* annotation, with an order value provided by an {@code Ordered}
* instance overriding a statically defined annotation value (if any).
*
* @author Juergen Hoeller
* @author Oliver Gierke
@ -36,6 +37,7 @@ import org.springframework.core.Ordered;
* @since 2.0.1
* @see org.springframework.core.Ordered
* @see Order
* @see javax.annotation.Priority
*/
public class AnnotationAwareOrderComparator extends OrderComparator {
@ -45,16 +47,55 @@ public class AnnotationAwareOrderComparator extends OrderComparator {
public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();
@Override
protected int getOrder(Object obj) {
if (obj instanceof Ordered) {
return ((Ordered) obj).getOrder();
/**
* This implementation checks for the {@link Order} annotation
* on various kinds of elements, in addition to the
* {@link org.springframework.core.Ordered} check in the superclass.
*/
protected Integer findOrder(Object obj) {
// Check for regular Ordered interface
Integer order = super.findOrder(obj);
if (order != null) {
return order;
}
if (obj != null) {
Class<?> clazz = (obj instanceof Class ? (Class<?>) obj : obj.getClass());
return OrderUtils.getOrder(clazz, Ordered.LOWEST_PRECEDENCE);
// Check for @Order annotation on various kinds of elements
if (obj instanceof Class) {
return OrderUtils.getOrder((Class) obj);
}
return Ordered.LOWEST_PRECEDENCE;
else if (obj instanceof Method) {
Order ann = AnnotationUtils.findAnnotation((Method) obj, Order.class);
if (ann != null) {
return ann.value();
}
}
else if (obj instanceof AnnotatedElement) {
Order ann = AnnotationUtils.getAnnotation((AnnotatedElement) obj, Order.class);
if (ann != null) {
return ann.value();
}
}
else if (obj != null) {
return OrderUtils.getOrder(obj.getClass());
}
return null;
}
/**
* This implementation checks retrieves a {@link javax.annotation.Priority}
* value, allowing for additional semantics over the regular {@link Order}
* annotation: typically, selecting one object over another in case of
* multiple matches but only one object to be returned.
*/
public Integer getPriority(Object obj) {
if (obj instanceof Class) {
return OrderUtils.getPriority((Class) obj);
}
else if (obj != null) {
return OrderUtils.getPriority(obj.getClass());
}
return null;
}

71
spring-core/src/main/java/org/springframework/core/annotation/DefaultOrderProviderComparator.java
View File

@ -1,71 +0,0 @@
/*
* 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.core.annotation;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* A default {@link OrderProviderComparator} implementation that uses the
* value provided by the {@link OrderProvider} and fallbacks to
* {@link AnnotationAwareOrderComparator} if none is set.
*
* <p>This essentially means that the value of the {@link OrderProvider}
* takes precedence over the behavior of {@link AnnotationAwareOrderComparator}
*
* @author Stephane Nicoll
* @since 4.1
*/
public class DefaultOrderProviderComparator implements OrderProviderComparator {
/**
* Shared default instance of DefaultOrderProviderComparator.
*/
public static final DefaultOrderProviderComparator INSTANCE = new DefaultOrderProviderComparator();
@Override
public void sortList(List<?> items, OrderProvider orderProvider) {
Collections.sort(items, new OrderProviderAwareComparator(orderProvider));
}
@Override
public void sortArray(Object[] items, OrderProvider orderProvider) {
Arrays.sort(items, new OrderProviderAwareComparator(orderProvider));
}
private static class OrderProviderAwareComparator extends AnnotationAwareOrderComparator {
private final OrderProvider orderProvider;
public OrderProviderAwareComparator(OrderProvider orderProvider) {
this.orderProvider = orderProvider;
}
@Override
protected int getOrder(Object obj) {
Integer order = this.orderProvider.getOrder(obj);
if (order != null) {
return order;
}
return super.getOrder(obj);
}
}
}

36
spring-core/src/main/java/org/springframework/core/annotation/OrderProvider.java
View File

@ -1,36 +0,0 @@
/*
* 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.core.annotation;
/**
* Strategy interface to provide the order value of a given instance.
*
* @author Stephane Nicoll
* @since 4.1
* @see OrderProviderComparator
*/
public interface OrderProvider {
/**
* Return the order value of the specified object or {@code null} if
* it cannot be retrieved.
* @param obj the object to handle
* @return the order value for that object or {@code null} if none is found
*/
Integer getOrder(Object obj);
}

49
spring-core/src/main/java/org/springframework/core/annotation/OrderProviderComparator.java
View File

@ -1,49 +0,0 @@
/*
* 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.core.annotation;
import java.util.List;
/**
* Sort a collection of element according to an {@link OrderProvider}.
*
* @author Stephane Nicoll
* @since 4.1
*/
public interface OrderProviderComparator {
/**
* Sort the specified list of items according to their order value,
* using the specified {@link OrderProvider} to retrieve an order
* if necessary.
* @param items the items to sort
* @param orderProvider the order provider to use
* @see java.util.Collections#sort(java.util.List, java.util.Comparator)
*/
void sortList(List<?> items, OrderProvider orderProvider);
/**
* Sort the specified array of items according to their order value,
* using the specified {@link OrderProvider} to retrieve an order
* if necessary.
* @param items the items to sort
* @param orderProvider the order provider to use
* @see java.util.Arrays#sort(Object[], java.util.Comparator)
*/
void sortArray(Object[] items, OrderProvider orderProvider);
}

16
spring-core/src/main/java/org/springframework/core/annotation/OrderUtils.java
View File

@ -38,7 +38,17 @@ public abstract class OrderUtils {
/**
* Return the order on the specified {@code type} or the specified
* Return the order on the specified {@code type}.
* <p>Take care of {@link Order @Order} and {@code @javax.annotation.Priority}.
* @param type the type to handle
* @return the order value, or {@code null} if none can be found
*/
public static Integer getOrder(Class<?> type) {
return getOrder(type, null);
}
/**
* Return the order on the specified {@code type}, or the specified
* default value if none can be found.
* <p>Take care of {@link Order @Order} and {@code @javax.annotation.Priority}.
* @param type the type to handle
@ -49,7 +59,7 @@ public abstract class OrderUtils {
if (order != null) {
return order.value();
}
Integer priorityOrder = getPriorityValue(type);
Integer priorityOrder = getPriority(type);
if (priorityOrder != null) {
return priorityOrder;
}
@ -62,7 +72,7 @@ public abstract class OrderUtils {
* @param type the type to handle
* @return the priority value if the annotation is set, {@code null} otherwise
*/
public static Integer getPriorityValue(Class<?> type) {
public static Integer getPriority(Class<?> type) {
if (priorityPresent) {
for (Annotation annotation : type.getAnnotations()) {
if (PRIORITY_ANNOTATION_CLASS_NAME.equals(annotation.annotationType().getName())) {

125
spring-core/src/test/java/org/springframework/core/annotation/DefaultOrderProviderComparatorTests.java → spring-core/src/test/java/org/springframework/core/annotation/OrderSourceProviderTests.java
View File

@ -16,22 +16,36 @@
package org.springframework.core.annotation;
import static org.junit.Assert.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.springframework.core.Ordered;
/**
*
* @author Stephane Nicoll
*/
public class DefaultOrderProviderComparatorTests {
import static org.junit.Assert.*;
private final DefaultOrderProviderComparator comparator = new DefaultOrderProviderComparator();
/**
* @author Stephane Nicoll
* @author Juergen Hoeller
*/
public class OrderSourceProviderTests {
private final AnnotationAwareOrderComparator comparator = AnnotationAwareOrderComparator.INSTANCE;
@Test
public void plainComparator() {
List<Object> items = new ArrayList<Object>();
C c = new C(5);
C c2 = new C(-5);
items.add(c);
items.add(c2);
Collections.sort(items, comparator);
assertOrder(items, c2, c);
}
@Test
public void listNoFactoryMethod() {
@ -40,12 +54,7 @@ public class DefaultOrderProviderComparatorTests {
B b = new B();
List<?> items = Arrays.asList(a, c, b);
comparator.sortList(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
return null;
}
});
Collections.sort(items, comparator.withSourceProvider(obj -> null));
assertOrder(items, c, a, b);
}
@ -56,18 +65,15 @@ public class DefaultOrderProviderComparatorTests {
B b = new B();
List<?> items = Arrays.asList(a, c, b);
comparator.sortList(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
if (obj == a) {
return 4;
}
if (obj == b) {
return 2;
}
return null;
Collections.sort(items, comparator.withSourceProvider(obj -> {
if (obj == a) {
return new C(4);
}
});
if (obj == b) {
return new C(2);
}
return null;
}));
assertOrder(items, b, c, a);
}
@ -77,20 +83,16 @@ public class DefaultOrderProviderComparatorTests {
C c = new C(5);
C c2 = new C(-5);
List<?> items = Arrays.asList(a, c, c2);
comparator.sortList(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
if (obj == a) {
return 4;
}
if (obj == c2) {
return 2;
}
return null;
Collections.sort(items, comparator.withSourceProvider(obj -> {
if (obj == a) {
return 4;
}
});
if (obj == c2) {
return 2;
}
return null;
}));
assertOrder(items, c2, a, c);
}
@ -101,12 +103,7 @@ public class DefaultOrderProviderComparatorTests {
B b = new B();
Object[] items = new Object[] {a, c, b};
comparator.sortArray(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
return null;
}
});
Arrays.sort(items, comparator.withSourceProvider(obj -> null));
assertOrder(items, c, a, b);
}
@ -117,18 +114,15 @@ public class DefaultOrderProviderComparatorTests {
B b = new B();
Object[] items = new Object[] {a, c, b};
comparator.sortArray(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
if (obj == a) {
return 4;
}
if (obj == b) {
return 2;
}
return null;
Arrays.sort(items, comparator.withSourceProvider(obj -> {
if (obj == a) {
return new C(4);
}
});
if (obj == b) {
return new C(2);
}
return null;
}));
assertOrder(items, b, c, a);
}
@ -139,21 +133,19 @@ public class DefaultOrderProviderComparatorTests {
C c2 = new C(-5);
Object[] items = new Object[] {a, c, c2};
comparator.sortArray(items, new OrderProvider() {
@Override
public Integer getOrder(Object obj) {
if (obj == a) {
return 4;
}
if (obj == c2) {
return 2;
}
return null;
Arrays.sort(items, comparator.withSourceProvider(obj -> {
if (obj == a) {
return 4;
}
});
if (obj == c2) {
return 2;
}
return null;
}));
assertOrder(items, c2, a, c);
}
private void assertOrder(List<?> actual, Object... expected) {
for (int i = 0; i < actual.size(); i++) {
assertSame("Wrong instance at index '" + i + "'", expected[i], actual.get(i));
@ -173,11 +165,14 @@ public class DefaultOrderProviderComparatorTests {
private static class A {
}
@Order(2)
private static class B {
}
private static class C implements Ordered {
private final int order;
private C(int order) {

4
spring-core/src/test/java/org/springframework/core/annotation/OrderUtilsTests.java
View File

@ -50,12 +50,12 @@ public class OrderUtilsTests {
@Test
public void getPriorityValueNoAnnotation() {
assertNull(OrderUtils.getPriorityValue(SimpleOrder.class));
assertNull(OrderUtils.getPriority(SimpleOrder.class));
}
@Test
public void getPriorityValue() {
assertEquals(Integer.valueOf(55), OrderUtils.getPriorityValue(OrderAndPriority.class));
assertEquals(Integer.valueOf(55), OrderUtils.getPriority(OrderAndPriority.class));
}
@Order(50)