摘要：面向切面的程序設(shè)計(jì)思想也是面向切面軟件開發(fā)的基礎(chǔ)。與切面相關(guān)的編程概念還包括元對(duì)象協(xié)議主題混入和委托。切面聲明類似于中的類聲明，在中會(huì)包含著一些以及相應(yīng)的。

面向切面的程序設(shè)計(jì)（Aspect-oriented programming，AOP，又譯作面向方面的程序設(shè)計(jì)、剖面導(dǎo)向程序設(shè)計(jì)）是計(jì)算機(jī)科學(xué)中的一種程序設(shè)計(jì)思想，旨在將橫切關(guān)注點(diǎn)與業(yè)務(wù)主體進(jìn)行進(jìn)一步分離，以提高程序代碼的模塊化程度。通過在現(xiàn)有代碼基礎(chǔ)上增加額外的通知（Advice）機(jī)制，能夠?qū)Ρ宦暶鳛椤扒悬c(diǎn)（Pointcut）”的代碼塊進(jìn)行統(tǒng)一管理與裝飾，如“對(duì)所有方法名以‘set*’開頭的方法添加后臺(tái)日志”。該思想使得開發(fā)人員能夠?qū)⑴c代碼核心業(yè)務(wù)邏輯關(guān)系不那么密切的功能（如日志功能）添加至程序中，同時(shí)又不降低業(yè)務(wù)代碼的可讀性。面向切面的程序設(shè)計(jì)思想也是面向切面軟件開發(fā)的基礎(chǔ)。

面向切面的程序設(shè)計(jì)將代碼邏輯切分為不同的模塊（即關(guān)注點(diǎn)（Concern），一段特定的邏輯功能)。幾乎所有的編程思想都涉及代碼功能的分類，將各個(gè)關(guān)注點(diǎn)封裝成獨(dú)立的抽象模塊（如函數(shù)、過程、模塊、類以及方法等），后者又可供進(jìn)一步實(shí)現(xiàn)、封裝和重寫。部分關(guān)注點(diǎn)“橫切”程序代碼中的數(shù)個(gè)模塊，即在多個(gè)模塊中都有出現(xiàn)，它們即被稱作“橫切關(guān)注點(diǎn)（Cross-cutting concerns, Horizontal concerns）”。

日志功能即是橫切關(guān)注點(diǎn)的一個(gè)典型案例，因?yàn)槿罩竟δ芡鶛M跨系統(tǒng)中的每個(gè)業(yè)務(wù)模塊，即“橫切”所有有日志需求的類及方法體。而對(duì)于一個(gè)信用卡應(yīng)用程序來說，存款、取款、帳單管理是它的核心關(guān)注點(diǎn)，日志和持久化將成為橫切整個(gè)對(duì)象結(jié)構(gòu)的橫切關(guān)注點(diǎn)。

切面的概念源于對(duì)面向?qū)ο蟮某绦蛟O(shè)計(jì)的改進(jìn)，但并不只限于此，它還可以用來改進(jìn)傳統(tǒng)的函數(shù)。與切面相關(guān)的編程概念還包括元對(duì)象協(xié)議、主題（Subject）、混入（Mixin）和委托（Delegate）。

看過了上面解釋，想必大家對(duì)aop已經(jīng)有個(gè)大致的雛形了,但是又對(duì)上面提到的切面之類的術(shù)語有一些模糊的地方，接下來就來講解一下AOP中的相關(guān)概念，了解了AOP中的概念，才能真正的掌握AOP的精髓。

Aspect（切面）： Aspect 聲明類似于 Java 中的類聲明，在 Aspect 中會(huì)包含著一些 Pointcut 以及相應(yīng)的 Advice。

Joint point（連接點(diǎn)）：表示在程序中明確定義的點(diǎn)，典型的包括方法調(diào)用，對(duì)類成員的訪問以及異常處理程序塊的執(zhí)行等等，它自身還可以嵌套其它 joint point。

Pointcut（切點(diǎn)）：表示一組 joint point，這些 joint point 或是通過邏輯關(guān)系組合起來，或是通過通配、正則表達(dá)式等方式集中起來，它定義了相應(yīng)的 Advice 將要發(fā)生的地方。

Advice（增強(qiáng)）：Advice 定義了在 Pointcut 里面定義的程序點(diǎn)具體要做的操作，它通過 before、after 和 around 來區(qū)別是在每個(gè) joint point 之前、之后還是代替執(zhí)行的代碼。

Target（目標(biāo)對(duì)象）：織入 Advice 的目標(biāo)對(duì)象.。

Weaving（織入）：將 Aspect 和其他對(duì)象連接起來, 并創(chuàng)建 Adviced object 的過程

Spring AOP使用純Java實(shí)現(xiàn)，它不需要專門的編譯過程，也不需要特殊的類裝載器，它在運(yùn)行期通過代理方式向目標(biāo)類織入增強(qiáng)代碼。在Spring中可以無縫地將Spring AOP、IoC和AspectJ整合在一起。Spring AOP構(gòu)建在動(dòng)態(tài)代理基礎(chǔ)之上，因此，Spring對(duì)AOP的支持局限于方法攔截。在Java中動(dòng)態(tài)代理有兩種方式：JDK動(dòng)態(tài)代理和CGLib動(dòng)態(tài)代理

jdk proxy

java動(dòng)態(tài)代理是利用反射機(jī)制生成一個(gè)實(shí)現(xiàn)代理接口的匿名類，在調(diào)用具體方法前調(diào)用InvokeHandler來處理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 

 *
 * @author leone
 * @since 2018-11-09
 **/
public class JdkProxy {

    interface IUserService {
        Integer delete(Integer userId);
    }

    static class UserServiceImpl implements IUserService {
        @Override
        public Integer delete(Integer userId) {
            // 業(yè)務(wù)
            System.out.println("delete user");
            return userId;
        }
    }

    // 自定義InvocationHandler
    static class UserServiceProxy implements InvocationHandler {
        // 目標(biāo)對(duì)象
        private Object target;

        public UserServiceProxy(Object target) {
            this.target = target;
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("------方法調(diào)用前---------");
            //執(zhí)行相應(yīng)的目標(biāo)方法
            Object result = method.invoke(target, args);
            System.out.println("------方法調(diào)用后---------");
            return result;
        }
    }

    public static void main(String[] args) {
        IUserService userService = new UserServiceImpl();
        // 創(chuàng)建調(diào)用處理類
        UserServiceProxy handler = new UserServiceProxy(userService);
        // 得到代理類實(shí)例
        IUserService proxy = (IUserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),
                                 new Class[]{IUserService.class}, handler);
        // 調(diào)用代理類的方法
        Integer userId = proxy.delete(3);
        System.out.println(userId);
    }

}

cglib proxy

而cglib動(dòng)態(tài)代理是利用asm開源包，對(duì)代理對(duì)象類的class文件加載進(jìn)來，通過修改其字節(jié)碼生成子類來處理。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 

 *
 * @author leone
 * @since 2018-11-09
 **/
public class CglibProxy {

    static class UserService implements MethodInterceptor {

        private Object target;

        /**
         * 業(yè)務(wù)方法
         *
         * @param userId
         * @return
         */
        public Integer delete(Integer userId) {
            System.out.println("delete user");
            return userId;
        }

        /**
         * 利用Enhancer類生成代理類
         *
         * @param target
         * @return
         */
        public Object getInstance(Object target) {
            this.target = target;
            // 創(chuàng)建加強(qiáng)器，用來創(chuàng)建動(dòng)態(tài)代理類
            Enhancer enhancer = new Enhancer();
            // 為加強(qiáng)器指定要代理的業(yè)務(wù)類（即：為下面生成的代理類指定父類）
            enhancer.setSuperclass(target.getClass());
            // 設(shè)置回調(diào)：對(duì)于代理類上所有方法的調(diào)用，都會(huì)調(diào)用CallBack，而Callback則需要實(shí)現(xiàn)intercept()方法進(jìn)行攔
            enhancer.setCallback(this);
            // 創(chuàng)建動(dòng)態(tài)代理類對(duì)象并返回
            return enhancer.create();
        }


        /**
         * @param o
         * @param method
         * @param objects
         * @param methodProxy
         * @return
         * @throws Throwable
         */
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) 
                                throws Throwable {
            System.out.println("------方法調(diào)用前---------");
            Object object = methodProxy.invokeSuper(o, objects);
            System.out.println("------方法調(diào)用后---------");
            return object;
        }

    }

    public static void main(String[] args) {
        UserService userService = new UserService();
        UserService proxy = (UserService) userService.getInstance(userService);
        Integer userId = proxy.delete(2);
        System.out.println(userId);
    }

}

1、如果目標(biāo)對(duì)象實(shí)現(xiàn)了接口，默認(rèn)情況下會(huì)采用JDK的動(dòng)態(tài)代理實(shí)現(xiàn)AOP，可以強(qiáng)制使用CGLIB實(shí)現(xiàn)AOP
2、如果目標(biāo)對(duì)象沒有實(shí)現(xiàn)了接口，必須采用CGLIB庫，spring會(huì)自動(dòng)在JDK動(dòng)態(tài)代理和CGLIB之間轉(zhuǎn)換

    org.springframework.boot
    spring-boot-starter-aop

@Before：該注解標(biāo)注的方法在業(yè)務(wù)模塊代碼執(zhí)行之前執(zhí)行，其不能阻止業(yè)務(wù)模塊的執(zhí)行，除非拋出異常；

@AfterReturning：該注解標(biāo)注的方法在業(yè)務(wù)模塊代碼執(zhí)行之后執(zhí)行；

@AfterThrowing：該注解標(biāo)注的方法在業(yè)務(wù)模塊拋出指定異常后執(zhí)行；

@After：該注解標(biāo)注的方法在所有的Advice執(zhí)行完成后執(zhí)行，無論業(yè)務(wù)模塊是否拋出異常，類似于finally的作用；

@Around：該注解功能最為強(qiáng)大，其所標(biāo)注的方法用于編寫包裹業(yè)務(wù)模塊執(zhí)行的代碼，其可以傳入一個(gè)ProceedingJoinPoint用于調(diào)用業(yè)務(wù)模塊的代碼，無論是調(diào)用前邏輯還是調(diào)用后邏輯，都可以在該方法中編寫，甚至其可以根據(jù)一定的條件而阻斷業(yè)務(wù)模塊的調(diào)用；

@DeclareParents：其是一種Introduction類型的模型，在屬性聲明上使用，主要用于為指定的業(yè)務(wù)模塊添加新的接口和相應(yīng)的實(shí)現(xiàn)。

1.通配符

[*] 匹配任意字符，但只能匹配一個(gè)元素

[..] 匹配任意字符，可以匹配任意多個(gè)元素，表示類時(shí)，必須和*聯(lián)合使用

[+] 必須跟在類名后面，如Horseman+，表示類本身和繼承或擴(kuò)展指定類的所有類

2.邏輯運(yùn)算符

表達(dá)式可由多個(gè)切點(diǎn)函數(shù)通過邏輯運(yùn)算組成

&& 與操作，求交集，也可以寫成and

例如?execution(* chop(..)) && target(Horseman) ?表示Horseman及其子類的chop方法

|| 或操作，任一表達(dá)式成立即為true，也可以寫成 or

例如?execution(* chop(..)) || args(String) ?表示名稱為chop的方法或者有一個(gè)String型參數(shù)的方法

! 非操作，表達(dá)式為false則結(jié)果為true，也可以寫成 not

例如?execution(* chop(..)) and !args(String)??表示名稱為chop的方法但是不能是只有一個(gè)String型參數(shù)的方法

execution() 方法匹配模式串

表示滿足某一匹配模式的所有目標(biāo)類方法連接點(diǎn)。如execution(* save(..))表示所有目標(biāo)類中的 save()方法。

由于Spring切面粒度最小是達(dá)到方法級(jí)別，而execution表達(dá)式可以用于明確指定方法返回類型，類名，方法名和參數(shù)名等與方法相關(guān)的部件，并且在Spring中，大部分需要使用AOP的業(yè)務(wù)場(chǎng)景也只需要達(dá)到方法級(jí)別即可，因而execution表達(dá)式的使用是最為廣泛的。如下是execution表達(dá)式的語法

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

execution(<修飾符> <返回類型> <類路徑> <方法名>(<參數(shù)列表>) <異常模式> )

modifiers-pattern：方法的可見性，如public，protected；

ret-type-pattern：方法的返回值類型，如int，void等；

declaring-type-pattern：方法所在類的全路徑名，如com.spring.Aspect；

name-pattern：方法名類型，如buisinessService()；

param-pattern：方法的參數(shù)類型，如java.lang.String；

throws-pattern：方法拋出的異常類型，如java.lang.Exception；

@annotation(annotation-type) 方法注解類名

如下示例表示匹配使用com.leone.aop.AopTest注解標(biāo)注的方法：

@annotation(com.leone.aop.AopTest)

args(param-pattern) 方法入?yún)⑶悬c(diǎn)函數(shù)

如下示例表示匹配所有只有一個(gè)參數(shù)，并且參數(shù)類型是java.lang.String類型的方法：

args(java.lang.String)

@args(annotation-type) 方法入?yún)㈩愖⒔馇悬c(diǎn)函數(shù)

如下示例表示匹配使用了com.leone.aop.AopTest注解標(biāo)注的類作為參數(shù)的方法：

@args(com.leone.aop.AopTest)

within(declaring-type-pattern) 類名匹配切點(diǎn)函數(shù)

within表達(dá)式只能指定到類級(jí)別，如下示例表示匹配com.leone.aop.UserService中的所有方法：

within(com.leone.aop.UserService)

@within(annotation-type) 類注解匹配切點(diǎn)函數(shù)

如下示例表示匹配使用org.springframework.web.bind.annotation.RestController注解標(biāo)注的類：

@within(org.springframework.web.bind.annotation.RestController)

target(declaring-type-pattern) 類名切點(diǎn)函數(shù)

如下示例表示匹配com.leone.aop.UserService中的所有方法：

target(com.leone.aop.UserService)

this

配置切面類，實(shí)現(xiàn)代理

1.在類上使用 @Component 注解把切面類加入到IOC容器中
2.在類上使用 @Aspect 注解使之成為切面類

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

/**
 * 描述一個(gè)切面類
 *
 * @author leone
 * @since 2018-06-21
 **/
@Slf4j
@Aspect
@Component
public class AopConfig {

    /**
     * 1.通配符
     * [*]  匹配任意字符，但只能匹配一個(gè)元素
     * 

     * [..] 匹配任意字符，可以匹配任意多個(gè)元素，表示類時(shí)，必須和*聯(lián)合使用
     * 

     * [+]  必須跟在類名后面，如Horseman+，表示類本身和繼承或擴(kuò)展指定類的所有類
     * 

     * 切點(diǎn)表達(dá)式分為 修飾符  返回類型  包路徑  方法名  參數(shù)
     * 

     * 2.切點(diǎn)表達(dá)式
     * 

     * 3.邏輯運(yùn)算符
     * 表達(dá)式可由多個(gè)切點(diǎn)函數(shù)通過邏輯運(yùn)算組成
     * ** && 與操作，求交集，也可以寫成and
     * 

     * 例如?execution(* chop(..)) && target(Horseman) ?表示Horseman及其子類的chop方法
     * 

     * ** || 或操作，任一表達(dá)式成立即為true，也可以寫成 or
     * 

     * 例如?execution(* chop(..)) || args(String) ?表示名稱為chop的方法或者有一個(gè)String型參數(shù)的方法
     * 

     * ** ! 非操作，表達(dá)式為false則結(jié)果為true，也可以寫成 not
     * 

     * 例如?execution(* chop(..)) and !args(String)??表示名稱為chop的方法但是不能是只有一個(gè)String型參數(shù)的方法
     */
    @Pointcut("execution(* com.leone.boot.aop.service.*.*(..))")
    public void pointCut() {
    }

    /**
     * 環(huán)繞通知在 target 開始和結(jié)束執(zhí)行
     *
     * @param point
     * @return
     */
    @Around(value = "pointCut()")
    public Object around(ProceedingJoinPoint point) {
        long start = System.currentTimeMillis();
        String methodName = point.getSignature().getName();
        log.info("around method name: {} params: {}", methodName, Arrays.asList(point.getArgs()));
        try {
            log.info("around end time: {}", (System.currentTimeMillis() - start) + " ms!");
            return point.proceed();
        } catch (Throwable e) {
            log.error("message: {}", e.getMessage());
        }
        return null;
    }

    /**
     * 前置通知在 target 前執(zhí)行
     *
     * @param joinPoint
     */
    // @Before("@annotation(com.leone.boot.aop.anno.AopBefore)")
    // @Before("within(com.leone.boot.aop.controller.*)")
    // @Before("@within(org.springframework.web.bind.annotation.RestController)")
    // @Before("target(com.leone.boot.aop.controller.UserController)")
    @Before("@target(com.leone.boot.aop.anno.ClassAop) && @annotation(com.leone.boot.aop.anno.AopBefore)")
    public void beforeMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        List