摘要
本章內(nèi)容：
1.Spring的bean容器
2.介紹Spring的核心模塊
3.更為強大的Spring生態(tài)系統(tǒng)
4.Spring的新功能
1.1 簡化Java開發(fā)
Spring是為了解決企業(yè)級應(yīng)用開發(fā)的復(fù)雜性而創(chuàng)建的，使用 Spring 可以讓簡單的 JavaBean 實現(xiàn)之前只有 EJB 才能完成的事情。但 Spring 不僅僅局限于服務(wù)器端開發(fā)，任何 Java 應(yīng)用都能在簡單性、可測試性和松耦合等方面從 Spring 中獲益。
為了降低Java開發(fā)的復(fù)雜性，Spring采取了以下4種關(guān)鍵策略：
1.基于POJO的輕量級和最小侵入性編程；
2.通過依賴注入和面向接口實現(xiàn)松耦合；
3.基于切面和慣例進行聲明式編程；
4.通過切面和模板減少樣板式代碼。
Spring竭力避免因自身的API而弄亂你的應(yīng)用代碼。Spring不會強迫你實現(xiàn)Spring規(guī)范的接口或繼承Spring規(guī)范的類，相反，在基于Spring構(gòu)建的應(yīng)用中，它的類通常沒有任何痕跡表明你使用了Spring。最壞的場景是，一個類或許會使用Spring注解，但它依舊是POJO。
程序清單1.1Spring不會在HelloWorldBean上有任何不合理的要求
package com.habuma.spring;
public class HelloWorldBean{
public String sayHello(){
return "Hello World";
}
}
1.1.2 依賴注入
任何一個有實際意義的應(yīng)用（肯定比Hello World示例更復(fù)雜）都會由兩個或者更多的類組成，這些類相互之間進行協(xié)作來完成特定的業(yè)務(wù)邏
輯。按照傳統(tǒng)的做法，每個對象負責(zé)管理與自己相互協(xié)作的對象（即它所依賴的對象）的引用，這將會導(dǎo)致高度耦合和難以測試的代碼。
通過DI，對象的依賴關(guān)系將由系統(tǒng)中負責(zé)協(xié)調(diào)各對象的第三方組件在創(chuàng)建對象的時候進行設(shè)定。對象無需自行創(chuàng)建或管理它們的依賴關(guān)系，依賴關(guān)系將被自動注入到需要它們的對象當(dāng)中去。
看下面這個例子：
package com.springination.knights;
public class BraveKnight implements Knight{
private Quest quest;
public BraveKnight(Quest quest){ //Quest 被注入進來
this.quest = quest;
}
public void embarkOnQuest(){
quest.embark();
}
}
BraveKnight沒有自行創(chuàng)建探險任務(wù)，而是在構(gòu)造的時候把探險任務(wù)作為構(gòu)造器參數(shù)傳入。這是依賴注入的方式之一，即構(gòu)造器注入。
為了測試BraveKnight，需要注入一個mock Quest：
package com.springination.knights;
import static org.mockito.Mockito.*;
import org.junit.Test;
public class BraveKnightTest{
@Test
public void knightShouldEmbarkOnQuest(){
Quest mockQuest = mock(Quest.class);//創(chuàng)建 mock Quest
BraveKnight knight = new BraveKnight(mockQuest); //注入 mock Quest
knight.embarkOnQuest();
verify(mockQuest,times(1)).embark();
}
}
你可以使用mock框架Mockito去創(chuàng)建一個Quest接口的mock實現(xiàn)。通過這個mock對象，就可以創(chuàng)建一個新的BraveKnight實例，并通過構(gòu)造器注入這個mock Quest。
創(chuàng)建應(yīng)用組件之間協(xié)作的行為通常稱為裝配。Spring有多種裝配bean的方式，采用XML是很常見的一種裝配方式。
使用Spring將SlayDragonQuest注入到BraveKnight中：
<?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">
<bean id="knight" class="com.springframework.knight.BraveKnight">
<constructor-arg reg="quest"/>
</bean>
<bean id="quest" class="com.springination.knights.SlayDragonQuest">
<constructor-arg value="#{T(System).out}"/>
</bean>
</beans>
Spring還支持使用Java來描述配置：
package com.springination.knights.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.springinaction.Knights.BraveKnight;
import com.springinaction.Knights.Knight;
import com.springinaction.Knights.Quest;
import com.springinaction.Knights.SlayDragonQuest;
public class KnightConfig {
@Configuration
public class KnightConfig{
@Bean
public Knight knight() {
return new BraveKnight(quest());
}
@Bean
public Quest quest() {
return new SlayDragonQuest(System.out);
}
}
}
Spring通過應(yīng)用上下文（Application Context）裝載bean的定義并把它們組裝起來。Spring應(yīng)用上下文全權(quán)負責(zé)對象的創(chuàng)建和組裝。Spring自帶
了多種應(yīng)用上下文的實現(xiàn)，它們之間主要的區(qū)別僅僅在于如何加載配置。
KnightMain.java加載包含Knight的Spring上下文:
package com.springinaction.knights;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class KnightMain{
public static void main(String[] args) throws Exception{
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("META-INF/spring/knights.xml");
Knight knight = context.getBean(Knight.class);
knight.embarkOnQuest();
context.close();
}
}
1.1.3 應(yīng)用切面
DI能夠讓相互協(xié)作的軟件組件保持松散耦合，而面向切面編程（AOP）允許你把遍布應(yīng)用各處的功能分離出來形成可重用的組件。
先來看下面這張圖：
AOP能夠使這些服務(wù)模塊化，并以聲明的方式將它們應(yīng)用到它們需要影響的組件中去。所造成的結(jié)果就是這些組件會具有更高的內(nèi)聚性并且會更加關(guān)注自身的業(yè)務(wù)，完全不需要了解涉及系統(tǒng)服務(wù)所帶來復(fù)雜性。總之，AOP能夠確保POJO的簡單性。
AOP 應(yīng)用:
下面程序展示了，吟游詩人吟唱騎士的英勇事跡：
package com.springinaction.knights;
import java.io.PrintStream;
public class Minstrel{
private PrintStream stream;
public Minstrel(PrintStream stream) {
this.stream = stream;
}
public void singBeforeQuest() {
stream.println("Fa la la, the knight is so brave!");
}
public void singAfterQuest() {
stream.println("Tee hee hee, the brave knight" + "did embark on a quest!");
}
}
package com.springinaction.knights;
public class BraveKnight implements Knight{
private Quest quest;
private Minstrel minstrel;
public BraveKnight(Quest quest, Minstrel minstrel) {
this.quest = quest;
this.minstrel = minstrel;
}
public void embarkOnQuest() throws QuestException{
minstrel.singBeforeQuest();
quest.embark();
minstrel.singAfterQuest();
}
}
這樣應(yīng)該能達到效果，在騎士行動前后，詩人歌頌騎士。但是詩人應(yīng)該是獨立的個體，但是這個程序復(fù)雜化了，這個騎士居然去管理詩人，其實跟詩人應(yīng)該是沒有關(guān)系的。
所以下面要將詩人聲明為一個切面：
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/beans
http://www/springframework.org/schema/beans/spring-beans.xsd">
<bean id="knight" class="com.springination.knights.BraveKnight">
<constructor-arg ref="quest"/>
</bean>
<bean id="quest" class="com.springination.knights.SlayDragonQuest">
<constructor-arg value="#{T(System).out}"/>
</bean>
<bean id="minstrel" class="com.springination.knights.Minstrel"> //聲明 Minstrel bean
<constructor-arg value="#{T(System).out}"/>
</bean>
<aop:config>
<aop:aspect ref="minstrel">
<aop:pointcut id="embark" expression="execution(* *.embarkOnQuest(..))"/> //定義切點
<aop:before pointcut-ref="embark" method="singBeforeQuest"/>
<aop:after pointcut-ref="embark" method="singAfterQuest"/>
</aop:aspect>
</aop:config>
</beans>
使用模板消除樣板式代碼
許多Java API，例如JDBC，會涉及編寫大量的樣板式代碼。
public Employee getEmployeeById(long id){
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try{
conn = dataSource.getConnection();
stmt = conn.prepareStatement("select id, firstname,lastname,salary from" +
"employee where id =?");
stmt.setLong(1,id);
rs = stmt.executeQuery();
Employee employee = null;
if(rs.next()){
employee = new Employee();
employee.setId(rs.getLong("id"));
employee.setFirstName(rs.getString("firstname"));
employee.setLastName(rs.getString("lastname"));
employee.setSalary(rs.getBigDecimal("salary"));
}
return employee;
}catch (SQLException e){
}finally {
if(rs != null){
try{
stmt.close();
}catch(SQLException e){}
}
if(conn != null){
try{
conn.close();
}catch(SQLException e){}
}
}
return null;
}
這段代碼很繁瑣，就是一個查詢數(shù)據(jù)庫的功能要寫很多重復(fù)的代碼，很多重復(fù)的異常處理。
使用Spring的JdbcTemplate（利用了 Java 5特性的JdbcTemplate實現(xiàn)）重寫的getEmployeeById()方法僅僅關(guān)注于獲取員工數(shù)據(jù)的核心邏輯，而不需要迎合JDBC API的需求。
public Employee getEmployeeById(long id){
return jdbcTemplate.queryForObject("select id, firstname, lastname, salary" +
"from employee where id=?",
new RowMapper<Employee>(){
public Employee mapRow(ResultSet rs, int rowNum) throws SQLException{
Employee employee = new Employee();
employee.setId(rs.getLong("id"));
employee.setFirstName(rs.getString("firstname"));
employee.setLastName(rs.getString("lastname"));
employee.setSalary(rs.getBigDecimal("salary"));
return employee;
}
},
id);
}
1.2 容納你的Bean
在基于Spring的應(yīng)用中，你的應(yīng)用對象生存于Spring容器中。Spring容器負責(zé)創(chuàng)建對象，裝配它們，配置它們并管理它們的整個生命周期，從生存到死亡（在這里，可能就是new到finalize()）。
Spring自帶了多個容器實現(xiàn)，可以歸為兩種不同的類型。bean工廠（由org.springframework. beans.factory.eanFactory接口定義）是最簡單的容器，提供基本的DI支持。應(yīng)用上下文（由org.springframework.context.ApplicationContext接口定義）基于BeanFactory構(gòu)建，并提供應(yīng)用框架級別的服務(wù)，例如從屬性文件解析文本信息以及發(fā)布應(yīng)用事件給感興趣的事件監(jiān)聽者。
Spring自帶了多種類型的應(yīng)用上下文。下面羅列的幾個是你最有可能
遇到的。
1.AnnotationConfigApplicationContext：從一個或多個基于Java的配置類中加載Spring應(yīng)用上下文。
2.AnnotationConfigWebApplicationContext：從一個或多個基于Java的配置類中加載Spring Web應(yīng)用上下文。
3.ClassPathXmlApplicationContext：從類路徑下的一個或多個XML配置文件中加載上下文定義，把應(yīng)用上下文的定義文件作為類資源。
4.FileSystemXmlapplicationcontext：從文件系統(tǒng)下的一個或多個XML配置文件中加載上下文定義。
5.XmlWebApplicationContext：從Web應(yīng)用下的一個或多個XML配置文件中加載上下文定義。
bean的生命周期
在傳統(tǒng)的Java應(yīng)用中，bean的生命周期很簡單。使用Java關(guān)鍵字new進行bean實例化，然后該bean就可以使用了。一旦該bean不再被使用，則由Java自動進行垃圾回收。
相比之下，Spring容器中的bean的生命周期就顯得相對復(fù)雜多了。
在bean準(zhǔn)備就緒之前，bean工廠執(zhí)行了若干啟動步驟:
1．Spring對bean進行實例化；
2．Spring將值和bean的引用注入到bean對應(yīng)的屬性中；
3．如果bean實現(xiàn)了BeanNameAware接口，Spring將bean的ID傳遞給setBean-Name()方法；
4．如果bean實現(xiàn)了BeanFactoryAware接口，Spring將調(diào)用setBeanFactory()方法，將BeanFactory容器實例傳入；
5．如果bean實現(xiàn)了ApplicationContextAware接口，Spring將調(diào)用setApplicationContext()方法，將bean所在的應(yīng)用上下文的引用傳入進來；
6．如果bean實現(xiàn)了BeanPostProcessor接口，Spring將調(diào)用它們的post-ProcessBeforeInitialization()方法；
7．如果bean實現(xiàn)了InitializingBean接口，Spring將調(diào)用它們的after-PropertiesSet()方法。類似地，如果bean使用initmethod聲明了初始化方法，該方法也會被調(diào)用；
8．如果bean實現(xiàn)了BeanPostProcessor接口，Spring將調(diào)用它們的post-ProcessAfterInitialization()方法；
9．此時，bean已經(jīng)準(zhǔn)備就緒，可以被應(yīng)用程序使用了，它們將一直駐留在應(yīng)用上下文中，直到該應(yīng)用上下文被銷毀；
10．如果bean實現(xiàn)了DisposableBean接口，Spring將調(diào)用它的destroy()接口方法。同樣，如果bean使用destroy-method聲明了銷毀方法，該方法也會被調(diào)用。
Spring模塊
總結(jié)
Spring致力于簡化企業(yè)級Java開發(fā)，促進代碼的松散耦合。成功的關(guān)鍵在于依賴注入和AOP。
