碼上快樂

相關內容    簡體    繁體

SPRING BOOT 注解之OBJECTPROVIDER源碼追蹤

本文轉載自   查看原文   2020-09-23 11:08   520    sprintboot/ 源碼/ springboot

最近依舊在學習閱讀Spring Boot的源代碼，在此過程中涉及到很多在日常項目中比較少見的功能特性，對此深入研究一下，也挺有意思，這也是閱讀源碼的魅力之一。這里寫成文章，分享給大家。

自動配置中的ObjectProvider

在閱讀Spring Boot自動配置源碼中關於redis的配置時，看到這樣如下的自動配置配置源代碼。

    /**
     * Redis connection configuration.
     */
    @Configuration
    @ConditionalOnClass(GenericObjectPool.class)
    protected static class RedisConnectionConfiguration {

        private final RedisProperties properties;

        private final RedisSentinelConfiguration sentinelConfiguration;

        private final RedisClusterConfiguration clusterConfiguration;

        public RedisConnectionConfiguration(RedisProperties properties,
                ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration,
                ObjectProvider<RedisClusterConfiguration> clusterConfiguration) {
            this.properties = properties;
            this.sentinelConfiguration = sentinelConfiguration.getIfAvailable();
            this.clusterConfiguration = clusterConfiguration.getIfAvailable();
        }

 和

//源自org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration
@Configuration
@AutoConfigureAfter(HttpMessageConvertersAutoConfiguration.class)
public class WebClientAutoConfiguration {
 
    @Configuration
    @ConditionalOnClass(RestTemplate.class)
    public static class RestTemplateConfiguration {
 
        private final ObjectProvider<HttpMessageConverters> messageConverters;
 
        private final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers;
 
        public RestTemplateConfiguration(
                ObjectProvider<HttpMessageConverters> messageConverters,
                ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
            this.messageConverters = messageConverters;
            this.restTemplateCustomizers = restTemplateCustomizers;
        }
.....

 

這就是一個常規的基於Java的配置類，那么你是否發現它在用法與其他的有所不同？是的，那就是三個ObjectProvider的參數。這也是本文要講的內容。

Spring的注入

在介紹ObjectProvider的使用之前，我們先來回顧一下注入相關的知識。

在Spring的使用過程中，我們可以通過多種形式將一個類注入到另外一個類當中，比如通過@Autowired和@Resources注解。

而@Autowired又可以注解在不同的地方來達到注入的效果，比如注解在構造函數上：

@Service
public class FooService {
    private final FooRepository repository;
    @Autowired
    public FooService(FooRepository repository) {
        this.repository = repository
    }
}

注解在屬性上：

@Service
public class FooService {
    @Autowired
    private final FooRepository repository;
}

注解在setter方法上：

@Service
public class FooService {
    private final FooRepository repository;
    @Autowired
    public void setFooRepository(FooRepository repository) {
        this.repository = repository
    }
}

spring4.3新特性--構造函數隱式注入

上面是最常見的注入方式，如果忘記寫@Autowired注解，那么在啟動的時候就會拋出異常。

但在spring 4.3之后，引入了一個新特性：當構造方法的參數為單個構造參數時，可以不使用@Autowired進行注解。

因此，上面的代碼可變為如下形式：

@Service
public class FooService {
    private final FooRepository repository;
    public FooService(FooRepository repository) {
        this.repository = repository
    }
}

同樣，您可能已經注意到@Configuration類歷史上不支持構造函數注入。它們現在從4.3開始，它們顯然也允許在單構造函數場景中省略@Autowired。使用此種形式便會顯得優雅一些。該特性，在Spring Boot的自動配置類中大量被使用。但是隱式注入也不是完美的，個人理解不完美是它是強依賴，如果這個依賴不存在，就會發生這樣的悲劇：

Parameter 0 of constructor in com.example.demo.FooRepository required a bean of type 'com.example.demo.OrderServiceV2' that could not be found.

怎么破？接下來就是今天的主角：ObjectProvider

依賴關系的改進版編程

Spring Framework 4.3版本中，

  1. 隱式的注入了單構造參數的屬性
  2. 還引入了ObjectProvider接口

ObjectProvider的使用場景：

  1. @Autowire注解可以用於字段，setter，構造函數
  2. 但是構造函數有多個參數的時候，@Autowire就不知道怎么辦了。
  3. Spring 4.x 以后，如果構造方法的參數只有一個，那么會自動加入@autowire進行依賴注入
  4. 同時，針對多個參數的情況，可以只用ObjectProvider進行包裹，在構造函數中，由編碼的方式進行延遲調用。

引入了ObjectProvider，它是現有ObjectFactory接口的擴展，具有方便的簽名，例如getIfAvailable和getIfUnique，只有在它實際存在時才檢索bean（可選支持）或者如果可以確定單個候選者（特別是：主要候選者）在多個匹配的bean的情況下）。使用ObjectProvider之后，上面的代碼便變為如下方式：

@Service
public class FooService {
    private final FooRepository repository;
    public FooService(ObjectProvider<FooRepository> repositoryProvider) {
        this.repository = repositoryProvider.getIfUnique();
    }
}

 

這樣的好處很顯然，當容器中不存在FooRepository或存在多個時，可以從容處理。但壞處也很明顯，如果FooRepository不能為null，則可能將異常從啟動階段轉移到業務運行階段。

ObjectProvider：

ObjectProvider接口是ObjectFactory接口的擴展，專門為注入點設計的，可以讓注入變得更加寬松和更具有可選項。

那么什么時候使用ObjectProvider接口？

如果待注入參數的Bean為空或有多個時，便是ObjectProvider發揮作用的時候了。

如果注入實例為空時，使用ObjectProvider則避免了強依賴導致的依賴對象不存在異常；如果有多個實例，ObjectProvider的方法會根據Bean實現的Ordered接口或@Order注解指定的先后順序獲取一個Bean。從而了提供了一個更加寬松的依賴注入方式。

Spring 5.1之后提供了基於Stream的orderedStream方法來獲取有序的Stream的方法。

ObjectProvider源碼

ObjectProvider接口是ObjectFactory接口的擴展，先看ObjectFactory接口源碼：

public interface ObjectFactory<T> {

    /**
     * Return an instance (possibly shared or independent)
     * of the object managed by this factory.
     * @return an instance of the bean (should never be {@code null})
     * @throws BeansException in case of creation errors
     */
    T getObject() throws BeansException;

}

 

 

ObjectProvider的源碼及解析如下：

@since 4.3
public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {

    // 返回指定類型的bean, 如果容器中不存在, 拋出NoSuchBeanDefinitionException異常
    // 如果容器中有多個此類型的bean, 拋出NoUniqueBeanDefinitionException異常
    T getObject(Object... args) throws BeansException;

    // 如果指定類型的bean注冊到容器中, 返回 bean 實例, 否則返回 null
    @Nullable
    T getIfAvailable() throws BeansException;

    // 如果返回對象不存在，則進行回調，回調對象由Supplier傳入
    default T getIfAvailable(Supplier<T> defaultSupplier) throws BeansException {
        T dependency = getIfAvailable();
        return (dependency != null ? dependency : defaultSupplier.get());
    }

     // 消費對象的一個實例（可能是共享的或獨立的），如果存在通過Consumer回調消耗目標對象。
    default void ifAvailable(Consumer<T> dependencyConsumer) throws BeansException {
        T dependency = getIfAvailable();
        if (dependency != null) {
            dependencyConsumer.accept(dependency);
        }
    }

    // 如果不可用或不唯一（沒有指定primary）則返回null。否則，返回對象。
    @Nullable
    T getIfUnique() throws BeansException;

    // 如果存在唯一對象，則調用Supplier的回調函數
    default T getIfUnique(Supplier<T> defaultSupplier) throws BeansException {
        T dependency = getIfUnique();
        return (dependency != null ? dependency : defaultSupplier.get());
    }

    // 如果存在唯一對象，則消耗掉該對象
    default void ifUnique(Consumer<T> dependencyConsumer) throws BeansException {
        T dependency = getIfUnique();
        if (dependency != null) {
            dependencyConsumer.accept(dependency);
        }
    }

    // 返回符合條件的對象的Iterator，沒有特殊順序保證（一般為注冊順序）
    @Override
    default Iterator<T> iterator() {
        return stream().iterator();
    }

    // 返回符合條件對象的連續的Stream，沒有特殊順序保證（一般為注冊順序）
    default Stream<T> stream() {
        throw new UnsupportedOperationException("Multi element access not supported");
    }

    // 返回符合條件對象的連續的Stream。在標注Spring應用上下文中采用@Order注解或實現Order接口的順序
    default Stream<T> orderedStream() {
        throw new UnsupportedOperationException("Ordered element access not supported");
    }
}

@since 4.3 ：也就是說它是spring 4.3版本才有的新東西。屬於ObjectFactory的變體，ObjectFactory接口的擴展，專門為注入點設計的，可以讓注入變得更加寬松和更具有可選項。

其中，在BeanFactory中也使用了該接口來定義方法的返回值：

public interface BeanFactory {

    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    ...
}

看ObjectProvider的繼承關系，只有一個DependencyObjectProvider，它的核心源碼在DefaultListableBeanFactory中，跟進去查看源碼：

/**
     * Serializable ObjectFactory/ObjectProvider for lazy resolution of a dependency.
     */
    private class DependencyObjectProvider implements ObjectProvider<Object>, Serializable {

        private final DependencyDescriptor descriptor;

        private final boolean optional;

        private final String beanName;

        public DependencyObjectProvider(DependencyDescriptor descriptor, String beanName) {
            this.descriptor = new NestedDependencyDescriptor(descriptor);
            this.optional = (this.descriptor.getDependencyType() == javaUtilOptionalClass);
            this.beanName = beanName;
        }

        @Override
        public Object getObject() throws BeansException {
            if (this.optional) {
                return new OptionalDependencyFactory().createOptionalDependency(this.descriptor, this.beanName);
            }
            else {
                return doResolveDependency(this.descriptor, this.beanName, null, null);
            }
        }

        @Override
        public Object getObject(final Object... args) throws BeansException {
            if (this.optional) {
                return new OptionalDependencyFactory().createOptionalDependency(this.descriptor, this.beanName, args);
            }
            else {
                DependencyDescriptor descriptorToUse = new DependencyDescriptor(descriptor) {
                    @Override
                    public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
                        return ((AbstractBeanFactory) beanFactory).getBean(beanName, requiredType, args);
                    }
                };
                return doResolveDependency(descriptorToUse, this.beanName, null, null);
            }
        }

        @Override
        public Object getIfAvailable() throws BeansException {
            if (this.optional) {
                return new OptionalDependencyFactory().createOptionalDependency(this.descriptor, this.beanName);
            }
            else {
                DependencyDescriptor descriptorToUse = new DependencyDescriptor(descriptor) {
                    @Override
                    public boolean isRequired() {
                        return false;
                    }
                };
                return doResolveDependency(descriptorToUse, this.beanName, null, null);
            }
        }

        @Override
        public Object getIfUnique() throws BeansException {
            DependencyDescriptor descriptorToUse = new DependencyDescriptor(descriptor) {
                @Override
                public boolean isRequired() {
                    return false;
                }
                @Override
                public Object resolveNotUnique(Class<?> type, Map<String, Object> matchingBeans) {
                    return null;
                }
            };
            if (this.optional) {
                return new OptionalDependencyFactory().createOptionalDependency(descriptorToUse, this.beanName);
            }
            else {
                return doResolveDependency(descriptorToUse, this.beanName, null, null);
            }
        }
    }

大概了解了起使用場景，他的解釋：
Serializable ObjectFactory/ObjectProvider for lazy resolution of a dependency.。他的大概意圖就是用於延遲延遲加載使用。在查看很多Spring的代碼時候，用處大多數是用於在構造方法上進行使用。

Spring使用的代碼段,
DefaultListableBeanFactory

@Override public Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException { descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (javaUtilOptionalClass == descriptor.getDependencyType()) { return new OptionalDependencyFactory().createOptionalDependency(descriptor, requestingBeanName); } else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) { return new DependencyObjectProvider(descriptor, requestingBeanName); }

使用場景：

@Service public class FooService { private final FooRepository repository; public FooService(ObjectProvider<FooRepository> repositoryProvider) { this.repository = repositoryProvider.getIfUnique(); } }

其實深入觀察，它實際上調用了的就是DefaultListableBeanFactory去解析依賴的Bean。

至此，關於ObjectProvider的使用和源碼解析完成。

原文鏈接：《SPRING BOOT 注解之OBJECTPROVIDER源碼追蹤》

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Spring Boot 自動配置注解源碼解析 【Spring Boot源碼分析】@EnableAutoConfiguration注解（一）@AutoConfigurationImportSelector注解的處理 Spring Boot中@ConfigurationProperties注解實現原理源碼解析 Spring Boot 之 annotation注解 Spring Boot中的注解 曹工說Spring Boot源碼（24）-- Spring注解掃描的瑞士軍刀，asm技術實戰（上） Spring延遲依賴注入ObjectFactory/ObjectProvider spring boot: 條件注解@Condition Spring Boot-2 （@GetMapping注解） spring boot bean對象及注解
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM