Spring框架学习笔记（2）——面向切面编程AOP

介绍

概念

面向切面编程AOP与面向对象编程OOP有所不同，AOP不是对OOP的替换，而是对OOP的一种补充，AOP增强了OOP。

假设我们有几个业务代码，都调用了某个方法，按照OOP的思想，我们就会将此方法封装在一个类中，之后通过对象.方法名调用

我们可以看作我们的业务代码被其他代码入侵或者是业务代码被其他与业务不相关的代码入侵了

这个时候，如果我们使用AOP进行编写代码，我们的业务代码就可以不需要写其他与业务相关的代码，这样就可以保证业务代码的纯洁性

AOP运行流程

通过配置文件，给各个业务方法标识切入点（PointCut），即切入点方法。
之后当程序运行到切入点方法的时候，就会发出一个通知（Advice），去通知执行某个切面方法（Aspect）

专业术语

Advice通知

PS：其实，这些通知就是相当于你可以在业务方法的执行前（前置通知）、执行中（环绕通知）、执行成功之后（后置通知）、发生异常（异常通知）、不管方法是发生异常还是执行成功（最终通知），执行某些与业务功能无关的功能代码。

这样就可以降低业务功能代码的入侵和污染

下面使用两种不同的方式来实现一个方法日志打印的简单例子

后置通知例子

下面的通知是基于xml配置的

1.添加依赖

除了之前的spring的jar包，还需要两个jar包，aopalliance.jar和aspectjweaver.jar

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>RELEASE</version>
</dependency>
<!-- aop需要的jar -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>RELEASE</version>
</dependency>
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>RELEASE</version>
</dependency>

2.业务代码

我编写了一个TeacherDao类，里面只有add和delete方法

package com.wan;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:34
 * @description
 */
public class TeacherDao {
    public void add(Teacher teacher) {
        System.out.println("往数据库中插入一条数据");
    }

    public void delete(Teacher teacher) {
        System.out.println("从数据库中删除一条数据");
    }
}

3.编写MyLogging.java

前面说过了通知具有五种类型，我们根据需要，选择合适的通知类型，让某个类实现通知对应的接口，这里其实就是相当于编写切面方法

我们日志输出，选择后置通知，也就是方法执行完成之后调用

MyLogging.java

package com.wan;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
public class MyLogging implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        String methodName = method.getName();//方法名
        int size = args.length;//参数个数
        System.out.println("调用了"+target+"的"+methodName+"方法，该方法的参数个数有"+size+"个");
    }
}

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

    <bean id="mylog" class="com.wan.MyLogging"/>
    <bean id="teacherdao" class="com.wan.TeacherDao"/>

    <aop:config>
        <aop:pointcut id="mypointcut" expression="execution(public void add(com.wan.Teacher))"/>
        <aop:advisor advice-ref="mylog" pointcut-ref="mypointcut"/>
    </aop:config>
</beans>

这里和之前一样，也需要引用aop命名空间，IDEA可以智能帮我们导入，输入<aop:，之后就会弹出提示

各元素和属性说明：

补充，关于expression的例子：

表达式要写在execution()的括号里面，多个条件可以使用or连接

5.测试

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
TeacherDao teacherdao = (TeacherDao) context.getBean("teacherdao");
teacherdao.add(new Teacher());

其他类型通知Advice使用

前置通知

前置通知和后置通知一样，也是实现对应的接口，然后重写before方法，这里就不过多说明了

异常通知

异常通知有点特殊，因为此接口是不需要重写方法的，但是，我们想要实现异常通知，得按照它定义的规则来

afterThrowing([Method method,Object[] args,Object target],Throwable ex)

1. 方法名必须是afterThrowing
2. 参数列表中的最后一个参数必须存在，可以是Throwable或者Throwable的子类
3. 方法列表的前三个参数要么都存在，要么一个都不存在

环绕通知

此通知是spring的最强扩展，因为环绕通知可以拦截方法，对方法的传入参数的数值、返回值进行更改，或者是决定方法是否执行，也可以对目标进行异常处理。

如果对破解有所了解的话，环绕通知还可以被称为hook，像Android的Xposed框架就是通过hook原理，来达到自由更改系统目的。
实现MethodInterceptor接口，重写其的invoke方法

invoke方法可以获得像之前的前置通知的三个参数，method，target，args，也可以获得返回值returnValue

package com.wan;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
public class MyLogging implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object target = invoke.getThis();
        Method method = invoke.getMethod();
        Object[] args = invoke.getArguments();
        //执行方法，获得返回值
        Object returnValue = invoke.proceed();
    }
}

基于注解配置使用

上面说的几个例子都是基于xml配置文件，我们可以使用注解，从而达到简化的目的

步骤

1. 导入相关jar（之前导入的那两个jar包）

2. 使用注解，标注类和方法

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

    <bean id="teacherdao" class="com.wan.TeacherDao"/>

    <aop:aspectj-autoproxy/>
    <bean class="com.wan.MyLogging"/>
</beans>

之后的测试代码和之前的一样

前置通知

package com.wan;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
@Aspect
public class MyLogging  {
    @Before("execution(public void add(com.wan.Teacher))")
    public void sayHello() {
        System.out.println("这是前置通知");
    }
}

注解使用挺简单的，大概看一下示例代码就能知道怎么使用了

获得三个参数target、args、method

AOP中有个JoinPoint的接口，此接口可以获得target、args、method这三个参数

package com.wan;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
@Aspect
public class MyLogging  {
    @AfterReturning(pointcut="execution(public boolean add(com.wan.Teacher))",returning="returnValue")
    public void test(JoinPoint jp,Object returnValue) {
        //上面的注解的returning属性把方法的返回值赋值给了参数returnValue
    }
}

环绕通知

环绕通知有个特殊的接口ProceedingJoinPoint，此接口是JoinPoint的子接口，比JoinPoint接口多了一个proceed方法，用于执行目的对象的方法获得返回值

package com.wan;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
@Aspect
public class MyLogging  {
    @Around("execution(public boolean add(com.wan.Teacher))")
    public void test(ProceedingJoinPoint jp) {
        Object returnValue = jp.proceed();
    }
}

异常通知

package com.wan;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * @author StarsOne
 * @date Create in  2019/9/25 0025 16:53
 * @description
 */
@Aspect
public class MyLogging  {
    @AfterThorwing(pointcut="execution(public boolean add(com.wan.Teacher))",throwing="e")
    public void test(JoinPoint jp,NullPointException e) {
        //上面的注解的throwing属性把异常赋值给了参数e
        //参数中指定了异常为空指针异常，所有，发生异常为空指针异常时候，异常通知才会调用此方法
    }
}

PS：除以上两种方式可以实现AOP，还有一种使用Schema进行配置，我看了一下步骤，觉得比上面两种还要繁琐，在这里就补充了