工作中常用到的 Spring 依賴(lài)管理技術(shù)盤(pán)點(diǎn)

作者：佚名 2021-09-23 15:13:02

今天主要和大家分享一些在工作中可能會(huì)用到的Spring依賴(lài)注入，依賴(lài)查找方面的技術(shù)點(diǎn)整理，非常實(shí)用。

Spring依賴(lài)查找專(zhuān)題

單一類(lèi)型查找

常見(jiàn)用法如下所示：

Object getBean(String name) throws BeansException;  
<T> T getBean(Class<T> requiredType) throws BeansException;  
<T> T getBean(String name, Class<T> requiredType) throws BeansException

ObjectProvider

隨著Spring版本的升高，也開(kāi)始出現(xiàn)了延遲查找的功能。當(dāng)我們實(shí)際需要用到某個(gè)bean的時(shí)候才將其從容器中進(jìn)行初始化并且提取出來(lái)。

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

Spring會(huì)返回一個(gè)ObjectProvider，當(dāng)查詢的時(shí)候才會(huì)觸發(fā)bean的創(chuàng)建。

延遲查找的好處在于，如果一個(gè)bean需要注入到spring容器中，但是不希望太過(guò)早地去進(jìn)行初始化，那么可以思考使用ObjectProvider的方式來(lái)進(jìn)行初始化。

集合類(lèi)型查找

Bean的名稱(chēng)查詢

String[] getBeanNamesForType(@Nullable Class<?> type);   
String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

獲取同類(lèi)型Bean實(shí)例列表

getBeansOfType(Class)

按照注解去查詢

String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);  
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;  
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;

使用依賴(lài)查找時(shí)候的一些小心得：

對(duì)于判斷一個(gè)bean是否存在，可以采用判斷其beandefinition是否存在，一般這樣不會(huì)觸發(fā)其中bean的初始化操作，例如：getBeanNamesForType。反觀getBeansOfType可能回觸發(fā)bean的初始化

層次性的bean查找

可能大多數(shù)人在實(shí)際使用Spring容器的時(shí)候?qū)τ趯哟涡缘腷ean做計(jì)算并沒(méi)有太多的實(shí)戰(zhàn)嘗試，這里我舉個(gè)例子：

例如說(shuō)A容器中包含了Bean A，如果B容器繼承了A容器，那么按道理來(lái)說(shuō)也應(yīng)該能夠獲得Bean A資源，這種設(shè)計(jì)可以減少Bean的額外存儲(chǔ)。

如果你理解了我上邊所說(shuō)的這個(gè)案例之后，再來(lái)看看下邊的這張圖可能就會(huì)有更加深入的理解了。

關(guān)于層次性的bean獲取，我這里給出一個(gè)小的demo供大家學(xué)習(xí)：

package org.idea.spring.look.up.factory;  
import org.springframework.beans.factory.BeanFactory;  
import org.springframework.beans.factory.HierarchicalBeanFactory;  
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
/**  
 * 層次性的依賴(lài)查找 {@link org.springframework.beans.factory.HierarchicalBeanFactory}  
 *  
 * @Author idea  
 * @Date created in 10:55 下午 2021/4/10  
 */  
public class SpringHierarchicalLookUpDemo {  
    public static void main(String[] args) {  
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
        applicationContext.register(SpringHierarchicalLookUpDemo.class);  
        applicationContext.refresh();  
        ParentIocContainer parentIocContainer = new ParentIocContainer();  
        ApplicationContext parentApplicationContext = parentIocContainer.getAndStartApplicationContext();  
        // ConfigurableListableBeanFactory -> ConfigurableBeanFactory -> HierarchicalBeanFactory  
        ConfigurableListableBeanFactory configurableListableBeanFactory = applicationContext.getBeanFactory();  
        System.out.println("此時(shí)的父類(lèi)BeanFactory為：" + configurableListableBeanFactory.getParentBeanFactory());  
        configurableListableBeanFactory.setParentBeanFactory(parentApplicationContext);  
        System.out.println("此時(shí)的父類(lèi)BeanFactory為：" + configurableListableBeanFactory.getParentBeanFactory());  
        ParentIocContainer.ParentBean parentBean = (ParentIocContainer.ParentBean) configurableListableBeanFactory.getBean("parentBean");  
        System.out.println(parentBean);  
        isContainedBean(configurableListableBeanFactory, "parentBean");  
        displayContainsBean(configurableListableBeanFactory, "parentBean");  
    }  
    /**  
     * 這里是子類(lèi)可以獲取自己和父類(lèi)層次內(nèi)部的bean，如果是使用containsLocalBean方法的話就只能判斷當(dāng)前所在層次的容器上下文  
     *  
     * @param beanFactory  
     * @param beanName  
     */  
    public static void isContainedBean(HierarchicalBeanFactory beanFactory, String beanName) {  
        System.out.println("getBean is " + beanFactory.getBean(beanName));  
        System.out.printf("contained is [%s] ,beanFactory is [%s],beanName is [%s]\n", beanFactory.containsLocalBean(beanName), beanFactory, beanName);  
    }  
    /**  
     * 查找關(guān)于父類(lèi)容器內(nèi)部的bean  
     *  
     * @param beanFactory  
     * @param beanName  
     */  
    private static void displayContainsBean(HierarchicalBeanFactory beanFactory, String beanName) {  
        System.out.printf("contained is [%s] ,beanFactory is [%s],beanName is [%s]\n", isContainedBeanInHoldApplication(beanFactory, beanName), beanFactory, beanName);  
    }  
    /**  
     * 使用遞歸判斷 -- 自上到下判斷父類(lèi)容器是否含有bean  
     *  
     * @param hierarchicalBeanFactory  
     * @param beanName  
     * @return  
     */  
    public static boolean isContainedBeanInHoldApplication(HierarchicalBeanFactory hierarchicalBeanFactory, String beanName) {  
        BeanFactory parentBeanFactory = hierarchicalBeanFactory.getParentBeanFactory();  
        if (parentBeanFactory instanceof HierarchicalBeanFactory) {  
            HierarchicalBeanFactory parentHierarchicalBeanFactory = HierarchicalBeanFactory.class.cast(parentBeanFactory);  
            if (isContainedBeanInHoldApplication(parentHierarchicalBeanFactory, beanName)) {  
                return true;  
            }  
        }  
        return hierarchicalBeanFactory.containsBean(beanName);  
    }  
}

對(duì)應(yīng)的父類(lèi)容器案例：

package org.idea.spring.look.up.factory;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
/**  
 * 父類(lèi)ioc容器 這里面的ioc容器只包含有ParentBean這個(gè)類(lèi)  
 *  
 * @Author idea  
 * @Date created in 8:46 上午 2021/4/11  
 */  
public class ParentIocContainer {  
    public static AnnotationConfigApplicationContext applicationContext = null;  
    class ParentBean {  
        int id;  
        public ParentBean(){  
            System.out.println("this is no arg init");  
        }  
        @Override  
        public String toString() {  
            return "ParentBean{" +  
                    "id=" + id +  
                    '}';  
        }  
    }  
    public ApplicationContext getAndStartApplicationContext(){  
       applicationContext = new AnnotationConfigApplicationContext();  
       applicationContext.register(ParentIocContainer.class);  
       //需要支持無(wú)參構(gòu)造函數(shù)  
       applicationContext.registerBean("parentBean",ParentBean.class); 
       applicationContext.refresh();  
       return applicationContext;  
    }  
    public static void main(String[] args) {  
        ParentIocContainer parentIocContainer = new ParentIocContainer();  
        ApplicationContext applicationContext = parentIocContainer.getAndStartApplicationContext();  
        String[] str = applicationContext.getBeanNamesForType(ParentBean.class);  
        for (String beanName : str) {  
            System.out.println(beanName);  
        }  
    } 
}

從這段代碼中可以看出，HierarchicalBeanFactory是一種常見(jiàn)的層次類(lèi)BeanFactory，并且當(dāng)我們需要判斷一個(gè)bean是否存在某個(gè)容器上下文中的時(shí)候，不妨可以試試使用BeanFacoty自帶的這個(gè)方法：

org.springframework.beans.factory.HierarchicalBeanFactory#containsLocalBean  
/**  
 * Return whether the local bean factory contains a bean of the given name,  
 * ignoring beans defined in ancestor contexts.  
 * <p>This is an alternative to {@code containsBean}, ignoring a bean  
 * of the given name from an ancestor bean factory.  
 * @param name the name of the bean to query  
 * @return whether a bean with the given name is defined in the local factory  
 * @see BeanFactory#containsBean 
 */  
boolean containsLocalBean(String name);

Spring依賴(lài)注入專(zhuān)題

依賴(lài)注入的幾種模式

手動(dòng)注入模式：

寫(xiě)XML的方式注入
通過(guò)注解的方式注入
通過(guò)API的方式去注入

自動(dòng)注入的模式：

使用Autowiring的模式進(jìn)行注入

常見(jiàn)的注入案例：

xml方式注入

例如通過(guò)xml配置文件對(duì)bean的屬性進(jìn)行注入：

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
        https://www.springframework.org/schema/beans/spring-beans.xsd">  
    <bean id="malePerson" class="org.idea.spring.ioc.bean.Person" >  
    <property name="id" value="1"></property>  
    <property name="name" value="idea"></property>  
</bean>  
    <bean class="org.idea.spring.dependency.inject.setter.PersonHolder">  
        <property name="person" ref="malePerson"></property>  
    </bean>  
</beans>

對(duì)應(yīng)的Person對(duì)象

@Data  
@AllArgsConstructor  
@NoArgsConstructor  
public class Person {  
    Integer id;  
    String name; 
}

注解的方式注入

例如加入一個(gè)@Bean的注解進(jìn)行注入容器

@Bean  
  public PersonHolder personHolder(Person person){  
      return new PersonHolder(person);  
  }

Spring容器內(nèi)部的api注入

核心是利用了BeanDefinitionBuilder進(jìn)行一個(gè)beanDefinition的構(gòu)建，然后將這個(gè)beanDefinition給注入到Spring容器當(dāng)中，上下文在啟動(dòng)之后會(huì)將之前準(zhǔn)備好的BeanDefinition機(jī)械能初始化創(chuàng)建。

import org.idea.spring.ioc.bean.Person;  
import org.springframework.beans.factory.config.BeanDefinition;  
import org.springframework.beans.factory.support.BeanDefinitionBuilder;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
import org.springframework.context.annotation.Bean; 
/**  
 * 通過(guò)api的方式進(jìn)行注入實(shí)現(xiàn)  
 *  
 * @Author idea  
 * @Date created in 11:11 下午 2021/4/21  
 */  
public class ApiDependencyInjectDemo {  
    @Bean  
    public Person myPerson(){  
        return new Person(1,"idea");  
    }  
    public static void main(String[] args) {  
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
        applicationContext.register(ApiDependencyInjectDemo.class);  
        BeanDefinition personBeanDefinition = createUserBeanDefinition();  
        applicationContext.registerBeanDefinition("personHolder",personBeanDefinition);  
        applicationContext.refresh();  
        PersonHolder personHolder = applicationContext.getBean(PersonHolder.class);  
        System.out.println(personHolder.getPerson());  
        applicationContext.close();  
    }  
    private static BeanDefinition createUserBeanDefinition() { 
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(PersonHolder.class);  
        //注意這里的add方法有多種類(lèi)型，需要注意下細(xì)節(jié)點(diǎn)  
        beanDefinitionBuilder.addPropertyReference("person","myPerson");  
        return beanDefinitionBuilder.getBeanDefinition();  
    }  
}

@Resource,@Autowire,@Qualifier模式注入

這兩類(lèi)的注入在實(shí)際使用中頻率比較高：

@Resource注解的注入會(huì)根據(jù)后邊的字段類(lèi)型識(shí)別進(jìn)行注入
@Autowire則會(huì)根據(jù)bean的類(lèi)型進(jìn)行注入

這里有一段案例：

public class AnnotationDependencyInjectDemo {  
    @Autowired  
    private PersonHolder personHolder2;  
    @Resource  
    private PersonHolder personHolder;  
    public static void main(String[] args) {  
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
        applicationContext.register(AnnotationDependencyInjectDemo.class);  
        applicationContext.refresh();  
        AnnotationDependencyInjectDemo annotationDependencyInjectDemo = applicationContext.getBean(AnnotationDependencyInjectDemo.class);  
        System.out.println(annotationDependencyInjectDemo.personHolder);  
        System.out.println(annotationDependencyInjectDemo.personHolder2);  
        //這里面的兩個(gè)bean都是同一個(gè)，因?yàn)閎ean的作用域是一致相同的  
        System.out.println(annotationDependencyInjectDemo.personHolder == annotationDependencyInjectDemo.personHolder2);  
        applicationContext.close();  
    }  
    @Bean  
    public PersonHolder personHolder(){  
        return new PersonHolder(new Person(1,"idea"));  
    }  
}

如果出現(xiàn)了一個(gè)接口對(duì)應(yīng)多個(gè)實(shí)現(xiàn)類(lèi)，但是代碼中使用的是@Autowire的方式進(jìn)行依賴(lài)注入，此時(shí)可以通過(guò)新增@Qualifier注解的方式來(lái)實(shí)現(xiàn)依賴(lài)注入的效果。

單純從實(shí)際使用來(lái)說(shuō)，我個(gè)人感覺(jué)@Resource = @Autowire + @Qualifier

依賴(lài)注入和依賴(lài)查找

在常見(jiàn)的業(yè)務(wù)開(kāi)發(fā)當(dāng)中，我們可能會(huì)使用到比較多的依賴(lài)注入注解，但是在一些基礎(chǔ)組件的開(kāi)發(fā)中，我個(gè)人感覺(jué)使用依賴(lài)查找往往更加具有靈活性。

Spring內(nèi)部的Bean有哪幾種

自定義的bean

例如業(yè)務(wù)系統(tǒng)中常見(jiàn)的XXXXDao,XXXXService

Spring容器中初始化構(gòu)建好的Bean

例如Spring容器中的Enviorment對(duì)象

Spring容器內(nèi)部的一些基礎(chǔ)服務(wù)對(duì)象

例如Spring容器內(nèi)部的BeanFactory對(duì)象，這類(lèi)Bean通常是無(wú)法通過(guò)getBean接口去直接獲取的。

Spring中的BeanDefinition對(duì)象

上邊我們有提及過(guò)到Spring內(nèi)部提供了相關(guān)的Api供開(kāi)發(fā)者進(jìn)行靈活的依賴(lài)注入。但是當(dāng)我們深入到具體細(xì)節(jié)進(jìn)行分析之后，其實(shí)是可以發(fā)現(xiàn)BeanDefinition對(duì)象也是有不同類(lèi)型差異的。

用戶自定義的BeanDeinition對(duì)象例如這樣一段代碼：

public class ApiDependencyInjectDemo {  
    @Bean  
    public Person myPerson(){  
        return new Person(1,"idea");  
    }  
    public static void main(String[] args) {  
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
        applicationContext.register(ApiDependencyInjectDemo.class);  
        BeanDefinition personBeanDefinition = createUserBeanDefinition();  
        applicationContext.registerBeanDefinition("personHolder",personBeanDefinition);  
        applicationContext.refresh();  
        PersonHolder personHolder = applicationContext.getBean(PersonHolder.class);  
        System.out.println(personHolder.getPerson());  
        applicationContext.close();  
    }  
    private static BeanDefinition createUserBeanDefinition() {  
        //spring官方比較推薦的一種注入方式  
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(PersonHolder.class);  
        //注意這里的add方法有多種類(lèi)型，需要注意下細(xì)節(jié)點(diǎn)  
        beanDefinitionBuilder.addConstructorArgReference("myPerson");  
        return beanDefinitionBuilder.getBeanDefinition();  
    }  
}

框架內(nèi)部初始化定義好的BeanDefinition對(duì)象

具體體現(xiàn)在Spring容器進(jìn)行初始化的時(shí)候，內(nèi)部的refresh函數(shù)中有個(gè)prepareBeanFactory。

點(diǎn)進(jìn)去這個(gè)函數(shù)，對(duì)它的源代碼進(jìn)行深入解讀之后你會(huì)發(fā)現(xiàn)，其實(shí)內(nèi)部已經(jīng)注冊(cè)了一系列的BeanDefinition對(duì)象。

在容器初始化之后是否還能注冊(cè)Bean？

其實(shí)是可以的，下邊我通過(guò)使用BeanDefiniation的案例來(lái)和你一起分析一下：

package org.idea.spring.bean.source;  
import org.springframework.beans.factory.config.BeanDefinition;  
import org.springframework.beans.factory.support.BeanDefinitionBuilder;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
import org.idea.spring.bean.beandefinitionbuilder.User;  
/**  
 * @Author idea  
 * @Date created in 4:44 下午 2021/9/18  
 */  
public class AddBeanAfterRefreshDemo {  
    public static void main(String[] args) {  
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();  
        annotationConfigApplicationContext.register(AddBeanAfterRefreshDemo.class);  
        annotationConfigApplicationContext.refresh();  
        try {  
            User user0 = annotationConfigApplicationContext.getBean(User.class);  
            System.out.println("user0 is " + user0);  
        } catch (Exception b) {  
            b.printStackTrace();  
        }  
        System.out.println("啟動(dòng)后手動(dòng)注入bean對(duì)象");  
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);  
        beanDefinitionBuilder.setScope("prototype"); 
        beanDefinitionBuilder  
                .addPropertyValue("id", 2)  
                .addPropertyValue("name", "idea");  
        annotationConfigApplicationContext.registerBeanDefinition("user", beanDefinitionBuilder.getBeanDefinition());  
        //1)  
        User user1 = (User) annotationConfigApplicationContext.getBean("user");  
        BeanDefinition beanDefinition = annotationConfigApplicationContext.getBeanDefinition("user");  
        System.out.println(beanDefinition.getScope());  
        System.out.println(user1);  
        annotationConfigApplicationContext.close();  
    } 
}

注意，這里面如果將1)部分的代碼調(diào)整為：

User user1 = (User) annotationConfigApplicationContext.getBean(User.class);

則不會(huì)實(shí)現(xiàn)容器啟動(dòng)后注冊(cè)了對(duì)應(yīng)的bean，但是依然查詢不到預(yù)期對(duì)象的效果。這是因?yàn)樵赟pring容器底層會(huì)有一個(gè)Map專(zhuān)門(mén)記錄不同的beanClass類(lèi)型對(duì)應(yīng)不同的beanName集合，從而導(dǎo)致第二次查詢的時(shí)候走了第一次查詢時(shí)候的緩存。代碼位于：

org.springframework.beans.factory.support.DefaultListableBeanFactory  
/** Map of singleton and non-singleton bean names, keyed by dependency type. */  
  private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);