Spring BeanFactory进阶指南：从入门到大神

Spring BeanFactory进阶指南：从入门到大神

引用

CSDN

等

14

来源

1.

https://blog.csdn.net/FebruaryQ/article/details/138688014

2.

https://blog.csdn.net/2401_86626301/article/details/144450399

3.

https://blog.csdn.net/m0_51176516/article/details/139415462

4.

https://blog.csdn.net/qq_44858608/article/details/139604054

5.

https://blog.csdn.net/Kaiser__/article/details/136532780

6.

https://blog.csdn.net/isea533/article/details/78072133

7.

https://blog.csdn.net/mamamalululu00000000/article/details/107813432

8.

https://blog.csdn.net/m0_51176516/article/details/139409214

9.

https://www.cnblogs.com/lilyflower/articles/18314018

10.

https://www.cnblogs.com/kukuxjx/p/18213361

11.

https://www.cnblogs.com/kukuxjx/p/18060839

12.

https://developer.aliyun.com/article/1085947

13.

https://springdoc.cn/spring-prototype-bean-runtime-arguments/

14.

https://www.cnblogs.com/TheMagicalRainbowSea/p/18168814

在Spring框架中，BeanFactory作为基础的IoC容器，负责管理bean的生命周期和依赖注入。对于想要深入掌握Spring框架的开发者来说，理解BeanFactory的高级配置和扩展能力是必不可少的。本文将带你深入探索BeanFactory的高级特性，从基础概念到实战应用，逐步掌握这个核心组件的精髓。

在开始进阶学习之前，让我们先回顾一下BeanFactory的基本概念和使用方法。BeanFactory是Spring框架中最基础的IoC容器接口，它提供了获取和管理bean实例的核心方法。最常用的实现类是DefaultListableBeanFactory。

下面是一个简单的示例，展示了如何创建BeanFactory实例并注册bean定义：

package com.cherry.chapter1.a02;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

public class TestBeanFactory {

    public static void main(String[] args) {
        // 创建一个 beanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // 添加一些bean的定义(描述信息)(类型，作用域，初始化方法。销毁方法等等)
    }
}

接下来，我们可以通过BeanDefinition对象来描述bean的定义信息，包括类型、作用域、初始化方法等：

// 创建一个 BeanDefinition
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class)
                                        .setScope("singleton").getBeanDefinition();
// 将beanDefinition注册到beanFactory中
beanFactory.registerBeanDefinition("config",beanDefinition);

ConfigurableBeanFactory是BeanFactory的一个子接口，提供了更多可配置的选项，使我们能够灵活地管理和调整Bean工厂的行为和属性。这个接口是实现高级配置的关键。

设置类加载器

在某些场景下，我们可能需要为Bean工厂指定特定的类加载器。这可以通过ConfigurableBeanFactory的setBeanClassLoader()方法来实现：

// 获取ConfigurableBeanFactory实例
ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
// 设置类加载器
beanFactory.setBeanClassLoader(new MyCustomClassLoader());

注册自定义Scope

Spring框架默认提供了几种作用域（如singleton、prototype、request等），但有时我们需要自定义作用域。这可以通过实现Scope接口并使用CustomScopeConfigurer来完成。

首先，创建一个自定义的Scope实现：

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

import java.util.HashMap;
import java.util.Map;

public class ThreadLocalScope implements Scope {

    private final ThreadLocal<Map<String, Object>> threadScope = ThreadLocal.withInitial(HashMap::new);

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadScope.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }

    @Override
    public Object remove(String name) {
        return threadScope.get().remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        // 实现销毁回调
    }

    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Override
    public String getConversationId() {
        return null;
    }
}

然后，使用CustomScopeConfigurer将自定义Scope注册到Spring容器中：

@Configuration
public class CustomScopeConfigurer implements BeanFactoryPostProcessor {

    private final Map<String, Scope> scopes = new HashMap<>();

    public void addScope(String scopeName, Scope scope) {
        scopes.put(scopeName, scope);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableBeanFactory beanFactory) {
        scopes.forEach(beanFactory::registerScope);
    }
}

在配置类中使用自定义Scope：

@Configuration
public class AppConfig {

    @Autowired
    private CustomScopeConfigurer customScopeConfigurer;

    @PostConstruct
    public void init() {
        customScopeConfigurer.addScope("thread", new ThreadLocalScope());
    }
}

为了更好地理解这些高级特性的实际应用，让我们通过Spring容器启动过程的源码解析来深入分析。

当Spring容器启动时，会依次执行以下关键步骤：

1. 解析配置类：将XML文件或配置类解析为BeanDefinition对象，并注册到BeanDefinitionRegister中。

2. 刷新容器：调用refresh()方法，这是容器初始化的核心逻辑。

3. 获取Bean工厂：通过obtainFreshBeanFactory()方法获取Bean工厂，期间会判断工厂是否存在，如果存在则销毁关闭并重新创建。

4. 设置Bean工厂属性：通过prepareBeanFactory(beanFactory)方法设置Bean工厂的属性，如类加载器、忽略的接口、环境相关的单例Bean等。

5. 后置处理Bean工厂：postProcessBeanFactory(beanFactory)方法允许在Bean定义加载完毕后进行自定义扩展。例如，可以修改特定bean的定义信息：

class MyApplicationContext extends ClassPathXmlApplicationContext{
    public MyApplicationContext(String s){
        super(s);
    }
    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("user");
        PropertyValue propertyValue=new PropertyValue("name", "www.so.com");
        beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
    }
}

6. 调用BeanFactory后置处理器：执行invokeBeanFactoryPostProcessors(beanFactory)方法，处理BeanFactoryPostProcessors及其子接口BeanDefinitionRegistryPostProcessor。

7. 注册Bean后置处理器：通过registerBeanPostProcessors(beanFactory)方法注册所有实现了BeanPostProcessors接口的类。

8. 初始化上下文相关组件：如MessageSource、事件派发器、监听器等。

通过以上步骤，我们可以看到ConfigurableBeanFactory在容器初始化过程中的重要作用。它不仅提供了基本的bean管理功能，还允许开发者进行深度定制和扩展。

在实际项目中，合理利用BeanFactory的高级配置能力可以带来以下好处：

1. 灵活性提升：通过自定义类加载器，可以实现更复杂的类加载策略，满足特定场景需求。

2. 性能优化：自定义Scope可以更精细地控制bean的生命周期，避免不必要的资源消耗。

3. 代码解耦：通过配置化的方式管理bean，使得业务代码与框架解耦，提高可维护性。

4. 功能扩展：利用BeanFactoryPostProcessor等机制，可以方便地添加自定义逻辑，实现功能扩展。

掌握这些高级特性需要一定的实践积累，但一旦熟练运用，将能显著提升开发效率和系统性能。

通过本文的介绍，相信你对BeanFactory的高级配置有了更深入的理解。在实际开发中，不妨尝试将这些特性应用到你的项目中，相信会带来意想不到的收获。