Spring 中的 ObjectProvider

一句话概括

ObjectProvider<T> 是 Spring 4.3 引入的依赖注入的"懒加载 + 安全容器"——它不直接给你 Bean 实例，而是给你一个"按需获取"的提供者，解决了可选依赖、延迟初始化、多 Bean 集合等痛点。

解决什么问题？

传统 @Autowired 的痛点	ObjectProvider 怎么解
依赖的 Bean 不存在 → 启动直接报错	getIfAvailable() 返回 null，优雅降级
想延迟获取 Bean（避免循环依赖/启动开销）	调用时才真正获取，天然懒加载
同类型有多个 Bean，想按条件选一个	getIfAvailable() + 自定义条件 / stream() 筛选
想拿同类型的所有 Bean	iterator() / stream() 遍历全部

接口核心方法

public interface ObjectProvider<T> extends Iterable<T> {

    // 1. 获取实例（不存在则抛 NoSuchBeanDefinitionException）
    T getObject() throws BeansException;

    // 2. 获取实例（不存在返回 null）
    T getIfAvailable() throws BeansException;

    // 3. 获取实例（不存在返回默认值）
    default T getIfAvailable(Supplier<T> defaultSupplier) { ... }

    // 4. 获取唯一实例（有多个候选时抛 NoUniqueBeanDefinitionException）
    T getIfUnique() throws BeansException;

    // 5. 遍历所有同类型 Bean（继承自 Iterable）
    Iterator<T> iterator();

    // 6. Stream 流式访问所有同类型 Bean
    Stream<T> stream();
}

使用场景与示例

1. 可选依赖 — Bean 可能不存在

@Service
public class NotificationService {

    // 如果 SmsSender 没有注册为 Bean，不会报错
    private final ObjectProvider<SmsSender> smsSenderProvider;

    public NotificationService(ObjectProvider<SmsSender> smsSenderProvider) {
        this.smsSenderProvider = smsSenderProvider;
    }

    public void notify(String msg) {
        SmsSender sender = smsSenderProvider.getIfAvailable();
        if (sender != null) {
            sender.send(msg);  // 有就用
        } else {
            System.out.println("SMS not available, skip");  // 没有就降级
        }
    }
}

2. 延迟获取 — 打破循环依赖 / 减少启动开销

@Component
public class A {
    // B 依赖 A，A 也依赖 B → 循环依赖
    // 用 ObjectProvider 延迟获取，调用时才解析，绕过启动期循环检查
    private final ObjectProvider<B> bProvider;

    public A(ObjectProvider<B> bProvider) {
        this.bProvider = bProvider;
    }

    public void doSomething() {
        bProvider.getObject().help();  // 运行时才拿 B，此时 B 已就绪
    }
}

3. 多 Bean 集合 — 遍历同类型所有实现

@Service
public class DataProcessor {

    private final ObjectProvider<DataFilter> filtersProvider;

    public DataProcessor(ObjectProvider<DataFilter> filtersProvider) {
        this.filtersProvider = filtersProvider;
    }

    public String process(String data) {
        // stream() 拿到所有 DataFilter 实现，组成过滤链
        return filtersProvider.stream()
                .reduce(data, (d, filter) -> filter.apply(d), (a, b) -> b);
    }
}

4. 条件选择 — 带默认值

@Component
public class CacheManager {

    private final CacheProvider cacheProvider;

    public CacheManager(ObjectProvider<CacheProvider> provider) {
        // 有自定义实现就用自定义，没有就用默认的本地缓存
        this.cacheProvider = provider.getIfAvailable(() -> new LocalCacheProvider());
    }
}

底层原理

注册阶段

Spring 容器解析 @Autowired / 构造器参数时，发现参数类型是 ObjectProvider<T>，不会去解析 T 对应的 Bean，而是直接注入一个 ObjectProvider 代理对象。

解析 @Autowired
  ├─ 类型是普通 Bean  → 立刻从容器获取/创建 Bean，注入实例
  └─ 类型是 ObjectProvider<T>  → 注入一个 Provider 代理，不解析 T

获取阶段

当你调用 getObject() / getIfAvailable() 等方法时，代理对象才去 BeanFactory.getBean() 真正解析：

// 简化版内部实现（Spring 的 DefaultListableBeanFactory 内部类）
class DependencyObjectProvider<T> implements ObjectProvider<T> {

    private final DependencyDescriptor descriptor;
    private final DefaultListableBeanFactory beanFactory;

    @Override
    public T getObject() {
        // 委托给 beanFactory，按 descriptor 解析
        return (T) beanFactory.getBean(descriptor);
    }

    @Override
    public T getIfAvailable() {
        if (beanFactory.containsBean(descriptor.getDependencyName())) {
            return getObject();
        }
        return null;
    }

    @Override
    public Iterator<T> iterator() {
        // 按类型查所有匹配 Bean
        return beanFactory.getBeansOfType(descriptor.getDependencyType())
                          .values().iterator();
    }
}

关键流程图

┌─────────────┐     注册时只注入代理      ┌──────────────────────┐
│  容器启动    │ ──────────────────────▶  │ ObjectProvider 代理   │
│  解析依赖    │    不触发 T 的创建        │ (持有 Descriptor +   │
└─────────────┘                          │  BeanFactory 引用)   │
                                         └──────────┬───────────┘
                                                    │
                      调用 getObject() / getIfAvailable() 时
                                                    │
                                                    ▼
                                         ┌──────────────────────┐
                                         │ BeanFactory.getBean() │
                                         │ 真正解析 & 创建 T     │
                                         └──────────────────────┘

对比其他方案

方案	可选依赖	懒加载	多 Bean	代码侵入
@Autowired(required=false)	✅	❌	❌	低
ObjectProvider<T>	✅	✅	✅	低
@Lazy @Autowired	❌	✅	❌	低
ApplicationContext.getBean()	✅	✅	✅	高（耦合容器）

ObjectProvider 是最优雅的方案——不耦合 ApplicationContext，不依赖注解组合，一个接口搞定可选 + 懒加载 + 多 Bean。

最佳实践

1. 构造器注入优先 — ObjectProvider 作为构造器参数，不可变、易测试
2. 可选依赖用 getIfAvailable() — 别用 getObject()，那会抛异常
3. 多实现用 stream() — 比 @Autowired List<T> 更灵活，支持过滤/排序
4. 别滥用 — 如果依赖一定是必须的，直接注入 Bean 更简洁

简单说：ObjectProvider 就是 Spring 给你发的一张提货券——你不提货，仓库不动；你提货时，仓库按需给你找。