阿里P8面试被问：Spring AOP Proxy创建出来的到底是个啥？

JavaEdge

修改于 2025-12-27 20:56:38

6410

文章被收录于专栏：JavaEdgeJavaEdge

本文已收录在Github，关注我，紧跟本系列专栏文章，咱们下篇再续！

🚀 魔都架构师 | 全网30W技术追随者
🔧 大厂分布式系统/数据中台实战专家
🏆 主导交易系统百万级流量调优 & 车联网平台架构
🧠 AIGC应用开发先行者 | 区块链落地实践者
🌍 以技术驱动创新，我们的征途是改变世界！
👉 实战干货：编程严选网

1 案例

直接访问被拦截类的属性抛NPE。

结算时，使用管理员用户的付款编号，User类：

public class User {

    /**
     * 用户的付款编号
     */
    private String payNum;
}

AdminUserService类

@Service
public class AdminUserService {

    // 管理员用户
    public final User admin = new User("202101166");

    public void login() {
        System.out.println("admin login...");
    }
}

修改CouponService类实现这个需求：在点券充值时，需管理员登录并使用其编号进行结算。

@Service
public class CouponService {

    @Autowired
    private AdminUserService adminUserService;

    public void deposit() throws Exception {
        System.out.println("Coupon depositing ...");
        CouponService couponService = ((CouponService) AopContext.currentProxy());
        couponService.pay();
    }
  
    public void pay() throws Exception {
        adminUserService.login();
        String payNum = adminUserService.admin.getPayNum();
        System.out.println("User pay num : " + payNum);
        System.out.println("Pay with WeChat Pay ...");
        // 模拟pay()方法调用耗时
        Thread.sleep(1000);
    }
}

执行deposit()，一切正常：

- Coupon depositing ...
- admin user login...
- User pay num : 202101166
- Pay with WeChat Pay ...
- Pay method time cost (ms) : 5168

这时，由于安全需要，需要管理员在登录时，记录一行日志以便于以后审计管理员操作，于是加个AOP配置：

@Aspect
@Service
public class AopConfig {

    @Before("execution(* com.javaedge.spring.aop.service.AdminUserService.login(..)) ")
    public void logAdminLogin(JoinPoint pjp) throws Throwable {
        System.out.println("admin login ...");
    }

执行deposit()，竟然直接抛 NPE：

public void pay() throws Exception {
    adminUserService.login();
    // npe
    String payNum = adminUserService.admin.getPayNum();

就多了个AOP切面，咋就NPE？debug看加入AOP后调用的对象：

AOP后的对象的确个代理对象，属性adminUser也的确是null，why？得理解Spring使用CGLIB生成Proxy的原理。

2 源码解析

正常情况下，AdminUserService只是普通对象，而AOP增强过的则是一个AdminUserService$$EnhancerBySpringCGLIB$$xxxx。

这个类实际上是AdminUserService的一个子类。它会重写所有public和protected方法，并在内部将调用委托给原始的AdminUserService实例。

从具体实现角度看，CGLIB中AOP的实现是基于org.springframework.cglib.proxy包中的如下两个接口：

Enhancer
MethodInterceptor

3 执行过程

定义自定义的MethodInterceptor，负责委托方法执行
创建Enhance，并设置Callback为上述MethodInterceptor
enhancer.create()创建代理

Spring的动态代理对象的初始化，在得到Advisors之后，会通过ProxyFactory.getProxy获取代理对象：

public Object getProxy(ClassLoader classLoader) {
	return createAopProxy().getProxy(classLoader);
}

以CGLIB的Proxy的实现类CglibAopProxy为例：

public Object getProxy(@Nullable ClassLoader classLoader) {
    // ...
    
    // 创建及配置 Enhancer
    Enhancer enhancer = createEnhancer();
    
    // ...
    
    // 获取Callback：包含DynamicAdvisedInterceptor，亦是MethodInterceptor
    Callback[] callbacks = getCallbacks(rootClass);
    
    // ...
    // 生成代理对象并创建代理（设置 enhancer 的 callback 值）
    return createProxyClassAndInstance(enhancer, callbacks);
    
    // ...
}

最后一般都会执行到CglibAopProxy子类

ObjenesisCglibAopProxy

createProxyClassAndInstance()

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
   // 创建代理类Class
   Class<?> proxyClass = enhancer.createClass();
   Object proxyInstance = null;
   // spring.objenesis.ignore 默认为false
   // 所以 objenesis.isWorthTrying() 一般为true
   if (objenesis.isWorthTrying()) {
      try {
         // 创建实例
         proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
      }
      catch (Throwable ex) {
          // ...
      }
   }
       
    if (proxyInstance == null) {
       // 普通反射方式创建实例
       try {
          Constructor<?> ctor = (this.constructorArgs != null ?
                proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
                proxyClass.getDeclaredConstructor());
          ReflectionUtils.makeAccessible(ctor);
          proxyInstance = (this.constructorArgs != null ?
                ctor.newInstance(this.constructorArgs) : ctor.newInstance());
      // ...
       }
    }
   // ...
   ((Factory) proxyInstance).setCallbacks(callbacks);
   return proxyInstance;
}

Spring会默认尝试使用objenesis方式实例化对象，如果失败则再次尝试使用常规方式实例化对象。objenesis方式实例化对象的流程。

objenesis方式最后使用JDK的ReflectionFactory.newConstructorForSerialization()实例化代理对象。

这种方式创建出来的对象不会初始化类成员变量。

案例的核心是代理类实例的默认构建方式很特别。

总结对比下通过反射来实例化对象的方式，包括：

java.lang.Class.newInsance()
java.lang.reflect.Constructor.newInstance()
sun.reflect.ReflectionFactory.newConstructorForSerialization().newInstance()

前两种初始化方式都会同时初始化类成员变量，但最后一种通过ReflectionFactory.newConstructorForSerialization().newInstance()实例化类，不会初始化类成员变量，这就是bug的答案。

4 修正

既然是因为无法直接访问被拦截类的成员变量，那就换个方式，在UserService里写个getUser()方法，从内部访问获取。在AdminUserService里加个getUser()：

@Service
public class AdminUserService {

    // 管理员用户
    public final User admin = new User("110");

    public void login() {
        System.out.println("admin login...");
    }

    public User getUser() {
        return admin;
    }
}

在CouponService通过getUser()获取User对象：

public void pay() throws Exception {
    adminUserService.login();
    String payNum = adminUserService.getUser().getPayNum();

观察到登录日志：

[http-nio-12345-exec-1] [INFO ] [o.s.web.servlet.DispatcherServlet:547 ] - Completed initialization in 6 ms

Coupon depositing ...
admin login ...
admin login...
User pay num : 110
Pay with WeChat Pay ...
Pay method time cost (ms) : 1006

既然代理类的类属性不会被初始化，为何可通过在AdminUserService里的getUser()获取代理类实例的属性？

createProxyClassAndInstance

创建代理类后，会调用setCallbacks来设置拦截后需要注入的代码：

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
   Class<?> proxyClass = enhancer.createClass();
   Object proxyInstance = null;
   if (objenesis.isWorthTrying()) {
      try {
         proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
      }
   // ...
   ((Factory) proxyInstance).setCallbacks(callbacks);
   return proxyInstance;
}

callbacks存在一种服务于AOP的DynamicAdvisedInterceptor，它的接口是MethodInterceptor（callback的子接口），实现了拦截方法intercept()

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    // ...
    TargetSource targetSource = this.advised.getTargetSource();
      // ...
      if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
         Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
         retVal = methodProxy.invoke(target, argsToUse);
      }
      else {
         // We need to create a method invocation...
         retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
      }
      retVal = processReturnType(proxy, target, method, retVal);
      return retVal;
   }
   // ...
}

当代理类方法被调用，会被Spring拦截，从而进入此intercept()，并在此方法中获取被代理的原始对象。

在原始对象中，类属性是被实例化过且存在的。因此代理类可通过方法拦截获取被代理对象实例的属性。

你改变一个属性，也可让产生的代理对象的属性值不为null。如修改启动参数