diff --git a/README.md b/README.md index 316ce76..0e09c4c 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,8 @@ + [关于BeanDefinitionRegistryPostProcessor源码分析](spring-interface-beanDefinitionRegistryPostProcessor/README.md) ++ [关于BeanPostProcessor源码分析](spring-interface-beanPostProcessor/README.md) + + [关于InstantiationAwareBeanPostProcessor源码分析](spring-interface-instantiationAwareBeanPostProcessor/README.md) + [关于DestructionAwareBeanPostProcessor源码分析](spring-interface-destructionAwareBeanPostProcessor/README.md) diff --git a/spring-interface-beanPostProcessor/README.md b/spring-interface-beanPostProcessor/README.md new file mode 100644 index 0000000..b79f223 --- /dev/null +++ b/spring-interface-beanPostProcessor/README.md @@ -0,0 +1,634 @@ +## BeanPostProcessor + +- [BeanPostProcessor](#beanpostprocessor) + - [一、接口描述](#一接口描述) + - [二、接口源码](#二接口源码) + - [三、主要功能](#三主要功能) + - [四、最佳实践](#四最佳实践) + - [五、时序图](#五时序图) + - [六、源码分析](#六源码分析) + - [七、注意事项](#七注意事项) + - [八、总结](#八总结) + - [8.1、最佳实践总结](#81最佳实践总结) + - [8.2、源码分析总结](#82源码分析总结) + + +### 一、接口描述 + +`BeanPostProcessor`接口，允许对新创建的 Bean 进行操作和修改。 + +### 二、接口源码 + +`BeanPostProcessor` 是 Spring 框架自 10.10.2003 开始引入的一个核心接口。该接口定义了两个主要的方法：`postProcessBeforeInitialization` 和 `postProcessAfterInitialization`，分别在 Bean 的初始化前后调用。从源码中可以发现`BeanPostProcessor`接口具备注册与排序功能，那什么是注册呢？首先是自动注册，当启动一个`AnnotationConfigApplicationContext`时，Spring 会自动扫描定义的所有 bean。如果某个 bean 实现了 `BeanPostProcessor` 接口，Spring 将自动识别并注册它。另外一个是手动注册通过调用 `ConfigurableBeanFactory` 的 `addBeanPostProcessor` 方法来完成。那为什么是排序呢？如果 `BeanPostProcessor` 实现了 `org.springframework.core.PriorityOrdered` 或 `org.springframework.core.Ordered` 接口，那么 Spring 将会根据它们的优先级或顺序进行排序。在 `AnnotationConfigApplicationContext` 中，Spring 会考虑上述两个接口的语义来确定 `BeanPostProcessor` 的执行顺序。但是需要注意的是，如果我们手动在 `ConfigurableBeanFactory` 中注册了 `BeanPostProcessor`，那么 Spring 会按照我们注册它们的顺序来应用这些后处理器，在这种情况下，即使 `BeanPostProcessor` 实现了 `PriorityOrdered` 或 `Ordered` 接口，这些排序语义也会被忽略。 + +```java +/** + * 工厂钩子，允许对新创建的bean实例进行自定义修改。 + * 例如，检查标记接口或使用代理包装beans。 + * + * 通常，通过标记接口等填充beans的后处理器会实现 #postProcessBeforeInitialization + * 而使用代理包装beans的后处理器通常会实现 #postProcessAfterInitialization + * + * 注册 + * ApplicationContext 可以在其bean定义中自动检测到 BeanPostProcessor beans， + * 并将这些后处理器应用于随后创建的任何beans。一个普通的 BeanFactory 允许以编程方式注册 + * 后处理器，将它们应用于通过bean工厂创建的所有beans。 + * + * 排序 + * 在 ApplicationContext 中自动检测到的 BeanPostProcessor beans 将根据 + * org.springframework.core.PriorityOrdered 和 + * org.springframework.core.Ordered 语义进行排序。相反，以编程方式在 + * BeanFactory 中注册的 BeanPostProcessor beans 将按注册顺序应用； + * 通过实现 PriorityOrdered 或 Ordered 接口表达的任何排序语义 + * 对于编程注册的后处理器都将被忽略。此外，org.springframework.core.annotation.Order @Order + * 注释不适用于 BeanPostProcessor beans。 + * + * @author Juergen Hoeller + * @author Sam Brannen + * @since 10.10.2003 + * @see InstantiationAwareBeanPostProcessor + * @see DestructionAwareBeanPostProcessor + * @see ConfigurableBeanFactory#addBeanPostProcessor + * @see BeanFactoryPostProcessor + */ +public interface BeanPostProcessor { + + /** + * 在任何bean初始化回调（如InitializingBean的 afterPropertiesSet + * 或自定义初始化方法）之前，将此 BeanPostProcessor 应用于给定的新bean实例。 + * 该bean已使用属性值填充。返回的bean实例可能是原始实例的包装。 + * 默认实现返回给定的 bean。 + * @param bean 新的bean实例 + * @param beanName bean的名称 + * @return 要使用的bean实例，可以是原始实例或其包装；如果为 null，则不会调用后续的BeanPostProcessors + * @throws org.springframework.beans.BeansException 出错时 + * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet + */ + @Nullable + default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { + return bean; + } + + /** + * 在任何bean初始化回调（如InitializingBean的 afterPropertiesSet + * 或自定义初始化方法）之后，将此 BeanPostProcessor 应用于给定的新bean实例。 + * 该bean已使用属性值填充。返回的bean实例可能是原始实例的包装。 + * 对于FactoryBean，此回调将被调用，既适用于FactoryBean实例，也适用于FactoryBean创建的对象（自Spring 2.0起）。 + * 后处理器可以决定通过相应的 bean instanceof FactoryBean 检查，是否应用于FactoryBean、创建的对象或两者。 + * 此回调还将在由 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation + * 方法触发的短路之后调用，与所有其他 BeanPostProcessor 回调相反。 + * 默认实现返回给定的 bean。 + * @param bean 新的bean实例 + * @param beanName bean的名称 + * @return 要使用的bean实例，可以是原始实例或其包装；如果为 null，则不会调用后续的BeanPostProcessors + * @throws org.springframework.beans.BeansException 出错时 + * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet + * @see org.springframework.beans.factory.FactoryBean + */ + @Nullable + default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + return bean; + } + +} +``` + +### 三、主要功能 + +**修改 Bean 属性**：在 Bean 初始化之前或之后，可以修改 Bean 的属性。例如，可以根据某些条件为 Bean 的某些属性设置默认值。 + +**验证 Bean 的状态**：在 Bean 初始化完成后，可以检查 Bean 的状态，确保它满足某些条件或约束。 + +**返回代理 Bean**：最常见的用例是返回一个代理（proxy）来包装原始的 Bean。例如，Spring AOP 使用它来为目标 Bean 创建代理，从而实现切面的功能。 + +**改变返回的 Bean 类型**：可以完全替换一个 Bean 的实例，返回一个不同类型的对象。这是一个高级用例，但在某些场景中可能是必要的 + +### 四、最佳实践 + +首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyService`类型的bean，最后打印了该`show`方法返回的值。 + +```java +public class BeanPostProcessorApplication { + + public static void main(String[] args) { + AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); + MyService myService = context.getBean(MyService.class); + System.out.println(myService.show()); + context.close(); + } +} +``` + +这里使用`@Bean`注解，定义了两个Bean，是为了确保`MyService`， `MyBeanPostProcessor` 被 Spring 容器执行 + +```java +@Configuration +public class MyConfiguration { + + @Bean + public MyService myService() { + return new MyServiceImpl(); + } + + @Bean + public BeanPostProcessor myBeanPostProcessor() { + return new MyBeanPostProcessor(); + } +} +``` + +在`postProcessBeforeInitialization`方法中，将 `MyServiceImpl` 中的 `message` 属性，为其添加 `Prefix:` 前缀。在`postProcessAfterInitialization`方法中，将 `MyServiceImpl` 中的 `message` 属性，为其添加 `:Suffix` 后缀。 + +```java +public class MyBeanPostProcessor implements BeanPostProcessor { + + @Override + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage("Prefix: " + myService.getMessage()); + } + return bean; + } + + @Override + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage(myService.getMessage() + " :Suffix"); + } + return bean; + } +} +``` + +一个简单的接口 + +```java +public interface MyService { + String show(); +} +``` + +一个简单的实现类 + +```java +public class MyServiceImpl implements MyService{ + + private String message = "Hello from MyService"; + + @Override + public String show() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} +``` + +运行结果发现， `MyBeanPostProcessor` 实现修改了 `MyServiceImpl` bean的`message`属性，首先在初始化前加了前缀，然后在初始化后加了后缀。 + +```java +Prefix: Hello from MyService :Suffix +``` + +### 五、时序图 + +~~~mermaid +sequenceDiagram + Title: BeanPostProcessor时序图 + participant BeanPostProcessorApplication + participant AnnotationConfigApplicationContext + participant AbstractApplicationContext + participant DefaultListableBeanFactory + participant AbstractBeanFactory + participant DefaultSingletonBeanRegistry + participant AbstractAutowireCapableBeanFactory + participant MyBeanPostProcessor + + BeanPostProcessorApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses) + AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh() + AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory) + AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons() + DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name) + AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly) + AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory) + DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject() + AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args) + AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args) + AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd) + AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean,beanName) + AbstractAutowireCapableBeanFactory->>MyBeanPostProcessor: postProcessBeforeInitialization(bean,beanName) + MyBeanPostProcessor-->>AbstractAutowireCapableBeanFactory: 返回Bean对象 + AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsAfterInitialization(existingBean,beanName) + AbstractAutowireCapableBeanFactory->>MyBeanPostProcessor: postProcessAfterInitialization(bean,beanName) + MyBeanPostProcessor-->>AbstractAutowireCapableBeanFactory: 返回Bean对象 + AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象 + AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象 + AnnotationConfigApplicationContext->>BeanPostProcessorApplication: 初始化完成 +~~~ + +### 六、源码分析 + +```java +public class BeanPostProcessorApplication { + + public static void main(String[] args) { + AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); + MyService myService = context.getBean(MyService.class); + System.out.println(myService.show()); + context.close(); + } +} +``` + +首先我们来看看源码中的，构造函数中，执行了三个步骤，我们重点关注`refresh()`方法 + +```java +public AnnotationConfigApplicationContext(Class... componentClasses) { + this(); + register(componentClasses); + refresh(); +} +``` + +`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法，其他方法不是本次源码阅读的重点暂时忽略，在`finishBeanFactoryInitialization(beanFactory)`方法会对实例化所有剩余非懒加载的单列Bean对象。 + +```java +@Override +public void refresh() throws BeansException, IllegalStateException { + // ... [代码部分省略以简化] + // Instantiate all remaining (non-lazy-init) singletons. + finishBeanFactoryInitialization(beanFactory); + // ... [代码部分省略以简化] +} +``` + +在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。 + +```java +public void preInstantiateSingletons() throws BeansException { + // ... [代码部分省略以简化] + // 循环遍历所有bean的名称 + for (String beanName : beanNames) { + // 获取合并后的bean定义，这包括了从父容器继承的属性 + RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); + + // 检查bean是否不是抽象的、是否是单例的，以及是否不是懒加载的 + if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { + + // 判断当前bean是否是一个FactoryBean + if (isFactoryBean(beanName)) { + // 获取FactoryBean实例 + Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); + + // 如果bean确实是FactoryBean的实例 + if (bean instanceof FactoryBean) { + FactoryBean factory = (FactoryBean) bean; + + boolean isEagerInit; + + // 判断当前环境是否有安全管理器，并且工厂bean是否是SmartFactoryBean的实例 + if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { + // 使用AccessController确保在受限制的环境中安全地调用isEagerInit方法 + isEagerInit = AccessController.doPrivileged( + (PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit, + getAccessControlContext()); + } + else { + // 检查FactoryBean是否是SmartFactoryBean，并且是否需要立即初始化 + isEagerInit = (factory instanceof SmartFactoryBean && + ((SmartFactoryBean) factory).isEagerInit()); + } + + // 如果工厂bean需要立即初始化，则获取bean实例，这将触发bean的创建 + if (isEagerInit) { + getBean(beanName); + } + } + } + // 如果不是FactoryBean，则直接获取bean实例，这将触发bean的创建 + else { + getBean(beanName); + } + } + } + // ... [代码部分省略以简化] +} +``` + +在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。 + +```java +@Override +public Object getBean(String name) throws BeansException { + return doGetBean(name, null, null, false); +} +``` + +在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。 + +```java +protected T doGetBean( + String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) + throws BeansException { + // ... [代码部分省略以简化] + + // 开始创建bean实例 + if (mbd.isSingleton()) { + // 如果bean是单例的，我们会尝试从单例缓存中获取它 + // 如果不存在，则使用lambda创建一个新的实例 + sharedInstance = getSingleton(beanName, () -> { + try { + // 尝试创建bean实例 + return createBean(beanName, mbd, args); + } + catch (BeansException ex) { + // 如果在创建bean过程中出现异常，从单例缓存中移除它 + // 这样做是为了防止循环引用的情况 + destroySingleton(beanName); + throw ex; + } + }); + // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例 + beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); + } + // ... [代码部分省略以简化] + + // 确保返回的bean实例与请求的类型匹配 + return adaptBeanInstance(name, beanInstance, requiredType); +} +``` + +在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。 + +```java +public Object getSingleton(String beanName, ObjectFactory singletonFactory) { + // 断言bean名称不能为空 + Assert.notNull(beanName, "Bean name must not be null"); + + // 同步访问单例对象缓存，确保线程安全 + synchronized (this.singletonObjects) { + // 从缓存中获取单例对象 + Object singletonObject = this.singletonObjects.get(beanName); + + // 如果缓存中没有找到 + if (singletonObject == null) { + // ... [代码部分省略以简化] + + // 在创建单例之前执行某些操作，如记录创建状态 + beforeSingletonCreation(beanName); + + boolean newSingleton = false; + boolean recordSuppressedExceptions = (this.suppressedExceptions == null); + if (recordSuppressedExceptions) { + this.suppressedExceptions = new LinkedHashSet<>(); + } + + try { + // 使用工厂创建新的单例实例 + singletonObject = singletonFactory.getObject(); + newSingleton = true; + } + catch (IllegalStateException ex) { + // ... [代码部分省略以简化] + } + catch (BeanCreationException ex) { + // ... [代码部分省略以简化] + } + finally { + // ... [代码部分省略以简化] + } + + // 如果成功创建了新的单例，将其加入缓存 + if (newSingleton) { + addSingleton(beanName, singletonObject); + } + } + + // 返回单例对象 + return singletonObject; + } +} +``` + +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，首先尝试调用`resolveBeforeInstantiation`，这个方法给`InstantiationAwareBeanPostProcessor`一个机会，允许它们返回一个代理对象，而不是目标bean的实例。如果这一步返回了一个非空的对象（也就是说，一个`InstantiationAwareBeanPostProcessor`创建了一个代理对象），那么这个代理对象将作为该bean的实例返回，跳过正常的bean创建过程。如果上面的步骤没有返回任何对象，那么代码将执行`doCreateBean`方法，这个方法负责实际的bean实例化、属性注入和初始化。 + +```java +@Override +protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) + throws BeanCreationException { + + // ... [代码部分省略以简化] + + try { + // 正常的bean实例化、属性注入和初始化。 + // 这里是真正进行bean创建的部分。 + Object beanInstance = doCreateBean(beanName, mbdToUse, args); + // 记录bean成功创建的日志 + if (logger.isTraceEnabled()) { + logger.trace("Finished creating instance of bean '" + beanName + "'"); + } + return beanInstance; + } + catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { + // ... [代码部分省略以简化] + } + catch (Throwable ex) { + // ... [代码部分省略以简化] + } +} +``` + +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，主要负责两大步骤，第一步是属性注入，第二步是bean初始化，确保bean是完全配置和准备好的。 + +```java +protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) + throws BeanCreationException { + + // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象 + Object exposedObject = bean; + + try { + // 属性注入：这一步将配置中的属性值注入到bean实例中。例如，XML中定义的属性或使用@Autowired和@Value注解的属性都会在这里被注入 + populateBean(beanName, mbd, instanceWrapper); + + // bean初始化：这一步会执行bean的初始化方法，同时也会调用BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法，它们可以对bean进行进一步的处理 + exposedObject = initializeBean(beanName, exposedObject, mbd); + } + catch (Throwable ex) { + // ... [代码部分省略以简化] + } + + // 返回创建和初始化后的bean + return exposedObject; +} +``` + +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean()`方法中，核心逻辑是对`BeanPostProcessors`接口中的`postProcessBeforeInitialization`，`postProcessAfterInitialization`进行回调。 + +```java +protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { + // ... [代码部分省略以简化] + + Object wrappedBean = bean; + if (mbd == null || !mbd.isSynthetic()) { + wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); + } + + // ... [代码部分省略以简化] + + if (mbd == null || !mbd.isSynthetic()) { + wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); + } + + return wrappedBean; +} +``` + +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强 + +```java +@Override +public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) + throws BeansException { + + Object result = existingBean; + for (BeanPostProcessor processor : getBeanPostProcessors()) { + Object current = processor.postProcessBeforeInitialization(result, beanName); + if (current == null) { + return result; + } + result = current; + } + return result; +} +``` + +在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessAfterInitialization` 方法都有机会对bean进行修改或增强 + +```java +@Override +public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) + throws BeansException { + + Object result = existingBean; + for (BeanPostProcessor processor : getBeanPostProcessors()) { + Object current = processor.postProcessAfterInitialization(result, beanName); + if (current == null) { + return result; + } + result = current; + } + return result; +} +``` + +在`com.xcs.spring.config.MyBeanPostProcessor`方法中，将 `MyServiceImpl` 中的 `message` 属性，为其添加 `Prefix:` 前缀。在`postProcessAfterInitialization`方法中，将 `MyServiceImpl` 中的 `message` 属性，为其添加 `:Suffix` 后缀。 + +```java +public class MyBeanPostProcessor implements BeanPostProcessor { + + @Override + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage("Prefix: " + myService.getMessage()); + } + return bean; + } + + @Override + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage(myService.getMessage() + " :Suffix"); + } + return bean; + } +} +``` + +### 七、注意事项 + +**执行顺序**：Spring容器中可能注册了多个 `BeanPostProcessor`。它们的执行顺序是由它们的`Ordered`值决定的（如果实现了`Ordered`接口）。如果有多个`BeanPostProcessor`对同一个bean进行处理，它们的处理顺序可能会对结果产生影响。 + +**返回值**：`postProcessBeforeInitialization` 和 `postProcessAfterInitialization` 方法都可以返回一个新的bean来替代原始bean。如果我们返回`null`，那么后续的`BeanPostProcessor`不会被执行。 + +**注意性能**：由于`BeanPostProcessor`方法对容器中的所有bean都会被调用，所以它们可能对启动时间和性能产生影响。我们应该确保这些方法的实现尽可能高效。 + +**不要修改无状态bean**：无状态的bean（如工具类或帮助类）应该避免在 `BeanPostProcessor` 中被修改，因为这通常没有意义，并可能导致不必要的性能开销。 + +**避免在`BeanPostProcessor`中抛出异常**：应该避免在`BeanPostProcessor`方法中抛出异常。这可能会导致Spring容器启动失败或其他bean初始化失败。 + +### 八、总结 + +#### 8.1、最佳实践总结 + +**启动类 `BeanPostProcessorApplication`：** + +此类首先初始化了一个基于Java配置的Spring上下文。在初始化完成后，从上下文中获取了一个`MyService`类型的bean，并调用了它的`show`方法，打印了返回的值。 + +**配置类 `MyConfiguration`：** + +这是一个基于Java的配置类，其中定义了两个beans：`MyService`和`MyBeanPostProcessor`。这确保了当Spring容器启动时，这两个beans都会被创建和管理。 + +**实现类 `MyBeanPostProcessor`：** + +该类实现了`BeanPostProcessor`接口，并覆盖了`postProcessBeforeInitialization`和`postProcessAfterInitialization`方法。在这两个方法中，它检查当前正在处理的bean是否是`MyServiceImpl`的实例。如果是，它会修改该bean的`message`属性： + +- 在`postProcessBeforeInitialization`中，给`message`添加了`Prefix:`前缀。 +- 在`postProcessAfterInitialization`中，给`message`添加了`:Suffix`后缀。 + +**接口与实现：** + +`MyService`接口定义了一个`show`方法，而`MyServiceImpl`是它的一个简单实现，其中包含一个`message`属性。 + +**运行结果：** + +当我们运行`BeanPostProcessorApplication`主程序，输出结果显示`MyServiceImpl` bean的`message`属性被成功地修改了。这是通过`MyBeanPostProcessor`实现的，该实现首先在bean初始化前加了前缀，然后在初始化后加了后缀。 + +#### 8.2、源码分析总结 + +**启动及初始化上下文**: + +- 使用`AnnotationConfigApplicationContext`进行Java配置方式的Spring上下文初始化。 +- 注册配置类，并刷新上下文，这触发了Spring容器的启动和bean生命周期的开始。 + +**`refresh()`方法**: + +- 是`AbstractApplicationContext`的核心方法，负责完整的容器刷新流程。 +- 重点关注的是`finishBeanFactoryInitialization(beanFactory)`方法，其负责初始化所有的非懒加载单例bean。 + +**预先实例化非懒加载的单例bean**: + +- `preInstantiateSingletons()`方法循环遍历所有的bean定义，并为非懒加载的单例bean进行初始化。 +- 它对每个bean都调用了`getBean(beanName)`，从而触发了bean的创建过程。 + +**`getBean()`方法**: + +- 是容器用于获取bean的核心方法。 +- 在内部，它调用了`doGetBean`，此方法处理bean的查找、创建和依赖注入。 + +**实际的bean创建过程**: + +- `doCreateBean`方法首先尝试用`InstantiationAwareBeanPostProcessor`创建代理对象（如果适用）。 +- 如果不返回代理对象，就会进入正常的bean创建、属性填充和初始化流程。 + +**`BeanPostProcessor`的角色**: + +- `BeanPostProcessor`接口是Spring中的核心扩展点，允许对bean实例进行额外的处理。 +- 在`initializeBean`方法中，我们可以看到`BeanPostProcessor`的两个主要回调方法——`postProcessBeforeInitialization`和`postProcessAfterInitialization`。 +- 这些方法提供了在bean初始化之前和之后进行额外处理的机会，如修改bean属性或返回代理对象。 + +**示例中的`MyBeanPostProcessor`**: + +- 我们定义的自定义`BeanPostProcessor`修改了`MyServiceImpl` bean的`message`属性。 +- 在初始化前，给`message`属性加了`Prefix:`前缀；在初始化后，又加了`:Suffix`后缀。 +- 最终的输出是对bean属性进行了修改的结果。 \ No newline at end of file diff --git a/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/BeanPostProcessorApplication.java b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/BeanPostProcessorApplication.java new file mode 100644 index 0000000..6f4dc96 --- /dev/null +++ b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/BeanPostProcessorApplication.java @@ -0,0 +1,19 @@ +package com.xcs.spring; + +import com.xcs.spring.config.MyConfiguration; +import com.xcs.spring.service.MyService; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; + +/** + * @author 林雷 + * @date 2023年09月16日 16时09分 + **/ +public class BeanPostProcessorApplication { + + public static void main(String[] args) { + AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); + MyService myService = context.getBean(MyService.class); + System.out.println(myService.show()); + context.close(); + } +} diff --git a/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyBeanPostProcessor.java b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyBeanPostProcessor.java new file mode 100644 index 0000000..91777f0 --- /dev/null +++ b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyBeanPostProcessor.java @@ -0,0 +1,30 @@ +package com.xcs.spring.config; + +import com.xcs.spring.service.MyServiceImpl; +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.config.BeanPostProcessor; + +/** + * @author 林雷 + * @date 2023年09月19日 16时42分 + **/ +public class MyBeanPostProcessor implements BeanPostProcessor { + + @Override + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage("Prefix: " + myService.getMessage()); + } + return bean; + } + + @Override + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + if(bean instanceof MyServiceImpl) { + MyServiceImpl myService = (MyServiceImpl) bean; + myService.setMessage(myService.getMessage() + " :Suffix"); + } + return bean; + } +} diff --git a/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyConfiguration.java b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyConfiguration.java new file mode 100644 index 0000000..c2a5289 --- /dev/null +++ b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/config/MyConfiguration.java @@ -0,0 +1,25 @@ +package com.xcs.spring.config; + +import com.xcs.spring.service.MyService; +import com.xcs.spring.service.MyServiceImpl; +import org.springframework.beans.factory.config.BeanPostProcessor; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * @author 林雷 + * @date 2023年09月19日 16时35分 + **/ +@Configuration +public class MyConfiguration { + + @Bean + public MyService myService() { + return new MyServiceImpl(); + } + + @Bean + public BeanPostProcessor myBeanPostProcessor() { + return new MyBeanPostProcessor(); + } +} diff --git a/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyService.java b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyService.java new file mode 100644 index 0000000..4f8a3c8 --- /dev/null +++ b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyService.java @@ -0,0 +1,9 @@ +package com.xcs.spring.service; + +/** + * @author 林雷 + * @date 2023年09月19日 16时43分 + **/ +public interface MyService { + String show(); +} diff --git a/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyServiceImpl.java b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyServiceImpl.java new file mode 100644 index 0000000..d6fa521 --- /dev/null +++ b/spring-interface-beanPostProcessor/src/main/java/com/xcs/spring/service/MyServiceImpl.java @@ -0,0 +1,23 @@ +package com.xcs.spring.service; + +/** + * @author 林雷 + * @date 2023年09月19日 16时43分 + **/ +public class MyServiceImpl implements MyService{ + + private String message = "Hello from MyService"; + + @Override + public String show() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} diff --git a/spring-interface-destructionAwareBeanPostProcessor/README.md b/spring-interface-destructionAwareBeanPostProcessor/README.md index 5f828b9..f3cd51e 100644 --- a/spring-interface-destructionAwareBeanPostProcessor/README.md +++ b/spring-interface-destructionAwareBeanPostProcessor/README.md @@ -19,7 +19,7 @@ ### 二、接口源码 -`DestructionAwareBeanPostProcessor` 是 Spring 框架自 1.0.1 版本开始引入的一个核心接口。其目的在于提供更细粒度的 bean 生命周期管理，特别是在 bean 即将被销毁时允许执行自定义的逻辑。另外它也是 `BeanPostProcessor` 的一个子接口。 +`DestructionAwareBeanPostProcessor` 是 Spring 框架自 1.0.1 版本开始引入的一个核心接口。该接口定义了两个主要的方法：`postProcessBeforeInitialization` 和 `postProcessAfterInitialization`，分别在 Bean 的初始化前后调用。 ```java /**