Spring AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP的做法是将通用、与业务无关的功能抽象封装为切面类

切面可配置在目标方法的执行前、后运行，真正做到即插即用，在不修改源码的情况下，对程序进行扩展

AOP底层使用动态代理

有接口情况，使用JDK动态代理没有接口情况，使用CGLIB动态代理

需要使用 Proxy类的newProInstance方法

static Object  newProxyInstance(ClassLoader loader,类[]interfaces,InvocationHandler h)
//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序

参数解读：

参数一：类加载器

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

参数三：实现这个接口InvacationHandler，创建代理对象，写增强的部分

1.创建接口

public interface UserDao {
    public int add(int a,int b);

    public String update(String id);
}

2.创建被增强的类

public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        System.out.println("方法obj被执行了...");
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

3.创建增强类

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

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
        UserDaoImpl obj=new UserDaoImpl();
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(obj));
        int sum = userDao.add(1, 2);
        System.out.println(sum);
    }
}
class UserDaoProxy implements InvocationHandler {
    private Object obj;

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

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

Aspectj不是Spring组成部分，独立AOP框架，一般把Aspectj和Spring框架一起使用，进行AOP操作

基于xml配置文件实现基于注解方式实现

maven

        org.springframework
        spring-context
        5.3.10


        org.springframework
        spring-aop
        5.3.10


        org.aspectj
        aspectjweaver
        1.5.4

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

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

配置文件

创建类，在类里面定义方法

import org.springframework.stereotype.Component;

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

创建增强类

package com.spring.aop.aopanno;

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

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

    
    @Before(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void before(){
        System.out.println("before.....");
    }

    
    @After(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void after(){
        System.out.println("after.....");
    }

    
    @AfterReturning(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }

    
    @AfterThrowing(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.....");
    }

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