Spring 内部类获取不到@Value配置值问题排查（附Spring代理方式）

目录

一、实例问题

1、现象

2、原因

3、解决

二、Spring的代理模式

1、静态代理（Static Proxy）

1）原理

2）优缺点

3）代码实现

2、JDK动态代理（JDK Dynamic Proxy）

1）原理

2）优缺点

3）代码实现

3、cglib 代理（Code Generation Library Proxy）

1）原理

2）优缺点

3）代码实现

---

一、实例问题

1、现象

业务场景中出现过使用内部类获取属性的时候获取不到，导致业务逻辑执行异常，观察代码后发现原因是最底层有@Async的方法导致Spring代理方式变更，特此梳理一下。

如下代码结果展示

类代码

 
/**
 * @author YY-帆S
 * @Date 2024/4/16 21:16
 */
@Service
@Slf4j
public class TestProxy {
 
    @Value("${test.boolean:true}")
    public boolean aBoolean;
 
    public void testAQuery() {
        log.info("testAQuery:{}", aBoolean);
        TestProxy bean = SpringContextUtils.getBean(TestProxy.class);
        bean.testBQuery();
        bean.testCQuery();
    }
 
    public void testBQuery() {
        log.info("testBQuery:{}", aBoolean);
    }
 
    private void testCQuery() {
        log.info("testCQuery:{}", aBoolean);
    }
 
    @Component
    public class InnerClass {
        public void testInnerQuery() {
            log.info("testInnerQuery:{}", aBoolean);
        }
    }
 
//第一次 不加上
//  @Async
//第二次加上
    @Async
    public void testAsync() {
    }
}

 调用代码

    @Resource
    TestProxy testProxy;
 
    @Resource
    TestProxy.InnerClass innerClass;
 
    @GetMapping("testQuery")
    public CommonResult<Object> testQuery() {
        testProxy.testAQuery();
        innerClass.testInnerQuery();
        return new CommonResult<>();
    }

不加上@Asnyc的结果

加上@Async的结果

2、原因

加Async之前的bean属性，内部aBoolean=true

加Async之后的bean，内部aBoolean=false，（默认值）

可以观察到，加@Async或@Transcational 这类的注解时，会导致spring切换对类切换代理方式，为cglib的代理模式，翻了spring源码的话会发现，spring生成代理对象的时候使用了Objenesis来创建，Objenesis可以绕过构造方法以及相关的初始化来创建对象，所以生成的代理类中所有的属性全部都是空的。

参考文档：

 spring——事务动态代理造成属性为null_切面生成的cglb代理类里面的属性为null-CSDN博客

3、解决

1）减少直接读写属性，而是调用其中的方法

//类代码
 
@Service
@Slf4j
@Data
public class TestProxy {
 
    @Value("${test.boolean.b:true}")
    public Boolean bBoolean;
 
    @Async
    public void testAsync() {
    }
}
 
//……调用代码
    @Resource
    TestProxy testProxy;
 
    @GetMapping("testQuery")
    public CommonResult<Object> testQuery() {
        log.info("user func:{}", testProxy.getBBoolean());
        log.info("direct use: {}", testProxy.bBoolean);
        return new CommonResult<>();
    }
 

结果：使用方法获取属性则正常返回配置后的结果true，直接使用属性的为null 空

2）多自测，兄弟们，必现的case，测一下就知道了

二、Spring的代理模式

1、静态代理（Static Proxy）

1）原理

静态代理在编译时确定代理类，代理类和目标类都实现相同的接口。代理类在调用目标类的方法之前或之后添加一些额外的操作。

2）优缺点

优点

• 简单直观：实现简单，易于理解和调试。
• 编译时检查：代理类在编译时确定，可以进行类型检查。

缺点

• 代码冗余：每个接口需要对应一个代理类，导致代码量增加。
• 不灵活：代理逻辑在编译时确定，无法在运行时动态改变。
• 维护困难：如果接口方法增加或修改，代理类需要同步修改。

3）代码实现

public interface UserService {
    void addUser(String name);
}
 
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("Adding user: " + name);
    }
}
 
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;
 
    public UserServiceProxy(UserServiceImpl userService) {
        this.userService = userService;
    }
 
    @Override
    public void addUser(String name) {
        System.out.println("Before adding user");
        userService.addUser(name);
        System.out.println("After adding user");
    }
}
 
// 使用代理
public class Main {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy(userService);
        proxy.addUser("Alice");
    }
}

2、JDK动态代理（JDK Dynamic Proxy）

1）原理

JDK动态代理基于Java的反射机制，通过在运行时生成代理类来实现。代理类必须实现一个或多个接口。JDK动态代理使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来创建代理实例。

2）优缺点

优点

• 接口支持：适用于代理实现了接口的类。
• 轻量级：相比于CGLIB，JDK动态代理生成的代理类较轻量。
• 无需依赖第三方库：基于JDK自带的反射机制实现。

缺点

• 只能代理接口：目标类必须实现接口，如果没有接口则无法使用。
• 性能较低：反射机制相对较慢，性能不如CGLIB。

3）代码实现

public interface UserService {
    void addUser(String name);
}
 
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("Adding user: " + name);
    }
}
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class UserServiceProxy implements InvocationHandler {
    private Object target;
 
    public UserServiceProxy(Object target) {
        this.target = target;
    }
 
    public Object getProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method");
        Object result = method.invoke(target, args);
        System.out.println("After method");
        return result;
    }
}
 
// 使用代理
UserService target = new UserServiceImpl();
UserService proxy = (UserService) new UserServiceProxy(target).getProxy();
proxy.addUser("Alice");

3、cglib 代理（Code Generation Library Proxy）

1）原理

CGLIB代理通过生成目标类的子类并覆盖其方法来实现代理。它使用字节码增强技术。

2）优缺点

优点

• 无需接口：可以代理没有实现接口的类。
• 性能较高：通常情况下，CGLIB代理的性能比JDK动态代理高。

缺点

• 依赖第三方库：需要CGLIB库（Spring中已经包含）。
• 无法代理final类和方法：由于CGLIB通过生成子类来实现代理，final类和方法无法被代理。
• 内存开销大：生成子类会占用更多内存

3）代码实现

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
 
public class ProductService {
    public void addProduct(String name) {
        System.out.println("Adding product: " + name);
    }
}
 
public class ProductServiceProxy implements MethodInterceptor {
    private Object target;
 
    public ProductServiceProxy(Object target) {
        this.target = target;
    }
 
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
 
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method");
        return result;
    }
}
 
// 使用代理
ProductService target = new ProductService();
ProductService proxy = (ProductService) new ProductServiceProxy(target).getProxy();
proxy.addProduct("Laptop");

总结：

• JDK动态代理：适用于目标类实现接口的情况，轻量但性能较低，无法代理没有实现接口的类。
• CGLIB代理：适用于没有实现接口的类，性能较高但依赖第三方库，无法代理final类和方法。
• 静态代理：实现简单但不灵活，代码冗余，适用于代理逻辑固定的情况。

根据具体需求和应用场景，可以选择合适的代理模式。Spring默认选择JDK动态代理，如果目标类没有实现接口，则使用CGLIB代理。