前言

前面已經學習了Struts2和Hibernate架構了。接下來學習的是Spring架構...本博文主要是引入Spring架構...

Spring介紹

Spring誕生：

建立Spring的目的就是用來替代更加重量級的的企業級Java技術
簡化Java的開發
- 基于POJO輕量級和最小侵入式開發
- 通過依賴注入和面向接口實作松耦合
- 基于切面和慣例進行聲明式程式設計
- 通過切面和模闆減少樣闆式代碼

侵入式概念

Spring是一種非侵入式的架構...

侵入式

對于EJB、Struts2等一些傳統的架構，通常是要實作特定的接口，繼承特定的類才能增強功能
- 改變了java類的結構

非侵入式

對于Hibernate、Spring等架構，對現有的類結構沒有影響，就能夠增強JavaBean的功能

松耦合

前面我們在寫程式的時候，都是面向接口程式設計，通過DaoFactroy等方法來實作松耦合

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);

    private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);

    private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

    private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

Spring入門看這一篇就夠了前言Spring介紹引出SpringCore子產品快速入門

DAO層和Service層通過DaoFactory來實作松耦合

如果Serivce層直接new DaoBook()，那麼DAO和Service就緊耦合了【Service層依賴緊緊依賴于Dao】。

而Spring給我們更加合适的方法來實作松耦合，并且更加靈活、功能更加強大！---->IOC控制反轉

切面程式設計

切面程式設計也就是AOP程式設計，其實我們在之前也接觸過...動态代理就是一種切面程式設計了...

當時我們使用動态代理+注解的方式給Service層的方法添權重限.

@Override
    @permission("添加分類")
    /*添加分類*/
    public void addCategory(Category category) {
        categoryDao.addCategory(category);
    }


    /*查找分類*/
    @Override
    public void findCategory(String id) {
        categoryDao.findCategory(id);
    }

    @Override
    @permission("查找分類")
    /*檢視分類*/
    public List<Category> getAllCategory() {
        return categoryDao.getAllCategory();
    }

    /*添加圖書*/
    @Override
    public void addBook(Book book) {
        bookDao.addBook(book);

    }

Controller調用Service的時候，Service傳回的是一個代理對象
代理對象得到Controller想要調用的方法，通過反射來看看該方法上有沒有注解
如果有注解的話，那麼就判斷該使用者是否有權限來調用此方法，如果沒有權限，就抛出異常給Controller，Controller接收到異常，就可以提示使用者沒有權限了。

AOP程式設計可以簡單了解成：在執行某些代碼前，執行另外的代碼

Struts2的攔截器也是面向切面程式設計【在執行Action業務方法之前執行攔截器】

Spring也為我們提供更好地方式來實作面向切面程式設計！

引出Spring

我們試着回顧一下沒學Spring的時候，是怎麼開發Web項目的

1. 實體類--->class User{ }
2. daoclass--> UserDao{ .. 通路db}
3. service--->class UserService{ UserDao userDao = new UserDao();}
4. actionclass UserAction{UserService userService = new UserService();}

使用者通路：

Tomcat->action->service->dao

我們來思考幾個問題：

①：對象建立建立能否寫死？

②：對象建立細節

對象數量

action  多個   【維護成員變量】

service 一個   【不需要維護公共變量】

dao     一個   【不需要維護公共變量】

建立時間

```
action    通路時候建立           
```
```
service   啟動時候建立           
```
```
dao       啟動時候建立           
```

③：對象的依賴關系
- action 依賴 service
- service依賴 dao

對于第一個問題和第三個問題，我們可以通過DaoFactory解決掉(雖然不是比較好的解決方法)

對于第二個問題，我們要控制對象的數量和建立事件就有點麻煩了....

而Spring架構通過IOC就很好地可以解決上面的問題....

IOC控制反轉

Spring的核心思想之一：Inversion of Control , 控制反轉 IOC

那麼控制反轉是什麼意思呢？？？對象的建立交給外部容器完成，這個就做控制反轉。

Spring使用控制反轉來實作對象不用在程式中寫死
控制反轉解決對象處理問題【把對象交給别人建立】

那麼對象的對象之間的依賴關系Spring是怎麼做的呢？？依賴注入，dependency injection.

Spring使用依賴注入來實作對象之間的依賴關系
在建立完對象之後，對象的關系處理就是依賴注入

上面已經說了，控制反轉是通過外部容器完成的，而Spring又為我們提供了這麼一個容器，我們一般将這個容器叫做：IOC容器.

無論是建立對象、處理對象之間的依賴關系、對象建立的時間還是對象的數量，我們都是在Spring為我們提供的IOC容器上配置對象的資訊就好了。

那麼使用IOC控制反轉這一思想有什麼作用呢？？？我們來看看一些優秀的回答...

來自知乎：

https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分：

ioc的思想最核心的地方在于，資源不由使用資源的雙方管理，而由不使用資源的第三方管理，這可以帶來很多好處。第一，資源集中管理，實作資源的可配置和易管理。第二，降低了使用資源雙方的依賴程度，也就是我們說的耦合度。

也就是說，甲方要達成某種目的不需要直接依賴乙方，它隻需要達到的目的告訴第三方機構就可以了，比如甲方需要一雙襪子，而乙方它賣一雙襪子，它要把襪子賣出去，并不需要自己去直接找到一個賣家來完成襪子的賣出。它也隻需要找第三方，告訴别人我要賣一雙襪子。這下好了，甲乙雙方進行交易活動，都不需要自己直接去找賣家，相當于程式内部開放接口，賣家由第三方作為參數傳入。甲乙互相不依賴，而且隻有在進行交易活動的時候，甲才和乙産生聯系。反之亦然。這樣做什麼好處麼呢，甲乙可以在對方不真實存在的情況下獨立存在，而且保證不交易時候無聯系，想交易的時候可以很容易的産生聯系。甲乙交易活動不需要雙方見面，避免了雙方的互不信任造成交易失敗的問題。因為交易由第三方來負責聯系，而且甲乙都認為第三方可靠。那麼交易就能很可靠很靈活的産生和進行了。這就是ioc的核心思想。生活中這種例子比比皆是，支付寶在整個淘寶體系裡就是龐大的ioc容器，交易雙方之外的第三方，提供可靠性可依賴可靈活變更交易方的資源管理中心。另外人事代理也是，雇傭機構和個人之外的第三方。

==========================update===========================

在以上的描述中，誕生了兩個專業詞彙，依賴注入和控制反轉所謂的依賴注入，則是，甲方開放接口，在它需要的時候，能夠講乙方傳遞進來(注入)所謂的控制反轉，甲乙雙方不互相依賴，交易活動的進行不依賴于甲乙任何一方，整個活動的進行由第三方負責管理。

參考優秀的博文①：

https://www.tianmaying.com/tutorial/spring-ioc

參考優秀的博文②：

這裡寫連結内容

知乎

@Intopass

的回答：

不用自己組裝，拿來就用。
享受單例的好處，效率高，不浪費空間。
便于單元測試，友善切換mock元件。
便于進行AOP操作，對于使用者是透明的。
統一配置，便于修改。

Spring子產品

Spring可以分為6大子產品：

Spring Core spring的核心功能： IOC容器, 解決對象建立及依賴關系

Spring Web Spring對web子產品的支援。

可以與struts整合,讓struts的action建立交給spring

```
spring mvc模式           
```

Spring DAO Spring 對jdbc操作的支援【JdbcTemplate模闆工具類】
Spring ORM spring對orm的支援：
- 既可以與hibernate整合，【session】
- 也可以使用spring的對hibernate操作的封裝
Spring AOP 切面程式設計
SpringEE spring 對javaEE其他子產品的支援

上面文主要引出了為啥我們需要使用Spring架構，以及大緻了解了Spring是分為六大子產品的....下面主要講解Spring的core子產品！

Core子產品快速入門

搭建配置環境

引入jar包:

本博文主要是core子產品的内容，涉及到Spring core的開發jar包有五個：

commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean節點
spring-context-3.2.5.RELEASE.jar spring上下文節點
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表達式相關表

我主要使用的是Spring3.2版本...

編寫配置檔案:

Spring核心的配置檔案

applicationContext.xml

或者叫

bean.xml

那這個配置檔案怎麼寫呢？？一般地，我們都知道架構的配置檔案都是有限制的...我們可以在

spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

找到XML配置檔案的限制

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
</beans>

我是使用Intellij Idea內建開發工具的，可以選擇自帶的Spring配置檔案,它長的是這樣：

<?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">

</beans>

前面在介紹Spring子產品的時候已經說了，Core子產品是：IOC容器，解決對象建立和之間的依賴關系。

是以Core子產品主要是學習如何得到IOC容器，通過IOC容器來建立對象、解決對象之間的依賴關系、IOC細節。

得到Spring容器對象【IOC容器】

Spring容器不單單隻有一個，可以歸為兩種類型

Bean工廠，BeanFactory【功能簡單】
應用上下文，ApplicationContext【功能強大，一般我們使用這個】

通過Resource擷取BeanFactory

加載Spring配置檔案
通過XmlBeanFactory+配置檔案來建立IOC容器

//加載Spring的資源檔案
        Resource resource = new ClassPathResource("applicationContext.xml");

        //建立IOC容器對象【IOC容器=工廠類+applicationContext.xml】
        BeanFactory beanFactory = new XmlBeanFactory(resource);

類路徑下XML擷取ApplicationContext

直接通過ClassPathXmlApplicationContext對象來擷取

// 得到IOC容器對象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        System.out.println(ac);

在Spring中總體來看可以通過三種方式來配置對象:

使用XML檔案配置
使用注解來配置
使用JavaConfig來配置

XML配置方式

在上面我們已經可以得到IOC容器對象了。接下來就是在applicationContext.xml檔案中配置資訊【讓IOC容器根據applicationContext.xml檔案來建立對象】

首先我們先有個JavaBean的類

/**
 * Created by ozc on 2017/5/10.
 */
public class User {

    private String id;
    private String username;


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

以前我們是通過new User的方法建立對象的....

User user = new User();

現在我們有了IOC容器，可以讓IOC容器幫我們建立對象了。在applicationContext.xml檔案中配置對應的資訊就行了

<!--
        使用bean節點來建立對象
            id屬性辨別着對象
            name屬性代表着要建立對象的類全名
        -->
    <bean id="user" class="User"/>

通過IOC容器對象擷取對象:

在外界通過IOC容器對象得到User對象

// 得到IOC容器對象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        User user = (User) ac.getBean("user");

        System.out.println(user);

上面我們使用的是IOC通過無參構造函數來建立對象，我們來回顧一下一般有幾種建立對象的方式：

無參構造函數建立對象
帶參數的構造函數建立對象
工廠建立對象
- 靜态方法建立對象
- 非靜态方法建立對象

使用無參的構造函數建立對象我們已經會了，接下來我們看看使用剩下的IOC容器是怎麼建立對象的。

首先，JavaBean就要提供帶參數的構造函數：

public User(String id, String username) {
        this.id = id;
        this.username = username;
    }

接下來，關鍵是怎麼配置applicationContext.xml檔案了。

<bean id="user" class="User">

        <!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個-->
        <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
        <constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg>
    </bean>

在constructor上如果構造函數的值是一個對象，而不是一個普通類型的值，我們就需要用到ref屬性了，而不是value屬性

比如說：我在User對象上維護了Person對象的值，想要在構造函數中初始化它。是以，就需要用到ref屬性了

<bean id="person" class="Person"></bean> 

    <bean id="user" class="User" >

        <!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個-->
        <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
        <constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg>
    </bean>

工廠靜态方法建立對象

首先，使用一個工廠的靜态方法傳回一個對象

public class Factory {

    public static User getBean() {

        return new User();
    }
      
}

配置檔案中使用工廠的靜态方法傳回對象

<!--工廠靜态方法建立對象，直接使用class指向靜态類，指定靜态方法就行了-->
    <bean id="user" class="Factory" factory-method="getBean" >

    </bean>

工廠非靜态方法建立對象

首先，也是通過工廠的非非靜态方法來得到一個對象

public class Factory {

    
    public User getBean() {

        return new User();
    }


}

配置檔案中使用工廠的非靜态方法傳回對象

<!--首先建立工廠對象-->
    <bean id="factory" class="Factory"/>

    <!--指定工廠對象和工廠方法-->
    <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

c名稱空間

我們在使用XML配置建立Bean的時候，如果該Bean有構造器，那麼我們使用

<constructor-arg>

這個節點來對構造器的參數進行指派...

<constructor-arg>

未免有點太長了，為了簡化配置，Spring來提供了c名稱空間...

要想c名稱空間是需要導入

xmlns:c="http://www.springframework.org/schema/c"

的

<bean id="userService" class="bb.UserService" c:userDao-ref="">

    </bean>

c名稱空間有個缺點：不能裝配集合，當我們要裝配集合的時候還是需要

<constructor-arg>

這個節點

裝載集合

如果對象上的屬性或者構造函數擁有集合的時候，而我們又需要為集合指派，那麼怎麼辦？

在構造函數上，普通類型

<bean id="userService" class="bb.UserService" >
        <constructor-arg >
            <list>
                //普通類型
                <value></value>
            </list>
        </constructor-arg>
    </bean>

在屬性上,引用類型

<property name="userDao">
         
         <list>
             <ref></ref>
         </list>
     </property>

注解方式

自從jdk5有了注解這個新特性，我們可以看到Struts2架構、Hibernate架構都支援使用注解來配置資訊...

通過注解來配置資訊就是為了簡化IOC容器的配置，注解可以把對象添加到IOC容器中、處理對象依賴關系，我們來看看怎麼用吧：

使用注解步驟：

1）先引入context名稱空間

xmlns:context="http://www.springframework.org/schema/context"

2）開啟注解掃描器
- ```
`<context:component-scan base-package=""></context:component-scan>`           
```
- 第二種方法:也可以通過自定義掃描類以 @CompoentScan 修飾來掃描IOC容器的bean對象。。如下代碼:

//表明該類是配置類
@Configuration

//啟動掃描器，掃描bb包下的
    //也可以指定多個基礎包
    //也可以指定類型
@ComponentScan("bb")
public class AnnotationScan {

}

在使用

@ComponentScan()

這個注解的時候，

在測試類上需要@ContextConfiguration這個注解來加載配置類

...

@ContextConfiguration 這個注解又在Spring的test包下..

建立對象以及處理對象依賴關系，相關的注解：

@ComponentScan 掃描器
@Configuration 表明該類是配置類
@Component 指定把一個對象加入IOC容器---> @Name 也可以實作相同的效果【一般少用】
@Repository 作用同@Component ；在持久層使用
@Service 作用同@Component ；在業務邏輯層使用
@Controller 作用同@Component ；在控制層使用
@Resource 依賴關系
- 如果 @Resource 不指定值，那麼就根據類型來找，相同的類型在IOC容器中不能有兩個
- @Resource 指定了值，那麼就根據名字來找

測試代碼:

UserDao

package aa;

import org.springframework.stereotype.Repository;

/**
 * Created by ozc on 2017/5/10.
 */

//把對象添加到容器中,首字母會小寫
@Repository
public class UserDao {

    public void save() {
        System.out.println("DB:儲存使用者");
    }


}

userService

package aa;


import org.springframework.stereotype.Service;

import javax.annotation.Resource;


//把UserService對象添加到IOC容器中,首字母會小寫
@Service
public class UserService {

    //如果@Resource不指定值，那麼就根據類型來找--->UserDao....當然了，IOC容器不能有兩個UserDao類型的對象
    //@Resource

    //如果指定了值，那麼Spring就在IOC容器找有沒有id為userDao的對象。
    @Resource(name = "userDao")
    private UserDao userDao;

    public void save() {
        userDao.save();
    }
}

userAction

package aa;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
 * Created by ozc on 2017/5/10.
 */

//把對象添加到IOC容器中,首字母會小寫
@Controller
public class UserAction {

    @Resource(name = "userService")
    private UserService userService;

    public String execute() {
        userService.save();
        return null;
    }
}

測試

package aa;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by ozc on 2017/5/10.
 */
public class App {

    public static void main(String[] args) {

        // 建立容器對象
        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");

        UserAction userAction = (UserAction) ac.getBean("userAction");

        userAction.execute();
    }
}

通過Java方式

由于Spring的自動裝配并不能将第三方庫元件裝配到應用中，于是需要顯式裝配配置。顯示裝配有兩種方式

通過java代碼裝配bean
通過XML裝配bean

Spring In Action作者首推使用自動裝配的功能，而後是通過java代碼配置bean，最後才用XML檔案配置的方式..

那麼怎麼通過java代碼來配置Bean呢？？

編寫一個java類，使用 @Configuration 修飾該類
被 @Configuration 修飾的類就是配置類

編寫配置類:

@org.springframework.context.annotation.Configuration
    public class Configuration {
      
    }

使用配置類建立bean:

使用 @Bean 來修飾方法，該方法傳回一個對象。
不管方法體内的對象是怎麼建立的，Spring可以擷取得到對象就行了。
Spring内部會将該對象加入到Spring容器中
容器中bean的ID預設為方法名

@org.springframework.context.annotation.Configuration
public class Configuration {

    @Bean
    public UserDao userDao() {

        UserDao userDao = new UserDao();
        System.out.println("我是在configuration中的"+userDao);
        return userDao;
    }

}

測試代碼：要使用@ContextConfiguration加載配置類的資訊【引入test包】

package bb;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;

/**
 * Created by ozc on 2017/5/11.
 */
//加載配置類的資訊
@ContextConfiguration(classes = Configuration.class)
public class Test2 {

    @Test
    public void test33() {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("bb/bean.xml");

        UserDao userDao = (UserDao) ac.getBean("userDao");

        System.out.println(userDao);
    }
}

三種方式混合使用

注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的...

如果JavaConfig的配置類是分散的，我們一般再建立一個更進階的配置類（root），然後使用

@Import

來将配置類進行組合

如果XML的配置檔案是分散的，我們也是建立一個更進階的配置檔案（root），然後使用

在JavaConfig引用XML

@ImportResource()

在XML引用JavaConfig

<bean> 節點就行了

bean對象建立細節

在Spring第一篇中，我們為什麼要引入Spring提出了這麼一些問題：

既然我們現在已經初步了解IOC容器了，那麼這些問題我們都是可以解決的。并且是十分簡單【對象寫死問題已經解決了，IOC容器就是控制反轉建立對象】

scope屬性

指定scope屬性，IOC容器就知道建立對象的時候是單例還是多例的了。

屬性的值就隻有兩個：單例/多例

當我們使用singleton【單例】的時候，從IOC容器擷取的對象都是同一個：

當我們使用prototype【多例】的時候，從IOC容器擷取的對象都是不同的：

scope屬性除了控制對象是單例還是多例的，還控制着對象建立的時間！

我們在User的構造函數中列印出一句話，就知道User對象是什麼時候建立了。

public User() {

        System.out.println("我是User，我被建立了");
    }

當使用singleton的時候，對象在IOC容器之前就已經建立了
- Spring入門看這一篇就夠了前言Spring介紹引出SpringCore子產品快速入門
當使用prototype的時候，對象在使用的時候才建立
- Spring入門看這一篇就夠了前言Spring介紹引出SpringCore子產品快速入門

lazy-init屬性

lazy-init屬性隻對singleton【單例】的對象有效.....lazy-init預設為false....

有的時候，可能我們想要對象在使用的時候才建立，那麼将lazy-init設定為ture就行了

init-method和destroy-method

如果我們想要對象在建立後，執行某個方法，我們指定為init-method屬性就行了。。

如果我們想要IOC容器銷毀後，執行某個方法，我們指定destroy-method屬性就行了。

<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>

Bean建立細節總結

/**
     * 1) 對象建立： 單例/多例
     *  scope="singleton", 預設值， 即 預設是單例 【service/dao/工具類】
     *  scope="prototype", 多例；              【Action對象】
     * 
     * 2) 什麼時候建立?
     *    scope="prototype"  在用到對象的時候，才建立對象。
     *    scope="singleton"  在啟動(容器初始化之前)， 就已經建立了bean，且整個應用隻有一個。
     * 3)是否延遲建立
     *    lazy-init="false"  預設為false,  不延遲建立，即在啟動時候就建立對象
     *    lazy-init="true"   延遲初始化， 在用到對象的時候才建立對象
     *    （隻對單例有效）
     * 4) 建立對象之後，初始化/銷毀
     *    init-method="init_user"       【對應對象的init_user方法，在對象建立之後執行 】
     *    destroy-method="destroy_user"  【在調用容器對象的destroy方法時候執行，(容器用實作類)】
     */

如果文章有錯的地方歡迎指正，大家互相交流。習慣在微信看技術文章，想要擷取更多的Java資源的同學，可以關注微信公衆号:Java3y

更多的文章可往：

文章的目錄導航

Spring入門看這一篇就夠了前言Spring介紹引出SpringCore子產品快速入門

前言