面试题：Spring 中的 ObjectFactory 是什么？

02510

ObjectFactory 是 Spring 框架中的一个接口，用于延迟获取 Bean 实例。它提供了一种灵活的方式来获取 Bean，而不是在容器启动时就立即创建或注入 Bean。ObjectFactory 的主要作用是 延迟加载 和 按需获取 Bean。

1. ObjectFactory 的核心作用

ObjectFactory 的核心作用是：

  1. 延迟加载：
    • 只有在调用 getObject() 方法时，才会真正获取或创建 Bean 实例。
    • 避免在容器启动时立即创建所有 Bean，从而提高启动性能。
  2. 按需获取：
    • 允许在需要时动态获取 Bean 实例，而不是在注入时就固定依赖。
  3. 解决循环依赖：
    • 在某些场景下，ObjectFactory 可以用于解决 Spring 容器中的循环依赖问题。

2. ObjectFactory 的接口定义

ObjectFactory 接口定义如下：

@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}
@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}
@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}
  • getObject()：获取目标对象的实例。

3. ObjectFactory 的使用场景

ObjectFactory 通常用于以下场景：

（1）延迟加载 Bean

在某些情况下，Bean 的创建成本较高，或者不需要在容器启动时就立即创建。此时可以使用 ObjectFactory 延迟加载 Bean。

示例：

@Component
public class MyService {
    private final ObjectFactory<ExpensiveBean> expensiveBeanFactory;
    @Autowired
    public MyService(ObjectFactory<ExpensiveBean> expensiveBeanFactory) {
        this.expensiveBeanFactory = expensiveBeanFactory;
    }
    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanFactory.getObject();
        expensiveBean.performTask();
    }
}
@Component
public class MyService {
    private final ObjectFactory<ExpensiveBean> expensiveBeanFactory;

    @Autowired
    public MyService(ObjectFactory<ExpensiveBean> expensiveBeanFactory) {
        this.expensiveBeanFactory = expensiveBeanFactory;
    }

    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanFactory.getObject();
        expensiveBean.performTask();
    }
}
@Component
public class MyService {
    private final ObjectFactory<ExpensiveBean> expensiveBeanFactory;

    @Autowired
    public MyService(ObjectFactory<ExpensiveBean> expensiveBeanFactory) {
        this.expensiveBeanFactory = expensiveBeanFactory;
    }

    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanFactory.getObject();
        expensiveBean.performTask();
    }
}

（2）解决循环依赖

在 Spring 容器中，如果两个 Bean 相互依赖，可能会导致循环依赖问题。使用 ObjectFactory 可以打破这种循环依赖。

示例：

@Component
public class ServiceA {
    private final ObjectFactory<ServiceB> serviceBFactory;
    @Autowired
    public ServiceA(ObjectFactory<ServiceB> serviceBFactory) {
        this.serviceBFactory = serviceBFactory;
    }
    public void doSomething() {
        ServiceB serviceB = serviceBFactory.getObject();
        serviceB.doSomethingElse();
    }
}
@Component
public class ServiceB {
    private final ServiceA serviceA;
    @Autowired
    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }
    public void doSomethingElse() {
        // ...
    }
}
@Component
public class ServiceA {
    private final ObjectFactory<ServiceB> serviceBFactory;

    @Autowired
    public ServiceA(ObjectFactory<ServiceB> serviceBFactory) {
        this.serviceBFactory = serviceBFactory;
    }

    public void doSomething() {
        ServiceB serviceB = serviceBFactory.getObject();
        serviceB.doSomethingElse();
    }
}

@Component
public class ServiceB {
    private final ServiceA serviceA;

    @Autowired
    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public void doSomethingElse() {
        // ...
    }
}
@Component
public class ServiceA {
    private final ObjectFactory<ServiceB> serviceBFactory;

    @Autowired
    public ServiceA(ObjectFactory<ServiceB> serviceBFactory) {
        this.serviceBFactory = serviceBFactory;
    }

    public void doSomething() {
        ServiceB serviceB = serviceBFactory.getObject();
        serviceB.doSomethingElse();
    }
}

@Component
public class ServiceB {
    private final ServiceA serviceA;

    @Autowired
    public ServiceB(ServiceA serviceA) {
        this.serviceA = serviceA;
    }

    public void doSomethingElse() {
        // ...
    }
}

（3）动态获取 Bean

在某些场景下，需要根据运行时条件动态获取不同的 Bean 实例。此时可以使用 ObjectFactory 实现按需获取。

示例：

@Component
public class MyService {
    private final ObjectFactory<MyBean> myBeanFactory;
    @Autowired
    public MyService(ObjectFactory<MyBean> myBeanFactory) {
        this.myBeanFactory = myBeanFactory;
    }
    public void doSomething(boolean condition) {
        MyBean myBean = myBeanFactory.getObject();
        if (condition) {
            myBean.performTaskA();
        } else {
            myBean.performTaskB();
        }
    }
}
@Component
public class MyService {
    private final ObjectFactory<MyBean> myBeanFactory;

    @Autowired
    public MyService(ObjectFactory<MyBean> myBeanFactory) {
        this.myBeanFactory = myBeanFactory;
    }

    public void doSomething(boolean condition) {
        MyBean myBean = myBeanFactory.getObject();
        if (condition) {
            myBean.performTaskA();
        } else {
            myBean.performTaskB();
        }
    }
}
@Component
public class MyService {
    private final ObjectFactory<MyBean> myBeanFactory;

    @Autowired
    public MyService(ObjectFactory<MyBean> myBeanFactory) {
        this.myBeanFactory = myBeanFactory;
    }

    public void doSomething(boolean condition) {
        MyBean myBean = myBeanFactory.getObject();
        if (condition) {
            myBean.performTaskA();
        } else {
            myBean.performTaskB();
        }
    }
}

4. ObjectFactory 与 Provider 的区别

ObjectFactory 和 javax.inject.Provider 的功能类似，都用于延迟获取 Bean 实例。它们的区别如下：

特性ObjectFactoryProvider
所属框架Spring 框架。JSR-330 标准（Java 依赖注入规范）。
接口定义T getObject()。T get()。
使用场景主要用于 Spring 应用程序。适用于任何支持 JSR-330 的框架。

示例：使用 Provider

import javax.inject.Provider;
@Component
public class MyService {
    private final Provider<ExpensiveBean> expensiveBeanProvider;
    @Autowired
    public MyService(Provider<ExpensiveBean> expensiveBeanProvider) {
        this.expensiveBeanProvider = expensiveBeanProvider;
    }
    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanProvider.get();
        expensiveBean.performTask();
    }
}
import javax.inject.Provider;

@Component
public class MyService {
    private final Provider<ExpensiveBean> expensiveBeanProvider;

    @Autowired
    public MyService(Provider<ExpensiveBean> expensiveBeanProvider) {
        this.expensiveBeanProvider = expensiveBeanProvider;
    }

    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanProvider.get();
        expensiveBean.performTask();
    }
}
import javax.inject.Provider;

@Component
public class MyService {
    private final Provider<ExpensiveBean> expensiveBeanProvider;

    @Autowired
    public MyService(Provider<ExpensiveBean> expensiveBeanProvider) {
        this.expensiveBeanProvider = expensiveBeanProvider;
    }

    public void doSomething() {
        ExpensiveBean expensiveBean = expensiveBeanProvider.get();
        expensiveBean.performTask();
    }
}

5. 总结

ObjectFactory 是 Spring 框架中用于延迟获取 Bean 实例的接口，核心作用是延迟加载和按需获取 Bean。它的主要使用场景包括：

  1. 延迟加载 Bean：避免在容器启动时立即创建所有 Bean。
  2. 解决循环依赖：打破 Spring 容器中的循环依赖。
  3. 动态获取 Bean：根据运行时条件动态获取不同的 Bean 实例。

与 Provider 相比，ObjectFactory 是 Spring 特有的接口，功能类似但更贴近 Spring 的生态系统。理解 ObjectFactory 的作用和使用场景有助于在开发中更好地管理 Bean 的生命周期和依赖关系。

THE END
Spring 面试题
点赞10 分享
相关推荐
评论 抢沙发
头像
欢迎您留下宝贵的见解！
提交
头像

昵称

取消
昵称

请填写用户信息：

  • 昵称(必填)
  • 邮箱(必填)
表情
[aoman][baiyan][bishi][bizui][cahan][ciya][dabing][daku][deyi][doge][fadai][fanu][fendou][ganga][guzhang][haixiu][hanxiao][zuohengheng][zhuakuang][zhouma][zhemo][zhayanjian][zaijian][yun][youhengheng][yiwen][yinxian][xu][xieyanxiao][xiaoku][xiaojiujie][xia][wunai][wozuimei][weixiao][weiqu][tuosai][tu][touxiao][tiaopi][shui][se][saorao][qiudale][se][qinqin][qiaoda][piezui][penxue][nanguo][liulei][liuhan][lenghan][leiben][kun][kuaikule][ku][koubi][kelian][keai][jingya][jingxi][jingkong][jie][huaixiao][haqian][aini][OK][qiang][quantou][shengli][woshou][gouyin][baoquan][aixin][bangbangtang][xiaoyanger][xigua][hexie][pijiu][lanqiu][juhua][hecai][haobang][caidao][baojin][chi][dan][kulou][shuai][shouqiang][yangtuo][youling]
代码

请输入代码：

确认
图片

    暂无评论内容

目录
目录