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;
}
}