Spring之旅第五篇-AOP详解

一、什么是AOP？

Aspect oritention programming(面向切面编程)，AOP是一种思想，高度概括的话是“横向重复，纵向抽取”，如何理解呢？举个例子：访问页面时需要权限认证，如果每个页面都去实现方法显然是不合适的，这个时候我们就可以利用切面编程。

每个页面都去实现这个方法就是横向的重复，我们直接从中切入，封装一个与主业务无关的权限验证的公共方法，这样可以减少系统的重复代码，降低模块之间的耦合度，简单的示意图如下：

二、应用场景

AOP用来封装横切关注点，具体可以在下面的场景中使用:

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading　懒加载

Debugging　　调试 l

ogging, tracing, profiling and monitoring　记录跟踪　优化　校准

Performance optimization　性能优化

Persistence　　持久化

Resource pooling　资源池

Synchronization　同步

Transactions 事务

三、相关概念

1.连接点（Joinpoint） 所谓连接点是指那些可能被拦截到的方法。例如：所有可以增加的方法

2.切点（Pointcut） 已经被增强的连接点

3.增强（Advice） 增强的代码

4.目标对象（Target） 目标类，需要被代理的类

5.织入（Weaving） 是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程

6.代理（Proxy） 一个类被AOP织入增强后，就产生出了一个结果类，它是融合了原类和增强逻辑的代理类。

7.切面（Aspect）切入点+通知

通知类型：Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

• 前置通知 （在目标方法执行前实施增强）

• 后置通知（在目标方法执行后实施增强）

• 环绕通知（在目标方法执行前后实施增加）

• 异常抛出通知（在方法跑出异常时通知）

• 引介通知（在目标类中添加一些新的方法和属性）

四、实现原理

AOP的实现关键在于AOP框架自动创建的AOP代理。AOP代理主要分为两大类：

静态代理：使用AOP框架提供的命令进行编译，从而在编译阶段就可以生成AOP代理类，因此也称为编译时增强；静态代理一Aspectj为代表。

动态代理：在运行时借助于JDK动态代理，CGLIB等在内存中临时生成AOP动态代理类，因此也被称为运行时增强，Spring AOP用的就是动态代理。

4.1 静态代理

例子：在增加员工和删除员工时增加事务处理

//员工类
public class Employee {
    private Integer uid;

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Integer getUid() {

        return uid;
    }

    private Integer age;

    private String name;

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
}

员工接口：

//员工接口
public interface EmployeeService {
    //新增方法
    void addEmployee(Employee employee);
    //删除方法
    void deleteEmployee(Integer uid);
}

员工实现：

//员工方法实现
public class EmployeeServiceImpl implements EmployeeService {
    @Override
    public void addEmployee(Employee employee) {
        System.out.println("新增员工");
    }

    @Override
    public void deleteEmployee(Integer uid) {
        System.out.println("删除员工");

    }
}

事务类：

//事务类
public class MyTransaction {
    //开启事务
    public void before(){
        System.out.println("开启事务");
    }
    //提交事务
    public void after(){
        System.out.println("提交事务");
    }
}

代理类：

//代理类
public class ProxyEmployee implements EmployeeService {
    //
    private EmployeeService employeeService;

    private MyTransaction myTransaction;

    public ProxyEmployee(EmployeeService employeeService,MyTransaction myTransaction)
    {
       this.employeeService=employeeService;
       this.myTransaction=myTransaction;
    }
    @Override
    public void addEmployee(Employee employee) {
         myTransaction.before();
         employeeService.addEmployee(employee);
         myTransaction.after();
    }

    @Override
    public void deleteEmployee(Integer uid) {
         myTransaction.before();
         employeeService.deleteEmployee(uid);
         myTransaction.after();
    }
}

测试：

@Test
    public void fun1(){
        MyTransaction transaction = new MyTransaction();
        EmployeeService EmployeeService = new EmployeeServiceImpl();
        //产生静态代理对象
        ProxyEmployee proxy = new ProxyEmployee(EmployeeService, transaction);
        proxy.addEmployee(null);
        proxy.deleteEmployee(0);
    }

结果：

这是静态代理的实现方式，静态代理有明显的缺点：

1、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

2、如果接口增加一个方法，比如 EmployeeService增加修改 updateEmployee(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

4.2 动态代理

动态代理就不要自己手动生成代理类了，我们去掉 ProxyEmployee.java 类，增加一个 ObjectInterceptor.java 类

public class ObjectInterceptor implements InvocationHandler {

    //目标类
    private Object target;
    //切面类（这里指事务类）
    private MyTransaction transaction;

    //通过构造器赋值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        this.transaction.before();
        method.invoke(target,args);
        this.transaction.after();
        return  null;
    }
}

测试：

@Test
public void fun2(){
    //目标类
    Object target = new EmployeeServiceImpl ();
    //事务类
    MyTransaction transaction = new MyTransaction();
    ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
    /**
     * 三个参数的含义：
     * 1、目标类的类加载器
     * 2、目标类所有实现的接口
     * 3、拦截器
     */
    EmployeeService employeeService = (EmployeeService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), proxyObject);
    employeeService.addEmployee(null);
    employeeService.deleteEmployee(0);
}

结果：

五、spring的处理AOP的方式

spring 有两种方式实现AOP的：一种是采用声明的方式来实现（基于XML），一种是采用注解的方式来实现（基于AspectJ）

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

     <!--目标类-->
     <bean name="employeeService" class="com.yuanqinnan.aop.EmployeeServiceImpl"></bean>
     <bean name="transaction" class="com.yuanqinnan.aop.MyTransaction"></bean>
     <aop:config>
          <aop:aspect ref="transaction">
               <aop:pointcut id="pointcut" expression="execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))"/>
               <!-- 配置前置通知，注意 method 的值要和 对应切面的类方法名称相同 -->
               <aop:before method="before" pointcut-ref="pointcut"></aop:before>
               <!--配置后置通知，注意 method 的值要和 对应切面的类方法名称相同-->
               <aop:after-returning method="after" pointcut-ref="pointcut"/>
          </aop:aspect>
     </aop:config>

</beans>

测试：

@Test
public void fun3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml");
    EmployeeService employeeService = (EmployeeService) context.getBean("employeeService");
    employeeService.addEmployee(null);
}

结果：

补充：

1.aop:pointcut如果位于aop:aspect元素中，则命名切点只能被当前aop:aspect内定义的元素访问到，为了能被整个aop:config元素中定义的所有增强访问，则必须在aop:config下定义切点。

2.如果在aop:config元素下直接定义aop:pointcut，必须保证aop:pointcut在aop:aspect之前定义。aop:config下还可以定义aop:advisor，三者在aop:config中的配置有先后顺序的要求：首先必须是aop:pointcut，然后是aop:advisor，最后是aop:aspect。而在aop:aspect中定义的aop:pointcut则没有先后顺序的要求，可以在任何位置定义。

aop:pointcut：用来定义切入点，该切入点可以重用；

aop:advisor：用来定义只有一个通知和一个切入点的切面；

aop:aspect：用来定义切面，该切面可以包含多个切入点和通知，而且标签内部的通知和切入点定义是无序的；和advisor的区别就在此，advisor只包含一个通知和一个切入点。

3.在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式 execution(* com.sample.service.impl...(..)) execution()是最常用的切点函数，其语法如下所示：

整个表达式可以分为五个部分： (1)、execution(): 表达式主体。

(2)、第一个号：表示返回类型，号表示所有的类型。

(3)、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

(4)、第二个号：表示类名，号表示所有的类。

(5)、(..):最后这个星号表示方法名，号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

5.2 注解配置

新建注解类：

@Component
@Aspect
public class AopAspectJ {
    /**
     * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的
     */
    public static final String EDP="execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))";

    /**
     * 切面的前置方法 即方法执行前拦截到的方法
     * 在目标方法执行之前的通知
     * @param jp
     */
    @Before(EDP)
    public void doBefore(JoinPoint jp){

        System.out.println("=========执行前置通知==========");
    }

    /**
     * 在方法正常执行通过之后执行的通知叫做返回通知
     * 可以返回到方法的返回值 在注解后加入returning
     * @param jp
     * @param result
     */
    @AfterReturning(value=EDP,returning="result")
    public void doAfterReturning(JoinPoint jp,String result){
        System.out.println("===========执行后置通知============");
    }

    /**
     * 最终通知：目标方法调用之后执行的通知（无论目标方法是否出现异常均执行）
     * @param jp
     */
    @After(value=EDP)
    public void doAfter(JoinPoint jp){
        System.out.println("===========执行最终通知============");
    }

    /**
     * 环绕通知：目标方法调用前后执行的通知，可以在方法调用前后完成自定义的行为。
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around(EDP)
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable{

        System.out.println("======执行环绕通知开始=========");
        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值
        // 调用proceed()方法，就会触发切入点方法执行
        Object result=pjp.proceed();
        System.out.println("输出,方法名：" + method + ";目标对象：" + target + ";返回值：" + result);
        System.out.println("======执行环绕通知结束=========");
        return result;
    }

    /**
     * 在目标方法非正常执行完成, 抛出异常的时候会走此方法
     * @param jp
     * @param ex
     */
    @AfterThrowing(value=EDP,throwing="ex")
    public void doAfterThrowing(JoinPoint jp,Exception ex) {
        System.out.println("===========执行异常通知============");
    }
}

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:context="http://www.springframework.org/schema/context"
       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/context
         http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:component-scan base-package="com.yuanqinnan.aop" ></context:component-scan>
    <!-- 声明spring对@AspectJ的支持 -->
    <aop:aspectj-autoproxy/>
    <!--目标类-->
    <bean name="employeeService" class="com.yuanqinnan.aop.EmployeeServiceImpl"></bean>
</beans>

测试：

@Test
public void fun4(){
    ApplicationContext act =  new ClassPathXmlApplicationContext("META-INF/applicationContext.xml");
    EmployeeService employeeService = (EmployeeService) act.getBean("employeeService");
    employeeService.addEmployee(null);
}

结果：

pringAOP的知识就总结到这里