AOP基本原理 --- Spring

AOP

面向切面编程，利用AOP可以对业务逻辑的各个方面进行隔离，从而降低各部分之间的耦合度，提高程序的可重用性，提高开发效率。

即：不修改源码的前提下，在主干功能里添加新功能，用以增强原有方法

AOP底层使用动态代理

1.有接口，使用JDK动态代理。

​ 通过创建接口实现类代理对象，增强类的方法

2.没有接口，使用CGLIB动态代理。

​ 创建子类代理对象，增强类的方法

JDK动态代理

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

java.lang.reflact.Proxy

调用newProxyInstance方法

static Object new ProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)

//返回指定接口的代理实现类实例，该方法调用分派给指定的调用处理程序
    
//loader 类加载器
//interfaces 增强方法所在的类，这个类实现的接口，支持多个接口
//h 实现这个接口 InvocationHandler，创建代理对象，写增强的部分

AOP操作

术语：
1.连接点 类中可以被增强的方法被称为连接点
2.切入点 实际被增强的方法
3.通知 实际增强的逻辑部分称为通知
分类：前置通知、后置通知、环绕通知、异常通知、最终通知
4.切面 把通知应用到切入点的过程

Spring框架一般基于AspectJ实现AOP操作。AspectJ不是Spring组成部分。

AspectJ实现AOP操作

1.基于xml配置文件实现
2.基于注解实现

切入点表达式
利用切入点表达式，对需要增强的方法进行定位

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

举例 1：对 dao.BookDao 类里面的 add 进行增强
execution(* dao.BookDao.add(..))

举例 2：对 dao.BookDao 类里面的所有的方法进行增强
execution(* dao.BookDao.* (..))

举例 3：对 dao 包里面所有类，类里面所有方法进行增强
execution(* dao.*.* (..))

举例

//被增强的类
@Component
public class User {
    public void add() {
        //int i = 10/0;
        System.out.println("add.......");
    }
}

//增强的类
@Component
@Aspect  //生成代理对象
//@Order(3)
public class UserProxy {

    //相同切入点抽取
    /*
    @Pointcut(value = "execution(* AOP.aopAnno.User.add(..))")
    public void pointdemo() {}
    */

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* AOP.aopAnno.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* AOP.aopAnno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知
    @After(value = "execution(* AOP.aopAnno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知
    @AfterThrowing(value = "execution(* AOP.aopAnno.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "execution(* AOP.aopAnno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
    }
}

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean07.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

执行结果：

环绕之前.........
before.........
add.......
环绕之后.........
after.........
afterReturning.........