AOP

AOP原理

概念

1. 面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2. 不修改源代码，在主干功能里添加新功能。

底层原理

AOP底层使用动态代理，分别针对有无接口分为两种。

一、有接口，使用JDK动态代理，创建接口实现类代理对象，增强类方法。

使用Proxy类里面的方法创建代理对象

第一参数：类加载器

第二参数：增强方法所在类的实现接口，支持多个接口

第三参数：实现这个接口InvocationHandler（调用处理器），创建代理对象，写增强的部分。

代码实现：

写注解扫包类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "spring5_1")
public class SpringConfig {
}

待增强方法所在类，及其接口

//待增强方法所在类
import org.springframework.stereotype.Service;

@Service
public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("原方法");
        return a+b;
    }
}
//接口
public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

接口代理对象代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;

@Service
public class UserDaoProxy implements InvocationHandler {

    //把需要增强的代理对象传进来
    //有参构造传递
    @Autowired
    private UserDao userDao;

    //增强逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法之前执行。。。"+method.getName()+":传递的参数。。。"+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(userDao,args);
        //方法之后
        System.out.println("方法之后执行。。。"+userDao);
        return res;
    }
}

测试：

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.lang.reflect.Proxy;

public class TestX {
    @Test
    public void test1(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = (UserDaoImpl)context.getBean("userDaoImpl");
        UserDaoProxy userDaoProxy = (UserDaoProxy)context.getBean("userDaoProxy");
        UserDao dao = (UserDao)Proxy.newProxyInstance(UserDaoProxy.class.getClassLoader(), interfaces, userDaoProxy);
        int result = dao.add(1,2);
        System.out.println("result:"+result);
    }
}

测试结果：

二、没有接口，使用CGLIB动态代理，创建子类的代理对象，增强类的方法

AOP注解实现

AOP术语

对于AOP的实现也是可以基于xml配置文件或者基于注解方法实现，但是一般情况下使用注解方式更方便，所以这里讲解注解方式。

应用框架，那么我们就需要引入jar包依赖，但是注意Spring框架一般都是基于AspectJ实现AOP操作的，AspectJ是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用。

切入点表达式

1. 切入点表达式作用：知道对哪个类里面的哪个方法进行增强

2. 语法结构：execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

   注：可以用*号代替表示全部，返回类型可以省略

3. 举例：

   • 对 com.pro.dao.CarDao 里面的add进行增强

     execution(* com.pro.dao.CarDao.add(…))

   • 对 CarDao里面的所有方法增强

     execution(* com.pro.dao.CarDao.*(…))

   • 对dao包下所有类的所有方法增强

     execution(* com.pro.dao.* .*(…))

第一步：写配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = "spring5_1")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {
}

注：对于组件扫描之前讲过了还是一样的，对于EnableAspectJAutoProxy默认为false，所以这里要配置为true。

第二步：写需增强类，以及增强代理类

User:里面有add方法，我们对这个方法进行增强

import org.springframework.stereotype.Service;

@Service
public class User {
    public void add(){
        System.out.println("add....");
    }
}

UserProxy:这个类我们设置为代理增强类，对其进行注解配置。

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

@Service
@Aspect
public class UserProxy {

    //将相同切入点表达式抽取出来
    @Pointcut(value = "execution(* spring5_1.service.User.add(..))")
    public void pointMethod(){

    }

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

    @After(value = "pointMethod()")
    public void after(){
        System.out.println("最终通知...");
    }

    @AfterReturning(value = "pointMethod()")
    public void afterReturning(){
        System.out.println("后置通知。。");
    }

    @AfterThrowing(value = "pointMethod()")
    public void afterThrowing(){
        System.out.println("异常通知");
    }

    @Around(value = "pointMethod()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前、、、");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后。。。。");
    }
}

注：

1. @Aspect代表这个类为代理类
2. @Before、@After、@AfterThrowing、@AfterReturning、@Around分别代表刚才所描述的五个通知注解，注解里的value可以设置为刚才将的切入点表达式，也可以将其抽取出来，用@pointcut注解

测试代码：

    @Test
    public void test2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();
    }

测试结果：

注：异常通知是待增强方法出现异常之后才会运行的，现将add方法里面写一个异常，来看看其效果。

可以看到，最终通知就类似于finally，是一定会执行的，然后异常通知也会执行。

增强优先级

在我们写代码的过程很有可能碰到这种情况，就是有多个增强代理类，那么这时候我们就需要对其排序，设置优先级，从而达成一个具有增强执行顺序的作用，注解的方式为在代理类前加注解@Order(优先级数),优先级数从0开始，且越小优先级越高。