2. 程式人生 > >BeanFactory和它的物件註冊和依賴繫結的三種方式

BeanFactory和它的物件註冊和依賴繫結的三種方式

阿新 • • 發佈：2019-01-08

一、Spring中的BeanFactory是什麼？

  BeanFactory是個基本的IoC容器，提供完整的IoC服務支援，負責物件建立的管理和依賴注入服務

  如果沒有特殊指定，預設採用延遲初始化策略（lazy-load）。只有當客戶端物件需要訪問容器中的某個受管物件的時候，才對該受管物件進行初始化以及依賴注入操作

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    boolean containsBean(String var1);

    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    String[] getAliases(String var1);
}

二、BeanFactory的物件註冊和依賴繫結的三種方式

1、直接編碼方式（無需xml檔案）

 1.1 專案結構

1.2 各個程式碼

public class App {
    private String says = "App";

    private App(){
        System.out.println("呼叫App無參構造");
    }

    public App(String says) {
        System.out.println("呼叫App有參構造, 引數says為：" + says);
        this.says = says;
    }

    public void say(){
        System.out.println("App.say()：" + says);
    }

    public String getSays() {
        return says;
    }

    public void setSays(String says) {
        this.says = says;
    }

    @Override
    public String toString() {
        return "App{" +
                "says='" + says + '\'' +
                '}';
    }
}
 
public class Coder {
    private App app;

    private Coder(){
        System.out.println("呼叫Coder無參構造");
    }

    public Coder(App app) {
        System.out.println("呼叫Coder有參構造，引數app為：" + app.toString());
        this.app = app;
    }

    public App getApp() {
        return app;
    }

    public void setApp(App app) {
        System.out.println("呼叫Coder.setApp(), 引數app為: " + app.toString());
        this.app = app;
    }
}
 
public class BeanFactoryTest extends TestCase {
    /**
     * 直接編碼方式
     */
    public void testRedirectCode() {
        DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
        BeanFactory beanFactory = bindViaCode(beanRegistry);
        Coder coder = (Coder) beanFactory.getBean("coder");
        coder.getApp().say();

        /**
         * 輸出為：
         * //通過構造方法注入的情況
         * 呼叫App無參構造
         * 呼叫Coder有參構造，引數app為：App{says='App'}
         * App.say()：App
         *
         * //通過setter方式注入的情況下
         * 呼叫Coder無參構造
         * 呼叫App無參構造
         * 呼叫Coder.setApp(), 引數app為: App{says='App'}
         * App.say()：App
         */
    }

    public static BeanFactory bindViaCode(BeanDefinitionRegistry registry){
        AbstractBeanDefinition appBeanDefinition = new RootBeanDefinition(App.class);
        AbstractBeanDefinition coderBeanDefinition = new RootBeanDefinition(Coder.class);

        //將beanDefinition註冊到容器中
        registry.registerBeanDefinition("app", appBeanDefinition);
        registry.registerBeanDefinition("coder", coderBeanDefinition);

        //指定依賴關係
        //1、可以通過構造方法注入
//        ConstructorArgumentValues argumentValues = new ConstructorArgumentValues();
//        argumentValues.addIndexedArgumentValue(0, appBeanDefinition);
//        coderBeanDefinition.setConstructorArgumentValues(argumentValues);

        //2、可以通過setter方法注入
        MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
        mutablePropertyValues.addPropertyValue("app", appBeanDefinition);
        coderBeanDefinition.setPropertyValues(mutablePropertyValues);

        //繫結完成
        return (BeanFactory)registry;
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--這是 pom.xml檔案 -->
    <groupId>com.me.sourcecode</groupId>
    <artifactId>spring-explore</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.1.3.RELEASE</spring.version>
    </properties>


    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

</project>

1.3 原理 （摘自《spring揭祕》）

   打個比方說，BeanDefinitionRegistry就像圖書館的書架，所有的書是放在書架上的。雖然你
還書或者借書都是跟圖書館（也就是BeanFactory，或許BookFactory可能更好些）打交道，但書架才
是圖書館存放各類圖書的地方。所以，書架相對於圖書館來說，就是它的“BookDefinitionRegistry”。


   每一個受管的物件，在容器中都會有一個BeanDefinition的例項（instance）與之相對應，該
BeanDefinition的例項負責儲存物件的所有必要資訊，包括其對應的物件的class型別、是否是抽象
類、構造方法引數以及其他屬性等。當客戶端向BeanFactory請求相應物件的時候，BeanFactory會
通過這些資訊為客戶端返回一個完備可用的物件例項。RootBeanDefinition和ChildBean-
Definition是BeanDefinition的兩個主要實現類。

2、xml配置檔案方式

2.1 專案結構（上面的基礎上）

2.2 新增檔案SpringBean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <bean id="app" class="com.me.sourcecode.bean.App"></bean>

    <!--<bean id="coder" class="com.me.sourcecode.bean.Coder">-->
        <!--<constructor-arg index="0">-->
            <!--<ref bean="app" />-->
        <!--</constructor-arg>-->
    <!--</bean>-->

    <bean id="coder" class="com.me.sourcecode.bean.Coder">
        <property name="app" ref="app"></property>
    </bean>
</beans>

BeanFactoryTest類裡，增加對xml檔案配置方式的測試

/**
     * xml配置檔案方式
     */
    public void testXmlFile(){
        DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();
        BeanFactory beanFactory = bindViaXmlFile(beanRegistry);
        Coder coder = (Coder) beanFactory.getBean("coder");
        coder.getApp().say();
    }

public static BeanFactory bindViaXmlFile(BeanDefinitionRegistry registry) {
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(registry);
        xmlBeanDefinitionReader.loadBeanDefinitions("classpath*:SpringBean.xml");
        return (BeanFactory) registry;
    }

2.3 原理（摘自《spring揭祕》）

  XmlBeanDefinitionReader負責讀取Spring指定格式的XML配置檔案並解析，之後將解析後的檔案內
容對映到相應的BeanDefinition，並載入到相應的BeanDefinitionRegistry中（在這裡是DefaultListableBeanFactory）

3、基於註解的方式

3.1 專案結構（不變）

3.2  有修改的內容

@Component
public class App {
    private String says = "App";

    private App(){
        System.out.println("呼叫App無參構造");
    }

    public App(String says) {
        System.out.println("呼叫App有參構造, 引數says為：" + says);
        this.says = says;
    }

    public void say(){
        System.out.println("App.say()：" + says);
    }

    public String getSays() {
        return says;
    }

    public void setSays(String says) {
        this.says = says;
    }

    @Override
    public String toString() {
        return "App{" +
                "says='" + says + '\'' +
                '}';
    }
}
@Component
public class Coder {
    @Autowired
    private App app;

    private Coder(){
        System.out.println("呼叫Coder無參構造");
    }

    public Coder(App app) {
        System.out.println("呼叫Coder有參構造，引數app為：" + app.toString());
        this.app = app;
    }

    public App getApp() {
        return app;
    }

    public void setApp(App app) {
        System.out.println("呼叫Coder.setApp(), 引數app為: " + app.toString());
        this.app = app;
    }
}

SpringBean.xml檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <context:component-scan base-package="com.me.sourcecode.bean" />
</beans>

BeanFactoryTest增加基於註解方式的測試

/**
     * 基於註解的方式
     */
    public void testAnnoation(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("SpringBean.xml");
        Coder coder = (Coder) applicationContext.getBean("coder");
        coder.getApp().say();

        /**
         * 輸出為：
         * 呼叫App無參構造
         * 呼叫Coder無參構造
         *
         * App.say()：App
         */
    }

3.3 原理  

  可以看到輸出結果中，沒有呼叫Coder.setApp()這一句，而又有App.say(): App這一句。它是Coder裡面的app是怎麼注入進入的呢？

 1） 通過SpringBean.xml檔案的<context:component-scan base-package="com.me.sourcecode.bean" />，開始掃描這個路徑，處理所有@Component註解標記的類（即App，Coder），生成對應的BeanDefinition

2）根據BeanDefinition建立Bean，此時Coder裡面的app還是null，也就說還沒有進行依賴注入

3）建立Bean之後，有個例項化Bean的流程。在這個流程中，AutowiredAnnotationBeanPostProcessor起了作用，通過反射的方式將App注入到Coder物件裡面了。

反射 field.set(bean, value) ，此時bean是Coder的例項，value是App的例項

相關推薦

Spring中BeanFactory的物件註冊與依賴繫結方式

概念 BeanFactory是spring的基礎型別IOC容器,提供完整的IOC服務支援 預設採用延遲初始化策略,當客戶端物件訪問受管物件時,才對其進行初始化和依賴注入 理解 BeanFactory將每個物件看做一個bean,通過配置檔案,編碼,註解等方式獲取組裝這個bean的 零

spring揭祕 讀書筆記 二 BeanFactory的物件註冊與依賴繫結

本文是王福強所著<<spring揭祕>>一書的讀書筆記 我們前面就說過,Spring的IoC容器時一個IoC Service Provider,而且IoC Service Provider提供兩個功能物件的建立,依賴關係的管理。 不過,IoC容器這個

在CDH5.14.0和Apache--Hbase1.2 中安裝Phoenix的三種方式

目錄: 第一種CDH離線安裝(下載解壓安裝) 第二種CDH線上安裝(下載parcer線上安裝) 第三種Apache-Hbase離線安裝(下載解壓安裝) 第一種離線安裝(下載解壓安裝) 沒有參考別人的,自己弄的.因為之前弄過apapche-hbase的安裝.後來

JS建立物件，陣列，函式的三種方式

  　　害怕自己忘記，簡單總結一下   　　建立物件的3種方法 　　①：建立一個空物件 　　 　　var obj = {}; 　　②：物件字面量 　　　　var obj = { 　　　　　　name: "Tom", 　　　　　　age: 27　　　　} 　　③

依賴注入的三種方式

Spring通過DI（依賴注入）實現IOC（控制反轉），常用的注入方式主要有三種：構造方法注入，setter注入，基於註解的注入。構造方法注入先簡單看一下測試專案的結構，用maven構建的，四個包：entity：儲存實體，裡面只有一個User類dao：資料訪問，一個介面，兩個

【SSH三大框架】Spring基礎第二篇：Spring依賴注入的三種方式

控制反轉(Inversion of Control)和依賴注入(Dependency Injection)：應用控制反轉，物件在被建立的時候，由一個調控系統內所有物件的外界實體將其所依賴的物件的引用傳遞給它。也可以說，依賴被注入到物件中。所以，控制反轉是，關於一個物件如何獲

註冊 Jdbc 驅動程式的三種方式及Class.forName 的作用

（1）jdbc中註冊驅動，首先匯入對應的包，例如mysql-connector-java-5.0.8-bin.jar。驅動包是java和具體資料庫之間的連線橋樑，由資料庫廠商開發。每一種資料庫對應一款驅動jar，甚至每一個版本的資料庫都有自己對應版本的驅動jar。 （2

【C++】輸入流物件cin讀取輸入流的三種方式

輸入流物件cin讀取輸入流的三種方式 cin 輸入流物件有三種讀取控制檯輸入的方法。 分別為: 使用“>>”運算子，這種方法只能讀取單個單詞，cin使用空白(空格、製表符和換行符)來確定字串的結束位置使用getline()成員函式，getline()方法面

Spring依賴注入的三種方式

Spring支援兩種依賴注入方式，分別是屬性注入和建構函式注入。除此之外，Spring還支援工廠方法注入。 1.屬性注入 實體類Car，有三個屬性 public class Car { private int maxSpeed; pr

ASP.NET MVC之下拉框繫結四種方式

http://www.cnblogs.com/CreateMyself/p/5424894.html 前言 上兩節我們講了檔案上傳的問題，關於這個上傳的問題還未結束，我也在花時間做做分割大檔案處理以及顯示進度的問題，到時完成的話再發表，為了不耽誤學習MVC其他

IOC與DI的講解以及依賴注入的三種方式

首先：第一個問題，參與者都有誰？1）物件2）IOC/DI容器3）某個物件的外部資源第二問題：依賴，誰依賴誰？為什麼需要依賴？依賴嘛，很好理解的，物件依賴於IOC/DI容器，至於為什麼要依賴呢？物件需要IOC/DI容器來提供物件需要的外部資源。第三個問題：注入，誰注入誰？又注入了什麼呢？顯而易見是IOC/DI容

BeanFactory和它的物件註冊和依賴繫結的三種方式

一、Spring中的BeanFactory是什麼？   BeanFactory是個基本的IoC容器，提供完整的IoC服務支援，負責物件建立的管理和依賴注入服務   如果沒有特殊指定，預設採用延遲初始化策略（lazy-load）。只有當客戶端物件需要訪問容器中的某個受管物件

spring揭秘 讀書筆記 二 BeanFactory的對象註冊與依賴綁定

oct anr ctx nfc col line 增加 sso default 本文是王福強所著<<spring揭秘>>一書的讀書筆記 我們前面就說過,Spring的IoC容器時一個IoC Service Provider,並且IoC

物件建立的三種方式和閉包的兩種常用場景--js

物件建立的三種方式 ①通過new關鍵字建立物件 var obj = new Object(); obj.name = 'daxue'; obj.age = 28; obj.fun = function(){ } alert(obj.age); ②

Kubenetes裡pod和service繫結的實現方式

我之前的文章 如何在Kubernetes裡建立一個Nginx service介紹瞭如何建立一個Kubernetes pod和service，使用的方法是命令kubectl run。 本文介紹另一種方式，通過這種方式來學習Kubernetes裡pod和對應的ser

JS建立物件的三種方式和閉包的兩種常用場景

物件建立的三種方式 ①通過new關鍵字建立物件 var obj = new Object(); obj.name = 'daxue'; obj.age = 28; obj.fun = function(){ } alert(obj.age); ②簡單字面量

AndroidStudio中新增依賴的三種方式以及如何引入so檔案和arr檔案

轉載自：http://blog.csdn.net/zxc514257857/article/details/56534863 前言   AndroidStudio中新增依賴的三個選項，如圖：   分別為：庫依賴（Library dependency）、檔案依賴（

Angular.js基本概念和用法--（一雙向資料繫結）

這個雙向資料繫結指的是從資料模型到檢視，從檢視到資料模型之間的雙向繫結。前面介紹過AngularJS是一個MVC框架，我們在操作的時候主要是通過控制器進行操作的，讓控制器去修改資料模型，然後資料模型的變更會反映到檢視上。內容簡介1.最簡單的例子2.取值表示式與ng-bind指

AngularJS中單選按鈕和多選框的動態繫結

AngularJS中的單選按鈕的動態繫結十分簡單，寫法如下： <input type="radio" name="sex" value="man" ng-model="sex">男 <input type="radio" name="se

backboneJS 使用心得（2）view和model事件的多次繫結（轉載）

一，new 一個新的View物件時，最好把，el引數傳進去；而不是在view裡面操作view的外部節點。 比如： 外部呼叫 var view=new BankboneView({el,$('body')}); view內部： $(this.el).html(-template(...)) 二，如果