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的基本用法》