Spring4（3）——IOC控制反轉

阿新 • • 發佈：2018-11-07

1.Spring裝配一個bean

在前一章中已涉及到此知識點，通俗的來講：在建立People實體之後，在beans.xml 中配置，然後在實現類中呼叫 beans.xml檔案，即裝配完成，呼叫預設的構造方法。

建立實體（People.java）類

public class People {

    private int id;
    private String name;
    private int age;
    
    // 構造方法
    public People() {     
        super();
    }
    
     
public People(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }  
}

配置beans.xml 檔案

<bean id="people" class="com.java1234.entity.People"></bean>

呼叫beans.xml 檔案

ApplicationContext ac=new 
 ClassPathXmlApplicationContext("beans.xml");

2.依賴注入

1. 屬性注入；
2. 建構函式注入；(通過型別；通過索引；聯合使用)
3. 工廠方法注入；(非靜態工廠，靜態工廠)

4. 泛型依賴注入；(參考後面 Spring4 整合 Hibernate4 記錄)

    <!-- 裝配 -->
    <bean id="people" class="com.java1234.entity.People"></bean>


    <!-- 
 屬性注入-->
    <bean id="people2" class="com.java1234.entity.People">
        <property name="id" value="1"></property>
        <property name="name" value="張三"></property>
        <property name="age" value="11"></property>
    </bean>


  
    <!-- 建構函式注入（通過型別）-->
    <bean id="people3" class="com.java1234.entity.People">
        <constructor-arg type="int" value="2"></constructor-arg>
        <constructor-arg type="String" value="李四"></constructor-arg>
        <constructor-arg type="int" value="22"></constructor-arg>
    </bean>
    
    <!-- 建構函式注入（通過索引）-->
    <bean id="people4" class="com.java1234.entity.People">
        <constructor-arg index="0" value="3"></constructor-arg>
        <constructor-arg index="1" value="王五"></constructor-arg>
        <constructor-arg index="2" value="55"></constructor-arg>
    </bean>
    
    <!-- 建構函式注入（型別索引聯合使用）-->
    <bean id="people5" class="com.java1234.entity.People">
        <constructor-arg index="0" type="int" value="4"></constructor-arg>
        <constructor-arg index="1" type="String" value="招六"></constructor-arg>
        <constructor-arg index="2" type="int" value="66"></constructor-arg>
    </bean>


    
    <!-- 工廠方法注入（非靜態工廠）-->
    <bean id="peopleFactory" class="com.java1234.factory.PeopleFactory"></bean>
    <bean id="people6" factory-bean="peopleFactory" factory-method="createPeople"></bean>
  
    <!-- 工廠方法注入（靜態工廠）-->
    <bean id="people7" class="com.java1234.factory.PeopleFactory2" factory-method="createPeople"></bean>

public class Test2 {

    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        People people=(People)ac.getBean("people");
        System.out.println(people);
        
        // 屬性注入
        People people2=(People)ac.getBean("people2");
        System.out.println(people2);
        
        // 構造方法注入
        People people3=(People)ac.getBean("people3");
        System.out.println(people3);
        
        People people4=(People)ac.getBean("people4");
        System.out.println(people4);
        
        People people5=(People)ac.getBean("people5");
        System.out.println(people5);
        
        // 工廠方法注入
        People people6=(People)ac.getBean("people6");
        System.out.println(people6);
        
        People people7=(People)ac.getBean("people7");
        System.out.println(people7);
    }
}

3.注入引數

1. 基本型別值：參見上一節屬性注入

2. 注入 bean；

<!-- 在 people2 裡面注入 dog1 -->
<bean id="dog1" class="com.java1234.entity.Dog">
　　<property name="name" value="Jack"></property>
</bean>
    
<bean id="people2" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <property name="dog" ref="dog1"></property>  <!-- bean 注入 ，在 People.java 類中宣告 dog類-->
</bean>

3. 內部 bean；

<bean id="people3" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <property name="dog">
        <bean class="com.java1234.entity.Dog">
            <property name="name" value="Tom"></property>
        </bean>
    </property>
</bean>

4. null 值；

<bean id="people4" class="com.java1234.entity.People">
     <property name="id" value="1"></property>
     <property name="name" value="張三"></property>
     <property name="age" value="11"></property>
     <property name="dog">
         <null></null>
     </property>
</bean>

5. 級聯屬性；

<bean id="people5" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <property name="dog.name" value="Jack2"></property> 
    <!-- 因為此處用到了dog的屬性，需要在宣告的時候new一個dog物件。（ private Dog dog = new Dog(); ） -->
</bean>

6. 集合型別屬性；

<bean id="people6" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <property name="dog" ref="dog1"></property>
    <property name="hobbies">
        <list>  <!-- list集合，可重複 -->
            <value>唱歌</value>
            <value>跳舞</value>
        </list>
    </property>
    <property name="loves">
        <set>  ·<!-- set集合，不可重複 -->
            <value>唱歌2</value>
            <value>跳舞2</value>
        </set>
    </property>
    <property name="works">
        <map>   <!-- Map鍵值對  -->
            <entry>
                <key><value>上午</value></key>
                <value>寫程式碼</value>
            </entry>
            <entry>
                <key><value>下午</value></key>
                <value>測試程式碼</value>
            </entry>
        </map>
    </property>
    <property name="addresses">
        <props>   <!-- props 輸入結果和Map類似，props 主要用於一些系統的配置-->
            <prop key="address1">aaaaa</prop>
            <prop key="address2">bbbbb</prop>
        </props>
    </property>
</bean>

private Dog dog;
private List<String> hobbies=new ArrayList<String>();
private Set<String> loves=new HashSet<String>();
private Map<String,String> works=new HashMap<String,String>();
private Properties addresses=new Properties();

4.自動裝配

通過配置 default-autowire 屬性（byName，byType，constructor），Spring IOC 容器可以自動為程式注入 bean；預設是 no，不啟用自動裝配；

<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
        http://www.springframework.org/schema/beans/spring-beans.xsd"
        default-autowire="constructor"> <!-- 在此處設定 -->

byName：通過名稱進行自動匹配，根據類中宣告的屬性名稱選擇注入的值；

// People.java
private Dog dog1;

<!-- beans.xml -->
<bean id="dog1" class="com.java1234.entity.Dog">
        <property name="name" value="Tom"></property>
</bean>

<bean id="dog2" class="com.java1234.entity.Dog">
    <property name="name" value="Jack"></property>
</bean>
    
<bean id="people1" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
</bean>

// 測試
public void test1() {
    private ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
    People people=(People)ac.getBean("people1");
    System.out.println(people);
}

結果是：取出的狗名叫：Tom，注意看People.java裡面宣告的狗是 dog1.

byType：根據型別進行自動匹配，class="com.java1234.entity.Dog ；
constructor：和 byType 類似，只不過它是根據構造方法注入而言的，根據型別，自動注入；

建議：自動裝配機制慎用，它遮蔽了裝配細節，容易產生潛在的錯誤；

5.方法注入

Spring bean 作用域預設是單例 singleton；可以通過配置 prototype ，實現多例；方法注入 lookup-method .

預設單例：每次獲取的例項都是一樣的

System.out.println(ac.getBean("dog")=ac.getBean("dog")); //返回true

配置多例：每次獲取的例項是不一樣的（ scope="prototype" ）
```
<bean id="dog" class="com.java1234.entity.Dog" scope="prototype">
    <property name="name" value="Jack"></property>
</bean>
```
```
System.out.println(ac.getBean("dog")=ac.getBean("dog")); //返回false
```
注：當把dog bean作為屬性注入給其他bean是，是同一條狗，而不是新的！所以可以使用lookup-method 方法注入修改

bean注入時lookup-method

<bean id="dog" class="com.java1234.entity.Dog" scope="prototype">
    <property name="name" value="Jack"></property>
</bean>
    
<bean id="people1" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <lookup-method name="getDog" bean="dog"/>  <!-- lookup-method -->
</bean>

注：此時要將getDog的方法改成抽象方法

public abstract class People {

    private Dog dog;
    
    public abstract Dog getDog();
    
    public void setDog(Dog dog) {
        this.dog = dog;
    }   
}

6.方法替換

假如，people1 有一條叫 Tom 的狗，people2 有一條叫 Jack 的狗，現在 people1 想要名叫 Jack 即 people2 的狗，即可用方法替換來實現。

此時需要將 people2 的 getDog() 方法替換成people1 的。

people2 實現介面 MethodReplacer

public class People2 implements MethodReplacer {

    @Override
    public Object reimplement(Object arg0, Method arg1, Object[] arg2)
            throws Throwable {
        Dog dog=new Dog();
        dog.setName("Tom");
        return dog;
    }
}

<bean id="people2" class="com.java1234.entity.People2"></bean>
    
<bean id="people1" class="com.java1234.entity.People">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
    <property name="age" value="11"></property>
    <replaced-method name="getDog" replacer="people2"></replaced-method>
    <!-- 用people2裡面的reimplement來替換people1裡面的getDog方法 -->
</bean>

7.Bean之間的關係

1. 繼承：抽象的Bean可以定義一些公共的屬性和方法（ abstract="true" ）

<!-- bstract="true" -->
<bean id="abstractPeople" class="com.java1234.entity.People" abstract="true">
    <property name="className" value="高三5班"></property>
    <property name="age" value="19"></property>
</bean>
    
<!-- parent="abstractPeople" -->
<bean id="lisi" parent="abstractPeople">  <!-- 無需class，可不建立實體類 -->
    <property name="id" value="2"></property>
    <property name="name" value="李四"></property>
    <property name="age" value="20"></property>  <!-- 屬性可重寫 -->
</bean>
    
<!-- 結果是：id=2——李四——高三5班——20歲 -->

2. 依賴：未加入依賴的時候，按順序執行bean；加入依賴後，會先去執行依賴的 bean （ depends-on="autority" ），可用於許可權設定

<!-- depends-on="autority" -->
<bean id="zhangsan" parent="abstractPeople" depends-on="autority">
    <property name="id" value="1"></property>
    <property name="name" value="張三"></property>
</bean>

<bean id="autority" class="com.java1234.service.Authority"></bean>

3. 引用：引用bean （ref），可參照前面的內容

8.Bean的作用範圍

1. singleton：Spring ioc 容器中僅有一個 Bean 例項，Bean 以單例的方式存在；
2. prototype：每次從容器中呼叫 Bean 時，都返回一個新的例項；
3. request：每次 HTTP 請求都會建立一個新的 Bean；
4. session：同一個 HTTP Session 共享一個 Bean；
5. global session：同一個全域性 Session 共享一個 Bean，一般用於 Portlet 應用環境；

6. application：同一個 Application 共享一個 Bean；

<!-- scope="singleton/prototype/....." -->
<bean id="dog" class="com.java1234.entity.Dog" scope="singleton">
    <property name="name" value="jack"></property>
</bean>

Spring4（3）——IOC控制反轉

1.Spring裝配一個bean 在前一章中已涉及到此知識點，通俗的來講：在建立People實體之後，在beans.xml 中配置，然後在實現類中呼叫 beans.xml檔案，即裝配完成，呼叫預設的構造方法。建立實體（People.java）類 publi

Spring4（2）——IOC控制反轉（概念理解）

控制引用接口 java的反射機制 test 法則 imp 基礎上 ava 1.IOC控制反轉的概念 IOC（控制反轉：Inverse of Control ），又稱作依賴註入，是一種重要的面向對象編程的法則來削減計算機程序的耦合問題，也是輕量級的 Spring 框架的

Spring詳解（二）------IOC控制反轉

tsp name 調試的人好的 turn 同時 eth 時機　　我相信提到 Spring，很多人會脫口而出IOC（控制反轉）、DI（依賴註入）、AOP等等概念，這些概念也是面試官經常問到的知識點。那麽這篇博客我們就來詳細的講解 IOC控制反轉。　　ps:本篇博客源

Spring學習（三）IOC控制反轉與DI依賴注入

IOC（Inversion of Control，控制反轉）是spring的核心，貫穿始終。所謂IOC，對於spring框架來說，就是由spring來負責控制物件的生命週期和物件間的關係：傳統開發

關於php中依賴注入（DI）和控制反轉（IOC）的理解

一、什麼是依賴注入和控制反轉 1.依賴注入（DI）— Dependecy Injection 為了更方便的理解，我們把依賴注入分開理解，首先什麼是依賴？顧名思義，依賴就是各元件之間的一種關係。一般來說，在面向物件程式設計中，我們在類A中使用到了類B的例項，我們就可以說

ASP.NET Core中的依賴注入（1）：控制反轉（IoC）

ASP.NET Core在啟動以及後續針對每個請求的處理過程中的各個環節都需要相應的元件提供相應的服務，為了方便對這些元件進行定製，ASP.NET通過定義介面的方式對它們進行了“標準化”，我們將這些標準化的元件稱為服務，ASP.NET在內部專門維護了一個DI容器來提供所需的服務。要了解這個DI容器以及現實其中

Spring學習（1）：控制反轉（IoC）和依賴注入（DI）的詳解以及註解（annotation）開發入門案例

前言以往的java學習中，我們要想得到一個物件，就把它new出來。如：Apple apple = new Apple(); 在一些複雜的系統中，一個物件A可能依賴於物件B，C等（程式碼表現為A類持有B，C類的物件作為A類的屬性）。以往來說，我們想要使用B，

依賴倒置原則（DIP）、控制反轉（IoC）、依賴注入（DI）（C#）

理解：依賴倒置原則（DIP）主程式要依賴於抽象介面，不要依賴於具體實現。高層模組不應該依賴底層模組，兩個都應該以來抽象。抽象不應該依賴細節，細節應該依賴抽象。（具體看我上一篇貼子）依賴倒置原則是六大設計原則中的一種，它的大致意思是所有模組都應該依賴於抽象，而不是直接依賴於另一個模組。依賴倒置原則僅僅只是一

python基礎（3）---流程控制

組成不同一個 if語句 range inpu n-1 一是選擇　　流程控制　　與C語言不通的是python的流程控制代碼塊不是用{}花括號表示的，而是強制縮進來控制的；而且縮進必須一致，官方推薦是使用4個空格，不建議使用tab（制表符）做縮進，一是不同的系統tab

C語言基礎教程（3）流程控制

流程控制什麼是流程控制程式程式碼執行的順序。流程控制的分類順序執行選擇執行定義：某些程式碼可能執行，可能不執行，有選擇的執行某些程式碼。分類：if If最簡單的用法：如果想控制多個語句的執行或者不執行，那麼需要

用Latex排版論文（3）《控制與決策》初稿LaTex模版編譯出現"\bibname undefined"解決辦法

師姐要投NEU辦的《控制與決策》，我幫忙用LaTex排版。我下載了《控制與決策》官網提供的模板之後，嘗試編譯了一下，結果出現“\bibname undefined”的錯誤。官網給出了一個解決這個問題的辦法如下：我嘗試了一下這個方法，要改的地方不只這一個問

（3）版本控制工具之SVN和MyEclipse整合

1.引言在本篇部落格主要介紹如何在Myeclipse中使用我們的SVN，首先我們需要安裝我們的SVN外掛，讓我們的軟體支援SVN，我用到的MyEclipse的版本是10，SVN的外掛下載地址為：SVN_MyEclipse下載連結

PHP基礎（3）---流程控制語句

一.PHP流程控制概述在其他語言中我們已經掌握了流程控制相關語句，在PHP裡面也是大同小異的東西，大致分為：順序結構，選擇結構，迴圈結構，很少有一個程式只使用一種結構來完成某種操作，基本上都是三種合用。順序結構順序結構是最基本的結構方式，各流程

ROS學習記錄（3）--Kobuki控制大合集

宣告：本文收錄Kobuki所有操作命令，以後都在本文更新。 1.啟動Kobuki roslaunch kobuki_node minimal.launch 2.改變顏色或關閉LED（通過釋出話

QT入門系列（3）：控制臺輸出QString

blog 版權 iostream out data 使用來源 str 控制臺方式一：使用qDebug()輸出 QString str("liyifeng");qDebug() << str;12輸出結果："liyifeng" QString str("liy

大話DI依賴註入+IOC控制反轉（一）之定義

註入調用加密想法搜索 rsa 資料 16px 方法依賴註入與控制反轉依賴註入與控制反轉是老生常談的問題。一般面試也會面試到這種問題。網上很多很多這方面的資料，搜索出來一大堆。下面我們大話一下這些個定義。 DI依賴註入依賴註入既依賴，又註入。

大話DI依賴注入+IOC控制反轉（二）之淺析.Net Core中的DI與IOC

在上一篇文章中，我們聊了很多關於定義的方面，比較孤燥，下面我們結合.Net Core聊一下依賴注入&控制反轉。三種物件生命週期關於.Net Core中的容

java IoC(控制反轉) 通俗易懂的解釋（轉）

IoC(控制反轉) 　　首先想說說IoC（Inversion of Control，控制反轉）。這是spring的核心，貫穿始終。所謂IoC，對於spring框架來說，就是由spring來負責控制物件的生命週期和物件間的關係。這是什麼意思呢，舉個簡單的例子，我們是如何找女朋友的？常見的情況是，我

Spring入門案例（Ioc 控制反轉）

1、首先匯入spring必須要的4個核心包（beans、core、context、expression）+1個依賴（commons-logging...jar） 2、目標類

spring框架（Ioc控制反轉）

重點： 1、什麼是Spring； 2、ioc的優勢； 3、Spring注入方式；重點解析：一、Spring是什麼，使用有什麼好處什麼是spring，它能夠做什麼? Spring是一個開源框架，它由Rod Johnson建立。它是為了解決企業應用開發

Spring4（3）——IOC控制反轉

1.Spring裝配一個bean

建立實體 （People.java） 類

配置beans.xml 檔案

呼叫beans.xml 檔案

2.依賴注入

3.注入引數

1. 基本型別值：參見上一節屬性注入

2. 注入 bean；

3. 內部 bean；

4. null 值；

5. 級聯屬性；

6. 集合型別屬性；

4.自動裝配

5.方法注入

6.方法替換

7.Bean之間的關係

8.Bean的作用範圍

相關推薦

建立實體（People.java）類