spring框架基礎筆記

認識 Spring 框架

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

什麼是 Spring：

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

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

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

Spring 中經常使用術語：

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

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

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

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、任務調度）整合，與更多技術整合（好比緩存框架）。

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

一個例子

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

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

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

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

編寫第一個 Spring 程序

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

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

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

1. 在 【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>

1. 在 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()); } }

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

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

參考地址：這裏

DI：Dependency Injection（依賴注入）

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

繼續上面的例子

1. 在 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; } }

1. 在 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>

1. 在 【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()); } }

1. 運行測試代碼：

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

IoC 如何實現的

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

1. 讀取標註或者配置文件，看看JuiceMaker依賴的是哪一個Source，拿到類名
2. 使用反射的API，基於類名實例化對應的對象實例
3. 將對象實例，經過構造函數或者 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 編程

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

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

1. 在 xml 文件中裝配該 bean：

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

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

1. 在 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; } }

1. 在 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>

1. 再次運行 TestSpring 中的測試代碼，代碼並無改變，可是在業務方法運行以前和運行以後，都分別輸出了日誌信息：

部分文章出處：我沒有三顆心臟。