Spring Framework 源码阅读（四）：BeanPostProcessor和Bean的生命周期

Spring framework 源码阅读（四）：BeanPostProcessor和Bean的生命周期

在介绍Aware接口及其实现类的作用中，就有说过在bean调用初始化方法的前后会调用BeanPostProcessor中的方法，以便对bean实现定制化。

BeanPostProcessor接口源码：

public interface BeanPostProcessor {

    // 在任何bean初始化（如调用InitializingBean的afterPropertiesSet方法或自定义初始化方法）之前进行回调
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
	
    // 在任何bean初始化（如调用InitializingBean的afterPropertiesSet方法或自定义初始化方法）之后进行回调
    // 在FactoryBean的情况下，将为FactoryBean实例和FactoryBean创建的对象调用此回调（从Spring 2.0开始）
    // PostProcessor可以通过bean instanceof FactoryBean检查来决定是应用于FactoryBean或创建的对象还是两者
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

工厂钩子：允许自定义修改新bean实例的工厂钩子，例如检查标记接口（接口不包含任何方法）或使用代理包装 bean。通常，通过标记接口填充bean的PostProcessor将实现postProcessBeforeInitialization方法，而使用代理包装bean的PostProcessor通常将实现postProcessAfterInitialization方法。
注册：ApplicationContext可以在其bean定义中自动检测BeanPostProcessor bean，并将这些PostProcessor应用于随后创建的任何bean。一个普通的BeanFactory允许以编程方式注册PostProcessor，并将它们应用于通过bean工厂创建的所有bean。
顺序：在ApplicationContext中自动检测的BeanPostProcessor bean将根据PriorityOrdered和Ordered语义进行排序。相比之下，以编程方式注册到BeanFactory的BeanPostProcessor bean 将按注册顺序应用；对于以编程方式注册的PostProcessor，通过实现PriorityOrdered或Ordered接口表达的任何排序语义都将被忽略。此外，@Order注解不会被BeanPostProcessor bean考虑在内。

首先了解一下bean的生命周期，标准的bean生命周期接口，初始化方法及其标准顺序（在BeanFactory接口中有描述）：

BeanNameAware的setBeanName方法。
BeanClassLoaderAware的setBeanClassLoader方法。
BeanFactoryAware的setBeanFactory方法。
EnvironmentAware的setEnvironment方法。
EmbeddedValueResolverAware的setEmbeddedValueResolver方法。
ResourceLoaderAware的setResourceLoader方法（仅在ApplicationContext中运行时适用）。
ApplicationEventPublisherAware的setApplicationEventPublisher方法（仅在ApplicationContext中运行时适用）。
MessageSourceAware的setMessageSource方法（仅在ApplicationContext中运行时适用）。
ApplicationContextAware的setApplicationContext方法（仅在ApplicationContext中运行时适用）。
ServletContextAware的setServletContext方法（仅在web ApplicationContext中运行时适用）。
BeanPostProcessors的postProcessBeforeInitialization方法。
InitializingBean的afterPropertiesSet方法。
自定义初始化方法（bean定义中的initMethod属性）。
BeanPostProcessors的postProcessAfterInitialization方法。

在关闭bean工厂或者注销bean时，会执行以下生命周期方法：

DestructionAwareBeanPostProcessors的postProcessBeforeDestruction方法。
DisposableBean的destroy方法。
自定义销毁方法（bean定义中的destroyMethod属性）。

前10个步骤都是基于Aware接口及其实现类来完成的：

Spring framework 源码阅读（一）：Aware接口及其实现类的作用

这篇博客会涉及到以下内容：

Spring framework 源码阅读（二）：BeanDefinition的作用
Spring framework 源码阅读（三）：认识FactoryBean

创建module

先在Spring framework源码中增加一个application module，这在之前的博文中已经介绍过了，这里就不再赘述：

编译 Spring framework 5.2.17源码 & 在源码中使用 ApplicationContext 获取定义的Bean

IMessageService接口：

package com.kaven.service;



public interface IMessageService {
	default String getMessage() {
		return "default message";
	}
}

MessageServiceImpl实现类：

package com.kaven.service.impl;

import com.kaven.service.IMessageService;
import org.springframework.util.StringUtils;



public class MessageServiceImpl implements IMessageService {

	private String message;

	public MessageServiceImpl(String message) {
		System.out.println("[MessageServiceImpl] : init");
		this.message = message;
	}

	@Override
	public String getMessage() {
		return message;
	}

	public void addMessagePrefix(String prefix) {
		message = prefix.concat(message);
	}
}

MessageServiceFactoryBean类（FactoryBean）：

package com.kaven.factory;

import com.kaven.service.IMessageService;
import com.kaven.service.impl.MessageServiceImpl;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;



@Component("myFactoryBean")
public class MessageServiceFactoryBean implements FactoryBean {
	@Override
	public IMessageService getObject() throws Exception {
		System.out.println("[MessageServiceFactoryBean] : getObject");
		return new MessageServiceImpl("Hello Spring");
	}

	@Override
	public Class getObjectType() {
		return IMessageService.class;
	}

	@Override
	public boolean isSingleton() {
		return false;
	}
}

MessageBeanPostProcess类（实现BeanPostProcess接口）：

package com.kaven.process;

import com.kaven.Application;
import com.kaven.service.impl.MessageServiceImpl;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
import org.springframework.stereotype.Component;



@Component
public class MessageBeanPostProcess implements DestructionAwareBeanPostProcessor {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if(bean instanceof MessageServiceImpl) {
			MessageServiceImpl service = (MessageServiceImpl) bean;
			System.out.println("[MessageBeanPostProcess - Before(MessageServiceImpl)] : " + service.getMessage());
		}
		else if(bean instanceof Application.Task) {
			Application.Task task = (Application.Task) bean;
			System.out.println("[MessageBeanPostProcess - Before(Application.Task)] : " + task.addTask());
		}
		else {
			System.out.println("[MessageBeanPostProcess - Before] : " + bean.getClass());
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if(bean instanceof MessageServiceImpl) {
			MessageServiceImpl service = (MessageServiceImpl) bean;
			service.addMessagePrefix("(ITKaven)");
			System.out.println("[MessageBeanPostProcess - After(MessageServiceImpl)] : " + service.getMessage());
		}
		else if(bean instanceof Application.Task) {
			Application.Task task = (Application.Task) bean;
			System.out.println("[MessageBeanPostProcess - After(Application.Task)] : " + task.addTask());
		}
		else {
			System.out.println("[MessageBeanPostProcess - After] : " + bean.getClass());
		}
		return bean;
	}

	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		System.out.println("[MessageBeanPostProcess - postProcessBeforeDestruction]" + bean.getClass());
	}
}

DestructionAwareBeanPostProcessor是BeanPostProcess接口的子接口，在bean生命周期的第15步会涉及到它。

启动类Application：

package com.kaven;

import com.kaven.service.IMessageService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;

import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;



@ComponentScan({"com.kaven"})
public class Application {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Application.class);

		IMessageService messageServiceBean = (IMessageService) applicationContext.getBean("myFactoryBean");

		Task task = (Task) applicationContext.getBean("myTask");
		System.out.println("taskCount: " + task.addTask());

		System.out.println("BeanDefinitionCount: " + applicationContext.getBeanDefinitionCount());
		Arrays.stream(applicationContext.getBeanDefinitionNames()).forEach(System.out::println);

		applicationContext.getBeanFactory().destroyBean("myTask", task);
	}

	@Bean(value = "myTask", initMethod = "initMethod", destroyMethod = "destroyMethod")
	public Task getTask() {
		return new Task();
	}

	public static class Task implements InitializingBean, DisposableBean {
		private final AtomicInteger taskCount;

		public Task() {
			taskCount = new AtomicInteger(0);
			System.out.println("[Task] : create");
		}

		public int addTask() {
			return taskCount.incrementAndGet();
		}

		@Override
		public void afterPropertiesSet() throws Exception {
			System.out.println("[Task - afterPropertiesSet] : ok");
		}

		public void initMethod() {
			System.out.println("[Task - initMethod] : ok");
		}

		@Override
		public void destroy() throws Exception {
			System.out.println("[Task - destroy] : ok");
		}

		public void destroyMethod() {
			System.out.println("[Task - destroyMethod] : ok");
		}
	}
}

输出结果：

> Task :application:Application.main()
[MessageBeanPostProcess - Before] : class com.kaven.Application
[MessageBeanPostProcess - After] : class com.kaven.Application
[MessageBeanPostProcess - Before] : class com.kaven.factory.MessageServiceFactoryBean
[MessageBeanPostProcess - After] : class com.kaven.factory.MessageServiceFactoryBean
[Task] : create
[MessageBeanPostProcess - Before(Application.Task)] : 1
[Task - afterPropertiesSet] : ok
[Task - initMethod] : ok
[MessageBeanPostProcess - After(Application.Task)] : 2
[MessageServiceFactoryBean] : getObject
[MessageServiceImpl] : init
[MessageBeanPostProcess - After(MessageServiceImpl)] : (ITKaven)Hello Spring
taskCount: 3
BeanDefinitionCount: 8
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
application
myFactoryBean
messageBeanPostProcess
myTask
[MessageBeanPostProcess - postProcessBeforeDestruction]class com.kaven.Application$Task
[Task - destroy] : ok
[Task - destroyMethod] : ok

BUILD SUCCESSFUL in 33s
61 actionable tasks: 2 executed, 59 up-to-date

大家根据上面的代码仔细看看输出结果，很显然是符合预期的。

创建这4个内置bean的过程在介绍BeanDefinition的作用时有介绍过。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory

其他bean都是我们自定义的。

源码分析

[MessageBeanPostProcess - Before] : class com.kaven.Application
[MessageBeanPostProcess - After] : class com.kaven.Application
[MessageBeanPostProcess - Before] : class com.kaven.factory.MessageServiceFactoryBean
[MessageBeanPostProcess - After] : class com.kaven.factory.MessageServiceFactoryBean

这4行输出，很显然是调用MessageBeanPostProcess类中的postProcessBeforeInitialization方法和postProcessAfterInitialization方法导致的。因为在bean调用初始化方法的前后会调用BeanPostProcessor中的方法。

而这是通过调用AbstractAutowireCapableBeanFactory抽象类的initializeBean方法来实现的。

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
		    // 调用aware methods
			AccessController.doPrivileged((PrivilegedAction

Spring Framework 源码阅读（四）：BeanPostProcessor和Bean的生命周期

Java相关栏目本月热门文章