1. IOC與DI
IOC（Inversion of Control）：控制反轉
DI（Dependency Injection）：依賴注入
“控制反轉”和“依賴注入”其實是同一個概念：
改變由調用者創建被調用者的過程。被調用者依賴Spring容器注入到調用者中。
之所以出現兩個名詞是因爲“控制反轉”比較難懂，聽者不明所以，所以有了更形象的“依賴注入”。
2. IOC的發展歷程
3. Spring容器
簡單說，就是Spring中生成“Bean”的工廠，並管理“Bean”的生命週期。Spring的配置文件說到底就是“Bean”的配置。
“Bean”是Spring管理的基本單位，不僅僅指簡單的POJO類，組件也是“Bean”，例如數據源、事務管理器，Hibernate的SessionFactory。
Spring中內置了兩種基礎DI容器：BeanFactory和ApplicationContext。
ApplicationContext繼承了BeanFactory的所有特性。關係如下圖：
BeanFactory應用與內存、CPU資源受限的場合，一般情況下優先使用ApplicationContext，因爲它除了擁有BeanFactory支持的所有功能，還可以：
- 載入多個配置文件
- 提供國際化支持
- 事件機制
- 默認初始化所有的singleton Bean（
BeanFactory則不會）
常用的ApplicationContext的子類如下圖：
- XmlWebApplicationContext：面向Web應用
- AnnotationConfigApplicationContext：基於註解存儲DI元數據
- XmlPortlerApplicationContext：面向Portal應用
- ClassPathXmlApplicationContext、FileSystemXmlApplicationContext：適用於各種場景
4. 注入方式
Spring的注入方式有三種：設值注入、構造器注入、工廠注入。
設置注入和構造器注入
實體類：
public class Person{
public String name;
private Axe axe;
public Person(Axe axe, String name) {
System.out.println("Person 的帶參構造方法");
this.axe = axe;
this.name = name;
}
/**
* 砍柴
*/
public void choopWood() {
if(axe!=null){
axe.useAxe();
}
}
public void info() {
System.out.println("This person's name is " + name);
}
public void setName(String name) {
this.name = name;
}
public void setAxe(Axe axe) {
this.axe = axe;
}
}注入類：
public interface Axe {
public void useAxe();
}
public class StoneAxe implements Axe {
public void useAxe() {
System.out.println(test + "石斧砍柴很慢");
}
}
public class IronAxe implements Axe{
public void useAxe() {
System.out.println("鐵斧砍柴很快");
}
}Spring配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!--spring配置文件的根元素，使用spring-beans-3.0.xsd語義約束（.xsd都是語言約束文件）
xmlns:p配置可使用p標籤更方便的配置屬性 -->
<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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- id 表示你這個組件的名字，class表示組件類；autowire爲是否自動加載； lazy-init爲是否懶加載，即applicationContext容器啓動不自動加載 -->
<bean id="person" class="test.wsz.spring.bean.Person" lazy-init="true" autowire="byType" >
<!--自定義set注入,name 爲成員變量名稱，value爲自定義的值 -->
<property name="name" value="wsz"></property>
<!--引用set注入,name 爲成員變量名稱，ref爲注入bean的id -->
<property name="axe" ref="ironaxe"></property>
<!--構造注入,index爲形參的位置，從0開始，ref爲注入bean的id -->
<constructor-arg ref="stoneaxe" index="0" />
<constructor-arg value="wsz" index="1" />
</bean>
<!--其餘實體Bean-->
<bean id="ironaxe" class="test.wsz.spring.bean.IronAxe" />
<bean id="stoneaxe" class="test.wsz.spring.bean.StoneAxe" />
</beans>從配置的註釋可以知道“設置注入”和“構造器注入”的配置方法。
- “設置注入”會調用成員變量的
setXXX方法。 - “構造器注入”會調用類對應的構造方法。
測試代碼：
ApplicationContext context=new ClassPathXmlApplicationContext("config/spring-config.xml");
Person person=context.getBean("person",Person.class);
person.info();
person.choopWood();工廠方式注入
工廠方式注入有好幾種，這裏只舉“靜態工廠注入”和“工廠Bean的例子”
- 靜態工廠注入
先創建一個工廠類：
/**
* 靜態簡單工程類
*/
public class AxeFactory {
/**
* 獲取產品的方法，根據形參返回不同的產品
*/
public static Axe getAxe(String type) {
if("stone".equals(type))
return new StoneAxe();
else if("iron".equals(type))
return new IronAxe();
return new StoneAxe();
}
}再修改之前的類當成產品類：
public class StoneAxe implements Axe {
private String test;
public StoneAxe() {
System.out.println("調用StoneAxe的無參構造方法");
}
public void useAxe() {
System.out.println(test + "石斧砍柴很慢");
}
public void setTest(String test) {
this.test = test;
}
}再在xml文件中進行對應的配置：
<!--靜態工廠類獲取Bean,class爲工廠類；factory-method爲工廠獲取方法-->
<bean id="stone" class="test.wsz.spring.factory.AxeFactory" factory-method="getAxe">
<!--設置傳入工廠類獲取產品方法形參的值-->
<constructor-arg value="stone"/>
<!--設置注入產品Bean的屬性-->
<property name="test" value="哈哈，"></property>
</bean>根據配置我們可以知道，現在設置的工廠類返回StoneAxe，我們進行測試：
Axe axe=context.getBean("stone",Axe.class);
axe.useAxe();輸出：
哈哈，石斧砍柴很慢- 工廠Bean注入
這種方式配置比較簡單。只需要創建一個實現了Spring工廠接口的工廠類，再將這個工廠類配置在<Beans />中即可。
工廠類，需實現接口的三個方法：
public class AxeBeanFactory implements FactoryBean<Axe>{
Axe axe=null;
/**
* 返回產品
*/
public Axe getObject() throws Exception {
if(axe==null){
axe=new StoneAxe();
}
return axe;
}
/**
* 返回產品的類型
*/
public Class<?> getObjectType() {
return Axe.class;
}
/**
* 是否單例
*/
public boolean isSingleton() {
return true;
}
}xml配置：
<!--容器中的工廠Bean-->
<bean id="stonefactory" class="test.wsz.spring.factory.AxeBeanFactory" />值得注意的是，雖然<Bean />中配置的好像是工廠類，但實現了Spring工廠接口的該類，最終getBean()時返回的是對應的產品類。
測試代碼：
Axe axe=context.getBean("stonefactory",Axe.class);
axe.useAxe();輸出：
null石斧砍柴很慢5. 配置細節
Spring的配置的參數太多，這裏只總結一些常用的。複雜的等用到時再看書就行。
<bean />中的常用配置
- scope：
Bean的作用域，有5種：
- singleton：單例模式，即整個容器裏面該Bean實例只有一個，默認
- prototype：原型模式，每次
getBean獲取的是一個新創建的對象 - request：每個HTTP請求，產生一個實例
- session：每個HTTP session，產生一個實例
- global session：每個全局的HTTP session，產生一個實例
- lazy-init：
懶加載，當使用使用ApplicationContext時，會自動初始化所有的singleton的“Bean”（“Bean”默認是singleton）。設置懶加載即不自動初始化這個類。 - autowire：
自動注入。即你不用在配置中設定成員變量的注入。設置爲byType時，會自動匹配依賴類型相同的Bean，若有多個類型相同的會拋出異常。設置爲byName時，會查找id名與屬性名相等的Bean。 - init-method：
指定Bean依賴關係設置完畢後執行的方法。另外一種實現方式是讓Bean類實現InitializingBean接口 - destory-method：
指定Bean銷燬之前執行的方法。另外一種實現方式是讓Bean類實現DisposableBean接口 - p名稱空間：
可以看作一個語法糖，在<beans />中添加：
xmlns:p="http://www.springframework.org/schema/p" 即可更簡單的設置注入：
<bean id="person" class="test.wsz.spring.bean.Person"
p:name="name" />等效於
<bean id="person" class="test.wsz.spring.bean.Person" >
<property name="name" value="wsz"></property>
</bean>6. 免XML的JAVA類配置
這個其實應用場景比較少，畢竟單純用Java類完成複雜的Spring配置還是比較困難的。下面簡單給個例子：
@Configuration
public class Config {
@Value("大樹") String personName; //注入Bean的屬性中的值
@Bean(name="person")
public Person person(){
Person p=new Person();
p.setName(personName);
p.setAxe(stoneAxe());
return p;
}
@Bean(name="stoneAxe")
public Axe stoneAxe() {
Axe axe=new StoneAxe();
return axe;
}
}除了純粹的Java類配置，還可以在xml中引用Java類配置，或者在Java類配置中引用xml配置。有興趣的朋友可以自行百度。
本文總結於
《瘋狂JavaEE》的第七章《Spring的基本用法》