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

時間 2020-05-28

標籤 spring 詳解 ioc 控制反轉欄目 Spring 简体版

原文原文鏈接

　　我相信提到 Spring，不少人會脫口而出IOC（控制反轉）、DI（依賴注入）、AOP等等概念，這些概念也是面試官常常問到的知識點。那麼這篇博客咱們就來詳細的講解 IOC控制反轉。java

　　ps:本篇博客源碼下載連接：http://pan.baidu.com/s/1miwZIf2 密碼：oquc程序員

一、什麼是 IOC？

　　IOC-Inversion of Control，即控制反轉。它不是什麼技術，而是一種設計思想。面試

　　傳統的建立對象的方法是直接經過 new 關鍵字，而 spring 則是經過 IOC 容器來建立對象，也就是說咱們將建立對象的控制權交給了 IOC 容器。咱們能夠用一句話來歸納 IOC：spring

　　IOC 讓程序員不在關注怎麼去建立對象，而是關注與對象建立以後的操做，把對象的建立、初始化、銷燬等工做交給spring容器來作。tomcat

二、分享Bromon的blog上對IoC與DI淺顯易懂的講解

　　IoC（Inversion of Control，控制反轉）。這是spring的核心，貫穿始終。所謂IoC，對於spring框架來講，就是由spring來負責控制對象的生命週期和對象間的關係。這是什麼意思呢，舉個簡單的例子，咱們是如何找女友的？常見的狀況是，咱們處處去看哪裏有長得漂亮身材又好的mm，而後打聽她們的興趣愛好、qq號、電話號、ip號、iq號………，想辦法認識她們，投其所好送其所要，而後嘿嘿……這個過程是複雜深奧的，咱們必須本身設計和麪對每一個環節。傳統的程序開發也是如此，在一個對象中，若是要使用另外的對象，就必須獲得它（本身new一個，或者從JNDI中查詢一個），使用完以後還要將對象銷燬（好比Connection等），對象始終會和其餘的接口或類藕合起來。session

　　那麼IoC是如何作的呢？有點像經過婚介找女友，在我和女友之間引入了一個第三者：婚姻介紹所。婚介管理了不少男男女女的資料，我能夠向婚介提出一個列表，告訴它我想找個什麼樣的女友，好比長得像李嘉欣，身材像林熙雷，唱歌像周杰倫，速度像卡洛斯，技術像齊達內之類的，而後婚介就會按照咱們的要求，提供一個mm，咱們只須要去和她談戀愛、結婚就好了。簡單明瞭，若是婚介給咱們的人選不符合要求，咱們就會拋出異常。整個過程再也不由我本身控制，而是有婚介這樣一個相似容器的機構來控制。Spring所倡導的開發方式就是如此，全部的類都會在spring容器中登記，告訴spring你是個什麼東西，你須要什麼東西，而後spring會在系統運行到適當的時候，把你要的東西主動給你，同時也把你交給其餘須要你的東西。全部的類的建立、銷燬都由 spring來控制，也就是說控制對象生存週期的再也不是引用它的對象，而是spring。對於某個具體的對象而言，之前是它控制其餘對象，如今是全部對象都被spring控制，因此這叫控制反轉。

app

三、Spring 容器建立對象的三種方式

　　第一步：建立工程，而後導入相應的 jar 包，以下圖：（詳情參見上面的源碼下載）框架

　　第二步：建立測試對象 HelloIoc函數

package com.ys.ioc;
//這是測試對象，咱們經過 IOC 來建立對象
public class HelloIoc {
	
	public void sayHello(){
		System.out.println("Hello IOC");
	}
}

　　傳統的建立對象的方法：new 關鍵字oop

//傳統的建立對象方法----new
	@Test
	public void testTradition(){
		HelloIoc hello = new HelloIoc();
		hello.sayHello();
	}

　　這裏經過 Spring 容器怎麼來建立呢？

　　第一種方法：利用默認的構造方法

　　在 src 目錄下新建 applicationContext.xml 文件，這是 spring 配置文件，添加以下代碼：

<?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
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
	建立對象的第一種方式：利用無參構造器
	id:惟一標識符
	class:類的全類名
	  -->
    <bean id="helloIoc" class="com.ys.ioc.HelloIoc" ></bean>   
    <!-- 別名屬性  name：和bean的 id 屬性對應 -->
	<alias name="helloIoc" alias="helloIoc2"/>
	
</beans>

　　測試代碼：

/**
	 *  Spring 容器利用構造函數建立對象
	 */
	@Test
	public void testCreateObjectByConstrutor(){
		//一、啓動 spring 容器
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		//二、從 spring 容器中取出數據
		HelloIoc IOC = (HelloIoc) context.getBean("helloIoc");
		//三、經過對象調用方法
		IOC.sayHello();
		
		//利用配置文件 alias 別名屬性建立對象
		HelloIoc IOC2 = (HelloIoc) context.getBean("helloIoc2");
		IOC2.sayHello();
	}

　　咱們能夠在測試類 HelloIoc.java 中手動添加無參的構造方法，而後執行上面的測試代碼，會發現構造方法會在 sayHello()方法執行以前調用。

　　第二種方法：利用靜態工廠方法

　　首先建立靜態工廠類 HelloStaticFactory.java

package com.ys.ioc;

public class HelloStaticFactory {
	public HelloStaticFactory(){
		System.out.println("HelloStaticFactory constructor");
	}
	//靜態工廠方法
	public static HelloIoc getInstances(){
		return new HelloIoc();
	}

}

　　接着在 applicationContext.xml 中進行以下配置：

<!--
    	建立對象的第二種方式：利用靜態工廠方法
    	factory-method：靜態工廠類的獲取對象的靜態方法
    	class:靜態工廠類的全類名
      -->    
    <bean id="helloStaticFactory" factory-method="getInstances" class="com.ys.ioc.HelloStaticFactory"></bean>

　　編寫測試類：

/**
	 * Spring 容器利用靜態工廠方法建立對象
	 */
	@Test
	public void createObjectStaticFactory(){
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloIoc staticFactory =
				(HelloIoc) context.getBean("helloStaticFactory");
		staticFactory.sayHello();
	}

　　注意：spring容器只負責調用靜態工廠方法，而這個靜態工廠方法內部實現由程序員完成

　　第三種方法：利用實例工廠方法

　　首先建立實例工廠類 HelloInstanceFactory .java

package com.ys.ioc;

public class HelloInstanceFactory {
	public HelloInstanceFactory(){
		System.out.println("實例工廠方法構造函數");
	}

	//利用實例工廠方法建立對象
	public HelloIoc getInstance(){
		HelloIoc instanceIoc = new HelloIoc();
		return instanceIoc;
	}
}

　　接着在 applicationContext.xml 中進行以下配置：

<!--
    	建立對象的第三種方式：利用實例工廠方法
    	factory-bean:指定當前Spring中包含工廠方法的beanID
    	factory-method:工廠方法名稱
      -->  
    <bean id="instanceFactory" class="com.ys.ioc.HelloInstanceFactory"></bean>  
    <bean id="instance" factory-bean="instanceFactory" factory-method="getInstance"></bean>

　　最後編寫測試類：

/**
	 * Spring 容器利用實例工廠方法建立對象
	 */
	@Test
	public void createObjectInstanceFactory(){
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloIoc staticFactory =
				(HelloIoc) context.getBean("instance");
		staticFactory.sayHello();
	}

四、Spring 容器建立對象的時機

　　第一種：默認狀況下，啓動 spring 容器便建立對象（遇到bean便建立對象）

　　測試：

　　第一步：咱們在 HelloIoc.java 中添加默認構造方法：

　　第二步：在 applicationContext.xml 文件中添加 bean（因爲上面咱們經過三種方式來建立對象了，裏面已經有三個bean了）

　　第三步：啓動 Spring 容器，查看無參構造函數的打印次數

　　控制檯打印結果以下：

　　第二種：在spring的配置文件bean中有一個屬性 lazy-init="default/true/false"

　　　　①、若是lazy-init爲"default/false"在啓動spring容器時建立對象（默認狀況）

　　　　 ②、若是lazy-init爲"true",在context.getBean時纔要建立對象

　　咱們測試 lazy-init=「true」的狀況

　　咱們測試經過斷點調試：

　　而後繼續往下面執行：

　　在第一種狀況下能夠在啓動spring容器的時候，檢查spring容器配置文件的正確性，若是再結合tomcat,若是spring容器不能正常啓動，整個tomcat就不能正常啓動。可是這樣的缺點是把一些bean過早的放在了內存中，若是有數據，則對內存來是一個消耗。

　　反過來，在第二種狀況下，能夠減小內存的消耗，可是不容易發現錯誤

五、spring的bean中的scope："singleton/prototype/request/session/global session"

　　1、默認scope的值是singleton，即產生的對象是單例的

　　applicationContext.xml 文件中配置：

<bean id="helloIoc" scope="singleton" class="com.ys.ioc.HelloIoc" ></bean>

　　驗證：

//spring 容器默認產生對象是單例的 scope="singleton"
	@Test
	public void test_scope_single_CreateObject(){
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloIoc hello1 = (HelloIoc) context.getBean("helloIoc");
		HelloIoc hello2 = (HelloIoc) context.getBean("helloIoc");
		System.out.println(hello1.equals(hello2)); //true
	}

　　2、scope=「prototype」

　　多例模式，而且spring容器啓動的時候並不會建立對象，而是在獲得 bean 的時候纔會建立對象

　　applicationContext.xml 文件中配置：

<bean id="helloIoc" scope="prototype" class="com.ys.ioc.HelloIoc" ></bean>

　　驗證：

//spring 容器默認產生對象是單例的 scope="prototype"
	@Test
	public void test_scope_prototype_CreateObject(){
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		HelloIoc hello1 = (HelloIoc) context.getBean("helloIoc");
		HelloIoc hello2 = (HelloIoc) context.getBean("helloIoc");
		System.out.println(hello1.equals(hello2)); //false
	}

　　總結：在單例模式下，啓動 spring 容器，便會建立對象；在多例模式下，啓動容器並不會建立對象，得到 bean 的時候纔會建立對象

五、Spring 容器生命週期

　　建立 SpringLifeCycle.java

package com.ys.ioc;
/**
 * Spring 容器的生命週期
 * @author hadoop
 *
 */
public class SpringLifeCycle {
	public SpringLifeCycle(){
		System.out.println("SpringLifeCycle");
	}
	//定義初始化方法
	public void init(){
		System.out.println("init...");
	}
	//定義銷燬方法
	public void destroy(){
		System.out.println("destroy...");
	}
	
	public void sayHello(){
		System.out.println("say Hello...");
	}
}

　　applicationContext.xml

<!-- 生命週期 -->
  	<bean id="springLifeCycle" init-method="init" destroy-method="destroy" class="com.ys.ioc.SpringLifeCycle"></bean>

　　測試：

//spring 容器的初始化和銷燬
	@Test
	public void testSpringLifeCycle(){
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		SpringLifeCycle hello = (SpringLifeCycle) context.getBean("springLifeCycle");
		
		hello.sayHello();
		
		//銷燬spring容器
		ClassPathXmlApplicationContext classContext = (ClassPathXmlApplicationContext) context;
		classContext.close();
	}

　　控制檯打印以下：

　　分析：spring 容器的聲明週期

　　　一、spring容器建立對象
        　　二、執行init方法
        　　三、調用本身的方法
        　　四、當spring容器關閉的時候執行destroy方法

　　注意：當scope爲"prototype"時，調用 close（）方法時是不會調用 destroy 方法的