【一頭扎進Spring】 01 | 從 HelloWorld 開始看Spring

• Spring 是一個開源框架.
• Spring 為簡化企業級應用開發而生. 使用 Spring 可以使簡單的 JavaBean 實現以前只有 EJB 才能實現的功能.
• Spring 是一個 IOC(DI) 和 AOP 容器框架.

開發環境

• 開發工具： IDEA
• JDK 8.0
• Spring 4.0

Spring 的簡單介紹

具體描述 Spring:

• 輕量級：Spring 是非侵入性的 - 基於 Spring 開發的應用中的對象可以不依賴於 Spring 的 API
• 依賴注入(DI --- dependency injection、IOC)
• 面向切面編程(AOP --- aspect oriented programming)
• 容器: Spring 是一個容器, 因為它包含並且管理應用對象的生命周期
• 框架: Spring 實現了使用簡單的組件配置組合成一個復雜的應用. 在 Spring 中可以使用 XML 和 Java 注解組合這些對象
• 一站式：在 IOC 和 AOP 的基礎上可以整合各種企業應用的開源框架和優秀的第三方類庫 （實際上 Spring 自身也提供了展現層的 SpringMVC 和 持久層的 Spring JDBC）

Spring 模塊

核心容器(Core Container) 包括Core、Beans、Context、EL模塊

1. Core和Beans模塊提供了Spring最基礎的功能，提供IoC和依賴注入特性。這里的基礎概念是BeanFactory，它提供對Factory模式的經典實現來消除對程序性單例模式的需要，並真正地允許你從程序邏輯中分離出依賴關系和配置。
2. Context模塊基於Core和Beans來構建，它提供了用一種框架風格的方式來訪問對象，有些像JNDI注冊表。Context封裝包繼承了beans包的功能，還增加了國際化（I18N）,事件傳播，資源裝載，以及透明創建上下文，例如通過servlet容器，以及對大量JavaEE特性的支持，如EJB、JMX。核心接口是ApplicationContext。
3. Expression Language，表達式語言模塊，提供了在運行期間查詢和操作對象圖的強大能力。支持訪問和修改屬性值，方法調用，支持訪問及修改數組、容器和索引器，命名變量，支持算數和邏輯運算，支持從Spring 容器獲取Bean，它也支持列表投影、選擇和一般的列表聚合等。

數據訪問/集成部分(Data Access/Integration)

1. JDBC模塊，提供對JDBC的抽象，它可消除冗長的JDBC編碼和解析數據庫廠商特有的錯誤代碼。
2. ORM模塊，提供了常用的"對象/關系"映射APIs的集成層。 其中包括JPA、JDO、Hibernate 和 iBatis 。利用ORM封裝包，可以混合使用所有Spring提供的特性進行"對象/關系"映射，如簡單聲明性 事務管理 。
3. OXM模塊，提供一個支持Object和XML進行映射的抽象層，其中包括JAXB、Castor、XMLBeans、JiBX和XStream。
4. JMS模塊，提供一套"消息生產者、消費者"模板用於更加簡單的使用JMS，JMS用於用於在兩個應用程序之間，或分布式系統中發送消息，進行異步通信。
5. Transaction模塊，支持程序通過簡單聲明性 事務管理，只要是Spring管理對象都能得到Spring管理事務的好處，即使是POJO，也可以為他們提供事務。

Web

1. Web模塊，提供了基礎的web功能。例如多文件上傳、集成IoC容器、遠程過程訪問、以及Web Service支持，並提供一個RestTemplate類來提供方便的Restful services訪問
2. Web-Servlet模塊，提供了Web應用的Model-View-Controller（MVC）實現。Spring MVC框架提供了基於注解的請求資源注入、更簡單的數據綁定、數據驗證等及一套非常易用的JSP標簽，完全無縫與Spring其他技術協作。
3. Web-Struts模塊， 提供了對Struts集成的支持，這個功能在Spring3.0里面已經不推薦了，建議你遷移應用到使用Struts2.0或Spring的MVC。
4. Web-Portlet模塊，提供了在Portlet環境下的MVC實現

AOP

1. AOP模塊，提供了符合AOP 聯盟規范的面向方面的編程實現，讓你可以定義如方法攔截器和切入點，從邏輯上講，可以減弱代碼的功能耦合，清晰的被分離開。而且，利用源碼級的元數據功能，還可以將各種行為信息合並到你的代碼中 。
2. Aspects模塊，提供了對AspectJ的集成。
3. Instrumentation模塊， 提供一些類級的工具支持和ClassLoader級的實現，可以在一些特定的應用服務器中使用。

Test

1. Test模塊，提供對使用JUnit和TestNG來測試Spring組件的支持，它提供一致的ApplicationContexts並緩存這些上下文，它還能提供一些mock對象，使得你可以獨立的測試代碼。

HelloWorld

首先創建一個 Maven 工程（也可以使用IDEA里面的那個 Spring . 這里初學，就不建議使用那個了。同樣，建議創建 maven 工程，方便 Jar 包的管理）；Maven工程大家就可以自己創建一個空白的 工程就行。

創建好我們的 Maven 工程后，我們需要配置好我們的 pom.xml 文件，引入我們的開發包。

 <dependencies>
        <!-- Spring Core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring WebMvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring Aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

我們的父工程的搭建好了之后，就開始創建我們的子工程。我這取名： spring-learning-quickstart.子工程是繼承父工程的，這樣我們就不用再次導入我們的開發包了。

我們在 子工程中創建一個 bean , 取名 HelloWorld .

public class HelloWorld {
    private String name ;
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.out.println("Hello " + name);
    }
    public HelloWorld() {
        System.out.println("Constructor for HelloWorld");
    }
}

然后，我們在創建一個主類 Main .

public class Main {
    public static void main(String[] args) {
        // 傳統做法( 這不是Spring 的做法)
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.setName("Spring");
        helloWorld.sayHello();
    }
}

一運行，我們就可以看到控制台出現了：

hello Spring

當然，這個不是 Spring 的方式。現在我們來看看 Spring 中怎么去做。

Spring 實現

在Spring 中，我們需要通過配置去實現我們的這個 HelloWorld 的。首先，我們在 resource 中新建一個 XML 的文件 。 我這就叫 applicationContext.xml 。 內容如下：

<?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 -->
    <bean id="helloWorld" class="com.spring.bean.HelloWorld">
        <property name="name" value="SunYang's Spring"></property>
    </bean>
</beans>

這里稍后在解釋。

然后我們在主類中，這么來寫。

        //1 創建 Spring 的 IOC 容器對象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 從IOC 容器中獲取 Bean 實例
        HelloWorld hello = (HelloWorld)applicationContext.getBean("helloWorld");
        //3 調用 sayHello()
        hello.sayHello();

這樣我們的控制台就出現：

hello SunYang's Spring

現在呢，先來看一下，Spring創建了這個容器的過程中幫我們做了什么。我們在這個容器創建這邊打一個斷點。

然后程序執行到這以后，會自動跳到我們的 HelloWorld 類里面，在看這個：

我們可以看到，這個時候Spring就已經把 SunYang's Spring 給了 name 了。

Spring 核心

兩個重點概念

• IOC: 控制反轉，與依賴注入 DI 一樣
• AOP： 面向切面編程

IOC

所謂控制反轉，其實是一個由主動轉被動的一個過程。舉個例子：

之前，我們沒有飲品店的時候，我們想喝果汁了，就是自己准備水果，然后自己榨果汁。這就是一個主動的創造一杯果汁的過程。但是，現在有飲品店了，我們想喝果汁了，我們就不在需要自己去榨一杯果汁，而是叫飲品店去榨一杯果汁，請注意，這里我們並沒有創造一杯果汁，但是依然達到了我們要喝果汁的目的。這邊是控制反轉的思想。比如說：
我現在要喝 一個 大杯的三分糖的橙子汁。

    /**
     * 我們要喝的水果汁
     * @param water 果汁加的水
     * @param fruit 水果類型
     * @param sugar 糖
     * @return
     */
    public static String juiceMix(String water , String fruit ,String sugar){
        String juice = String.format("我要喝 %s 的 , %s 的 %s" , water ,sugar ,fruit ) ;
        return juice ;
    }

現在我們有了要喝的果汁，現在就是需要有人去做，相當於一個店家去做。

public class JuiceProduce {

    private String water ;
    private String fruit ;
    private String sugar ;

    public void setWater(String water) {
        this.water = water;
        System.out.println(this.water);
    }

    public void setFruit(String fruit) {
        this.fruit = fruit;
    }

    public void setSugar(String sugar) {
        this.sugar = sugar;
    }

    public JuiceProduce() {
        System.out.println("Constructor for JuiceProduce");
    }

    public String juiceProduce(){
        return Blende.juiceMix(this.water , this.fruit , this.sugar) ;
    }
}

現在我們需要選擇那家店去喝這個果汁了，就是在 配置文件里面去配置一下。

    <bean id="juiceProduce" class="com.spring.bean.JuiceProduce">
        <property name="water" value="大杯" />
        <property name="fruit" value="橙汁" />
        <property name="sugar" value="三分糖"/>
    </bean>

我們選擇這個名叫 juiceProduce 的店家來制造我們的果汁。最后的結果就是:

我要喝 大杯 的 , 三分糖 的 橙汁

在下一篇中，講一下這個關於 Bean 的配置問題。