Spring之AOP编程

一、AOP简介

    AOP的英文全称是Aspect Oriented Programming，意为：面向切面编程。

    AOP采取横向抽取的机制，取代了传统纵向继承体系的代码复用。AOP常用于：事务管理，性能监视，安全检查，缓存，日志等。

    Spring AOP使用纯Java实现，在程序运行期间通过代理的方式向目标类织入增强代码。

    AspectJ是一个基于Java语言的AOP框架，Spring在2.0版本引入了对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译期间提供横向代码的织入。

 

二、spring-aop的实现原理

    spring-aop的底层采用代理机制进行实现。

    如果目标类实现了接口，spring默认采用jdk的动态代理；

    如果目标类没有实现接口，spring默认采用cglib字节码增强。不过，我们可以声明强制使用cglib的代理方式。

 

三、AOP的术语【重要】

    1. target（目标类），需要被代理的类。我们将会用：UserService + UserServiceImpl作为目标类。

    2. joinPoint（连接点），连接点是指那些可能被拦截到的方法。例如：目标类中的所有方法

    3. pointCut（切入点），已经被增强的连接点。例如：目标类中的addUser()方法。切入点是连接点的一个子集。

    4. advice（通知 / 增强），增强代码。例如：切面类中的before、after方法。

    5. weaving（织入），指把通知（advice）应用到目标对象（target）来创建新的代理对象（proxy）的过程。可知，织入是一个过程。

    6. proxy（代理类）

    7. aspect（切面），切面是指切入点（pointcut）和通知(advice)的结合。

 

四、用JDK的动态代理实现AOP

    JDK的动态代理是对装饰者设计模式的简化。使用的前提是目标类必须实现接口。

    用JDK动态代理有三个主要模块需要实现：

    1. 目标类：接口+实现类（UserService + UserServiceImpl）

    2. 切面类：切面类用于存放通知（MyAspect）

    3. 工厂类：工厂类用来生成代理对象

    4. 测试类

 

    下面给出一个JDK动态代理实现AOP的例子

    1. 目标类（接口+实现类）

package cn.african.service;
public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

package cn.african.service;
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser...");
    }
    @Override
    public void updateUser() {
        System.out.println("updateUser...");
    }
    @Override
    public void deleteUser() {
        System.out.println("deleteUser...");
    }
}

    2. 切面类

package cn.african.aspect;
public class MyAspect {
    public void before() {
        System.out.println("before");
    }
    public void after() {
        System.out.println("after");
    }
}

    3. 工厂类

package cn.african.factory;

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

import cn.african.aspect.MyAspect;
import cn.african.service.UserService;
import cn.african.service.UserServiceImpl;

public class MyFactoryBean {

    public static UserService createService() {
        // 1. 目标对象
        UserService userService = new UserServiceImpl();
        // 2. 切面对象
        MyAspect myAspect = new MyAspect();
        // 3. 代理对象
        UserService proxyService = (UserService) Proxy.newProxyInstance(
                MyFactoryBean.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置通知
                        myAspect.before();
                        //执行目标类的方法
                        Object object = method.invoke(userService, args);
                        //后置通知
                        myAspect.after();
                        return object;
                    }
                });
        //4. 返回代理对象
        return proxyService;
    }
}

    我们重点分析工厂类中代理对象的生成：

    public static Object newProxyInstance(ClassLoader loader,

                                          Class<?>[] interfaces,

InvocationHandler h)

            参数1：loader，类加载器。因为动态代理是在运行时创建代理对象，而任何类都需要类加载器将其加载到内存，所以我们要给将来运行期间产生的这个代理类提供一个类加载器。   一般情况下，使用  当前类.class.getClassLoader()，或者  目标实例.getClass().getClassLoader()；其实他们俩是一个ClassLoader。

            参数2：interfaces，代理类需要实现的所有接口。有两个方式来提供这些接口：

                        方式1：目标实例.getClass().getInterfaces()；但是这种方式只能获得自己的接口，不能获得父类的接口。

                        方式2：new Class[ ] { UserService.class }；这种方式可以获得父类的接口

            参数3：InvocationHandler，处理类，这是JDK反射包中提供的接口，里面只有一个invoke方法，代理类的每一个方法执行时，都将调用一次invoke方法。InvocationHandler需要实现，一般采用匿名内部类来实现。

                        我们在分析这个invoke方法，方法的格式为：public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

                        参数3.1：proxy，代理对象

                        参数3.2：method：代理对象当前要执行的方法

                        参数3.3：args：要执行的方法的入参

 

    4. 测试类

 

package cn.african.test;

import org.junit.Test;

import cn.african.factory.MyFactoryBean;
import cn.african.service.UserService;

public class TestJdkProxy {

    @Test
    public void testJdkProxy() {
        UserService userService = MyFactoryBean.createService();
        userService.addUser();
        System.out.println("--------------");
        userService.updateUser();
        System.out.println("--------------");
        userService.deleteUser();
    }
}

 打印结果：

五、用CGLIB实现AOP 

    如果目标类没有实现接口，就无法使用JDK的动态代理来生成代理类，这时候我们采用纵向继承机制来实现目标类的代码增强，这就是cglib要完成的工作。

    cglib代理是在程序运行期间，创建目标类的子类，在子类中对目标类的方法进行增强。

    cglib有两个jar包依赖：cglib.jar和asm.jar，但这两个jar都已经被整合在spring-core.jar中了。

    下面我们手动实现一个cglib代理：

    1. 目标类

package cn.african.service;
public class UserServiceImpl {
    public void addUser() {
        System.out.println("addUser...");
    }
    public void updateUser() {
        System.out.println("updateUser...");
    }
    public void deleteUser() {
        System.out.println("deleteUser...");
    }
}

    2. 切面类

package cn.african.aspect;
public class MyAspect {
    public void before() {
        System.out.println("before");
    }

    public void after() {
        System.out.println("after");
    }
}

    3. 工厂类                  

    采用cglib，底层将创建目标类的子类

package cn.african.factory;

import java.lang.reflect.Method;

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

import cn.african.aspect.MyAspect;
import cn.african.service.UserService;
import cn.african.service.UserServiceImpl;

public class CglibBeanFactory {

    public static UserService createService() {
        // 目标类
        UserServiceImpl userService = new UserServiceImpl();
        // 切面类
        MyAspect myAspect = new MyAspect();
        // 1. 核心类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(UserServiceImpl.class);
        // 3. 设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
                    throws Throwable {
                myAspect.before();
                Object object = method.invoke(userService, args);
                myAspect.after();
                return object;
            }
        });
        // 4. 创建代理
        UserServiceImpl proxyService = (UserServiceImpl) enhancer.create();
        return proxyService;
    }
}

    我们解释一下这个回调函数：

    MethodInterceptor接口类似于JDK中的InvocationHandler接口，而intercept方法类似于InvocationHandler接口中的invoke方法。

    前三个参数和invoke方法中的三个参数是一样的。

    第四个参数methodProxy是方法代理，可以通过它执行代理类的父类，也就是执行目标类。

    Object object = method.invoke(userService, args) 可以替换成 methodProxy.invokeSuper(proxy, args)，两个效果是一样的。

 

    4. 测试类

package cn.african.test;

import org.junit.Test;

import cn.african.factory.CglibBeanFactory;
import cn.african.service.UserService;

public class TestCglibProxy {

    @Test
    public void demo01() {
        UserService userService = CglibBeanFactory.createService();
        userService.addUser();
        System.out.println("--------------");
        userService.updateUser();
        System.out.println("--------------");
        userService.deleteUser();
    }
}

打印结果：

六、半自动代理实现AOP

    我们之所以称之为半自动代理，是因为Spring自动创建了代理对象，但是却需要我们手动去容器中获取这个代理对象。

    在实现这个半自动的demo之前，我们首先介绍一下aop联盟（aopalliance）定义的一套通知（advice）接口规范。

 

    音乐博士Rod Johnson童鞋在aop联盟的规范里定义了一个空的通知接口Advice：

package org.aopalliance.aop;
/**
 * Tag interface for Advice. Implementations can be any type
 * of advice, such as Interceptors.
 * @author Rod Johnson
 * @version $Id: Advice.java,v 1.1 2004/03/19 17:02:16 johnsonr Exp $
 */
public interface Advice {}

    Spring按照通知在目标类方法上连接点的位置，把通知又分为以下五大接口规范：

    1. 前置通知：org.springframework.aop.MethodBeforeAdvice

    2. 后置通知：org.springframework.aop.AfterReturningAdvice

    3. 环绕通知：org.aopalliance.intercept.MethodInterceptor

        注意环绕通知并不是定义在spring中，而是在aop联盟的规范中。同时也要注意在cglib代理中设置回调函数的时候new了一个org.springframework.cglib.proxy.MethodInterceptor的匿名实现，这是两个不同的MethodInterceptor，注意区分。环绕通知是我们的重点。

    4. 异常抛出通知：org.springframework.aop.ThrowsAdvice

    5. 引介通知：org.springframework.aop.IntroductionInterceptor

        引介通知用来在目标类中添加一些新的属性和方法，但是很少用。

 

    我们先模拟一下环绕通知的流程。注意，环绕通知必须手动执行目标方法。

try{
    //1. 前置通知
    //2. 执行目标方法
    //3. 后置通知
}catch{
    //4. 抛出异常通知
}

    1,2,3如果有任何一处抛出异常，都会停止后面代码的执行，进入catch块。

    所以，如果在前置通知中抛出异常，可以阻止目标方法的执行。

    后置通知是在目标方法执行后执行，所以它可以获得目标方法的返回值。

 

    下面我们来实现一个半自动代理的demo：

    1. 目标类

package cn.african.service;
public interface UserService {
    void addUser();
    void updateUser();
    void deleteUser();
}

package cn.african.service;
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser...");
    }
    @Override
    public void updateUser() {
        System.out.println("updateUser...");
    }
    @Override
    public void deleteUser() {
        System.out.println("deleteUser...");
    }
}

    2. 切面类

        切面类中装有通知，我们环绕通知为例，所以这个类需要实现环绕通知的接口org.aopalliance.intercept.MethodInterceptor。同时要注意到，环绕通知必须手动执行目标方法。

package cn.african.aspect;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyAspect implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 前置通知
        System.out.println("before");
        // 手动执行目标方法，这是一个放行方法
        Object object = invocation.proceed();
        // 后置通知
        System.out.println("after");
        return object;
    }
}

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

    <!-- 1. 目标类 -->
    <bean id="userService" class="cn.african.service.UserServiceImpl"></bean>

    <!-- 2. 切面类 -->
    <bean id="myAspect" class="cn.african.aspect.MyAspect"></bean>

    <!-- 3. 代理类 -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="cn.african.service.UserService"></property>
        <property name="target" ref="userService"></property>
        <property name="interceptorNames" value="myAspect"></property>
        <!-- <property name="optimize" value="true"></property> -->    <!--如果声明optimize=true，无论是否有接口，都采用cglib代理-->
    </bean>
</beans>

    我们分下一下代理类的配置：

    org.springframework.aop.framework.ProxyFactoryBean是FactoryBean的一个实现，它是一个代理类的工厂Bean，专门用来生成代理对象，底层会调用ProxyFactoryBean中的getObject()方法来返回这个代理对象。

    interfaces：确定接口

    target：确定目标类

    interceptorNames：切面类实例的Bean ID，但是这里使用value，却没有使用ref，这是因为setInterceptorNames接收的参数是个String的可可变参数，本质上是一个String[ ]。

    optimize：当值为true时，强制使用cglib代理；默认值为false。

 

    4. 测试类

package cn.african.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.african.service.UserService;

public class TestAop {

    @Test
    public void demo01() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans-aop.xml");
        UserService userService = context.getBean("proxyService", UserService.class);
        userService.addUser();
        System.out.println("----------------");
        userService.updateUser();
        System.out.println("----------------");
        userService.deleteUser();
        context.getClass().getMethod("close").invoke(context);
    }
}

打印结果：

七、Spring AOP编程

    从Spring容器中获取目标对象，如果配置了AOP，Spring将自动生成代理对象并返回。

    想要确定目标类，得使用AspectJ的切入点表达式。关于AspectJ我们将在另一篇文章中详细介绍。

    下面是一个AOP编程的demo：

    1. 目标类

package cn.african.service;
public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

package cn.african.service;
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser...");
    }
    @Override
    public void updateUser() {
        System.out.println("updateUser...");
    }
    @Override
    public void deleteUser() {
        System.out.println("deleteUser...");
    }
}

    2. 切面类

    我们使用环绕通知，环绕通知要手动执行目标方法。

package cn.african.aspect;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyAspect implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 前置通知
        System.out.println("before");
        // 手动执行目标方法，这是一个放行方法
        Object object = invocation.proceed();
        // 后置通知
        System.out.println("after");
        return object;
    }
}

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

    <!-- 1. 目标类 -->
    <bean id="userService" class="cn.african.service.UserServiceImpl"></bean>

    <!-- 2. 切面类 -->
    <bean id="myAspect" class="cn.african.aspect.MyAspect"></bean>

    <!-- 3. AOP配置 -->
    <aop:config>
        <aop:pointcut expression="execution(* cn.african.service.UserServiceImpl.*(..))" id="myPointcut"/>
        <aop:advisor advice-ref="myAspect" pointcut-ref="myPointcut"/>
    </aop:config>
</beans>

    下面解释一下这段AOP的配置：

    1. 使用<aop:config>必须要导入aop的命名空间。

    2. aop编程就是在<aop:config>之间进行配置：

            <aop:pointcut>：切入点，从目标对象中获取具体的方法

            <aop:advisor>：这个标签描述一个特殊的切面，这个特殊的切面是一个通知和一个切入点的结合。

                        advice-ref：通知的引用

                        pointcut-ref：切入点的引用

                        注意advisor和advice的区别！！！

    3. 切入点表达式

            execution(* cn.african.service.UserServiceImpl.*(..))

            execution：按照官方的解释是： for matching method execution join points, this is the primary pointcut designator(指示符) you will use when working with Spring AOP。

             execution(     *      cn.african.service.  UserServiceImpl. *        (..)  )

                            返回类型任意    包名              类名           方法任意   参数任意

 

    4. 测试类

package cn.african.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.african.service.UserService;

public class TestAop {

    @Test
    public void demo01() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans-aop.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.addUser();
        System.out.println("----------------");
        userService.updateUser();
        System.out.println("----------------");
        userService.deleteUser();
        context.getClass().getMethod("close").invoke(context);
    }
}

打印结果：