Spring（三） AOP

AOP 的相關概念

AOP 概述

什麼是 AOP

AOP：全稱是 Aspect Oriented Programming 即：面向切面編程。
簡單的說它就是把我們程序重複的代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的
基礎上，對我們的已有方法進行增強。

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

AOP 的作用及優勢

作用：
在程序運行期間，不修改源碼對已有方法進行增強。
優勢：
減少重複代碼
提高開發效率
維護方便

AOP 的實現方式

使用動態代理技術

AOP 的具體應用

案例中問題

下面是客戶的業務層實現類。我們能看出什麼問題嗎?

客戶的業務層實現類
/**
* 賬戶的業務層實現類
*/
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao; 
    }
    @Override
    public void saveAccount(Account account) throws SQLException {
        accountDao.save(account);
    }
    @Override
    public void updateAccount(Account account) throws SQLException{
        accountDao.update(account);
    }
    @Override
    public void deleteAccount(Integer accountId) throws SQLException{
        accountDao.delete(accountId);
    }
    @Override
    public Account findAccountById(Integer accountId) throws SQLException {
        return accountDao.findById(accountId);
    }
    @Override
    public List<Account> findAllAccount() throws SQLException{
        return accountDao.findAll();
    } 
}

問題就是：
事務被自動控制了。換言之，我們使用了 connection 對象的 setAutoCommit(true)
此方式控制事務，如果我們每次都執行一條 sql 語句，沒有問題，但是如果業務方法一次要執行多條 sql
語句，這種方式就無法實現功能了。

我們在業務層中多加入一個方法。
業務層接口
/**
* 轉賬
* @param sourceName
* @param targetName
* @param money
*/
    void transfer(String sourceName,String targetName,Float money);
    業務層實現類：
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        //根據名稱查詢兩個賬戶信息
        Account source = accountDao.findByName(sourceName);
        Account target = accountDao.findByName(targetName);
        //轉出賬戶減錢，轉入賬戶加錢
        source.setMoney(source.getMoney()-money);
        target.setMoney(target.getMoney()+money);
        //更新兩個賬戶
        accountDao.update(source);
        int i=1/0; //模擬轉賬異常
        accountDao.update(target);
}
當我們執行時，由於執行有異常，轉賬失敗。但是因爲我們是每次執行持久層方法都是獨立事務，導致無法實
現事務控制（不符合事務的一致性）

問題的解決

解決辦法：
讓業務層來控制事務的提交和回滾。（這個我們之前已經在 web 階段講過了）
改造後的業務層實現類：
注：此處沒有使用 spring 的 IoC.
/**
* 賬戶的業務層實現類
*/
public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
    @Override
    public void saveAccount(Account account) {
        try {
            TransactionManager.beginTransaction();
            accountDao.save(account);
            TransactionManager.commit();
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        } 
    }
    @Override
    public void updateAccount(Account account) {
        try {
            TransactionManager.beginTransaction();
            accountDao.update(account);
            TransactionManager.commit();
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        } 
    }
    @Override
    public void deleteAccount(Integer accountId) {
        try {
            TransactionManager.beginTransaction();
            accountDao.delete(accountId);
            TransactionManager.commit();
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        } 
    }
    @Override
    public Account findAccountById(Integer accountId) {
        Account account = null;
        try {
            TransactionManager.beginTransaction();
            account = accountDao.findById(accountId);
            TransactionManager.commit();
            return account;
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        }
        return null; 
    }
    @Override
    public List<Account> findAllAccount() {
        List<Account> accounts = null;
        try {
            TransactionManager.beginTransaction();
            accounts = accountDao.findAll();
            TransactionManager.commit();
            return accounts;
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        }
        return null; 
    }
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            TransactionManager.beginTransaction();
            Account source = accountDao.findByName(sourceName);
            Account target = accountDao.findByName(targetName);
            source.setMoney(source.getMoney()-money);
            target.setMoney(target.getMoney()+money);
            accountDao.update(source);
            int i=1/0;
            accountDao.update(target);
            TransactionManager.commit();
        } catch (Exception e) {
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            TransactionManager.release();
        } 
    } 
}


TransactionManager 類的代碼：
/**
* 事務控制類
* @author 黑馬程序員
* @Company http://www.ithiema.com
* @Version 1.0
*/
public class TransactionManager {
    //定義一個 DBAssit
    private static DBAssit dbAssit = new DBAssit(C3P0Utils.getDataSource(),true);
    //開啓事務
    public static void beginTransaction() {
        try {
            dbAssit.getCurrentConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        } 
    }
    //提交事務
    public static void commit() {
        try {
            dbAssit.getCurrentConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        } 
    }
    //回滾事務
    public static void rollback() {
        try {
            dbAssit.getCurrentConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        } 
    }
    //釋放資源
    public static void release() {
        try {
            dbAssit.releaseConnection();
            connectionUtils.removeConnection();
這裏要注意一下，因爲JavaEE工程使用連接池技術，所以有可能線程放回線程池之後，其綁定的數據庫
連接池沒有放回，所以需要解綁
        } catch (Exception e) {
            e.printStackTrace();
        } 
    } 
}

/**
 * 連接的工具類，它用於從數據源中獲取一個連接，並且實現和線程的綁定
 */
public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 獲取當前線程上的連接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            //1.先從ThreadLocal上獲取
            Connection conn = tl.get();
            //2.判斷當前線程上是否有連接
            if (conn == null) {
                //3.從數據源中獲取一個連接，並且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回當前線程上的連接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
     * 把連接和線程解綁
     */
    public void removeConnection(){
        tl.remove();
    }
}

新的問題

通過對業務層改造，已經可以實現事務控制了，但是由於我們添加了事務控制，也產生了一
個新的問題：
業務層方法變得臃腫了，裏面充斥着很多重複代碼。並且業務層方法和事務控制方法耦合了。
試想一下，如果我們此時提交，回滾，釋放資源中任何一個方法名變更，都需要修改業務層的代碼，況且這還
只是一個業務層實現類，而實際的項目中這種業務層實現類可能有十幾個甚至幾十個。

動態代理回顧

動態代理的特點

字節碼隨用隨創建，隨用隨加載。
它與靜態代理的區別也在於此。因爲靜態代理是字節碼一上來就創建好，並完成加載。
裝飾者模式就是靜態代理的一種體現。

動態代理常用的有兩種方式

基於接口的動態代理
提供者：JDK 官方的 Proxy 類。
要求：被代理類最少實現一個接口。

基於子類的動態代理
提供者：第三方的 CGLib，如果報 asmxxxx 異常，需要導入 asm.jar。
要求：被代理類不能用 final 修飾的類（最終類）。

使用 JDK 官方的 Proxy 類創建代理對象

此處我們使用的是一個演員的例子：
在很久以前，演員和劇組都是直接見面聯繫的。沒有中間人環節。
而隨着時間的推移，產生了一個新興職業：經紀人（中間人），這個時候劇組再想找演員就需要通過經紀
人來找了。下面我們就用代碼演示出來。
/**
* 一個經紀公司的要求:
* 能做基本的表演和危險的表演
*/
public interface IActor {
/**
* 基本演出
* @param money
*/
public void basicAct(float money);
/**
* 危險演出
* @param money
*/
public void dangerAct(float money);
}
/**
* 一個演員
*/

//實現了接口，就表示具有接口中的方法實現。即：符合經紀公司的要求
public class Actor implements IActor{
    public void basicAct(float money){
        System.out.println("拿到錢，開始基本的表演："+money);
    }
    public void dangerAct(float money){
        System.out.println("拿到錢，開始危險的表演："+money);
    } 
}

public class Client {
    public static void main(String[] args) {
    //一個劇組找演員：
    final Actor actor = new Actor();//直接
/**
* 代理：
* 間接。
* 獲取代理對象：
* 要求：
* 被代理類最少實現一個接口
* 創建的方式
* Proxy.newProxyInstance(三個參數)
* 參數含義：
* ClassLoader：和被代理對象使用相同的類加載器。
* Interfaces：和被代理對象具有相同的行爲。實現相同的接口。
* InvocationHandler：如何代理。
* 策略模式：使用場景是：
* 數據有了，目的明確。
* 如何達成目標，就是策略。
* 
*/
    IActor proxyActor = (IActor) Proxy.newProxyInstance(
    actor.getClass().getClassLoader(), 
    actor.getClass().getInterfaces(), 
    new InvocationHandler() {
/**
* 執行被代理對象的任何方法，都會經過該方法。
* 此方法有攔截的功能。
* 
* 參數：
* proxy：代理對象的引用。不一定每次都用得到
* method：當前執行的方法對象
* args：執行方法所需的參數
* 返回值：
* 當前執行方法的返回值
*/
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
                String name = method.getName();
                Float money = (Float) args[0];
                Object rtValue = null;
                //每個經紀公司對不同演出收費不一樣，此處開始判斷
                if("basicAct".equals(name)){
                    //基本演出，沒有 2000 不演
                    if(money > 2000){
                        //看上去劇組是給了 8000，實際到演員手裏只有 4000
                        //這就是我們沒有修改原來 basicAct 方法源碼，對方法進行了增強
                        rtValue = method.invoke(actor, money/2);
                    } 
                }
                if("dangerAct".equals(name)){
                    //危險演出,沒有 5000 不演
                    if(money > 5000){
                        //看上去劇組是給了 50000，實際到演員手裏只有 25000
                        //這就是我們沒有修改原來 dangerAct 方法源碼，對方法進行了增強
                        rtValue = method.invoke(actor, money/2);
                    } 
                }
                return rtValue;
            }
        });
//沒有經紀公司的時候，直接找演員。
// actor.basicAct(1000f);
// actor.dangerAct(5000f);
//劇組無法直接聯繫演員，而是由經紀公司找的演員
        proxyActor.basicAct(8000f);
        proxyActor.dangerAct(50000f);
    } 
}

使用 CGLib 的 Enhancer 類創建代理對象

還是那個演員的例子，只不過不讓他實現接口。
/**
* 一個演員
*/
public class Actor{//沒有實現任何接口
    public void basicAct(float money){
        System.out.println("拿到錢，開始基本的表演："+money);
    }
    public void dangerAct(float money){
        System.out.println("拿到錢，開始危險的表演："+money);
    } 
}




public class Client {
/**
* 基於子類的動態代理
* 要求：
* 被代理對象不能是最終類
* 用到的類：
* Enhancer
* 用到的方法：
* create(Class, Callback)
* 方法的參數：
* Class：被代理對象的字節碼
* Callback：如何代理
Callback：用於提供增強的代碼
         *          它是讓我們寫如何代理。我們一般都是些一個該接口的實現類，
通常情況下都是匿名內部類，但不是必須的。
         *          此接口的實現類都是誰用誰寫。
         *          我們一般寫的都是該接口的子接口實現類：MethodInterceptor
* @param args
*/
    public static void main(String[] args) {
        final Actor actor = new Actor();
        Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
                        new MethodInterceptor() {
/**
* 執行被代理對象的任何方法，都會經過該方法。在此方法內部就可以對被代理對象的任何
方法進行增強。
* 
* 參數：
* 前三個和基於接口的動態代理是一樣的。
* MethodProxy：當前執行方法的代理對象。
* 返回值：
* 當前執行方法的返回值
*/
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, 
                MethodProxy methodProxy) throws Throwable {
                    String name = method.getName();
                    Float money = (Float) args[0];
                    Object rtValue = null;
                    if("basicAct".equals(name)){
                        //基本演出
                        if(money > 2000){
                            rtValue = method.invoke(actor, money/2);
                        } 
                    }
                    if("dangerAct".equals(name)){
                        //危險演出
                        if(money > 5000){
                            rtValue = method.invoke(actor, money/2);
                        } 
                    }
                    return rtValue;
                }
            });
        cglibActor.basicAct(10000);
        cglibActor.dangerAct(100000);
    } 
}

解決案例中的問題

/**
* 用於創建客戶業務層對象工廠（當然也可以創建其他業務層對象，只不過我們此處不做那麼繁瑣）
*/
public class BeanFactory {
/**
* 創建賬戶業務層實現類的代理對象
* @return
*/
    public static IAccountService getAccountService() {
        //1.定義被代理對象
        final IAccountService accountService = new AccountServiceImpl();
        //2.創建代理對象
        IAccountService proxyAccountService = (IAccountService) 
        Proxy.newProxyInstance(accountService.getClass().getClassLoader(), 
        accountService.getClass().getInterfaces(),
        new InvocationHandler() {
/**
* 執行被代理對象的任何方法，都會經過該方法。
* 此處添加事務控制
*/
            @Override
 public Object invoke(Object proxy, Method method,Object[] args) throws Throwable {
        Object rtValue = null;
        try {
            //開啓事務
            TransactionManager.beginTransaction();
            //執行業務層方法
            rtValue = method.invoke(accountService, args);
            //提交事務
            TransactionManager.commit();
        }catch(Exception e) {
            //回滾事務
            TransactionManager.rollback();
            e.printStackTrace();
        }finally {
            //釋放資源
            TransactionManager.release();
        }
            return rtValue; 
        }
    });
        return proxyAccountService; 
    } 
}
當我們改造完成之後，業務層用於控制事務的重複代碼就都可以刪掉了。

Spring 中的 AOP

Spring 中 AOP 的細節

說明

我們學習 spring 的 aop，就是通過配置的方式，實現上一章節的功能。

 AOP 相關術語

Joinpoint(連接點):
所謂連接點是指那些被攔截到的點。在 spring 中,這些點指的是方法,因爲 spring 只支持方法類型的
連接點。
Pointcut(切入點):
所謂切入點是指我們要對哪些 Joinpoint 進行攔截的定義。
Advice(通知/增強):
所謂通知是指攔截到 Joinpoint 之後所要做的事情就是通知。
通知的類型：前置通知,後置通知,異常通知,最終通知,環繞通知。
Introduction(引介):
引介是一種特殊的通知在不修改類代碼的前提下, Introduction 可以在運行期爲類動態地添加一些方
法或 Field。
Target(目標對象):
代理的目標對象。
Weaving(織入):
是指把增強應用到目標對象來創建新的代理對象的過程。
spring 採用動態代理織入，而 AspectJ 採用編譯期織入和類裝載期織入。
Proxy（代理）:
一個類被 AOP 織入增強後，就產生一個結果代理類。
Aspect(切面):
是切入點和通知（引介）的結合。

學習 spring 中的 AOP 要明確的事

a、開發階段（我們做的）
編寫核心業務代碼（開發主線）：大部分程序員來做，要求熟悉業務需求。
把公用代碼抽取出來，製作成通知。（開發階段最後再做）：AOP 編程人員來做。
在配置文件中，聲明切入點與通知間的關係，即切面。：AOP 編程人員來做。
b、運行階段（Spring 框架完成的）
Spring 框架監控切入點方法的執行。一旦監控到切入點方法被運行，使用代理機制，動態創建目標對
象的代理對象，根據通知類別，在代理對象的對應位置，將通知對應的功能織入，完成完整的代碼邏輯運行。

關於代理的選擇

在 spring 中，框架會根據目標類是否實現了接口來決定採用哪種動態代理的方式。

基於 XML 的 AOP 配置

環境搭建

拷貝必備的 jar 包到工程的 lib 目錄

此處要拷貝 spring 的 ioc 和 aop 兩組 jar 包

創建 spring 的配置文件並導入約束

此處要導入 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"
 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>

public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("執行了保存");
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("執行了更新"+i);

    }

    @Override
    public int deleteAccount() {
        System.out.println("執行了刪除");
        return 0;
    }
}

public class Logger {

    /**
     * 用於打印日誌：計劃讓其在切入點方法執行之前執行（切入點方法就是業務層方法）
     */
    public  void printLog(){
        System.out.println("Logger類中的pringLog方法開始記錄日誌了。。。");
    }
}

使用 aop:config 聲明 aop 配置，使用 aop:aspect 配置切面 ，使用 aop:pointcut 配置切入點表達式 

spring中基於XML的AOP配置步驟
        1、把通知Bean也交給spring來管理
        2、使用aop:config標籤表明開始AOP的配置
        3、使用aop:aspect標籤表明配置切面
                id屬性：是給切面提供一個唯一標識
                ref屬性：是指定通知類bean的Id。
        4、在aop:aspect標籤的內部使用對應標籤來配置通知的類型
               我們現在示例是讓printLog方法在切入點方法執行之前之前：所以是前置通知
               aop:before：表示配置前置通知
                    method屬性：用於指定Logger類中哪個方法是前置通知
                    pointcut屬性：用於指定切入點表達式，該表達式的含義指的是對業務層中哪些方法增強

            切入點表達式的寫法：
                關鍵字：execution(表達式)
                表達式：
                    訪問修飾符  返回值  包名.包名.包名...類名.方法名(參數列表)
                標準的表達式寫法：
                    public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                訪問修飾符可以省略
                    void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.itheima.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有幾級包，就需要寫幾個*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示當前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                類名和方法名都可以使用*來實現通配
                    * *..*.*()
                參數列表：
                    可以直接寫數據類型：
                        基本類型直接寫名稱           int
                        引用類型寫包名.類名的方式   java.lang.String
                    可以使用通配符表示任意類型，但是必須有參數
                    可以使用..表示有無參數均可，有參數可以是任意類型
                全通配寫法：
                    * *..*.*(..)

                實際開發中切入點表達式的通常寫法：
                    切到業務層實現類下的所有方法
                        * com.itheima.service.impl.*.*(..)


    <!-- 配置Logger類 -->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的類型，並且建立通知方法和切入點方法的關聯-->
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

使用 <aop:pointcut>配置切入點

<!-- 配置切入點表達式 id屬性用於指定表達式的唯一標識。expression屬性用於指定表達式內容
              此標籤寫在aop:aspect標籤內部只能當前切面使用。
              它還可以寫在aop:aspect外面，此時就變成了所有切面可用
     aop約束要求，改標籤必須出現在 <aop:aspect>之前
          -->
<aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>

使用 aop:xxx 配置對應的通知類型

aop:before
作用：
用於配置前置通知。指定增強的方法在切入點方法之前執行
屬性：
method:用於指定通知類中的增強方法名稱
ponitcut-ref：用於指定切入點的表達式的引用
poinitcut：用於指定切入點表達式
執行時間點：
切入點方法執行之前執行
<aop:before method="beginTransaction" pointcut-ref="pt1"/>


aop:after-returning
作用：
用於配置後置通知
屬性：
method：指定通知中方法的名稱。
pointct：定義切入點表達式
pointcut-ref：指定切入點表達式的引用
執行時間點：
切入點方法正常執行之後。它和異常通知只能有一個執行
<aop:after-returning method="commit" pointcut-ref="pt1"/>


aop:after-throwing
作用：
用於配置異常通知
屬性：
method：指定通知中方法的名稱。
pointct：定義切入點表達式
pointcut-ref：指定切入點表達式的引用
執行時間點：
切入點方法執行產生異常後執行。它和後置通知只能執行一個
<aop:after-throwing method="rollback" pointcut-ref="pt1"/>


aop:after
作用：
用於配置最終通知
屬性：
method：指定通知中方法的名稱。
pointct：定義切入點表達式
pointcut-ref：指定切入點表達式的引用
執行時間點：
無論切入點方法執行時是否有異常，它都會在其後面執行。
<aop:after method="release" pointcut-ref="pt1"/>

 

配置環繞通知

<aop:config>
        <!-- 配置切入點表達式 id屬性用於指定表達式的唯一標識。expression屬性用於指定表達式內容
              此標籤寫在aop:aspect標籤內部只能當前切面使用。
              它還可以寫在aop:aspect外面，此時就變成了所有切面可用
          -->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置環繞通知 -->
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

     * 環繞通知
     * 問題：
     *      當我們配置了環繞通知之後，切入點方法沒有執行，而通知方法執行了。
     * 分析：
     *      通過對比動態代理中的環繞通知代碼，發現動態代理的環繞通知有明確的切入點方法調用，而我們的代碼中沒有。
     * 解決：
     *      Spring框架爲我們提供了一個接口：ProceedingJoinPoint。該接口有一個方法proceed()，此方法就相當於明確調用切入點方法。
     *      該接口可以作爲環繞通知的方法參數，在程序執行時，spring框架會爲我們提供該接口的實現類供我們使用。
     *
     * spring中的環繞通知：
     *  它是spring框架爲我們提供的一種可以在代碼中手動控制增強方法何時執行的方式。
其他方法寫在切入點方法前，就是前置方法，寫在後就是後置方法，寫在catch中就是異常方法，寫在finally中就是最終方法
     */
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法執行所需的參數

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。前置");

            rtValue = pjp.proceed(args);//明確調用業務層方法（切入點方法）

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。後置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。異常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。最終");
        }
    }
}

基於註解的 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="com.itheima"></context:component-scan>

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

把資源使用註解配置

/**
 * 用於記錄日誌的工具類，它裏面提供了公共的代碼
 */
@Component("logger")
@Aspect//表示當前類是一個切面類
public class Logger {

    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     */
    @Before("pt1()")
    public  void beforePrintLog(){
        System.out.println("前置通知Logger類中的beforePrintLog方法開始記錄日誌了。。。");
    }

    /**
     * 後置通知
     */
    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("後置通知Logger類中的afterReturningPrintLog方法開始記錄日誌了。。。");
    }
    /**
     * 異常通知
     */
    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("異常通知Logger類中的afterThrowingPrintLog方法開始記錄日誌了。。。");
    }

    /**
     * 最終通知
     */
    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最終通知Logger類中的afterPrintLog方法開始記錄日誌了。。。");
    }
}

值得注意的是，使用以上四種註解通知之後，執行順序不是我們預期的，所以推薦使用環繞通知的註解方式。

另外切入點註解中不能省略括號。

@Around("pt1()")
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法執行所需的參數

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。前置");

            rtValue = pjp.proceed(args);//明確調用業務層方法（切入點方法）

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。後置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。異常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。最終");
        }
    }

不使用 XML 的配置方式（純註解）

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}