向非Spring管理对象注入Spring属性的优雅方案

嘿，这个场景我之前也踩过坑！第三方库这种自己内部实例化类、不给外部留构造方法的操作确实有点棘手，不过咱们可以借助Spring的特性来优雅搞定，给你几个实用的方案：

方案一：使用@Configurable + AspectJ编译时织入（最推荐） #

Spring默认只对自己创建的Bean做属性注入，但@Configurable注解能让Spring接管任何方式创建的类的注入逻辑，配合AspectJ的织入就能实现无侵入的属性注入。

步骤： #

1. 给你的CustomClass加上@Configurable注解，同时用@Value或@Autowired注入需要的属性：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configurable;

@Configurable
public static class CustomClass implements ExternalClass {
    @Value("${my.app.custom.property}")
    private String customProperty;

    @Override
    public Object create() {
        // 这里直接用customProperty就行啦
        System.out.println("使用注入的属性：" + customProperty);
        return new Object();
    }
}

2. 在Spring配置类中开启Spring Configured支持：

import org.springframework.context.annotation.EnableSpringConfigured;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableSpringConfigured
public class AppConfig {
    // 其他配置...
}

3. 添加必要的依赖（Maven为例）：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>你的Spring版本</version>
</dependency>

4. 开启AspectJ编译时织入：如果是Maven，需要在pom.xml中添加AspectJ插件，确保编译时把注入逻辑织入到CustomClass中。

原理：AspectJ会在CustomClass的构造方法执行时，自动触发Spring的属性注入逻辑，不管这个类是Spring创建的还是第三方库内部实例化的，都能完成注入。

方案二：手动从Spring上下文获取属性（无额外依赖） #

如果不想引入AspectJ，咱们可以通过一个上下文持有类，手动在create方法里获取属性。虽然有点"手动"，但胜在简单快速。

步骤： #

1. 创建一个ApplicationContextHolder类，用来持有Spring上下文：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }

    // 获取属性值
    public static String getProperty(String propertyKey) {
        return context.getEnvironment().getProperty(propertyKey);
    }

    // 获取自定义配置Bean（如果你的属性是封装在配置类里的）
    public static <T> T getConfigBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }
}

2. 在CustomClass的create方法里调用：

public static class CustomClass implements ExternalClass {
    @Override
    public Object create() {
        // 获取单个属性
        String customProperty = ApplicationContextHolder.getProperty("my.app.custom.property");
        
        // 如果是自定义配置类（比如@ConfigurationProperties的类）
        // MyAppConfig appConfig = ApplicationContextHolder.getConfigBean(MyAppConfig.class);
        
        // 业务逻辑...
        return new Object();
    }
}

注意：这个方案要确保ApplicationContextHolder被Spring正确扫描并初始化，不然会出现空指针。

方案三：让第三方库使用Spring管理的Bean（视库的API支持而定） #

如果第三方库允许你提供ExternalClass的实例（比如有setExternalClass方法、或者支持SPI方式加载），那咱们可以直接把CustomClass注册为Spring Bean，然后传给第三方库：

1. 把CustomClass变成Spring Bean：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public static class CustomClass implements ExternalClass {
    @Value("${my.app.custom.property}")
    private String customProperty;

    @Override
    public Object create() {
        // 使用属性...
        return new Object();
    }
}

2. 在Spring配置类中，获取CustomClass的实例并传给第三方库：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public ThirdPartyLibrary thirdPartyLibrary(CustomClass customClass) {
        ThirdPartyLibrary library = new ThirdPartyLibrary();
        // 假设第三方库有这个方法来设置自定义实现
        library.setExternalClass(customClass);
        return library;
    }
}

前提：第三方库必须支持外部传入ExternalClass的实例，如果它是完全自己内部new的CustomClass，那这个方案就用不了。

内容的提问来源于stack exchange，提问作者Nats