Spring學習(1)——快速入門

時間 2019-11-13

原文原文鏈接

認識 Spring 框架

Spring 框架是 Java 應用最廣的框架，它的成功來源於理念，而不是技術自己，它的理念包括 IoC (Inversion of Control，控制反轉) 和 AOP(Aspect Oriented Programming，面向切面編程)。html

什麼是 Spring：

Spring 是一個輕量級的 DI / IoC 和 AOP 容器的開源框架，來源於 Rod Johnson 在其著做《Expert one on one J2EE design and development》中闡述的部分理念和原型衍生而來。
Spring 提倡以「最少侵入」的方式來管理應用中的代碼，這意味着咱們能夠隨時安裝或者卸載 Spring

適用範圍：任何 Java 應用
Spring 的根本使命：簡化 Java 開發

儘管 J2EE 可以遇上 Spring 的步伐，但 Spring 並無中止前進， Spring 繼續在其餘領域發展，而 J2EE 則剛剛開始涉及這些領域，或者尚未徹底開始在這些領域的創新。移動開發、社交 API 集成、NoSQL 數據庫、雲計算以及大數據都是 Spring 正在涉足和創新的領域。Spring 的前景依然會很美好。java

Spring 中經常使用術語：

框架：是能完成必定功能的半成品。
框架可以幫助咱們完成的是：項目的總體框架、一些基礎功能、規定了類和對象如何建立，如何協做等，當咱們開發一個項目時，框架幫助咱們完成了一部分功能，咱們本身再完成一部分，那這個項目就完成了。
非侵入式設計：
從框架的角度能夠理解爲：無需繼承框架提供的任何類
這樣咱們在更換框架時，以前寫過的代碼幾乎能夠繼續使用。
輕量級和重量級：
輕量級是相對於重量級而言的，輕量級通常就是非入侵性的、所依賴的東西很是少、資源佔用很是少、部署簡單等等，其實就是比較容易使用，而重量級正好相反。
JavaBean：
即符合 JavaBean 規範的 Java 類
POJO：即 Plain Old Java Objects，簡單老式 Java 對象
它能夠包含業務邏輯或持久化邏輯，但不擔當任何特殊角色且不繼承或不實現任何其它Java框架的類或接口。

注意：bean 的各類名稱——雖然 Spring 用 bean 或者 JavaBean 來表示應用組件，但並不意味着 Spring 組件必須遵循 JavaBean 規範，一個 Spring 組件能夠是任意形式的 POJO。git

容器：
在平常生活中容器就是一種盛放東西的器具，從程序設計角度看就是裝對象的的對象，由於存在放入、拿出等操做，因此容器還要管理對象的生命週期。

Spring 的優點

低侵入 / 低耦合 （下降組件之間的耦合度，實現軟件各層之間的解耦）
聲明式事務管理（基於切面和慣例）
方便集成其餘框架（如MyBatis、Hibernate）
下降 Java 開發難度
Spring 框架中包括了 J2EE 三層的每一層的解決方案（一站式）

Spring 能幫咱們作什麼

①.Spring 能幫咱們根據配置文件建立及組裝對象之間的依賴關係。
②.Spring 面向切面編程能幫助咱們無耦合的實現日誌記錄，性能統計，安全控制。
③.Spring 能很是簡單的幫咱們管理數據庫事務。
④.Spring 還提供了與第三方數據訪問框架（如Hibernate、JPA）無縫集成，並且本身也提供了一套JDBC訪問模板來方便數據庫訪問。
⑤.Spring 還提供與第三方Web（如Struts1/二、JSF）框架無縫集成，並且本身也提供了一套Spring MVC框架，來方便web層搭建。
⑥.Spring 能方便的與Java EE（如Java Mail、任務調度）整合，與更多技術整合（好比緩存框架）。github

Spring 的框架結構

Data Access/Integration層包含有JDBC、ORM、OXM、JMS和Transaction模塊。
Web層包含了Web、Web-Servlet、WebSocket、Web-Porlet模塊。
AOP模塊提供了一個符合AOP聯盟標準的面向切面編程的實現。
Core Container(核心容器)：包含有Beans、Core、Context和SpEL模塊。
Test模塊支持使用JUnit和TestNG對Spring組件進行測試。

Spring IoC 和 DI 簡介

IoC：Inverse of Control（控制反轉）

讀做「反轉控制」，更好理解，不是什麼技術，而是一種設計思想，就是將本來在程序中手動建立對象的控制權，交由Spring框架來管理。
正控：若要使用某個對象，須要本身去負責對象的建立
反控：若要使用某個對象，只須要從 Spring 容器中獲取須要使用的對象，不關心對象的建立過程，也就是把建立對象的控制權反轉給了Spring框架
好萊塢法則：Don’t call me ,I’ll call you

一個例子

控制反轉顯然是一個抽象的概念，咱們舉一個鮮明的例子來講明。web

在現實生活中，人們要用到同樣東西的時候，第一反應就是去找到這件東西，好比想喝新鮮橙汁，在沒有飲品店的日子裏，最直觀的作法就是：買果汁機、買橙子，而後準備開水。值得注意的是：這些都是你本身「主動」創造的過程，也就是說一杯橙汁須要你本身創造。spring

然而到了今時今日，因爲飲品店的盛行，當咱們想喝橙汁時，第一想法就轉換成了找到飲品店的聯繫方式，經過電話等渠道描述你的須要、地址、聯繫方式等，下訂單等待，過一下子就會有人送來橙汁了。數據庫

請注意你並無「主動」去創造橙汁，橙汁是由飲品店創造的，而不是你，然而也徹底達到了你的要求，甚至比你創造的要好上那麼一些。express

編寫第一個 Spring 程序

新建一個空的 Java 項目，命名爲【spring】
新建一個名爲【lib】的目錄，並添加進必要的 jar 包，導入項目

在 Packge【pojo】下新建一個【Source】類：

package pojo;

public class Source {  
    private String fruit;   // 類型
    private String sugar;   // 糖分描述
    private String size;    // 大小杯    
    /* setter and getter */
}

在【src】目錄下新建一個【applicationContext.xml】文件，經過 xml 文件配置的方式裝配咱們的 bean

<?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 name="source" class="pojo.Source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
</beans>

在 Packge【test】下新建一個【TestSpring】類：

package test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Source;

public class TestSpring {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"applicationContext.xml"}
        );

        Source source = (Source) context.getBean("source");
        System.out.println(source.getFruit());
        System.out.println(source.getSugar());
        System.out.println(source.getSize());
    }
}

運行測試代碼，能夠正常拿到 xml 配置的 bean

總結：
傳統的方式：
經過new 關鍵字主動建立一個對象
IOC方式：
對象的生命週期由Spring來管理，直接從Spring那裏去獲取一個對象。 IOC是反轉控制 (Inversion Of Control)的縮寫，就像控制權從原本在本身手裏，交給了Spring。

參考地址：這裏編程

DI：Dependency Injection（依賴注入）

指 Spring 建立對象的過程當中，將對象依賴屬性（簡單值，集合，對象）經過配置設值給該對象

繼續上面的例子

在 Packge【pojo】下新建一個【JuiceMaker】類：

package pojo;

public class JuiceMaker {

    // 惟一關聯了一個 Source 對象
    private Source source = null;

    /* setter and getter */

    public String makeJuice(){
        String juice = "xxx用戶點了一杯" + source.getFruit() + source.getSugar() + source.getSize();
        return juice;
    }
}

在 xml 文件中配置 JuiceMaker 對象：

注意：這裏要使用 ref 來注入另外一個對象

<?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 name="source" class="pojo.Source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
    <bean name="juickMaker" class="pojo.JuiceMaker">
        <property name="source" ref="source" />
    </bean>
</beans>

在【TestSpring】中添加以下代碼：

package test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.JuiceMaker;
import pojo.Source;

public class TestSpring {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"applicationContext.xml"}
        );

        Source source = (Source) context.getBean("source");
        System.out.println(source.getFruit());
        System.out.println(source.getSugar());
        System.out.println(source.getSize());

        JuiceMaker juiceMaker = (JuiceMaker) context.getBean("juickMaker");
        System.out.println(juiceMaker.makeJuice());
    }
}

運行測試代碼：

總結：IoC 和 DI 實際上是同一個概念的不一樣角度描述，DI 相對 IoC 而言，明確描述了「被注入對象依賴 IoC 容器配置依賴對象」緩存

IoC 如何實現的

最後咱們簡單說說IoC是如何實現的。想象一下若是咱們本身來實現這個依賴注入的功能，咱們怎麼來作？無外乎：

讀取標註或者配置文件，看看JuiceMaker依賴的是哪一個Source，拿到類名
使用反射的API，基於類名實例化對應的對象實例
將對象實例，經過構造函數或者 setter，傳遞給 JuiceMaker

咱們發現其實本身來實現也不是很難，Spring實際也就是這麼作的。這麼看的話其實IoC就是一個工廠模式的升級版！固然要作一個成熟的IoC框架，仍是很是多細緻的工做要作，Spring不只提供了一個已經成爲業界標準的Java IoC框架，還提供了更多強大的功能，因此你們就別去造輪子啦！但願瞭解IoC更多實現細節不妨經過學習Spring的源碼來加深理解！

引用地址：這裏

Spring AOP 簡介

若是說 IoC 是 Spring 的核心，那麼面向切面編程就是 Spring 最爲重要的功能之一了，在數據庫事務中切面編程被普遍使用。

AOP 即 Aspect Oriented Program 面向切面編程

首先，在面向切面編程的思想裏面，把功能分爲核心業務功能，和周邊功能。

所謂的核心業務，好比登錄，增長數據，刪除數據都叫核心業務
所謂的周邊功能，好比性能統計，日誌，事務管理等等

周邊功能在 Spring 的面向切面編程AOP思想裏，即被定義爲切面

在面向切面編程AOP的思想裏面，核心業務功能和切面功能分別獨立進行開發，而後把切面功能和核心業務功能 "編織" 在一塊兒，這就叫AOP

AOP 的目的

AOP可以將那些與業務無關，卻爲業務模塊所共同調用的邏輯或責任（例如事務處理、日誌管理、權限控制等）封裝起來，便於減小系統的重複代碼，下降模塊間的耦合度，並有利於將來的可拓展性和可維護性。

AOP 當中的概念：

切入點（Pointcut）
在哪些類，哪些方法上切入（where）
通知（Advice）
在方法執行的什麼實際（when:方法前/方法後/方法先後）作什麼（what:加強的功能）
切面（Aspect）
切面 = 切入點 + 通知，通俗點就是：在什麼時機，什麼地方，作什麼加強！
織入（Weaving）
把切面加入到對象，並建立出代理對象的過程。（由 Spring 來完成）

AOP 編程

在 Packge【service】下建立【ProductService】類：

package service;

public class ProductService {
    public void doSomeService(){
        System.out.println("doSomeService");
    }
}

在 xml 文件中裝配該 bean：

<bean name="productService" class="service.ProductService" />

在【TestSpring】中編寫測試代碼，運行：

在 Packge【aspect】下準備日誌切面【LoggerAspect】類：

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;

public class LoggerAspect {
    
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start log:" + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        System.out.println("end log:" + joinPoint.getSignature().getName());
        return object;
    }
}

在 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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean name="productService" class="service.ProductService" />
    <bean id="loggerAspect" class="aspect.LoggerAspect"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- where：在哪些地方（包.類.方法）作增長 -->
        <aop:pointcut id="loggerCutpoint"
                      expression="execution(* service.ProductService.*(..)) "/>

        <!-- what:作什麼加強 -->
        <aop:aspect id="logAspect" ref="loggerAspect">
            <!-- when:在什麼時機（方法前/後/先後） -->
            <aop:around pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
    </aop:config>
</beans>