Spring AOP之簡單實踐

Spring AOP建立在代理之上，所以先對代理有個簡單的認識也是很有必要的，下面結合代碼來進行簡要說明。

1，首先定義一個接口和實體對象

public class Student {
    public String name ;
    public int age ;
}
public interface IStudentService {
    /**
     * 添加學生
     * */
    void addStudent(Student student) ;
    /**
     * 刪除學生
     * */
    void removeStudent(String studentId) ; 
}
public class DefaultStudentService implements IStudentService {
    @Override
    public void addStudent(Student student) {
        System.out.println("新增學生信息");
    }
    @Override
    public void removeStudent(String studentId) {
        System.out.println("刪除ID為" + studentId+"的學生信息");
    }
}

2，Java的動態代理技術

Java的動態代理主要涉及到下面兩個類型
1）java.lang.reflect.InvocationHandler接口

/**
代理實例的調用處理程序實現的接口;
每個代理實例都有一個關聯的調用處理程序。
在代理實例上調用方法時，方法調用將被處理并發送到其調用處理程序的invoke方法。
*/
public interface InvocationHandler {
    /**
            @param proxy 動態生成的代理對象實例
            @param method 被代理對象調用的方法
            @param args 被調用的方法的參數
            @return 從代理實例上的方法調用返回的值,其類型必須和被代理接口中所定義的返回類型兼容。
    */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

2）java.lang.reflect.Proxy對象

簡單的說，Java動態代理就是通過Java的Proxy對象來創建某個實例對象的代理對象，在調用代理對象的時候便會觸發調用InvocationHandler的invoke方法，我們在invoke方法中可以添加一些額外的代碼來擴充能力，同時在invoke中我們可以判斷哪個方法被調用，然后通過反射執行被代理對象上的這個方法。

3，使用Java動態代理實例

/**
     * Java的動態代理技術【代理整個接口類】
     */
    public static void javaDyncProxy() {
        // 要被代理的目標對象
        DefaultStudentService studentService = new DefaultStudentService();
        // 代理的調用處理器【當我們通過動態代理對象調用任何一個方法時候，這個方法的調用就會被轉發到實現InvocationHandler接口類的invoke方法來調用】
        StudentServiceInvocationHandler invocationHandler = new StudentServiceInvocationHandler(studentService);
        // 創建代理對象
        IStudentService service = (IStudentService)Proxy.newProxyInstance(studentService.getClass().getClassLoader(),
                studentService.getClass().getInterfaces(), invocationHandler);
        service.addStudent(new Student());
    }
    public static class StudentServiceInvocationHandler implements InvocationHandler {
        private IStudentService target;
        public StudentServiceInvocationHandler(IStudentService studentService) {
            this.target = studentService;
        }

        /*
         * @param proxy
         * 真實對象的真實代理對象；InvocationHandler本身,例如這里的：StudentServiceInvocationHandler
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("是的，你已經是在使用Proxy了");
            return method.invoke(target, args);
        }
    }
    public static void main(String[] args) {
         javaDyncProxy() ;
    }

執行main方法后，得到的打印輸入如下

是的，你已經是在使用Proxy了
新增學生信息

4，Spring AOP

前面的文章中有介紹過Spring AOP中的一些概念，其中包括Advice和Pointcut。 Pointcut用于篩選類和方法，而Advice負責確實執行點，通過兩則的結合就有了Advisor(切面)。

我們先看下SpringAOP中這些對象的關系。

由上圖可知
1）Pointcut接口依賴于ClassFilter和MethodMatcher兩個接口，通過這兩個接口來達到篩選類和方法的目的
2）Advice接口【是個Tag Interface】包含了眾多的子接口，通過子接口來擴展其功能，每個子接口都分別代表不同的方法執行點(內部的抽象方法便是添加增強代碼的地方)
3）Adisor接口依賴于Advice接口，代表一個類中的所有方法的某些執行點，其最常用的子接口類型PointcutAdvisor有添加了對Pointcut接口的依賴，表示某些類中某些方法的某些執行點

下面我們更進一步的看看各個接口都有哪些實現

Pointcut實現類關系圖

Advice接口關系圖

ThrowsAdvice是一個Tag interface，實現類具有以下任意一個或多個方法實現均可：
public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)

Advisor關系圖

上面通過類圖展現了SpringAOP中幾個關鍵概念間的關系，下面再看看SpringProxy的類圖

1）ProxyCreatorSupport與AopProxyFactory關聯，在內部默認創建DefaultAopProxyFactory對象

2）AopProxyFactory依賴AopProxy接口，AopProxy的實現類包含了基于Java動態代理的JdkDynamicAopProxy和基于cglib的CglibAopProxy對象

3）我們在使用AopProxy的時候，內部會根據我們的設置來動態的選擇使用Java動態代理還是基于cglib的代理。

下面通過示例代碼來說明Spring Aop的以上這些對象

使用ProxyFactory

/**
 * 定義“方位”以及對應的增強代碼。
 * 使用時，如果沒提供具體的Ponitcut，該增強會織入到目標類的所有方法上。
 * */
public class StudentServiceAdvice implements MethodBeforeAdvice, AfterReturningAdvice,ThrowsAdvice {

    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("調用方法" + method.getName() +"前");

    }

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("調用方法" + method.getName() +"返回后");
    }

    /**
     * 方法名必須是afterThrowing,前三個參數是可選【同時都出現或都不出現】，最后個參數不行是Throwable或子類。
     * 可以定義多個afterThrowing方法，Spring會自動選用最匹配的增強方法。
     * */
    public void afterThrowing(Method method, Object[] args, Object target,RuntimeException e) {
        System.out.println("調用方法" + method.getName() +"拋出異常后");
    }
}

/**
     * 只用增強應用到類上的所有方法上
     */
    public static void springProxy() {
        // 要被代理的目標對象
        DefaultStudentService studentService = new DefaultStudentService();
        /*
         * 代理工廠根據代理配置在內部使用AopProxy類型的代理創建代理對象,AopProxy的實現類有以下兩個： 
         * 1）JdkDynamicAopProxy :基于Java的動態代理技術 
         * 2）Cglib2AopProxy ： 基于CGLib的動態代理技術
         * 在使用ProxyFactory的時候，如果通過setInterface()方法指定目標接口進行代理，則使用JdkDynamicAopProxy;
         * 如果針對類的代理或者設置SetOptimize(true)，則使用Cglib2AopProxy；
         */
        ProxyFactory factory = new ProxyFactory();
        // 設置要被代理的接口類型
        factory.setInterfaces(studentService.getClass().getInterfaces());
        // 設置代理的目標對象
        factory.setTarget(studentService);
        // 為代理目標添加增強[Advice包含了橫切代碼和連接點信息，所以本身就是一個簡單的切面]
        factory.addAdvice(new StudentServiceAdvice());
        // 生成代理實例
        IStudentService proxy = (IStudentService) factory.getProxy();
        // 調用方法
        proxy.addStudent(new Student("test", 22));
        proxy.removeStudent("10001");
    }

執行后的輸出結果：

調用方法addStudent前
新增學生信息
調用方法addStudent返回后
調用方法removeStudent前
刪除ID為10001的學生信息
調用方法removeStudent返回后

使用AspectJProxyFactory

        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.4</version>
        </dependency>

@Aspect
public class CommAspect {

    /**
     * 前置增強
     * 所有目標類中的所有addStudent方法
     * */
    @Before("execution (* addStudent(..))")
    public void defore(JoinPoint joinPoint) {
        System.out.println(">>>>befor addStudent");
    }
}

public static void springAspectProxy() {
        // 要被代理的目標對象
        DefaultStudentService studentService = new DefaultStudentService();
        // 基于AspectJ的代理工廠
        AspectJProxyFactory factory = new AspectJProxyFactory();
        // 設置代理目標
        factory.setTarget(studentService);
        // 添加切面類
        factory.addAspect(CommAspect.class);
        // 生成代理實例
        IStudentService proxy = (IStudentService) factory.getProxy();
        // 調用方法
        proxy.addStudent(new Student("test", 22));
        proxy.removeStudent("10001");
    }

執行后輸出：

>>>>befor addStudent
新增學生信息
刪除ID為10001的學生信息