Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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
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);
}
}