【一頭扎進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 的配置問題。