【萬字長文】Spring AOP 層層遞進輕鬆入門！

時間 2020-03-07

標籤萬字長文 spring aop 層層遞進輕鬆入門欄目 Spring 简体版

原文原文鏈接

初識 AOP（傳統程序）

Tips：若是想要快速查閱的朋友，能夠直接跳轉到初識AOP（Spring 程序）這一大節php

前面的內容以聯繫過去 Java、JavaWeb 的知識逐步引入到 AOP 爲主真正的Spring AOP內容包括下面幾個板塊能夠跳轉一下哈java

(一) AOP 術語mysql

(二) AOP 入門案例：XML 、註解方式spring

(三) 徹底基於 Spring 的事務控制：XML、註解方式、純註解方式sql

(一) AOP的簡單分析介紹

在軟件業，AOP爲Aspect Oriented Programming的縮寫，意爲：面向切面編程，經過預編譯方式和運行期間動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟件開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生範型。利用AOP能夠對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度下降，提升程序的可重用性，同時提升了開發的效率。數據庫

—— 百度百科express

開篇就直接來看 Spring AOP 中的百科說明，我我的認爲是很是晦澀的，當回過來頭再看這段引言的時候，才恍然大悟，這段話的意思呢，說白了，就是說咱們把程序中一些重複的代碼拿出來，在須要它執行的時候，能夠經過預編譯或者運行期的動態代理實現不動源碼而動態的給程序進行加強或者添加功能的技術apache

拿出一些重複的代碼？拿出的到底是什麼代碼呢？舉個例子！編程

在下面的方法中，咱們模擬的是程序中對事務的管理，下面代碼中的 A B均可以看作「開啓事務」、「提交事務」的一些事務場景，這些代碼就能夠看作是上面所說的重複的代碼的一種設計模式

而還有一些重複代碼大可能是關於權限管理或者說日誌登陸等一些雖然影響了咱們代碼業務邏輯的「乾淨」，可是卻不得不存在，若是有什麼辦法可以抽取出這些方法，使得咱們的業務代碼更加簡潔，天然咱們能夠更專一與咱們的業務，利於開發，這也就是咱們今天想要說重點

最後不得不提的是，AOP 做爲 Spring 這個框架的核心內容之一，很顯然應用了大量的設計模式，設計模式，歸根結底，就是爲了解耦，以及提升靈活性，可擴展性，而咱們所學的一些框架，直接把這些東西封裝好，讓你直接用，說的白一點，就是爲了讓你偷懶，讓你既保持了良好的代碼結構，又不須要和你去本身編寫這些複雜的數據結構，提升了開發效率

一上來就直接談 AOP術語阿，面向切面等等，很顯然不是很合適，光聽名字老是能能讓人「望文生怯」，任何技術的名字只不過是一個名詞罷了，實際上對於入門來講，咱們更須要搞懂的是，經過傳統的程序與使用 Spring AOP 相關技術的程序進行比較，使用 AOP 能夠幫助咱們解決哪些問題或者需求，經過知其然，而後應用其因此然，這樣相比較於，直接學習其基本使用方式，會有靈魂的多！

(二) 演示案例（傳統方式）

說明：下面的第一部分的例子是在上一篇文章的程序加以改進，爲了照顧到全部的朋友，我把從依賴到類的編寫都會提到，方便你們有須要來練習，看一下程序的總體結構，對後面的說明也有必定的幫助

(1) 添加必要的依賴

spring-context
mysql-connector-java
c3p0（數據庫鏈接池）
commons-dbutils（簡化JDBC的工具）—後面會簡單介紹一下
junit （單元自測）
spring-test

說明：因爲我這裏建立的是一個Maven項目，因此在這裏修改 pom.xml 添加一些必要的依賴座標就能夠

若是建立時沒有使用依賴的朋友，去下載咱們所須要的 jar 包導入就能夠了

<packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>
複製代碼

簡單看一下，spring核心的一些依賴，以及數據庫相關的依賴，還有單元測試等依賴就都導入進來了

(2) 建立帳戶表以及實體

下面所要使用的第一個案例，涉及到兩個帳戶之間的模擬轉帳交易，因此咱們建立出含有名稱以及餘額這樣幾個字段的表

A：建立 Account 表

-- ----------------------------
-- Table structure for account
-- ----------------------------
CREATE TABLE `account`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32),
  `balance` float,
  PRIMARY KEY (`id`)
)
複製代碼

B：建立 Account 類

沒什麼好說的，對應着咱們的表創出實體

public class Account implements Serializable {
    private  Integer id;
    private String name;
    private Float balance;
    ......補充 get set toString 方法
複製代碼

(3) 建立Service以及Dao

下面咱們演示事務問題，最主要仍是使用 transfer 這個轉帳方法，固然還有一些增刪改查的方法，我只留了一個查詢全部的方法，到時候就能夠看出傳統方法中一些代碼的重複以及複雜的工做度

A：AccountService 接口

public interface AccountService {
    /** * 查詢全部 * @return */
    List<Account> findAll();

    /** * 轉帳方法 * @param sourceName 轉出帳戶 * @param targetName 轉入帳戶 * @param money */
    void transfer(String sourceName,String targetName,Float money);
}
複製代碼

B：AccountServiceImpl 實現類

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public List<Account> findAll() {
        return accountDao.findAllAccount();
    }
    
    public void transfer(String sourceName, String targetName, Float money) {
        //根據名稱分別查詢到轉入轉出的帳戶
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targetName);

        //轉入轉出帳戶加減
        source.setBalance(source.getBalance() - money);
        target.setBalance(target.getBalance() + money);
        //更新轉入轉出帳戶
        accountDao.updateAccount(source);
        accountDao.updateAccount(target);
    }
}
複製代碼

C：AccountDao 接口

public interface AccountDao {

    /** * 更細帳戶信息（修改） * @param account */
    void updateAccount(Account account);

    /** * 查詢全部帳戶 * @return */
    List<Account> findAllAccount();

    /** * 經過名稱查詢 * @param accountName * @return */
    Account findAccountByName(String accountName);
}
複製代碼

D：AccountDaoImpl 實現類

咱們引入了 DBUtils 這樣一個操做數據庫的工具，它的做用就是封裝代碼，達到簡化 JDBC 操做的目的，因爲之後整合 SSM 框架的時候，持久層的事情就能夠交給 MyBatis 來作，而今天咱們重點仍是講解 Spring 中的知識，因此這部分會用就能夠了

用到的內容基本講解：

QueryRunner 提供對 sql 語句進行操做的 API （insert delete update）

ResultSetHander 接口，定義了查詢後，如何封裝結果集（僅提供了咱們用到的）

BeanHander：將結果集中第第一條記錄封裝到指定的 JavaBean 中
BeanListHandler：將結果集中的全部記錄封裝到指定的 JavaBean 中，而且將每個 JavaBean封裝到 List 中去

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private QueryRunner runner;

    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,balance=? where id=?", account.getName(), account.getBalance(), account.getId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountByName(String accountName) {
        try {
            List<Account> accounts = runner.query("select * from account where name = ?", new BeanListHandler<Account>(Account.class), accountName);

            if (accounts == null || accounts.size() == 0) {
                return null;
            }
            if (accounts.size() > 1) {
                throw new RuntimeException("結果集不惟一，數據存在問題");
            }
            return accounts.get(0);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
複製代碼

(4) 配置文件

A:bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" 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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--開啓掃描-->
    <context:component-scan base-package="cn.ideal"></context:component-scan>

    <!--配置 QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner">
        <!--注入數據源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <!--配置數據源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ideal_spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root99"></property>
    </bean>
</beans>
複製代碼

B: jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ideal_spring
jdbc.username=root
jdbc.password=root99
複製代碼

(5) 測試代碼

A：AccountServiceTest

在這裏，咱們使用 Spring以及Junit 測試

說明：使用 @RunWith 註解替換原有運行器而後使用 @ContextConfiguration 指定 spring 配置文件的位置，而後使用 @Autowired 給變量注入數據

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    private AccountService as;

    @Test
    public void testFindAll() {
        List<Account> list = as.findAll();
        for (Account account : list) {
            System.out.println(account);
        }
    }

    @Test
    public void testTransfer() {
        as.transfer("李四", "張三", 500f);
    }

}
複製代碼

(6) 執行效果

先執行查詢全部：

再執行模擬轉帳方法：

方法中也就是李四向張三轉帳500，看到下面的結果，是沒有任何問題的

(三) 初步分析以及解決

(1) 分析事務問題

首先分析一下，咱們並無顯式的進行事務的管理，可是不用否認，事務必定存在的，若是沒有提交事務，很顯然，查詢功能是不可以測試成功的，咱們的代碼事務隱式的被自動控制了，使用了 connection 對象的 setAutoCommit(true)，即自動提交了

接着看一下配置文件中，咱們只注入了了數據源，這樣作表明什麼呢？

<!--配置 QueryRunner-->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner">
	<!--注入數據源-->
	<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
複製代碼

也就是說，每一條語句獨立事務：

說白了，就是各管各的，彼此沒任何溝通，例如在Service的轉帳方法中，下面標着 1 2 3 4 5 的位置處的語句，每個調用時，都會建立一個新的 QueryRunner對象，而且從數據源中獲取一個鏈接，可是，當在某一個步驟中忽然出現問題，前面的語句仍然會執行，可是後面的語句就由於異常而終止了，這也就是咱們開頭說的，彼此之間是獨立的

public void transfer(String sourceName, String targetName, Float money) {
        //根據名稱分別查詢到轉入轉出的帳戶
        Account source = accountDao.findAccountByName(sourceName); // 1
        Account target = accountDao.findAccountByName(targetName); // 2

        //轉入轉出帳戶加減
        source.setBalance(source.getBalance() - money); // 3
        target.setBalance(target.getBalance() + money);
        //更新轉入轉出帳戶
        accountDao.updateAccount(source); // 4
        //模擬轉帳異常
        int num = 100/0; // 異常
        accountDao.updateAccount(target); //5
}
複製代碼

很顯然這是很是不合適的，甚至是致命的，像咱們代碼中所寫，轉出帳戶的帳戶信息已經扣款更新了，可是轉入方的帳戶信息卻因爲前面異常的發生，致使並無成功執行，李四從2500 變成了 2000，可是張三卻沒有成功收到轉帳

(2) 初步解決事務問題

上面出現的問題，歸根結底是因爲咱們持久層中的方法獨立事務，因此沒法實現總體的事務控制（與事務的一致性相悖）那麼咱們解決問題的思路是什麼呢？

首先咱們須要作的，就是使用 ThreadLocal 對象把 Connection 和當前線程綁定，從而使得一個線程中只有一個控制事務的對象，

簡單提一下Threadlocal：

Threadlocal 是一個線程內部的存儲類，能夠在指定線程內存儲數據，也就至關於，這些數據就被綁定在這個線程上了，只能經過這個指定的線程，才能夠獲取到想要的數據

這是官方的說明：

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copLy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).

就是說，ThreadLoacl 提供了線程內存儲局部變量的方式，這些變量比較特殊的就是，每個線程獲取到的變量都是獨立的，獲取數據值的方法就是 get 以及 set

A：ConnectionUtils 工具類

建立 utils 包，而後建立一個 ConnectionUtils 工具類，其中最主要的部分，其實也就是寫了一個簡單的判斷，若是這個線程中已經存在鏈接，就直接返回，若是不存在鏈接，就獲取數據源中的一個連接，而後存入，再返回

@Component
public class ConnectionUtils {
    private ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

    @Autowired
    private DataSource dataSource;

    public Connection getThreadConnection() {

        try {
            // 從 ThreadLocal獲取
            Connection connection = threadLocal.get();
            //先判斷是否爲空
            if (connection == null) {
                //從數據源中獲取一個鏈接，且存入 ThreadLocal
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            }
            return connection;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void removeConnection(){
        threadLocal.remove();
    }
}
複製代碼

B：TransactionManager 工具類

接着能夠建立一個管理事務的工具類，其中包括，開啓、提交、回滾事務，以及釋放鏈接

@Component
public class TransactionManager {

    @Autowired
    private ConnectionUtils connectionUtils;

    /** * 開啓事務 */
    public void beginTransaction() {
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** * 提交事務 */
    public void commit() {
        try {
            connectionUtils.getThreadConnection().commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** * 回滾事務 */
    public void rollback() {
        try {
            System.out.println("回滾事務" + connectionUtils.getThreadConnection());
            connectionUtils.getThreadConnection().rollback();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** * 釋放鏈接 */
    public void release() {
        try {
            connectionUtils.getThreadConnection().close();//還回鏈接池中
            connectionUtils.removeConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
複製代碼

C：業務層增長事務代碼

在方法中添加事務管理的代碼，正常狀況下執行開啓事務，執行操做（你的業務代碼），提交事務，捕獲到異常後執行回滾事務操做，最終執行釋放鏈接

在這種狀況下，即便在某個步驟中出現了異常狀況，也不會對數據形成實際的更改，這樣上面的問題就初步解決了

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private TransactionManager transactionManager;

    public List<Account> findAll() {
        try {
            //開啓事務
            transactionManager.beginTransaction();
            //執行操做
            List<Account> accounts = accountDao.findAllAccount();
            //提交事務
            transactionManager.commit();
            //返回結果
            return accounts;
        } catch (Exception e) {
            //回滾操做
            transactionManager.rollback();
            throw new RuntimeException(e);
        } finally {
            //釋放鏈接
            transactionManager.release();
        }
    }

    public void transfer(String sourceName, String targetName, Float money) {

        try {
            //開啓事務
            transactionManager.beginTransaction();
            //執行操做

            //根據名稱分別查詢到轉入轉出的帳戶
            Account source = accountDao.findAccountByName(sourceName);
            Account target = accountDao.findAccountByName(targetName);

            //轉入轉出帳戶加減
            source.setBalance(source.getBalance() - money);
            target.setBalance(target.getBalance() + money);

            //更新轉出轉入帳戶
            accountDao.updateAccount(source);
            //模擬轉帳異常
            int num = 100 / 0;
            accountDao.updateAccount(target);

            //提交事務
            transactionManager.commit();

        } catch (Exception e) {
            //回滾操做
            transactionManager.rollback();
            e.printStackTrace();
        } finally {
            //釋放鏈接
            transactionManager.release();
        }
    }
}
複製代碼

(四) 思考再改進方式

雖然上面，咱們已經實現了在業務層進行對事務的控制，可是很顯然能夠看見，咱們在每個方法中都存在着太多重複的代碼了，而且以業務層與事務管理的方法出現了耦合，打個比方，事務管理類中的隨便一個方法名進行更改，就會直接致使業務層中找不到對應的方法，所有須要修改，若是在業務層方法較多時，很顯然這是很麻煩的

這種狀況下，咱們能夠經過使用靜態代理這一種方式，來進行對上面程序的改進，改進以前爲了照顧到全部的朋友，回顧一下動態代理的一個介紹以及基本使用方式

(五) 回顧動態代理

(1) 什麼是動態代理

動態代理，也就是給某個對象提供一個代理對象，用來控制對這個對象的訪問

簡單的舉個例子就是：買火車、飛機票等，咱們能夠直接從車站售票窗口進行購買，這就是用戶直接在官方購買，可是咱們不少地方的店鋪或者一些路邊的亭臺中均可以進行火車票的代售，用戶直接能夠在代售點購票，這些地方就是代理對象

(2) 使用代理對象有什麼好處呢？

功能提供的這個類（火車站售票處），能夠更加專一於主要功能的實現，好比安排車次以及生產火車票等等
代理類（代售點）能夠在功能提供類提供方法的基礎上進行增長實現更多的一些功能

這個動態代理的優點，帶給咱們不少方便，它能夠幫助咱們實現無侵入式的代碼擴展，也就是在不用修改源碼的基礎上，同時加強方法

動態代理分爲兩種：① 基於接口的動態代理 ② 基於子類的動態代理

(3) 動態代理的兩種方式

A：基於接口的動態代理方式

A：建立官方售票處（類和接口）

RailwayTicketProducer 接口

/** * 生產廠家的接口 */
public interface RailwayTicketProducer {

    public void saleTicket(float price);

    public void ticketService(float price);

}
複製代碼

RailwayTicketProducerImpl 類

實現類中，咱們後面只對銷售車票方法進行了加強，售後服務並無涉及到

/** * 生產廠家具體實現 */
public class RailwayTicketProducerImpl implements RailwayTicketProducer{

    public void saleTicket(float price) {
        System.out.println("銷售火車票，收到車票錢：" + price);
    }

    public void ticketService(float price) {
        System.out.println("售後服務（改簽），收到手續費：" + price);
    }
}
複製代碼

Client 類

這個類，就是客戶類，在其中，經過代理對象，實現購票的需求

首先先來講一下如何建立一個代理對象：答案是 Proxy類中的 newProxyInstance 方法

注意：既然叫作基於接口的動態代理，這就是說被代理的類，也就是文中官方銷售車票的類最少必須實現一個接口，這是必要的！

public class Client {

    public static void main(String[] args) {
        RailwayTicketProducer producer = new RailwayTicketProducerImpl();

        //動態代理
        RailwayTicketProducer proxyProduce = (RailwayTicketProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),new MyInvocationHandler(producer));

        //客戶經過代理買票
        proxyProduce.saleTicket(1000f);
    }
}
複製代碼

newProxyInstance 共有三個參數 來解釋一下：

ClassLoader：類加載器
- 用於加載代理對象字節碼，和被代理對象使用相同的類加載器
Class[]：字節碼數組
- 爲了使被代理對象和的代理對象具備相同的方法，實現相同的接口，可看作固定寫法
InvocationHandler：如何代理，也就是想要加強的方式
- 也就是說，咱們主須要 new 出 InvocationHandler，而後書寫其實現類，是否寫成匿名內部類能夠本身選擇
- 如上述代碼中 new MyInvocationHandler(producer) 實例化的是我本身編寫的一個 MyInvocationHandler類，實際上能夠在那裏直接 new 出 InvocationHandler，而後重寫其方法，其本質也是經過實現 InvocationHandler 的 invoke 方法實現加強

MyInvocationHandler 類

這個 invoke 方法具備攔截的功能，被代理對象的任何方法被執行，都會通過 invoke

public class MyInvocationHandler implements InvocationHandler {

    private  Object implObject ;

    public MyInvocationHandler (Object implObject){
        this.implObject=implObject;
    }

    /** * 做用：執行被代理對象的任何接口方法都會通過該方法 * 方法參數的含義 * @param proxy 代理對象的引用 * @param method 當前執行的方法 * @param args 當前執行方法所需的參數 * @return 和被代理對象方法有相同的返回值 * @throws Throwable */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnValue = null;
        //獲取方法執行的參數
        Float price = (Float)args[0];
        //判斷是否是指定方法（以售票爲例）
        if ("saleTicket".equals(method.getName())){
            returnValue = method.invoke(implObject,price*0.8f);
        }
        return returnValue;
    }
}
複製代碼

在此處，咱們獲取到客戶購票的金額，因爲咱們使用了代理方進行購票，因此代理方會收取必定的手續費，因此用戶提交了 1000 元，實際上官方收到的只有800元，這也就是這種代理的實現方式，結果以下

銷售火車票，收到車票錢：800.0

B：基於子類的動態代理方式

上面方法簡單的實現起來也不是很難，可是惟一的標準就是，被代理對象必須提供一個接口，而如今所講解的這一種就是一種能夠直接代理普通 Java 類的方式，同時在演示的時候，我會將代理方法直接之內部類的形式寫出，就不單首創建類了，方便你們與上面對照

增長 cglib 依賴座標

<dependencies>
	<dependency>
		<groupId>cglib</groupId>
		<artifactId>cglib</artifactId>
        <version>3.2.4</version>
    </dependency>
</dependencies>
複製代碼

TicketProducer 類

/** * 生產廠家 */
public class TicketProducer {

    public void saleTicket(float price) {
        System.out.println("銷售火車票，收到車票錢：" + price);
    }

    public void ticketService(float price) {
        System.out.println("售後服務（改簽），收到手續費：" + price);
    }
}
複製代碼

Enhancer 類中的 create 方法就是用來建立代理對象的

而 create 方法又有兩個參數

Class ：字節碼
- 指定被代理對象的字節碼
Callback：提供加強的方法
- 與前面 invoke 做用是基本一致的
- 通常寫的都是該接口的子接口實現類：MethodInterceptor

public class Client {

    public static void main(String[] args) {
        // 因爲下方匿名內部類，須要在此處用final修飾
        final TicketProducer ticketProducer = new TicketProducer();

        TicketProducer cglibProducer =(TicketProducer) Enhancer.create(ticketProducer.getClass(), new MethodInterceptor() {

            /** * 前三個三個參數和基於接口的動態代理中invoke方法的參數是同樣的 * @param o * @param method * @param objects * @param methodProxy 當前執行方法的代理對象 * @return * @throws Throwable */
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                //獲取方法執行的參數
                Float price = (Float)objects[0];
                //判斷是否是指定方法（以售票爲例）
                if ("saleTicket".equals(method.getName())){
                    returnValue = method.invoke(ticketProducer,price*0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleTicket(900f);
    }
複製代碼

(六) 動態代理程序再改進

在這裏咱們寫一個用於建立業務層對象的工廠

在這段代碼中，咱們使用了前面所回顧的基於接口的動態代理方式，在執行方法的先後，分別寫入了開啓事務，提交事務，回滾事務等事務管理方法，這時候，業務層就能夠刪除掉前面所寫的關於業務的重複代碼

@Component
public class BeanFactory {
    @Autowired
    private AccountService accountService;
    @Autowired
    private TransactionManager transactionManager;

    @Bean("proxyAccountService")
    public AccountService getAccountService() {
        return (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object returnValue = null;
                        try {
                            //開啓事務
                            transactionManager.beginTransaction();
                            //執行操做
                            returnValue = method.invoke(accountService, args);
                            //提交事務
                            transactionManager.commit();
                            //返回結果
                            return returnValue;
                        } catch (Exception e) {
                            //回滾事務
                            transactionManager.rollback();
                            throw new RuntimeException();
                        } finally {
                            //釋放鏈接
                            transactionManager.release();
                        }
                    }
                });
    }
}
複製代碼

AccountServiceTest 類

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")

public class AccountServiceTest {
    @Autowired
    @Qualifier("proxyAccountService")
    private AccountService as;

    @Test
    public void testFindAll() {
        List<Account> list = as.findAll();
        for (Account account : list) {
            System.out.println(account);
        }
    }

    @Test
    public void testTransfer() {
        as.transfer("李四", "張三", 500f);
    }

}
複製代碼

到如今，一個相對完善的案例就改造完成了，因爲咱們上面大致使用的是註解的方式，並無所有使用 XML 進行配置，若是使用 XML 進行配置，配置也是相對繁瑣的，那麼咱們鋪墊這麼多的內容，實際上就是爲了引出 Spring 中 AOP 的概念，從根源上，一步一步，根據問題引出要學習的技術

讓咱們一塊兒來看一看！

初識 AOP（Spring 程序）

在前面，大篇幅的講解咱們在傳統的程序中，是如何一步一步，改進以及處理例如事務這樣的問題的，而 Spring 中 AOP 這個技術，就能夠幫助咱們來在不修源碼的基礎上對已經存在的方法進行加強，一樣維護也是很方便，大大的提升了開發的效率，如今咱們開始正式介紹 AOP 的知識，有了必定的知識鋪墊後，就可使用 AOP 的方式繼續對前面的程序進行改進！

(一) AOP 術語

任何一門技術，都會有其特定的術語，實際上就是一些特定的名稱而已，事實上，我之前在學習的時候，感受 AOP 的一些術語都是相對抽象的，並無很直觀的體現出它的意義，可是這些術語已經普遍的被開發者熟知，成爲了在這個相關技術中，默認已知的一些概念，雖然更重要的是理解 AOP 的思想與使用方式，可是，咱們仍是須要講這樣一種「共識」介紹一下

《Spring 實戰》中有這樣一句話，摘出來：

在咱們進入某個領域以前，必須學會在這個領域該如何說話

通知（Advice）

將安全，事務，或日誌定義好，在某個方法先後執行一些通知、加強的處理
也就是說：通知就是指，攔截到**鏈接點（Joinpoint）**後須要作的事情
通知分爲五種類型：
- 前置通知（Before）：在目標方法被執行前調用
- 後置通知（After）：在目標方法完成後使用，輸出的結果與它無關
- 返回通知（After-returning）：在目標方法成功執行以後調用
- 異常通知（After-throwing）：在目標方法拋出異常後調用
- 環繞通知（Around）：通知包裹了被通知的方法，在被通知的方法調用以前和調用以後執行自定義的行爲（在註解中體現明顯，後面能夠注意下）

鏈接點（Joinpoint）

是在應用執行過程當中可以插入切面的一個點。這個點能夠是調用方法時、拋出異常時、甚至修改一個字段時。切面代碼能夠利用這些點插入到應用的正常流程之中，並添加新的行爲
例如咱們前面對 Service 中的方法增長了事務的管理，事務層中的方法都會被動態代理所攔截到，這些方法就能夠看作是這個鏈接點，在這些方法的先後，咱們就能夠增長一些通知
一句話：方法的先後均可以看作是鏈接點

切入點（Pointcut）

有的時候，類中方法有不少，可是咱們並不想將全部的方法先後都增長通知，咱們只想對指定的方法進行經過，這就是切入點的概念
一句話：切入點就是對鏈接點進行篩選，選出最終要用的

切面（Aspect）

切入點，告訴程序要在哪一個位置進行加強或處理，通知告訴程序在這個點要作什麼事情，以及何時去作，因此切入點 + 通知 ≈ 切面
切面事實上，就是將咱們在業務模塊中重複的部分切分放大，你們能夠對比前面咱們直接在業務層中的每一個方法上進行添加劇復的事務代碼，理解一下
一句話：切面就是切入點和通知的結合

引入（Introduction）

它是一種特殊的通知，在不修改源代碼的前提下，能夠在運行期爲類動態的添加一些方法或者屬性

織入（Weaving）

把切面（加強）應用到目標對象而且建立新的代理對象的過程
實際上就是相似前面，在經過動態代理對某個方法進行加強，且添加事務方法的過程

(二) AOP 入門案例

首先，經過一個很是簡單的案例，來演示一下，如何在某幾個方法執行前，均執行一個日誌的打印方法，簡單模擬爲輸出一句話，前面的步驟咱們都很熟悉，須要注意的就是 bean.xml 中配置的方法，我會代碼下面進行詳的講解

(1) 基於 XML 的方式

A：依賴座標

aspectjweaver，這個依賴用來支持切入點表達式等，後面配置中會提到這個知識

<packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>
複製代碼

B：業務層

AccountService 接口

public interface AccountService {
    /** * 保存帳戶 */
    void addAccount();
    /** * 刪除帳戶 * @return */
    int deleteAccount();
    /** * 更新帳戶 * @param i */
    void updateAccount(int i);
}
複製代碼

AccountServiceImpl 實現類

public class AccountServiceImpl implements AccountService {
    public void addAccount() {
        System.out.println("這是增長方法");
    }

    public int deleteAccount() {
        System.out.println("這是刪除方法");
        return 0;
    }

    public void updateAccount(int i) {
        System.out.println("這是更新方法");
    }
}
複製代碼

C：日誌類

public class Logger {
    /** * 用於打印日誌：計劃讓其在切入點方法執行以前執行（切入點方法就是業務層方法） */
    public void printLog(){
        System.out.println("Logger類中的printLog方法執行了");
    }
}
複製代碼

D：配置文件

bean.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--配置Spring的IOC，配置service進來-->
    <bean id="accountService" class="cn.ideal.service.impl.AccountServiceImpl"></bean>

    <!--配置 Logger 進來-->
    <bean id="logger" class="cn.ideal.utils.Logger"></bean>

    <!--配置 AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--通知的類型，以及創建通知方法和切入點方法的關聯-->
            <aop:before method="printLog" pointcut="execution(* cn.ideal.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>
複製代碼

(2) XML配置分析

A：基本配置

<?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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>
複製代碼

首先須要引入的就是這個XML的頭部文件，一些約束，能夠直接複製這裏的，也能夠像之前同樣，去官網找對應的約束等

接着，將 Service 和 Logger 經過 bean 標籤配置進來

B：AOP基本配置

aop:config：代表開始 aop 配置，配置的代碼所有寫在這個標籤內

aop:aspect：代表開始配置切面

id屬性：給切面提供一個惟一的標識
ref屬性：用來引用已經配置好的通知類 bean，填入通知類的id便可

aop:aspect 標籤內部，經過對應的標籤，配置通知的類型

<aop:config>
	<!--配置切面-->
	<aop:aspect id="logAdvice" ref="logger">
    	<!--通知的類型，以及創建通知方法和切入點方法的關聯-->
	</aop:aspect>
</aop:config>
複製代碼

C：AOP四種常見通知配置

題目中咱們是以在方法執行前執行通知，因此是使用了前置通知

aop:before：用於配置前置通知，指定加強的方法在切入點方法以前執行

aop:after-returning：用於配置後置通知，與異常通知只能執行其中一個

aop:after-throwing：用於配置異常通知，異常通知只能執行其中一個

aop:after：用於配置最終通知，不管切入點方法執行時是否有異常，它都會在其後面執行

參數：

method：用於指定通知類中的加強方法名稱，也就是咱們上面的 Logger類中的 printLog 方法
poinitcut：用於指定切入點表達式（文中使用的是這個）指的是對業務層中哪些方法進行加強
ponitcut-ref：用於指定切入點的表達式的引用（調用次數過多時，更多的使用這個，減小了重複的代碼）

切入點表達式的寫法：

首先，在poinitcut屬性的引號內加入execution() 關鍵字，括號內書寫表達式
基本格式：訪問修飾符返回值包名.包名.包名...類名.方法名(方法參數)
- 說明：包名有幾個是根據本身的類全部在的包結構決定
- 全匹配寫法
  - public void cn.ideal.service.impl.AccountServiceImpl.addAccount()
- 訪問修飾符，如 public 能夠省略，返回值可使用通配符，表示任意返回值
  - void cn.ideal.service.impl.AccountServiceImpl.addAccount()
- 包名可使用通配符，表示任意包，有幾級包，就須要寫幾個*.
  - * *.*.*.*.AccountServiceImpl.addAccount()
- 包名可使用..表示當前包及其子包
  - cn..*.addAccount()
- 類名和方法名均可以使用*來實現通配，下面表示全通配
  - * *..*.*(..)
方法參數
- 能夠直接寫數據類型：例如 int
- 引用類型寫包名.類名的方式 java.lang.String
- 可使用通配符表示任意類型，可是必須有參數
- 可使用..表示有無參數都可，有參數能夠是任意類型

在實際使用中，更加推薦的寫法也就是上面代碼中的那種，將包結構給出（通常都是對業務層加強），其餘的使用通配符

pointcut="execution(* cn.ideal.service.impl.*.*(..))"

在給出4中通知類型後，就須要屢次書寫這個切入表達式，因此咱們可使用 pointcut-ref 參數解決重複代碼的問題，其實就至關於抽象出來了，方便之後調用

ponitcut-ref：用於指定切入點的表達式的引用（調用次數過多時，更多的使用這個，減小了重複的代碼）

位置放在 config裏，aspect 外就能夠了

<aop:pointcut id="pt1" expression="execution(* cn.ideal.service.impl.*.*(..))"></aop:pointcut>
複製代碼

調用時：

<aop:before method="PrintLog" pointcut-ref="pt1"></aop:before>
複製代碼

D：環繞通知

接着，spring框架爲咱們提供的一種能夠手動在代碼中控制加強代碼何時執行的方式，也就是環繞通知

配置中須要這樣一句話，pt1和前面是同樣的

<aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
複製代碼

Logger類中這樣配置

public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {
    Object returValue = null;
    try {
        Object[] args = proceedingJoinPoint.getArgs();
        System.out.println("這是Logger類中的aroundPrintLog前置方法");

        returValue = proceedingJoinPoint.proceed(args);

        System.out.println("這是Logger類中的aroundPrintLog後置方法");

        return returValue;
    } catch (Throwable throwable) {
        System.out.println("這是Logger類中的aroundPrintLog異常方法");
        throw new RuntimeException();
    } finally {
        System.out.println("這是Logger類中的aroundPrintLog最終方法");
    }
}
複製代碼

來解釋一下：

Spring 中提供了一個接口：ProceedingJoinPoint，其中有一個方法叫作 proceed(args)，這個方法就至關於明確調用切入點方法，proceed() 方法就好像之前動態代理中的 invoke，同時這個接口能夠做爲環繞通知的方法參數，這樣看起來，和前面的動態代理的那種感受仍是很類似的

(3) 基於註解的方式

依賴，以及業務層方法，咱們都是用和 XML 一致的嗎，不過爲了演示方便，這裏就只留下一個 add 方法

A：配置文件

配置文件中一個是須要引入新的約束，再有就是開啓掃描以及開啓註解 AOP 的支持

<?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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring建立容器時要掃描的包-->
    <context:component-scan base-package="cn.ideal"></context:component-scan>

    <!-- 配置spring開啓註解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>
複製代碼

B：添加註解

首先是業務層中把 Service 注進來

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    public void addAccount() {
        System.out.println("這是增長方法");
    }
}
複製代碼

接着就是最終要的位置Logger類中，首先將這個類經過 @Component("logger") 總體注入

而後使用 @Aspect 代表這是一個切面類

下面我分別使用了四種通知類型，以及環繞通知類型，在註解中這裏是須要注意的

第一次我首先測試的是四種通知類型：將環繞通知先註釋掉，把前面四個放開註釋

@Component("logger")
@Aspect//表示當前類是一個切面類
public class Logger {

    @Pointcut("execution(* cn.ideal.service.impl.*.*(..))")
    private void pt1(){}


// @Before("pt1()")
    public void printLog1(){
        System.out.println("Logger類中的printLog方法執行了-前置");
    }

// @AfterReturning("pt1()")
    public void printLog2(){
        System.out.println("Logger類中的printLog方法執行了-後置");
    }

// @AfterThrowing("pt1()")
    public void printLog3(){
        System.out.println("Logger類中的printLog方法執行了-異常");
    }

// @After("pt1()")
    public void printLog4(){
        System.out.println("Logger類中的printLog方法執行了-最終");
    }


    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint) {
        Object returValue = null;
        try {
            Object[] args = proceedingJoinPoint.getArgs();
            System.out.println("這是Logger類中的aroundPrintLog前置方法");

            returValue = proceedingJoinPoint.proceed(args);

            System.out.println("這是Logger類中的aroundPrintLog後置方法");

            return returValue;
        } catch (Throwable throwable) {
            System.out.println("這是Logger類中的aroundPrintLog異常方法");
            throw new RuntimeException();
        } finally {
            System.out.println("這是Logger類中的aroundPrintLog最終方法");
        }
    }

}

複製代碼

四種通知類型測試結果：

能夠看到，一個特別詭異的事情出現了，後置通知和最終通知的位置出現了問題，一樣異常狀況下也會出現這樣的問題，確實這是這裏的一個問題，因此咱們註解中通常使用環繞通知的方式

環繞通知測試結果：

(4) 純註解方式

純註解仍是比較簡單的加好 @EnableAspectJAutoProxy 就能夠了

@Configuration
@ComponentScan(basePackages="cn.ideal")
@EnableAspectJAutoProxy//主要是這個註解
public class SpringConfiguration {
}
複製代碼

到這裏，兩種XML以及註解兩種方式的基本使用就都說完了，下面咱們會講一講如何徹底基於 Spring 實現事務的控制

(三) 徹底基於 Spring 的事務控制

上面Spring中 AOP 知識的入門，可是實際上，Spring 做爲一個強大的框架，爲咱們業務層中事務處理，已經進行了考慮，它爲咱們提供了一組關於事務控制的接口，基於 AOP 的基礎之上，就能夠高效的完成事務的控制，下面咱們就經過一個案例，來對這部份內容進行介紹，這一部分，咱們選用的的例如持久層單元測試等中的內容均使用 Spring，特別注意：持久層咱們使用的是 Spring 的 JdbcTemplate ，不熟悉的朋友能夠去簡單瞭解一下，在這個案例中，重點仍是學習事務的控制，這裏不會形成太大的影響的

(1) 準備代碼

注：準備完代碼第一個要演示的是基於 XML 的形式，因此咱們準備的時候都沒有使用註解，後面介紹註解方式的時候，會進行修改

A：導入依賴座標

<packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
複製代碼

B：建立帳戶表以及實體

建立 Account 表

-- ----------------------------
-- Table structure for account
-- ----------------------------
CREATE TABLE `account`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32),
  `balance` float,
  PRIMARY KEY (`id`)
)
複製代碼

建立 Account 類

沒什麼好說的，對應着咱們的表創出實體

public class Account implements Serializable {
    private  Integer id;
    private String name;
    private Float balance;
    ......補充 get set toString 方法
複製代碼

C：建立 Service 和 Dao

爲了減小篇幅，就給了實現類，接口就不貼了，這很簡單

業務層

package cn.ideal.service.impl;

import cn.ideal.dao.AccountDao;
import cn.ideal.domain.Account;
import cn.ideal.service.AccountService;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }

    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("轉帳方法執行");
        //根據名稱分別查詢到轉入轉出的帳戶
        Account source = accountDao.findAccountByName(sourceName);
        Account target = accountDao.findAccountByName(targetName);

        //轉入轉出帳戶加減
        source.setBalance(source.getBalance() - money);
        target.setBalance(target.getBalance() + money);
        //更新轉入轉出帳戶
        accountDao.updateAccount(source);

        int num = 100/0;

        accountDao.updateAccount(target);
    }
}
複製代碼

持久層

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    public Account findAccountById(Integer accountId) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }


    public Account findAccountByName(String accountName) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("結果集不惟一");
        }
        return accounts.get(0);
    }


    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update account set name=?,balance=? where id=?",account.getName(),account.getBalance(),account.getId());
    }
}
複製代碼

D：建立 bean.xml 配置文件

提一句：若是沒有用過 JdbcTemplate，可能會好奇下面的 DriverManagerDataSource 是什麼，這個是 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">

    <!-- 配置業務層-->
    <bean id="accountService" class="cn.ideal.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置帳戶的持久層-->
    <bean id="accountDao" class="cn.ideal.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>


    <!-- 配置數據源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/ideal_spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root99"></property>
    </bean>
</beans>
複製代碼

E：測試

/** * 使用Junit單元測試：測試咱們的配置 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    private AccountService as;

    @Test
    public void testTransfer() {
        as.transfer("張三", "李四", 500f);
    }
複製代碼

(2) 基於 XML 的方式

首先要作的就是修改配置文件，這裏須要引入的就是 aop 和 tx 這兩個名稱空間

配置業務層持久層以及數據源沒什麼好說的，直接複製過來，下面就是咱們真正的重要配置

A：配置事務管理器

真正管理事務的對象 Spring 已經提供給咱們了

使用Spring JDBC或iBatis 進行持久化數據時可使用 org.springframework.jdbc.datasource.DataSourceTransactionManager

使用 Hibernate 進行持久化數據時可使用org.springframework.orm.hibernate5.HibernateTransactionManager

在其中將數據源引入

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>
複製代碼

B：配置事務通知

進行事務通知以及屬性配置時就須要引入事務的約束，tx 以及 aop 的名稱空間和約束

在這裏，就能夠將事務管理器引入

<!-- 配置事務的通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">

</tx:advice>
複製代碼

C：配置事務屬性

在 <tx:advice></tx:advice> 中就能夠配置事務的屬性了，這裏有一些屬性須要熟悉一下，關於事務的隔離級別能夠暫時看一看就能夠了，只針對這個例程的話，咱們並無太多的涉及，事務是一個大問題，須要深刻的瞭解，咱們在這裏更重點講的是如何配置使用它

name：指定你須要增長某種事務的方法名，可使用通配符，例如 * 表明全部 find* 表明名稱開頭爲 find 的方法，第二種優先級要更高一些
isolation：用於指定事務的隔離級別，表示使用數據庫的默認隔離級別，默認值是DEFAULT
- 未提交讀取（Read Uncommitted）
  - Spring標識：ISOLATION_READ_UNCOMMITTED
  - 表明容許髒讀取，但不容許更新丟失。也就是說，若是一個事務已經開始寫數據，則另一個事務則不容許同時進行寫操做，但容許其餘事務讀此行數據
- 已提交讀取（Read Committed）
  - Spring標識：ISOLATION_READ_COMMITTED
  - 只能讀取已經提交的數據，解決了髒讀的問題。讀取數據的事務容許其餘事務繼續訪問該行數據，可是未提交的寫事務將會禁止其餘事務訪問該行
- 可重複讀取（Repeatable Read）
  - Spring標識：ISOLATION_REPEATABLE_READ
  - 是否讀取其餘事務提交修改後的數據，解決了不可重複讀以及髒讀問題，可是有時可能出現幻讀數據。讀取數據的事務將會禁止寫事務（但容許讀事務），寫事務則禁止任何其餘事務
- 序列化（Serializable）
  - Spring標識：ISOLATION_SERIALIZABLE。
  - 提供嚴格的事務隔離。它要求事務序列化執行，解決幻影讀問題，事務只能一個接着一個地執行，不能併發執行。
propagation：用於指定事務的傳播屬性，默認值是 REQUIRED，表明必定會有事務，通常被用於增刪改，查詢方法能夠選擇使用 SUPPORTS
read-only：用於指定事務是否只讀。默認值是false示讀寫，通常查詢方法才設置爲true
timeout：用於指定事務的超時時間，默認值是-1，表示永不超時，若是指定了數值，以秒爲單位，通常不會用這個屬性
rollback-for：用於指定一個異常，當產生該異常時，事務回滾，產生其餘異常時，事務不回滾。沒有默認值。表示任何異常都回滾
no-rollback-for：用於指定一個異常，當產生該異常時，事務不回滾，產生其餘異常時事務回滾。沒有默認值。表示任何異常都回滾

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 配置事務的屬性 -->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false"/>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>
複製代碼

D：配置 AOP 切入點表達式

<!-- 配置aop-->
<aop:config>
     !-- 配置切入點表達式-->
    <aop:pointcut id="pt1" expression="execution(* cn.ideal.service.impl.*.*(..))"></aop:pointcut>
</aop:config>
複製代碼

E：創建切入點表達式和事務通知的對應關係

在 <aop:config></aop:config> 中進行此步驟

<!-- 配置aop-->
<aop:config>
     !-- 配置切入點表達式-->
    <aop:pointcut id="pt1" expression="execution(* cn.ideal.service.impl.*.*(..))"></aop:pointcut>
    <!--創建切入點表達式和事務通知的對應關係 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
</aop:config>
複製代碼

F：所有配置代碼

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

    <!-- 配置業務層-->
    <bean id="accountService" class="cn.ideal.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置帳戶的持久層-->
    <bean id="accountDao" class="cn.ideal.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置數據源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/ideal_spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root99"></property>
    </bean>

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
	<!-- 配置事務的通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事務的屬性 -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop-->
    <aop:config>
        <!-- 配置切入點表達式-->
        <aop:pointcut id="pt1" expression="execution(* cn.ideal.service.impl.*.*(..))"></aop:pointcut>
        <!--創建切入點表達式和事務通知的對應關係 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
    
</beans>
複製代碼

(3) 基於註解的方式

仍是基本的代碼，可是須要對持久層進行一個小小的修改，前面爲了配置中簡單一些，咱們直接使用了繼承 JdbcDaoSupport 的方式，可是它只能用於 XML 的方式，註解是不能夠這樣用的，因此，咱們仍是須要用傳統的一種方式，也就是在 Dao 中定義 JdcbTemplate

A：修改 bean.xml 配置文件

註解的常規操做，開啓註解，咱們這裏把數據源和JdbcTemplate也配置好

<?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.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring建立容器時要掃描的包-->
    <context:component-scan base-package="cn.ideal"></context:component-scan>

    <!-- 配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置數據源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/ideal_spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root99"></property>
    </bean>

</beans>
複製代碼

B：業務層和持久層添加基本註解

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
    
    //下面是同樣的
}
複製代碼

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    //下面基本是同樣的
    //只須要將原來的 super.getJdbcTemplate().xxx 改成直接用 jdbcTemplate 執行
}
複製代碼

C：在bean.xml中配置事務管理器

<!-- 配置事務管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
複製代碼

D：在bean.xml中開啓對註解事務的支持

<!-- 開啓spring對註解事務的支持-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
複製代碼

E：業務層添加 @Transactional 註解

這個註解能夠出如今接口上，類上和方法上

出現接口上，表示該接口的全部實現類都有事務支持
出如今類上，表示類中全部方法有事務支持
出如今方法上，表示方法有事務支持

例以下例中，咱們類中指定了事務的爲只讀型，可是下面的轉帳還涉及到了寫操做，因此又在方法上增長了一個 readOnly 值爲 false 的註解

@Service("accountService")
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public class AccountServiceImpl implements AccountService {
	.... 省略
	@Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    public void transfer(String sourceName, String targetName, Float money) {
    	...... 省略
    }
}
複製代碼

F：測試代碼

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    private AccountService as;

    @Test
    public void testTransfer() {
        as.transfer("張三", "李四", 500f);
    }
}

複製代碼

(4) 基於純註解方式

下面使用的就是純註解的方式，bean.xml 就能夠刪除掉了，這種方式不是很難

A：配置類註解

@Configuration

指定當前類是 spring 的一個配置類，至關於 XML中的 bean.xml 文件

獲取容器時須要使用下列形式

private ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
複製代碼

若是使用了 spring 的單元測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes= SpringConfiguration.class)
public class AccountServiceTest {
	......
}
複製代碼

B：指定掃描包註解

@ComponentScan

@Configuration 至關於已經幫咱們把 bean.xml 文件創立好了，按照咱們往常的步驟，應該指定掃描的包了，這也就是咱們這個註解的做用

指定 spring 在初始化容器時要掃描的包，在 XML 中至關於：

<!--開啓掃描-->
<context:component-scan base-package="cn.ideal"></context:component-scan>
複製代碼

其中 basePackages 用於指定掃描的包，和這個註解中value屬性的做用是一致的

C：配置 properties 文件

@PropertySource

之前在建立數據源的時候，都是直接把配置信息寫死了，若是想要使用 properties 進行內容的配置，在這時候就須要，使用 @PropertySource 這個註解

用於加載 .properties 文件中的配置
value [] 指定 properties 文件位置，在類路徑下，就須要加上 classpath

SpringConfiguration 類（至關於 bean.xml）

/** * Spring 配置類 */
@Configuration
@ComponentScan("cn.ideal")
@Import({JdbcConfig.class,TransactionConfig.class})
@PropertySource("jdbcConfig.properties")
@EnableTransactionManagement
public class SpringConfiguration {

}
複製代碼

D：建立對象

@Bean

寫好了配置類，以及指定了掃描的包，下面該作的就是配置 jdbcTemplate 以及數據源，再有就是建立事務管理器對象，在 XML 中咱們會經過書寫 bean 標籤來配置，而 Spring 爲咱們提供了 @Bean 這個註解來替代原來的標籤

將註解寫在方法上（只能是方法），也就是表明用這個方法建立一個對象，而後放到 Spring 的容器中去
經過 name 屬性給這個方法指定名稱，也就是咱們 XML 中 bean 的 id
這種方式就將配置文件中的數據讀取進來了

JdbcConfig （JDBC配置類）

/** * 和鏈接數據庫相關的配置類 */
public class JdbcConfig {

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    /** * 建立JdbcTemplate * @param dataSource * @return */
    @Bean(name="jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    /** * 建立數據源對象 * @return */
    @Bean(name="dataSource")
    public DataSource createDataSource(){
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}
複製代碼

jdbcConfig.properties

將配置文件單獨配置出來

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ideal_spring
jdbc.username=root
jdbc.password=root99
複製代碼

TransactionConfig

/** * 和事務相關的配置類 */
public class TransactionConfig {
    /** * 用於建立事務管理器對象 * @param dataSource * @return */
    @Bean(name="transactionManager")
    public PlatformTransactionManager createTransactionManager(DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}
複製代碼

總結：

① 這篇文章就寫到這裏了，學習任何一門技術，只有知其然，才能明白其全部然，不少人在某個技術領域已經沉浸多年，天然有了特殊的思考與理解，憑藉着強大的經驗，天然也能快速上手，但若是處於門外狀態，或者對這一方面接觸的很少，就更須要了解一門技術的來龍去脈，不過什麼源碼分析，各類設計模式，這也都是後話，咱們的第一要義就是要用它作事，要讓他跑起來，自認爲我不是什麼過於聰明的人，直接去學習一堆配置，一堆註解，一堆專有名詞，太空洞了，很難理解。

② 咱們每每都陷入了一種，爲學而學的狀態，可能你們都會SSM我也學，你們都說 SpringBoot 簡單舒服，我也去學，固然不少時候由於一些工做或者學習的須要，沒有辦法，可是仍以爲，私下再次看一門技術的時候，能夠藉助一些文章或者資料，亦或者找點視頻資源，去看看這一門究竟帶來了什麼，其過人之處，必然是解決了咱們之前遇到的，或者沒考慮到的問題，這樣一種按部就班的學習方式，能夠幫助咱們對一些技術有一個總體的概念，以及瞭解其之間的聯繫。

③ 這一篇文章，我參考了《Spring 實戰》、某馬的視頻、以及百度谷歌上的一些參考內容，從一個很是簡單的增刪改查的案例出發，經過分析其事務問題，一步一步從動態代理，到 AOP進行了屢次的改進，其中涉及到一些例如動態代理或者JdcbTemplate的知識，或許有的朋友不熟悉，我也用了一些篇幅說明，寫這樣一篇長文章，確實很費功夫，若是想要了解 Spring AOP 相關知識的朋友，能夠看一看，也能夠當作一個簡單的參考，用來手生的時候做爲工具書參考

很是但願能給你們帶來幫助，再次感謝你們的支持，謝謝！

Tips：同時有須要的朋友能夠去看個人前一篇文章

【萬字長文】Spring框架層層遞進輕鬆入門 (IOC和DI)

juejin.im/post/5e47c5…