类库开发中基于Spring DI实现动态配置多实例注入的方案问询

Spring是否适用？ #

完全适用。你的类库虽不是独立可执行应用，但Spring提供了轻量级的依赖注入工具类，无需启动完整Spring上下文即可实现需求，不会给依赖你的应用带来过重负担。

基于Spring的实现步骤 #

1. 定义配置类 #

先明确Config结构，包含各接口实现类的选择标识：

public class Config {
    private String barImplType; // 可选值："BarOne"或"BarTwo"
    private String playerImplType;
    // 其他依赖的选择标识，以及对应的getter/setter
}

2. 实现FooFactory类 #

核心逻辑：根据Config动态匹配对应接口实现类，手动触发Spring的@Autowired注入逻辑。需要用到Spring的AutowiredAnnotationBeanPostProcessor（处理注解注入）和DefaultListableBeanFactory（轻量级Bean容器）。

import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;

public class FooFactory {

    // 预注册所有可能的实现类到Bean容器
    private static final DefaultListableBeanFactory beanFactory;

    static {
        beanFactory = new DefaultListableBeanFactory();
        // 注册Autowired注解处理器
        AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();
        processor.setBeanFactory(beanFactory);
        beanFactory.addBeanPostProcessor(processor);

        // 注册Bar的所有实现类
        beanFactory.registerBeanDefinition("barOne", 
            BeanDefinitionBuilder.genericBeanDefinition(BarOne.class).getBeanDefinition());
        beanFactory.registerBeanDefinition("barTwo", 
            BeanDefinitionBuilder.genericBeanDefinition(BarTwo.class).getBeanDefinition());
        // 同理注册Player的所有实现类，比如PlayerOne、PlayerTwo等
    }

    public static Foo create(Config config) {
        // 1. 根据Config获取对应实现类实例
        Bar bar = getBarInstance(config.getBarImplType());
        Player player = getPlayerInstance(config.getPlayerImplType());

        // 2. 注册当前配置对应的实例为临时Bean
        beanFactory.registerSingleton("currentBar", bar);
        beanFactory.registerSingleton("currentPlayer", player);

        // 3. 创建Foo实例并触发依赖注入
        Foo foo = new Foo();
        beanFactory.autowireBean(foo);

        // 4. 清理临时Bean，避免影响下一次创建
        beanFactory.destroySingleton("currentBar");
        beanFactory.destroySingleton("currentPlayer");

        return foo;
    }

    private static Bar getBarInstance(String barImplType) {
        return switch (barImplType) {
            case "BarOne" -> beanFactory.getBean(BarOne.class);
            case "BarTwo" -> beanFactory.getBean(BarTwo.class);
            default -> throw new IllegalArgumentException("不支持的Bar实现类：" + barImplType);
        };
    }

    private static Player getPlayerInstance(String playerImplType) {
        // 实现Player实例的匹配逻辑，同Bar的处理方式
    }
}

优化点 #

如果实现类较多，可通过包扫描自动注册，避免手动逐个添加：

import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;

// 替换静态代码块中的手动注册逻辑
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(beanFactory);
scanner.scan("com.yourpackage.bar.impl", "com.yourpackage.player.impl");

替代方案：Google Guice #

若不想依赖Spring，Google Guice是更轻量的DI框架，适合类库场景：

1. 定义动态绑定Module #

import com.google.inject.AbstractModule;

public class FooModule extends AbstractModule {
    private final Config config;

    public FooModule(Config config) {
        this.config = config;
    }

    @Override
    protected void configure() {
        // 根据Config绑定Bar到对应实现类
        switch (config.getBarImplType()) {
            case "BarOne" -> bind(Bar.class).to(BarOne.class);
            case "BarTwo" -> bind(Bar.class).to(BarTwo.class);
            default -> throw new IllegalArgumentException("不支持的Bar实现类");
        }
        // 同理绑定Player接口到对应实现类
    }
}

2. 实现FooFactory #

import com.google.inject.Guice;
import com.google.inject.Injector;

public class FooFactory {
    public static Foo create(Config config) {
        Injector injector = Guice.createInjector(new FooModule(config));
        return injector.getInstance(Foo.class);
    }
}

这种方式代码更简洁，学习成本低，适合轻量级类库使用。

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