动态加载新实现类后更新Spring Bean：关联Bean重建原因及解决方法

类路径上存在接口IServiceA及其默认实现类ServiceA0，二者由AppClassLoader加载，实例被注入至其他Bean中。现在希望调用REST API加载该接口的新实现类，创建实例并更新注入关系。以下代码看似可行，但销毁旧Bean后，其他Bean（如MainController）会被重建，请问原因是什么？该如何修复？

@Component(value = "serviceA")
public class ServiceA0 implements IServiceA {
}

@RestController
@RequestMapping("/api")
public class MainController {

    @Autowired
    @Lazy
    @Qualifier("serviceA")
    private IServiceA service;
    @Autowired
    private ConfigurableApplicationContext context;
    private URLClassLoader loader;

    @GetMapping("/f0/")
    public void f0() {
        service.print();
    }
    @GetMapping("/f1/{className}")
    public void f1(@PathVariable String className) throws Exception {
        System.out.println("i'm "+this+", my classloader = "+this.getClass().getClassLoader());
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getBeanFactory();
        if(beanFactory.containsSingleton("serviceA")) {
            beanFactory.destroySingleton("serviceA");
            System.out.println("destroySingleton");
        }
        if(beanFactory.containsBeanDefinition("serviceA")) {
            beanFactory.removeBeanDefinition("serviceA");
            System.out.println("removeBeanDefinition");
        }
        if(loader != null) {
            System.out.println("unload service "+service+" and loader "+loader);
            service = null;
            loader = null;
            System.gc();
        }
        loader = new URLClassLoader("ClassLoaderFor"+className
                , new URL[]{new URL("file:///.../target/classes/")}
                , IServiceA.class.getClassLoader());
        Class<?> clazz = loader.loadClass(className);
        IServiceA newService = (IServiceA) clazz.getDeclaredConstructor().newInstance();
        context.getBeanFactory().registerSingleton("serviceA", newService);
        service.print();
        System.out.println("new service "+service+" and loader "+loader);
    }
}

1. 依赖连锁销毁机制：MainController作为单例Bean，通过@Autowired直接依赖serviceA。当调用destroySingleton("serviceA")销毁旧实例时，Spring容器会检查所有依赖该Bean的单例Bean，判定这些Bean的依赖已失效，因此会销毁并重建这些依赖Bean（包括MainController）以保证容器内Bean状态的一致性。
2. @Lazy的局限性：@Lazy仅延迟serviceA的首次初始化，无法改变Spring容器对依赖关系的跟踪逻辑。当旧实例被销毁后，容器依然会识别到MainController的依赖缺失，触发重建流程。

方案1：通过代理层隔离直接依赖 #

新增代理类封装IServiceA的实例获取逻辑，让MainController依赖代理而非直接依赖IServiceA实例，切断Spring对动态替换Bean的依赖跟踪：

@Component
public class ServiceAProxy implements IServiceA {
    @Autowired
    private ConfigurableApplicationContext context;

    @Override
    public void print() {
        // 每次调用都从容器取最新的serviceA实例
        IServiceA service = context.getBean("serviceA", IServiceA.class);
        service.print();
    }
}

修改MainController的依赖与逻辑：

@RestController
@RequestMapping("/api")
public class MainController {
    @Autowired
    private ServiceAProxy serviceProxy;
    @Autowired
    private ConfigurableApplicationContext context;
    private URLClassLoader loader;

    @GetMapping("/f0/")
    public void f0() {
        serviceProxy.print();
    }

    @GetMapping("/f1/{className}")
    public void f1(@PathVariable String className) throws Exception {
        System.out.println("i'm "+this+", my classloader = "+this.getClass().getClassLoader());
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getBeanFactory();
        if(beanFactory.containsSingleton("serviceA")) {
            beanFactory.destroySingleton("serviceA");
            System.out.println("destroySingleton");
        }
        if(beanFactory.containsBeanDefinition("serviceA")) {
            beanFactory.removeBeanDefinition("serviceA");
            System.out.println("removeBeanDefinition");
        }
        if(loader != null) {
            System.out.println("unload service and loader "+loader);
            loader = null;
            System.gc();
        }
        loader = new URLClassLoader("ClassLoaderFor"+className
                , new URL[]{new URL("file:///.../target/classes/")}
                , IServiceA.class.getClassLoader());
        Class<?> clazz = loader.loadClass(className);
        IServiceA newService = (IServiceA) clazz.getDeclaredConstructor().newInstance();
        context.getBeanFactory().registerSingleton("serviceA", newService);
        serviceProxy.print();
        System.out.println("new service "+newService+" and loader "+loader);
    }
}

方案2：手动维护实例引用，脱离Spring依赖管理 #

移除@Autowired注解，手动初始化和更新IServiceA实例，让Spring容器不跟踪该依赖关系：

@RestController
@RequestMapping("/api")
public class MainController {
    private IServiceA service;
    @Autowired
    private ConfigurableApplicationContext context;
    private URLClassLoader loader;

    // 初始化时获取默认实例
    @PostConstruct
    public void init() {
        this.service = context.getBean("serviceA", IServiceA.class);
    }

    @GetMapping("/f0/")
    public void f0() {
        service.print();
    }

    @GetMapping("/f1/{className}")
    public void f1(@PathVariable String className) throws Exception {
        System.out.println("i'm "+this+", my classloader = "+this.getClass().getClassLoader());
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getBeanFactory();
        if(beanFactory.containsSingleton("serviceA")) {
            beanFactory.destroySingleton("serviceA");
            System.out.println("destroySingleton");
        }
        if(beanFactory.containsBeanDefinition("serviceA")) {
            beanFactory.removeBeanDefinition("serviceA");
            System.out.println("removeBeanDefinition");
        }
        if(loader != null) {
            System.out.println("unload service "+service+" and loader "+loader);
            service = null;
            loader = null;
            System.gc();
        }
        loader = new URLClassLoader("ClassLoaderFor"+className
                , new URL[]{new URL("file:///.../target/classes/")}
                , IServiceA.class.getClassLoader());
        Class<?> clazz = loader.loadClass(className);
        IServiceA newService = (IServiceA) clazz.getDeclaredConstructor().newInstance();
        context.getBeanFactory().registerSingleton("serviceA", newService);
        // 手动更新本地引用
        this.service = newService;
        service.print();
        System.out.println("new service "+service+" and loader "+loader);
    }
}

关键注意事项 #

• 核心思路是切断Spring容器对动态替换Bean的依赖跟踪，避免销毁旧实例时触发依赖Bean的重建。
• 动态类加载后，需手动释放旧实例和类加载器的引用，辅助GC回收，避免类加载泄漏。

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