前言

AOP(Aspect OrientedProgramming)：面向切面编程，面向切面编程（也叫面向方面编程），是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

一、动态代理

动态代理是AOP实现的关键技术之一。动态代理通过创建一个代理对象来代替原始对象执行目标方法，并在目标方法的前后插入额外的逻辑（切面），从而实现对目标方法的增强。

• JDK动态代理：Java提供的动态代理机制，它基于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。JDK动态代理只能代理实现了接口的类。

• CGLIB代理：Spring框架在Spring Boot后更改为了使用CGLIB库来实现动态代理。CGLIB通过子类继承的方式动态插入需要的内容，并调用父类的方法实现。因此，CGLIB可以代理没有实现接口的类。

传统方式：

• 自定义代理类：

package com.test;
 
import cn.hutool.core.date.DateUtil;
 
//用户服务接口
interface UserService {
    //登入
    void login();
    //登出
    void logout();
}
 
//用户服务实现类
class UserServiceImpl implements UserService {
    @Override
    public void login() {
        System.out.println(">>>>>>>登入<<<<<<<<");
        //睡眠3秒，方便看日志时间
        try{
            Thread.sleep(3000l);
        }catch (Exception e){
        }
    }
    @Override
    public void logout() {
        System.out.println(">>>>>>>登出<<<<<<<<");
        //睡眠3秒，方便看日志时间
        try{
            Thread.sleep(3000l);
        }catch (Exception e){
        }
    }
}
 
//用户代理对象
public class UserServiceProxy implements UserService {
    //代理对象
    private UserService userService;
    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }
 
    @Override
    public void login() {
        before();
        userService.login();
        after();
    }
 
    @Override
    public void logout() {
        before();
        userService.logout();
        after();
    }
 
    //调用方法之前执行
    private void before() {
        System.out.println("日志开始" + DateUtil.now());
    }
 
    //调用方法之后执行
    private void after() {
        System.out.println("日志结束" + DateUtil.now());
    }
 
 
    public static void main(String[] args) {
        //创建用户实现类
        UserServiceImpl userService = new UserServiceImpl();
        //创建用户代理类
        UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
        //执行代理方法,登入
        userServiceProxy.login();
        System.out.println("==========================");
        //执行代理方法,登出
        userServiceProxy.logout();
    }
}
 

• 执行结果：

日志开始2024-11-04 16:46:22
>>>>>>>登入<<<<<<<<
日志结束2024-11-04 16:46:25
==========================
日志开始2024-11-04 16:46:25
>>>>>>>登出<<<<<<<<
日志结束2024-11-04 16:46:28

动态代理方式：

• jdk动态代理

package com.test;
 
import cn.hutool.core.date.DateUtil;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
 
 
//用户服务接口
interface UserService {
    //登入
    void login();
 
    //登出
    void logout();
}
 
//用户服务实现类
class UserServiceImpl implements UserService {
    @Override
    public void login() {
        System.out.println(">>>>>>>登入<<<<<<<<");
        try {
            Thread.sleep(3000l);
        } catch (Exception e) {
        }
    }
 
    @Override
    public void logout() {
        System.out.println(">>>>>>>登出<<<<<<<<");
        try {
            Thread.sleep(3000l);
        } catch (Exception e) {
        }
    }
}
 
//实现InvocationHandler接口
class LogInvocationHandler implements InvocationHandler {
    //代理对象
    private UserService userService;
    public LogInvocationHandler(UserService userService) {
        this.userService = userService;
    }
 
    //代理方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(userService, args);
        after();
        return invoke;
    }
 
    // 调用invoke方法之前执行
    private void before() {
        System.out.println("日志开始" + DateUtil.now());
    }
    // 调用invoke方法之后执行
    private void after() {
        System.out.println("日志结束" + DateUtil.now());
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 1. 创建被代理的对象，UserService接口的实现类
        UserServiceImpl userService = new UserServiceImpl();
        // 2. 获取对应的 ClassLoader
        ClassLoader classLoader = userService.getClass().getClassLoader();
        // 3. 获取所有接口的Class，这里的UserServiceImpl只实现了一个接口UserService，
        Class[] interfaces = userService.getClass().getInterfaces();
        // 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用，这里创建的是一个自定义的日志处理器，须传入实际的执行对象 userServiceImpl
        LogInvocationHandler logHandler = new LogInvocationHandler(userService);
        /*
		   5.根据上面提供的信息，创建代理对象 在这个过程中，
               a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
               b.然后根据相应的字节码转换成对应的class，
               c.然后调用newInstance()创建代理实例
		 */
        UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
        proxy.login();
        System.out.println("=================");
        proxy.logout();
    }
}

• cglib动态代理

package com.test;
 
import cn.hutool.core.date.DateUtil;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
 
import java.lang.reflect.Method;
 
 
//用户服务实现类
class UserServiceImpl {
    public void login() {
        System.out.println(">>>>>>>登入<<<<<<<<");
        try {
            Thread.sleep(3000l);
        } catch (Exception e) {
        }
    }
 
    public void logout() {
        System.out.println(">>>>>>>登出<<<<<<<<");
        try {
            Thread.sleep(3000l);
        } catch (Exception e) {
        }
    }
}
 
 
class LogInvocationHandler implements MethodInterceptor {
 
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        // 注意这里是调用 invokeSuper 而不是 invoke，否则死循环，methodProxy.invokesuper执行的是原始类的方法，method.invoke执行的是子类的方法
        Object result = methodProxy.invokeSuper(o, objects);
        after();
        return result;
    }
 
    // 调用方法之前执行
    private void before() {
        System.out.println("日志开始" + DateUtil.now());
    }
 
    // 调用方法之后执行
    private void after() {
        System.out.println("日志结束" + DateUtil.now());
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        LogInvocationHandler logInvocationHandler = new LogInvocationHandler();
        Enhancer enhancer = new Enhancer();
        //设置超类，cglib是通过继承来实现的
        enhancer.setSuperclass(UserServiceImpl.class);
        enhancer.setCallback(logInvocationHandler);
        //创建代理类
        UserServiceImpl userService = (UserServiceImpl) enhancer.create();   
        userService.login();
        userService.logout();
    }
}
 

执行结果：

日志开始2024-11-04 16:56:03
>>>>>>>登入<<<<<<<<
日志结束2024-11-04 16:56:07
=================
日志开始2024-11-04 16:56:07
>>>>>>>登出<<<<<<<<
日志结束2024-11-04 16:56:10

传统方式与动态代理对比：

传统的方式，需要在每个方法加上before()方法和after()方法，这样每次新增一个方法就需要加上这两个日志记录方法，与业务代码耦合；使用jdk动态代理或者cglib动态代理可以将业务代码与日志方法进行隔离，不需要针对每个方法进行前后加日志记录方法。

jdk与cglib对比：

• JDK 动态代理只需要实现 InvocationHandler 接口，重写 invoke 方法便可以完成代理的实现，是利用反射生成代理类 Proxyxx.class 代理类字节码，并生成对象，所以只能代理接口是因为代理类本身已经extends了Proxy，而java是不允许多重继承的，但是允许实现多个接口，基于接口设计实现的，如果没有接口，会抛异常。
• CGLIB动态代理可以代理没有实现接口的类，这是通过生成目标类的子类来实现的。这使得CGLIB在某些情况下比Java内置的动态代理更加灵活和强大。然而，需要注意的是，由于CGLIB通过继承来实现代理，因此它不能代理那些被标记为final的类或方法。

二、AOP与动态代理的关系

在Spring AOP中，动态代理是实现AOP原理的关键技术。Spring AOP通过动态代理技术，在目标方法执行前后插入切面逻辑，从而实现对目标方法的增强。

• 切面逻辑的实现：通过定义切面类，并在切面类中编写前置通知、后置通知、返回通知、异常通知等增强处理逻辑。

• 代理对象的创建：Spring AOP根据目标对象是否实现了接口，选择使用JDK动态代理或CGLIB代理来创建代理对象。

• 切面逻辑的插入：在调用代理对象的方法时，代理对象会根据配置文件或注解等方式，判断是否需要在目标方法前后插入切面逻辑。如果需要插入，则在目标方法执行之前调用切面的前置通知，在目标方法执行之后调用切面的后置通知等。

使用场景：日志记录，性能统计，安全控制，权限管理，事务处理,异常处理,资源池管理。

三、AOP原理

AOP是面向对象编程（OOP）的一种补充，它将程序运行过程分解成各个切面，以在不修改源代码的情况下实现功能的增强。AOP的核心概念包括：

• 切面（Aspect）：切面用于组织多个Advice（增强处理），Advice放在切面中定义。

• 连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或异常的抛出。在Spring AOP中，连接点总是方法的调用。

• 增强处理（Advice）：AOP框架在特定的切入点执行的增强处理。

• 切入点（Pointcut）：可以插入增强处理的连接点。简而言之，当某个连接点满足指定要求时，该连接点将被添加增强处理，该连接点也就变成了切入点。

代码演示：

示例：使用Aop记录用户系统操作日志

• 定义注解

/**
* 系统日志注解
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AutoLog {
 
	/**
	 * 日志内容
	 * 
	 * @return
	 */
	String value() default "";
 
	/**
	 * 日志类型
	 * 
	 * @return 0:操作日志;1:登录日志
	 */
	int logType() default 0;
	
	/**
	 * 操作日志类型
	 * 
	 * @return （1查询，2添加，3修改，4删除）
	 */
	int operateType() default 0;
}

• 定义日志实体类

/**
 * 日志对象
 * cloud api 用到的接口传输对象
 */
@Data
public class LogDTO  {
 
 
    /**日志类型(0:操作日志;1:登录日志;*/
    private Integer logType;
 
    /**操作类型(1:添加;2:修改;3:删除;) */
    private Integer operateType;
 
    /** ip */
    private String ip;
 
    /**请求类型*/
    private String requestType;
 
    /**请求方法 */
    private String method;
 
    /**操作人用户名称*/
    private String username;
 
    /**操作人用户账户*/
    private String userid;
 
}

• 定义切面类

/**
 *系统日志，切面处理类
 */
@Aspect
@Component
public class AutoLogAspect {
 
 
    @Pointcut("@annotation(com.das.common.aspect.annotation.AutoLog)")
    public void logPointCut() {
 
    }
 
    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;
 
        //保存日志
        saveSysLog(point, time, result);
 
        return result;
    }
 
    private void saveSysLog(ProceedingJoinPoint joinPoint, long time, Object obj) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
 
        LogDTO dto = new LogDTO();
        AutoLog syslog = method.getAnnotation(AutoLog.class);
        if(syslog != null){
            //注解上的描述,操作日志内容
            dto.setLogType(syslog.logType());
            dto.setLogContent(syslog.value());
            //请求的方法名
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = signature.getName();
            //获取request
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            //设置IP地址
            String ip = getIpAddr(request);
            //获取登录用户信息
            LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
            if(sysUser!=null){
                dto.setUserid(sysUser.getUsername());
                dto.setUsername(sysUser.getRealname());
            }
            dto.setIp(ip);
            dto.setLogType(syslog.logType());
            dto.setLogContent(syslog.value());
            dto.setOperateType(syslog.operateType());
            dto.setMethod(className + "." + methodName + "()");
        }
    }
 
    /**
     * 获取IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
        }
        return ip;
    }
}

• controller测试

 
@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {
 
    @AutoLog(value = "分页查询", logType = 0, operateType = 0)
    @GetMapping(value = "/list")
    public String queryPageList() {
        return "测试";
    }
 
}