编辑“︁Spring容器扩展点”︁（章节）

= Spring容器扩展点 =

== 介绍 ==
Spring IoC（控制反转）容器是Spring框架的核心，负责管理应用程序中的对象（bean）及其依赖关系。Spring容器提供了多个'''扩展点'''，允许开发者在容器的生命周期中插入自定义逻辑，以满足特定的需求。这些扩展点使得Spring框架具有高度的灵活性和可扩展性。

扩展点通常用于以下场景：
* 在bean创建前后执行自定义逻辑
* 修改bean的定义
* 动态注册bean
* 响应容器事件

== 主要扩展点 ==

=== 1. BeanPostProcessor ===
`BeanPostProcessor`接口允许在Spring容器实例化bean之后、初始化前后执行自定义逻辑。它是Spring容器中最常用的扩展点之一。

<syntaxhighlight lang="java">
public interface BeanPostProcessor {
    // 初始化前调用
    Object postProcessBeforeInitialization(Object bean, String beanName);
    
    // 初始化后调用
    Object postProcessAfterInitialization(Object bean, String beanName);
}
</syntaxhighlight>

'''示例：'''
<syntaxhighlight lang="java">
public class CustomBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Before initialization: " + beanName);
        return bean; // 可以返回原始bean或包装后的bean
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("After initialization: " + beanName);
        return bean;
    }
}
</syntaxhighlight>

'''注册方式：'''
<syntaxhighlight lang="xml">
<bean class="com.example.CustomBeanPostProcessor"/>
</syntaxhighlight>

=== 2. BeanFactoryPostProcessor ===
`BeanFactoryPostProcessor`允许在容器加载完bean定义后、实例化bean前修改bean的定义（如修改属性值）。

<syntaxhighlight lang="java">
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory);
}
</syntaxhighlight>

'''示例：'''
<syntaxhighlight lang="java">
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        BeanDefinition beanDef = beanFactory.getBeanDefinition("someBean");
        beanDef.getPropertyValues().add("propertyName", "newValue");
    }
}
</syntaxhighlight>

=== 3. ApplicationContextAware ===
通过实现`ApplicationContextAware`接口，bean可以获取对`ApplicationContext`的引用。

<syntaxhighlight lang="java">
public class AwareBean implements ApplicationContextAware {
    
    private ApplicationContext context;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }
    
    // 可以使用context获取其他bean等
}
</syntaxhighlight>

=== 4. 生命周期接口 ===
Spring提供了多个生命周期接口：
* `InitializingBean` - 定义初始化方法
* `DisposableBean` - 定义销毁方法

'''示例：'''
<syntaxhighlight lang="java">
public class LifecycleBean implements InitializingBean, DisposableBean {
    
    @Override
    public void afterPropertiesSet() {
        // 初始化逻辑
    }
    
    @Override
    public void destroy() {
        // 销毁逻辑
    }
}
</syntaxhighlight>

== 执行顺序 ==
以下是Spring容器中这些扩展点的典型执行顺序：

<mermaid>
sequenceDiagram
    participant BFP as BeanFactoryPostProcessor
    participant BP as BeanPostProcessor
    participant Bean as Bean
    
    BFP->>BFP: postProcessBeanFactory()
    Bean->>Bean: 实例化
    BP->>Bean: postProcessBeforeInitialization()
    Bean->>Bean: afterPropertiesSet() (如果实现InitializingBean)
    Bean->>Bean: 自定义init方法
    BP->>Bean: postProcessAfterInitialization()
    Note right of Bean: Bean就绪可用
    Bean->>Bean: destroy() (容器关闭时)
</mermaid>

== 实际应用案例 ==

=== 案例1：性能监控 ===
使用`BeanPostProcessor`为服务类添加性能监控：

<syntaxhighlight lang="java">
public class PerformanceMonitorPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof MyService) {
            return Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    long start = System.currentTimeMillis();
                    Object result = method.invoke(bean, args);
                    long duration = System.currentTimeMillis() - start;
                    System.out.println(method.getName() + " executed in " + duration + "ms");
                    return result;
                });
        }
        return bean;
    }
}
</syntaxhighlight>

=== 案例2：动态属性覆盖 ===
使用`BeanFactoryPostProcessor`从外部配置覆盖bean属性：

<syntaxhighlight lang="java">
public class PropertyOverrideProcessor implements BeanFactoryPostProcessor {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        Properties props = loadExternalProperties();
        
        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition def = beanFactory.getBeanDefinition(beanName);
            String propKey = beanName + ".property";
            
            if (props.containsKey(propKey)) {
                def.getPropertyValues().add("property", props.getProperty(propKey));
            }
        }
    }
}
</syntaxhighlight>

== 高级主题 ==

=== 自定义作用域 ===
Spring允许通过实现`Scope`接口来创建自定义作用域：

<syntaxhighlight lang="java">
public class ThreadScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadLocal = 
        ThreadLocal.withInitial(HashMap::new);
    
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadLocal.get();
        Object obj = scope.get(name);
        if (obj == null) {
            obj = objectFactory.getObject();
            scope.put(name, obj);
        }
        return obj;
    }
    
    // 其他方法实现...
}
</syntaxhighlight>

'''注册自定义作用域：'''
<syntaxhighlight lang="java">
ConfigurableListableBeanFactory beanFactory = ...;
beanFactory.registerScope("thread", new ThreadScope());
</syntaxhighlight>

=== 事件机制 ===
Spring容器的事件发布机制也是重要的扩展点：

<syntaxhighlight lang="java">
// 自定义事件
public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }
}

// 事件监听器
@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        // 处理事件
    }
}

// 发布事件
applicationContext.publishEvent(new CustomEvent(this));
</syntaxhighlight>

== 最佳实践 ==
1. 优先使用注解方式（如`@PostConstruct`）而非实现接口
2. 避免在扩展点中执行耗时操作
3. 注意扩展点的执行顺序
4. 考虑使用Spring Boot的自动配置机制替代部分扩展点实现

== 总结 ==
Spring容器的扩展点提供了强大的定制能力，使开发者能够深度集成自定义逻辑到框架生命周期中。理解这些扩展点对于构建灵活、可扩展的Spring应用至关重要。从简单的属性修改到复杂的AOP集成，这些扩展点都能满足各种定制需求。

[[Category:后端框架]]
[[Category:Spring]]
[[Category:Spring Ioc容器]]