Spring Bean的基本流程

一、Bean实例化基本流程

二、Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器:

• BeanFactoryPostProcessor: Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

• BeanPostProcessor: Bean后处理器，一般在Bean实例化之后，填充到单例池sinqletonObiects之前执行。

1. Bean工厂后处理器-BeanFactoryPostProcessor

BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

BeanFactorvPostProcessor 定义如下：

public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

其中ConfigurableListableBeanFactory继承了ListableBeanFactory，ListableBeanFactory继承了BeanFactory，所以使用ConfigurableListableBeanFactory就可以操作BeanDefinition。

那么怎么才能操作BeanDefinition呢，那就要先创建一个自己的类来实现BeanFactoryPostProcessor并重写postProcessBeanFactory了（需要配置MyBeanFactoryPostProcessor到bean）:

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
       System.out.println("beanDefinitionMap填充完毕后回调该方法");
    }
}

• 修改某个BeanDefinition：

BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
beanDefinition.setBeanClassName("com.zkt.dao.impl.UserDaoImpl");

当你看到这里可能就有个疑问了，为什么只能修改某个BeanDefinition呢，我能不能批量修改BeanDefinition呢，那么很抱歉，为了安全考虑，ConfigurableListableBeanFactory并没有提供关于BeanDefinitionMap的接口，所以还是老老实实的用名字去单个获取吧。

• 注册BeanDefinition（使用RootBeanDefinition，其中PersonDaoImpl是没有被注册到BeanDefinition中的）：

// 注册BeanDefinition
BeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClassName("com.zkt.dao.impl.PersonDaoImpl");
// 强转成DefaultListableBeanFactory
DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
defaultListableBeanFactory.registerBeanDefinition("personDao", beanDefinition);

ConfigurableListableBeanFactory中并没有注册BeanDefinition的方法，而这里beanFactory的实质其实是DefaultListableBeanFactory，所以这里我们直接强转成DefaultListableBeanFactory。

但是每次强转类型并不好，所以Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor，专门用于注册BeanDefinition操作，其定义如下：

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    @Override
    default void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    }
}

• 有了这个接口，我们就能不用强转类型就能直接注册BeanDefinition了：

public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		//注册BeanDefinition
		BeanDefinition beanDefinition = new RootBeanDefinition();
		beanDefinition.setBeanClassName("com.zkt.dao.impl.PersonDaoImpl");
		registry.registerBeanDefinition("personDao", beanDefinition);
	}
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		
	}
}

• 有了BeanFactoryPostProcessor了，那么Bean实例化流程就变成了
  

案例：使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描

• 要求：

  • 自定义@MyComponent注解，使用在类上；

  • 自定义包扫描器工具BaseClassScanUtils完成指定包的类扫描；

  • 自定义MyComponentBeanFactoryPostProcessor完成注解@MyComponent的解析，解析后最终被Spring管理。

1. 定义@MyComponent注解；

@Target(ElementType.TYPE)  // 设置该注解使用在类上
@Retention(RetentionPolicy.RUNTIME)  // 设置该注解存活到运行时
public @interface MyComponent {
    String value();
}

2. 定义包扫描器工具BaseClassScanUtils；

public class BaseClassScanUtils {
    // 设置资源规则
    private static final String RESOURCE_PATTERN = "/**/*.class";
    // 定义扫描注解的方法
    public static Map<String, Class> scanMyComponentAnnotation(String basePackage) {
       // 创建容器存储使用了指定注解的Bean字节码对象
       Map<String, Class> annotationClassMap = new HashMap<String, Class>();
       // spring工具类，可以获取指定路径下的全部类
       ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
       try {
          String pattern =
                ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                      ClassUtils.convertClassNameToResourcePath(basePackage) + RESOURCE_PATTERN;
          Resource[] resources = resourcePatternResolver.getResources(pattern);
          // MetadataReader 的工厂类
          MetadataReaderFactory refractory = new CachingMetadataReaderFactory(resourcePatternResolver);
          for (Resource resource : resources) {
             // 用于读取类信息
             MetadataReader reader = refractory.getMetadataReader(resource);
             // 扫描到的class
             String classname = reader.getClassMetadata().getClassName();
             Class<?> clazz = Class.forName(classname);
             // 判断是否属于指定的注解类型
             if (clazz.isAnnotationPresent(MyComponent.class)) {
                // 获得注解对象
                MyComponent annotation = clazz.getAnnotation(MyComponent.class);
                // 获得属value属性值
                String beanName = annotation.value();
                // 判断是否为""
                if (beanName != null && !beanName.equals("")) {
                   // 存储到Map中去
                   annotationClassMap.put(beanName, clazz);
                   continue;
                }
                // 如果为"",那就把当前类的类名作为beanName
                annotationClassMap.put(clazz.getSimpleName(), clazz);
             }
          }
       } catch (Exception exception) {}
       return annotationClassMap;
    }
}

3. 定义MyComponentBeanFactoryPostProcessor完成注解@Component的解析，并把解析出来的Bean交由Spring管理；

public class MyComponentBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
       // 通过扫描工具去扫描指定包及其子包下的所有类，收集使用@Component的注解的类
       Map<String, Class> myComponentAnnotationMap = BaseClassScanUtils.scanMyComponentAnnotation("com.zkt");
       // 遍历Map，组装BeanDefinition进行注册
       myComponentAnnotationMap.forEach((beanName, calzz) -> {
          // 获得beanClassName
          String beanClassName = clazz.getName();
          // 创建BeanDefinition
          BeanDefinition beanDefinition = new RootBeanDefinition();
          beanDefinition.setBeanClassName(beanClassName);
          // 注册
          registry.registerBeanDefinition(beanClassName, beanDefinition);
       });
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
       BeanDefinitionRegistryPostProcessor.super.postProcessBeanFactory(beanFactory);
    }
}

4. 创建两个用来测试的类，并在类上添加@MyComponent注解；

@MyComponent("otherBean")
public class OtherBean {}

@MyComponent("")
public class XxxBean {}

5. 在applicationContext.xml中配置MyComponentBeanFactoryPostProcessor的bean；

<bean class="com.zkt.processor.MyComponentBeanFactoryPostProcessor"></bean>

这里只配置class而不配置id是因为MyComponentBeanFactoryPostProcessor的方法不需要手动调用，如果不清楚为啥不需要手动调用请回去看有了BeanFactoryPostProcessor的Bean实例化的流程图。

6. 进行测试。

public class ApplicationContextTest {
    public static void main(String[] args) throws Exception {
       ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
       OtherBean otherBean = applicationContext.getBean(OtherBean.class);
       XxxBean xxxBean = applicationContext.getBean(XxxBean.class);
       System.out.println(otherBean);
       System.out.println(xxxBean);
    }
}

输出结果：

​ com.zkt.beans.OtherBean@52e6fdee
​ com.zkt.beans.XxxBean@6c80d78a

2. Bean后处理器-BeanPostProcessor

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如: 属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理器。跟上面的Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

BeanPostProcessor的接口定义如下：

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       return bean;
    }
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       return bean;
    }
}

想要操作Bean，还是一样，实现BeanPostProcessor接口：

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       System.out.println(beanName + ":postProcessBeforeInitialization");
       return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       System.out.println(beanName + ":postProcessAfterInitialization");
       return bean;
    }
}

• 修改Bean的属性

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof UserDaoImpl) {
       UserDaoImpl userDao = (UserDaoImpl) bean;
       userDao.setUsername("zkt");
    }
    System.out.println(beanName + ":postProcessBeforeInitialization");
    return bean;
}

看到这里你可能会想，postProcessBeforeInitialization和postProcessAfterInitialization都是在Bean实例化之后执行的，那么这两个方法执行的中间会执行什么方法呢？

首先让UserDaoImpl实现InitializingBean接口，然后再定义初始化方法：

public class UserDaoImpl implements UserDao, InitializingBean {
    private String username;
    public void setUsername(String username) {
       this.username = username;
    }
    public UserDaoImpl() {
       System.out.println("userDao实例化");
    }
    public void init(){
       System.out.println("init初始化方法执行...");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
       System.out.println("属性设置之后执行...");
    }
}

在配置文件中配置UserDaoImpl和MyBeanPostProcessor：

<bean id="userDao" class="com.zkt.dao.impl.UserDaoImpl" init-method="init"></bean>
<bean class="com.zkt.processor.MyBeanPostProcessor"></bean>

然后在测试类中进行测试：

public static void main(String[] args) throws Exception {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    Object userDao = applicationContext.getBean("userDao");
}

输出结果：

​ userDao实例化
​ userDao:postProcessBeforeInitialization
​ 属性设置之后执行…
​ init初始化方法执行…
​ userDao:postProcessAfterInitialization

由此可见，postProcessBeforeInitialization和postProcessAfterInitialization中间还会执行afterPropertiesSet和init方法。

案例：对Bean方法进行执行时间日志增强

• 要求：

  • Bean的方法执行之前控制台打印当前时间；

  • Bean的方法执行之后控制台打印当前时间。

• 分析：

  • 对方法进行增强主要就是代理设计模式和包装设计模式；
  • 由于Bean方法不确定，所以使用动态代理在运行期间执行增强操作；
  • 在Bean实例创建完毕后，进入到单例池之前，使用Proxy代替真实的目标Bean。

1. 创建TimeLogBeanPostProcessor类实现BeanPostProcessor接口并在postProcessAfterInitialization方法中实现逻辑

public class TimeLogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       // 使用动态代理对目标Bean进行增强，返回proxy对象，进而存储到单例池singletonObjects中
       Object beanProxy = Proxy.newProxyInstance(
             bean.getClass().getClassLoader(),
             bean.getClass().getInterfaces(),
             (proxy, method, args) -> {
                // 1、输出开始时间
                System.out.println("方法：" + method.getName() + "-开始时间：" + new Date());
                // 2、执行目标方法
                Object result = method.invoke(bean, args);
                // 3、输出结束时间
                System.out.println("方法：" + method.getName() + "-结束时间：" + new Date());
                
                return result;
             }
       );
       return beanProxy;
    }
}

2. 配置bean

<bean id="userDao" class="com.zkt.dao.impl.UserDaoImpl"></bean>
<bean class="com.zkt.processor.TimeLogBeanPostProcessor"></bean>

3. 测试

public static void main(String[] args) throws Exception {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.show();
}

输出结果：

​ 方法：show-开始时间：Sat Jul 13 11:35:05 GMT+08:00 2024
​ show…
​ 方法：show-结束时间：Sat Jul 13 11:35:05 GMT+08:00 2024

该案例还可以进行延展，可以进行判断是否要对这个bean进行代理增强，还可以设置增强什么功能，并不是仅仅打印时间，可以灵活添加增强功能。

• 有了BeanPostProcessor后Bean实例化流程：
  

三、Spring Bean的生命周期

Spring Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段：

• Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化；

• Bean的初始化阶段：Bean创建之后还仅仅是个”半成品“，还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，Aop增强功能、Spring的注解功能等、Spring高频面试题Bean的循环引用问题都是在这个阶段体现的；

• Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期。

由于Bean的初始化阶段的步骤比较复杂，所以着重研究Bean的初始化阶段

Spring Bean的初始化过程涉及如下几个过程：

• Bean实例的属性填充

• Aware接口属性注入

• BeanPostProcessor的before()方法回调

• InitializingBean接口的初始化方法回调

• 自定义初始化方法init回调

• BeanPostProcessor的after()方法回调

Bean实例的属性填充

Spring在进行属性注入时，会分为如下几种情况:

• 注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；

• 注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；

• 注入双向对象引用属性时，就比较复杂了，涉及了循环引用(循环依赖)问题，下面会详细阐述解决方案。

前两种情况前面已经遇到过，所以在这里只演示第二种情况和讲解第三种情况。

第二种情况：

public class UserDaoImpl implements UserDao {
    public UserDaoImpl() {
       System.out.println("userDao创建");
    }
}

public class UserServiceImpl implements UserService {
	private UserDao userDao;
	private String username;
	
	public UserServiceImpl() {
		System.out.println("userService创建");
	}
	public void setUsername(String username) {
		this.username = username;
	}
	// BeanFactory去调用该方法   从容器中获得userDao设置到此处
	public void setUserDao(UserDao userDao) {
		System.out.println("userService执行注入userDao的操作：setUserDao方法执行");
		this.userDao = userDao;
	}
}

// 配置文件
<bean id="userService" class="com.zkt.service.impl.UserServiceImpl" autowire="byName">
	<property name="userDao" ref="userDao"></property>
	<property name="username" value="zkt"></property>
</bean>
<bean id="userDao" class="com.zkt.dao.impl.UserDaoImpl"></bean>

// 测试类
public class ApplicationContextTest {
	public static void main(String[] args) throws Exception {
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService bean = applicationContext.getBean(UserService.class);
	}
}

输出结果：

​ userService创建

​ userDao创建

​ userService执行注入userDao的操作：setUserDao方法执行

接下来我们修改一下配置文件，我们把userDao和userService的注入的顺序换一下：

<bean id="userDao" class="com.zkt.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.zkt.service.impl.UserServiceImpl" autowire="byName">
    <property name="userDao" ref="userDao"></property>
    <property name="username" value="zkt"></property>
</bean>

输出结果：

​ userDao创建

​ userService创建

​ userService执行注入userDao的操作：setUserDao方法执行

第三种情况：

多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖”，也叫做”循环引用。

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
}
public class UserDaoImpl implements UserDao {
	private UserService userService;
	public void setUserService(UserService userService){
		this.userService = userService;
	}
}

<bean id="userDao" class="com.zkt.dao.impl.UserDaoImpl">
    <property name="userService" ref="userService"></property>
</bean>

<bean id="userService" class="com.zkt.service.impl.UserServiceImpl" autowire="byName">
    <property name="userDao" ref="userDao"></property>
</bean>

• 循环引用执行基本流程
  

这张图所示并不能解决循环引用问题，那么怎么解决这个死循环的问题呢，那么就引出了三级缓存来了。

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环引用问题，在DefaultListableBeanFactory的上四级父类DefaultSingletonBeanRegistry中提供如下三个Map:

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    //1、 最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为“一级缓存”
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    //2、 早期Bean单例池，缓存半成品对象，且当前对象已被其他对象引用了，称之为“二级缓存”
	private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    //3、 单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时再通过工厂创建Bean，称之为“三级缓存”
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

当userService注入userDao时发现没有userDao，会到三级缓存中去找被封装为ObjectFactory的userDao，找到后会把userDao注入给userService，并把userDao在三级缓存中去掉，在二级缓存中添加userDao。

UserService和UserDao循环依赖的过程结合上述三级缓存描述一下：

• UserService 实例化对象，但尚未初始化，将UserService存储到三级缓存；

• UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao；

• UserDao 实例化对象，但尚未初始化，将UserDao存储到到三级缓存；

• UserDao 属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级缓存；

• UserDao 执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存；

• UserService 注入UserDao:

• UserService 执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存。

三级缓存源码剖析流程：

• 三级缓存的大致流程如下：
  
  
  
  

如果你有能力，可以去看一看源码，这里我看源码已经看昏了，就这样吧😵。

常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。

Aware接口	回调方法	作用
ServletContextAware	setServletContext(ServletContext context)	Spring框架毁掉方法注入ServletContext对象，web环境下才生效
BeanFactoryAware	setBeanFactory(BeanFactory factory)	Spring框架毁掉方法注入beanFactory对象
BeanNameAware	setBeanName(String beanName)	Spring框架回调方法注入当前Bean在容器中的beanName
ApplicationContextAware	setApplicationContext(ApplicationContext applicationContext)	Spring框架回调方法注入applicationContext对象

Spring IoC整体流程

注：本文为自己学习笔记，学习视频链接为：【黑马程序员新版Spring零基础入门到精通，一套搞定spring全套视频教程（含实战源码）】
如有侵权请联系删除