SpringBoot中获取Bean的7种方式与最佳实践-代码聚汇网

SpringBoot中获取Bean的7种方式与最佳实践

小叮当做事小丁当·2026-08-24·阅读 23 GEO检测（免费）

SpringBootBean获取ApplicationContext

|难度：普通|阅读约 25 分钟

1. 为什么需要获取Spring容器中的Bean？

在SpringBoot应用中，我们经常需要从容器中获取已经注册的Bean实例。这种需求主要源于以下几个场景：

框架扩展点开发：当我们实现一些Spring的扩展接口（如ApplicationContextAware）时，需要主动获取容器中的其他Bean来完成功能集成。
静态方法调用：在工具类等静态方法中，有时需要访问Spring管理的Bean，这时就需要通过特定方式从容器获取。
第三方库集成：某些第三方库需要手动获取Spring容器中的Bean进行配置或初始化。
动态代理场景：在AOP编程中，有时需要根据运行时条件动态获取不同的Bean实例。

注意：虽然获取Bean的方式有多种，但应当尽量避免滥用。过度依赖显式获取Bean会破坏Spring的依赖注入原则，导致代码耦合度增高。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 基础方式：通过ApplicationContext直接获取

2.1 注入ApplicationContext

最直接的方式是通过依赖注入获取ApplicationContext实例：

java复制@Service
public class MyService {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    public void someMethod() {
        MyBean bean = applicationContext.getBean(MyBean.class);
        // 使用bean...
    }
}

这种方式简单直接，但需要注意：

确保类本身是Spring管理的Bean（带有@Component等注解）
避免在构造函数中使用，因为此时注入尚未完成

2.2 使用BeanFactory接口

BeanFactory是ApplicationContext的父接口，也可以用于获取Bean：

java复制@Service
public class MyService {
    
    @Autowired
    private BeanFactory beanFactory;
    
    public void someMethod() {
        MyBean bean = beanFactory.getBean(MyBean.class);
        // 或者按名称获取
        MyBean beanByName = (MyBean) beanFactory.getBean("myBean");
    }
}

两者主要区别：

BeanFactory提供基础功能，ApplicationContext扩展了更多企业级特性
在大多数SpringBoot应用中，直接使用ApplicationContext即可

3. 实现ApplicationContextAware接口

对于非Spring管理的普通类，可以实现ApplicationContextAware接口：

java复制public class MyUtil implements ApplicationContextAware {
    
    private static ApplicationContext context;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        context = applicationContext;
    }
    
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }
}

使用方式：

java复制MyBean bean = MyUtil.getBean(MyBean.class);

注意事项：

需要将该类声明为Spring Bean（通过@Bean或@Component）
静态变量在多环境下可能导致问题（如测试环境）
不是线程安全的实现方式

4. 使用@PostConstruct初始化Bean引用

在某些场景下，我们可以在Bean初始化完成后立即获取依赖：

java复制@Service
public class OrderService {
    
    private ProductService productService;
    
    @Autowired
    private ApplicationContext context;
    
    @PostConstruct
    public void init() {
        this.productService = context.getBean(ProductService.class);
    }
}

这种方式的优点：

避免了在每次方法调用时都获取Bean
保持了代码的清晰性
适合那些在生命周期中不会改变的依赖

5. 通过ObjectProvider延迟获取

Spring 4.3+提供了ObjectProvider接口，可以更安全地获取Bean：

java复制@Service
public class PaymentService {
    
    @Autowired
    private ObjectProvider<PaymentStrategy> paymentStrategyProvider;
    
    public void processPayment(PaymentRequest request) {
        PaymentStrategy strategy = paymentStrategyProvider.getIfAvailable();
        if(strategy != null) {
            strategy.execute(request);
        }
    }
}

ObjectProvider的优势：

支持延迟查找
可以处理可选依赖
避免NoSuchBeanDefinitionException异常
支持流式操作（如orderedStream()）

6. 静态工具类模式

结合Spring的BeanFactoryPostProcessor，我们可以创建全局工具类：

java复制@Component
public class SpringContextHolder implements BeanFactoryPostProcessor {
    
    private static ConfigurableListableBeanFactory beanFactory;
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        SpringContextHolder.beanFactory = beanFactory;
    }
    
    public static <T> T getBean(Class<T> clazz) {
        return beanFactory.getBean(clazz);
    }
    
    public static Object getBean(String name) {
        return beanFactory.getBean(name);
    }
}

使用示例：

java复制UserService userService = SpringContextHolder.getBean(UserService.class);

这种方式的优缺点：

优点：全局可用，使用简单
缺点：破坏了IoC原则，测试困难，可能引起内存泄漏

7. 各种获取方式的对比与选型建议

方式	适用场景	线程安全	测试友好度	代码侵入性
@Autowired ApplicationContext	常规Spring Bean内部使用	是	高	低
ApplicationContextAware	工具类等非托管对象	需自行保证	中	中
@PostConstruct初始化	固定依赖且不常变化	是	高	低
ObjectProvider	可选依赖或延迟加载	是	高	低
静态工具类	无法注入的静态方法	需自行保证	低	高

选型建议：

优先使用依赖注入（@Autowired）
对于可选依赖，使用ObjectProvider
在必须使用静态方法的场景，考虑ApplicationContextAware
避免滥用静态工具类模式

8. 实际开发中的常见问题与解决方案

8.1 Bean循环依赖问题

当使用getBean()方法时，如果存在循环依赖，可能会抛出BeanCurrentlyInCreationException。解决方案：

使用setter注入替代构造器注入
使用@Lazy注解延迟初始化
重构代码消除循环依赖

8.2 多环境下的Bean获取

在测试环境中，可能会遇到Bean不存在的情况。建议：

java复制@Autowired(required = false)
private Optional<MyBean> myBean;

或者：

java复制try {
    MyBean bean = context.getBean(MyBean.class);
} catch (NoSuchBeanDefinitionException e) {
    // 处理Bean不存在的情况
}

8.3 性能考量

频繁调用getBean()方法会影响性能，特别是在循环中。最佳实践：

在初始化阶段获取并缓存Bean引用
对于原型(prototype)作用域的Bean，考虑使用ObjectProvider
避免在每次请求中都重新获取相同的Bean

9. 高级技巧：自定义Bean获取策略

对于复杂场景，可以实现自定义的Bean获取逻辑：

java复制public interface BeanLocator {
    <T> T getBean(Class<T> requiredType);
    
    default <T> T getBean(String name, Class<T> requiredType) {
        // 默认实现...
    }
}

@Component
public class SpringBeanLocator implements BeanLocator {
    
    @Autowired
    private ApplicationContext context;
    
    @Override
    public <T> T getBean(Class<T> requiredType) {
        return context.getBean(requiredType);
    }
}

这种模式的优势：

抽象了具体的获取方式
便于单元测试（可以mock BeanLocator）
可以在获取前后添加统一逻辑（如日志、监控）

10. SpringBoot特定场景下的Bean获取

10.1 在CommandLineRunner中获取Bean

java复制@Component
public class MyRunner implements CommandLineRunner {
    
    @Autowired
    private ApplicationContext context;
    
    @Override
    public void run(String... args) {
        MyService service = context.getBean(MyService.class);
        service.initialize();
    }
}

10.2 在Filter中获取Bean

由于Filter不是由Spring管理的，需要通过其他方式：

java复制public class MyFilter implements Filter {
    
    private MyService myService;
    
    @Override
    public void init(FilterConfig filterConfig) {
        ApplicationContext context = WebApplicationContextUtils
            .getRequiredWebApplicationContext(filterConfig.getServletContext());
        this.myService = context.getBean(MyService.class);
    }
}

10.3 在非托管对象中获取Bean

对于无法通过Spring管理的类，可以使用前面提到的ApplicationContextAware方式，或者：

java复制public class NonSpringClass {
    
    public static MyService getMyService() {
        return ApplicationContextProvider.getApplicationContext()
            .getBean(MyService.class);
    }
}

11. 测试环境中的特殊处理

在单元测试中，可能需要手动创建和获取Bean：

java复制@SpringBootTest
class MyServiceTest {
    
    @Autowired
    private ApplicationContext context;
    
    @Test
    void testBeanRetrieval() {
        MyService service = context.getBean(MyService.class);
        assertNotNull(service);
    }
}

对于非Spring测试：

java复制class PlainTest {
    
    @Test
    void testWithMockContext() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MyConfig.class);
        context.refresh();
        
        MyService service = context.getBean(MyService.class);
        // 测试逻辑...
    }
}

12. 性能优化与最佳实践

缓存频繁使用的Bean引用：对于单例Bean，可以在初始化阶段获取并保存引用
避免在循环中获取Bean：将getBean()调用移到循环外部
合理使用ObjectProvider：对于可能不存在的依赖，使用ObjectProvider更安全
注意原型作用域的Bean：每次getBean()都会创建新实例，确保这是你期望的行为
考虑使用方法注入：对于原型Bean，可以使用@Lookup注解的方法注入

java复制public abstract class MyAbstractClass {
    
    @Lookup
    protected abstract MyPrototypeBean createPrototypeBean();
    
    public void doSomething() {
        MyPrototypeBean bean = createPrototypeBean();
        // 使用bean...
    }
}

13. 安全注意事项

避免暴露ApplicationContext：特别是在Web环境中，不要将ApplicationContext暴露给不可信的代码
谨慎处理动态Bean获取：当根据用户输入决定获取哪个Bean时，要进行严格的验证
注意Bean的作用域：确保理解获取的Bean是单例还是原型，避免意外的状态共享
清理静态引用：对于使用静态方式持有ApplicationContext的类，在应用关闭时应该清理这些引用

14. 与其他Spring特性的集成

14.1 与@Conditional注解配合使用

可以根据条件动态决定是否获取某个Bean：

java复制public MyBean getMyBean() {
    try {
        return context.getBean(MyBean.class);
    } catch (NoSuchBeanDefinitionException e) {
        if (someCondition) {
            return new FallbackBean();
        }
        throw e;
    }
}

14.2 与@Profile注解结合

根据不同的profile获取不同的Bean实现：

java复制public DataSource getDataSource() {
    if (context.getEnvironment().acceptsProfiles("dev")) {
        return context.getBean(DevDataSource.class);
    } else {
        return context.getBean(ProdDataSource.class);
    }
}

14.3 与Spring Cloud集成

在Spring Cloud环境中，可以使用ServiceRegistry动态获取服务实例：

java复制@Autowired
private DiscoveryClient discoveryClient;

public ServiceInstance getServiceInstance(String serviceId) {
    List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
    // 选择合适的实例...
}

15. 未来演进与替代方案

随着Spring框架的发展，一些新的方式也值得关注：

函数式Bean注册：Spring 5.x引入了函数式注册Bean的方式

java复制GenericApplicationContext context = new GenericApplicationContext();
context.registerBean(MyBean.class, () -> new MyBean());
context.refresh();
MyBean bean = context.getBean(MyBean.class);

RSocket服务间调用：在响应式应用中，可以考虑使用RSocket而不是直接获取Bean
GraalVM原生镜像支持：在为GraalVM准备原生镜像时，某些动态获取Bean的方式可能需要调整

在实际项目中，选择哪种方式获取Bean应该基于具体需求、团队规范和性能要求综合考虑。记住，依赖注入是Spring的核心原则，显式获取Bean应该是最后的选择而非首选方案。