aop源码分析(一)——开启aop到代理类生成（未完成）

2021-09-28 01:53:47

我们都知道spring aop的底层是动态代理，这篇博客会分析下spring aop的实现原理。当然，spring aop的实现还是非常复杂的，这里会拆成多篇博客分析。

在分析spring aop之前，先弄明白spring aop实现了个什么样的功能。

从配置文件开始

先来看个例子（代码来自https://my.oschina.net/sniperLi/blog/491854）

<?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/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 激活组件扫描功能,在包com.hdj.learn.spring.aop及其子包下面自动扫描通过注解配置的组件 -->
    <context:component-scan base-package="com.hdj.learn.spring.aop"/>
    <!-- 激活自动代理功能 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

    <!-- 用户服务对象 -->
    <bean id="userService" class="com.hdj.learn.spring.aop.service.UserService" />

</beans>

//声明这是一个组件
@Component
//声明这是一个切面Bean
@Aspect
@Slf4j
public class ServiceAspect {

    //配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
    @Pointcut("execution(* com.hdj.learn.spring.aop.service..*(..))")
    public void aspect() {
    }

    /*
     * 配置前置通知,使用在方法aspect()上注册的切入点
     * 同时接受JoinPoint切入点对象,可以没有该参数
     */
    @Before("aspect()")
    public void before(JoinPoint joinPoint) {
        log.info("before " + joinPoint);
    }

    //配置后置通知,使用在方法aspect()上注册的切入点
    @After("aspect()")
    public void after(JoinPoint joinPoint) {
        log.info("after " + joinPoint);
    }

    //配置环绕通知,使用在方法aspect()上注册的切入点
    @Around("aspect()")
    public void around(JoinPoint joinPoint) {
        long start = System.currentTimeMillis();
        try {
            ((ProceedingJoinPoint) joinPoint).proceed();
            long end = System.currentTimeMillis();
            log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms!");
        } catch (Throwable e) {
            long end = System.currentTimeMillis();
            log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
        }
    }

    //配置后置返回通知,使用在方法aspect()上注册的切入点
    @AfterReturning("aspect()")
    public void afterReturn(JoinPoint joinPoint) {
        log.info("afterReturn " + joinPoint);
    }

    //配置抛出异常后通知,使用在方法aspect()上注册的切入点
    @AfterThrowing(pointcut = "aspect()", throwing = "ex")
    public void afterThrow(JoinPoint joinPoint, Exception ex) {
        log.info("afterThrow " + joinPoint + "\t" + ex.getMessage());
    }

}

通过xml 及注解的方式，我们就完成了最简单的spring aop的配置

客户端调用

//client 调用
public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:aop/applicationContext.xml");
    UserService person = (UserService) context.getBean("userService");
    person.getUser();
}

结果输出

看这里，我们在不改变userService的方法前提下，往person.getUser的方法之前，及方法之后，添加了代码。

于是，我们会从以下几个角度来分析源码：
1）最重要的，如何在不改变源码的前提下，往代码的前后增加代码
2）如何配置要在哪个方法前后增加代码

这篇博客先进行一个概述，细节会在后面几篇博客里分析。

aop:aspectj-autoproxy 开启自动代理

之前分析spring注解配置依赖注入时，我们有分析过annotation-config，aop和此处的处理方式一致，都是配置一个专门的解析器，对其进行解析。

追一下调用过程，大概流程如下：
1）注册 internalAutoProxyCreator 的实现类 AnnotationAwareAspectJAutoProxyCreator
2）如果配置了proxy-target-class 为true，将proxyTargetClass这个属性记录下来
3）expose-proxy 同样，如果存在，记录exposeProxy为true
4）注册该BeanDefinition

代理对象的创建

分析了spring aop的创建，继续分析spring aop

spring初始化到创建aop代理对象流程图

cglib实现

由于该代理对象没有实现接口，所以这里底层使用cglib对其进行增强

总结

有点事，今天就写到这里了2333，很多细节没有说清楚，后续会完善的。
后续会完善以下几点：
1）切面，通知的配置
2）方法增强原理
todo o(╥﹏╥)o

码农公寓