spring AOP学习

AOP概念

面向切面（方面）编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，在不改变源代码的情况下添加新的功能，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率（如声明式事务管理）。

AOP底层原理

AOP底层为动态代理实现，主要有jdk动态代理和cglib动态代理。

jdk动态代理实现

在有接口的情况下，使用jdk动态代理，创建接口的实现类代理对象，增强类的方法，实现如下：
创建UserDao接口

package dao;

public interface UserDao {
    void print();
}

创建UserDaoImpl类实现UserDao并重写方法

package dao;

import org.springframework.stereotype.Repository;

public class UserDaoImpl implements UserDao{

    @Override
    public void print() {
        System.out.println("hello userDaoImpl");
    }
}

创建测试类JdkProxy

package proxy;

import dao.UserDao;
import dao.UserDaoImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(
                JdkProxy.class.getClassLoader(),
                new Class[]{UserDao.class},
                new UserDaoProxy(userDaoImpl)
        );
        dao.print();
    }
}

/**
 * 实现InvocationHandler接口，并且重写invoke方法实现增强
 */
class UserDaoProxy implements InvocationHandler {
    private Object object;

    public UserDaoProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强：方法执行前执行");
        Object obj = method.invoke(object, args);
        System.out.println("后置增强，方法执行后执行");
        return obj;
    }
}

执行结果

cglib动态代理实现

在没有接口的情况下，使用cglib动态代理，创建类的子类的代理对象，增强类的方法

AOP的术语

1、连接点：可以被增强的方法；

2、切入点：实际被增强的方法；

3、通知（增强）：增强的逻辑，比如在方法执行前输出一句话，这个输出语句就是通知（增强）；
通知主要分为五种：
（1）前置通知（@Before）：方法执行前增强；
（2）后置通知（@AfterReturning）：方法执行后增强；
（3）环绕通知（@Around）：方法执行前后都增强；
（4）异常通知（@AfterThrowing）：抛出异常时增强；
（5）最终通知（@After）：无论如何都会增强，类似finally；

4、切面：将通知应用到切入点的过程（是一个动作）；

基于注解实现AOP

先要引入aspectj依赖，xml也要引入aop命名空间
创建User类（被增强的类）

package aop;

import org.springframework.stereotype.Component;

@Component
public class User {
    public void print() {
        System.out.println("print");
    }
}

创建TestAop类（增强类）

package aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//生成代理对象
@Aspect
@Component
public class TestAop {

    //前置通知
    @Before("execution(* aop.User.print())")
    public void before() {
        System.out.println("before");
    }

    //后置通知
    @AfterReturning("execution(* aop.User.print())")
    public void last() {
        System.out.println("last");
    }

    //环绕通知
    @Around("execution(* aop.User.print())")
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("before1");
        point.proceed();
        System.out.println("after1");
    }
    
    //异常通知
    @AfterThrowing("execution(* aop.User.print())")
    public void exception() {
        System.out.println("exception");
    }

    //最终通知
    @After("execution(* aop.User.print())")
    public void after() {
        System.out.println("after");
    }
}

创建bean.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="aop"></context:component-scan>

    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

创建测试类MyTest

import aop.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;

public class MyTest {
    @Test
    public void testAop() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.print();
    }
}

执行结果

修改User类

package aop;

import org.springframework.stereotype.Component;

@Component
public class User {
    public void print() {
        int a = 1 / 0;
        System.out.println("print");
    }
}

执行结果

发生异常之后只有前置前置通知，异常通知，后置通知和环绕通知的前半部分执行

抽取公共切入点

当多个增强具有同一个切入点的时候，可以使用@Pointcut注解抽取公共切入点

package aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//生成代理对象
@Aspect
@Component
public class TestAop {

    @Pointcut("execution(* aop.User.print())")
    public void point() {

    }
    
    //前置通知
    @Before("point()")
    public void before() {
        System.out.println("before");
    }

    //后置通知
    @AfterReturning("point()")
    public void last() {
        System.out.println("last");
    }

    //环绕通知
    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before1");
        joinPoint.proceed();
        System.out.println("after1");
    }

    //异常通知
    @AfterThrowing("point()")
    public void exception() {
        System.out.println("exception");
    }

    //最终通知
    @After("point()")
    public void after() {
        System.out.println("after");
    }
}

执行结果

多个增强类排序

当有多个增强类对一个类增强的时候，可以使用@Order(数字值)注解排序，数字越小优先级越高
创建TestAop2

package aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Order(1)
public class TestAop2 {

    @Pointcut("execution(* aop.User.print())")
    public void point() {

    }

    @Before("point()")
    public void before() {
        System.out.println("testAop2");
    }
}

TestAop

package aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//生成代理对象
@Aspect
@Component
@Order(2)
public class TestAop {

    @Pointcut("execution(* aop.User.print())")
    public void point() {

    }
    //前置通知
    @Before("point()")
    public void before() {
        System.out.println("before");
    }
}

执行结果

execution的配置规则：
execution([返回类型] [包名] [类名]
[方法名] [参数])，其中 返回值类型 ，方法名，方法参数 是必需的，通配符可以使用 *，如果方法不需要参数可以写()

基于xml配置实现AOP

被增强类 User

package aop;

public class User {
    public void print() {
        System.out.println("print");
    }
}

增强类 TestAop

package aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class TestAop {
    //前置通知
    public void before() {
        System.out.println("before");
    }

    //后置通知
    public void last() {
        System.out.println("last");
    }

    //环绕通知
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before1");
        joinPoint.proceed();
        System.out.println("after1");
    }

    //异常通知
    public void exception() {
        System.out.println("exception");
    }

    //最终通知
    public void after() {
        System.out.println("after");
    }
}

配置文件bean1.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="user" class="aop.User"/>
    <bean id="testAop" class="aop.TestAop"/>

    <!--配置aop-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcut" expression="execution(* aop.User.print(..))"/>
        <!--配置切面-->
        <aop:aspect id="a" ref="testAop">
            <!--配置增强类型,method的值要在增强类中声明，否则会报BeanCreationException异常-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
            <aop:after-returning method="last" pointcut-ref="pointcut"/>
            <aop:after-throwing method="exception" pointcut-ref="pointcut"/>
            <aop:around method="around" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

测试类MyTest

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

public class MyTest {
    @Test
    public void testAop() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.print();
    }
}

执行结果