Spring中Map类型Bean的元素销毁方法配置问询

这个问题我之前也帮不少开发者解决过——当你把多个Producer实例打包成Map集合返回成Bean时，Spring默认只会管集合本身的生命周期，不会自动处理集合里每个元素的销毁逻辑。下面给你几个实用的解决方案，你可以根据自己的场景选最合适的：

方案1：让Producer类本身支持Spring生命周期（最直接，若能修改类） #

如果Producer是你自己的代码，或者有权修改源码的话，直接在它的销毁方法上加上@PreDestroy注解，或者让它实现DisposableBean接口：

public class Producer {
    // ... 其他业务方法

    @PreDestroy
    public void close() {
        // 这里写你的销毁逻辑，比如关闭连接、释放资源
    }
}

这样不管Producer是在集合里还是单独的Bean，Spring都会在上下文关闭时自动调用它的close方法。但如果Producer是第三方类没法修改源码，这个方案就不适用了。

方案2：将每个Producer单独注册为Spring Bean（推荐，适配动态配置场景） #

如果是从外部配置动态创建Producer，更推荐的方式是把每个Producer都注册成独立的Spring Bean，再把它们收集到Map里。这样每个Producer都会被Spring完整管理，你可以通过@Bean(destroyMethod = "close")指定销毁方法。

具体实现步骤：

1. 先在配置文件里定义好各个Producer的配置，比如：

producers.user-producer.url=http://user-service
producers.order-producer.url=http://order-service

2. 在配置类里用@ConfigurationProperties绑定配置，再动态注册每个Producer Bean：

@Configuration
@ConfigurationProperties(prefix = "producers")
public class ProducerConfiguration {
    // 绑定配置文件里的所有Producer配置，key是Producer名称，value是对应属性
    private Map<String, ProducerProps> producerPropsMap;

    // 注册所有Producer到Map中（供业务代码使用）
    @Bean("producers")
    public Map<String, Producer> producers(ApplicationContext context) {
        Map<String, Producer> producerMap = new HashMap<>();
        producerPropsMap.keySet().forEach(name -> {
            Producer producer = context.getBean(name + "Producer", Producer.class);
            producerMap.put(name, producer);
        });
        return producerMap;
    }

    // 动态注册每个Producer为独立Bean，并指定销毁方法
    @Bean
    public BeanDefinitionRegistryPostProcessor producerBeanRegistry() {
        return registry -> {
            producerPropsMap.forEach((name, props) -> {
                BeanDefinition beanDef = BeanDefinitionBuilder
                        .genericBeanDefinition(Producer.class)
                        .addConstructorArgValue(props.getUrl())
                        .setDestroyMethodName("close") // 这里指定销毁方法
                        .getBeanDefinition();
                registry.registerBeanDefinition(name + "Producer", beanDef);
            });
        };
    }

    // 辅助类：绑定配置的属性
    public static class ProducerProps {
        private String url;

        // Getter & Setter
        public String getUrl() { return url; }
        public void setUrl(String url) { this.url = url; }
    }

    // Getter & Setter for producerPropsMap
    public Map<String, ProducerProps> getProducerPropsMap() {
        return producerPropsMap;
    }
    public void setProducerPropsMap(Map<String, ProducerProps> producerPropsMap) {
        this.producerPropsMap = producerPropsMap;
    }
}

这种方式的好处是每个Producer都是Spring托管的Bean，生命周期完全由Spring控制，包括销毁方法的调用，动态配置场景下也能灵活适配任意数量的Producer。

方案3：在集合Bean里手动处理销毁逻辑（适合受限场景） #

如果上面两种方案都不适用（比如不能修改Producer，也不能单独注册Bean），你可以让集合Bean的持有者手动接管销毁逻辑：

@Configuration
public class ProducerConfiguration implements DisposableBean {
    private Map<String, Producer> producers;

    @Bean("producers")
    public Map<String, Producer> producers() {
        producers = new HashMap<>();
        // 从外部配置创建Producer实例并放入Map
        producers.put("user", new Producer("http://user-service"));
        producers.put("order", new Producer("http://order-service"));
        return producers;
    }

    @Override
    public void destroy() throws Exception {
        if (producers != null) {
            // 遍历Map，手动调用每个Producer的close方法
            producers.values().forEach(producer -> {
                try {
                    producer.close();
                } catch (Exception e) {
                    // 这里可以加日志记录异常，避免一个实例销毁失败影响其他
                    System.err.println("Failed to close producer: " + producer);
                }
            });
        }
    }
}

或者你也可以单独注册一个销毁处理器Bean，不用让配置类实现接口：

@Configuration
public class ProducerConfiguration {
    @Bean("producers")
    public Map<String, Producer> producers() {
        Map<String, Producer> producers = new HashMap<>();
        // 初始化逻辑
        return producers;
    }

    @Bean
    public DisposableBean producerDestroyer(@Qualifier("producers") Map<String, Producer> producers) {
        return () -> producers.values().forEach(producer -> {
            try {
                producer.close();
            } catch (Exception e) {
                // 异常处理
            }
        });
    }
}

这种方式的核心是手动触发每个Producer的销毁方法，缺点是需要自己处理异常和执行顺序，但在受限场景下非常实用。

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