spring生命周期随笔

spring生命周期上：

要注意的是spring启动的时候已经经过了spring的生命周期了

transformBeanName(name)

getSingleton(beanName)是可以拿到

getObjectForBeanInstance 是不是factoryBean
name 程序员传入、beanName 真名

双重机制校验
普通bean直接返回
是factoryBean执行下面的逻辑

从缓存中调用
factoryObejctCanche
当前缓存没有强制转换成factoryBean ，因为他要调用getObject方法
doGetObjectFromFactoryBean

// 调用BeanPostProcessor执行初始化后的逻辑，主要就是进行AOP

调用初始化之后的方法因为他可能要进行aop做动态代理
得到的对象要看他是不是实现了factoryBean

所以FactoryBean相当于是懒加载。只有在调用getBean(factoryBeanName)的时候才会调用getObject方法去获取User 对象

getObject的user对象会放到容器中：
就是factoryBeanObjectCache 容器中而LubanFactoryBean就会放到singletonObjects 0：41：00

beanFactroy是大工厂，spring中所有的Bean 都是由BeanFactory创建出来的。它可以创建普通bean 和特殊bean 、单例bean原型bean
FactoryBean是通过beanFactory 创建出来的
FactoryBean是一个小的工厂，只能产生一个对象。或者scope是原型的，可以产生同一个类型的多个对象

factoryBean的作用有的时候我们希望自己构造一个对象，把他放到Ioc容器中

这边getBean（"user"）拿不到User这个对象，因为这个User对象不是一个配置类，不能够生成Bean定义

@component
public class UserService{
@Autowired
private UserMapper userMapper；

}
UserMapper接口，需要把UserMapper接口的代理对象注册到Ioc容器中。。既可以有代理对象又需要注册到容器中
在我们的容器中我们需要一个UserMapper的代理对象

还有啥方式：如何把我们自己new 出来的对象放到容器中呢？？
1、@Bean 功能比较单一，只能写在方法上，这个方法内部也能够弄一个代理对象出来
2、class 实现 FactoryBean 接口之外，还能够实现其他接口 BeanClassLoaderAware
回调函数可以拿到这个类是哪个类加载器加载
00：00 - 00：58：543 都在讲一个东西就是FactoryBean

bean的生命周期
进行扫描，扫描类
生成Bean

推断构造方法，加载类之后要实例化对象的话，多个构造方法要选哪一个呢所以会去推断构造方法
属性赋值就是依赖注入

有一个问题，当我们在扫描的时候，扫描到userService这个类的时候，我们没有去加载这个类，我们说的加载这个类指的是生成这个类的class
对象放到jvm中去，我们在扫描的时候没有做到这一步。。。那我们如何发现UserService这个类上面是否有component这个注解呢，第一步进行扫描，然后我们用的asm技术
解析字节码文件识别这个类的信息生成一个beanDefintion

入口：

怎样实例化非懒加载的单例ban

合并之后的bd 叫做rootBd
合并之前的叫做 genericBd
bd常用的类型
bd是接口有实现类
genericbd 是支持拥有父
rootbd 不支持parent
创建bean 一定是拿合并之后的bd 就是拿rootbd，
不会去改扫描出来的bd 就是genricBd
就只是会生成mergedBd

beanName --》mergedMap ==》genercicBeanDefintion -parent -》rootBeanDefintion

合并bean定义

抽象的不能生成bean定义抽象类不能实例化--》

@dependSon 注解
程序员自定义的

a depends on b
b depends on a
无法创建

@component
@dependson("orderService")
public class UserService(){
}

@component
@dependson("userService)
public class OrderService(){
}

RequestScope AbstractRequestAttributesScope
SessionScope AbstractRequestAttributesScope

"RequestScope":RequestScope
"session":SessionScope
get方法
结论：

"request" ,UserService -->>Bean对象 request.getAttribute().get("beanName")
"session" ,UserService -->>Bean对象 session.getAttribute().get("beanName")

doCreateBean spring自带的创建方法
resolveBeforeInstantiation(beanName, mbdToUse); 让程序员自己返回一个bean 实现方法用bean的后置处理器

bean的后置处理器，spring在创建bean的过程中，我们可以设置一些bean的后置处理器去干涉soring创建bean的过程

实例化之前的bean后置处理器得到bean 则再执行初始化后的bean后置处理器因为它跟aop 有关系不能够拒绝aop

填充属性 @Autowired
populateBean(beanName, mbd, instanceWrapper); //

初始化和 BeanPostProcessor 正常AOP BeanPostProcessor
exposedObject = initializeBean(beanName, exposedObject, mbd);
initializeBean 中 1、执行aware
2、初始化之前 @pointConstruct
3、初始化调用实现了InitializingBean 接口的
4、初始化后

对于任何一个bean 他都有一个beanName

还要判断从单例池拿到的bean是不是一个factoryBean

如果是原型的就直接去创建bean 不去单例池拿了

createBean 是如何创建Bean

第一步：
加载类
beanName mbd
如何返回class对象

AbstractBeanDefinition 的
@Nullable
private volatile Object beanClass; // String Class
获取BeanDefinition中所指定的beanClass属性的值，beanClass属性的类型为Object，可以指定为某个类名
// className可以有SpEL,所以需要解析

@Component
public class UserService(){
@value("#{orderService}") // 可以注入成功
private OrderService orderService；

public void test (){

sout(orderService；)}
}

@value("#{orderService1}") 报错

表示是表达式

@value("${orderService1}") 报错
$表示是占位符需要填充用什么填充呢，用的是spring的Enviroment

1、定义properties
2、vm options 的时候指定 -D LunbanXX=123

@Autowired 是先byType 再byName

rootbeandefintion 中 beanclass = "com.lunban.UserService"
beanClass 是一个全限定名去加载类，然后重新设置回bean的class属性
asm技术

spring用什么类加载器去加载类呢 ?

AbstractBeanFactory  
 	@Nullable
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

Thread.CurrentThread().setContextClassLoader(XXX);
applicationContext.getBeanFactroy().setBeanClassLoder(xxx) 程序员自己指定的类加载器
会利用BeanFactory所设置的类加载器来加载类，。

AbstractBeanFactory 类 
 	@Nullable
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

如果没有上面的BeanFactory没有设置，则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载

ClassUtils.getDefaultClassLoader()

优先获取当前线程中的ClassLoader（正常情况下，就是AppClassLoader）
如果为空，则获取加载ClassUtils类的类加载器（正常情况下，就是AppClassLoader，但是如果是在Tomcat中运行，那么则会是Tomcat中为每个应用所创建的WebappClassLoader，tomcat会在前面设置）
如果为空，那么则是bootstrap类加载器加载的ClassUtils类，那则获取系统类加载器进行加载系统类加载器默认返回的是appClassLoader

luban 第三期spring生命周期下 00：53：19
什么叫做bootstrap加载，spring项目的jar包放到 jre/lib下放到这个目录下面的类都会用bootstrap 加载

类加载器的看jvm 里面有讲。。。。。。。。。

// 如果没有设置，则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载
如果BeanFactory所设置的类加载器来加载类为空，则获取加载ClassUtils类的类加载器（正常情况下，就是AppClassLoader，但是如果是在Tomcat中运行，那么则会是Tomcat中为每个应用所创建的WebappClassLoader）

asm技术解析字节码生成bd文件

Object bean = resolveBeforeInstantiation(beanName, mbdToUse); // 对象在doCreateBean之前

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

// 4.1、执行Aware
invokeAwareMethods(beanName, bean); BeanNameAware BeanClassLoaderAware BeanFactoryAware

UserService 实现了InitializingBean，ApplicatioContextAware（对ApplicationContextAwareProcessor）

// 4.2、初始化前
ApplicatioContextAware 在初始化前执行对ApplicationContextAwareProcessor ---》applyBeanPostProcessorsBeforeInitialization

// 4.2、初始化前
@pointConstruct注解 ---》applyBeanPostProcessorsBeforeInitialization InitDestroyAnnotationBeanPostProcess --》找注解 pointConstruct注解 preDestroy 注解
InitDestroyAnnotationBeanPostProcess -》CommonAnnotationBeanPostProcess 的父类

// 4.3、初始化
afterPropertiesSet 在初始化时候执行 ---》invokeInitMethods(beanName, wrappedBean, mbd);

有一个判断逻辑为什么不行，因为luBanBeanPostProcess 的postProcessBeforeInitialization 方法返回空了，而且因为luBanBeanPostProcess 优于InitDestroyAnnotationBeanPostProcess 执行，只要保证
luBanBeanPostProcess 的postProcessBeforeInitialization 方法执行不为空就能让 CommonAnnotationBeanPostProcess（InitDestroyAnnotationBeanPostProcess) 执行的postProcessBeforeInitialization （调用@pointConStruct方法）
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {

	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		// BPP1--》BPP2-->BPP3
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

上一个beanPostProcess 执行完之后没有返回下一个bpp 就不会执行

加载类
实例化前 --》 bpp InstantiationAwareBeanPostProcessor 只有他有 postProcessBeforeInstantiation
实例化
BeanDefinition的后置处理 --》对bd进行操作 BeanDefinition的后置处理 MergedBeanDefinitionPostProcessor --》 postProcessMergedBeanDefinition
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 运行修改合并好了的BeanDefinition
// 这里会查找@Autowired的注入点(InjectedElement)，并把这些注入点添加到mbd的属性externallyManagedConfigMembers中
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}

实例化后 --》 bpp InstantiationAwareBeanPostProcessor 只有他有 postProcessAfterInstantiation
填充属性
填充属性后 --》 InstantiationAwareBeanPostProcessors 中的 postProcessPropertyValues 、postProcessProperties 进行依赖注入
aware
初始化前 --》 bpp postProcessBeforeInitialization
初始化
初始化后 --》 bpp postProcessAfterInitialization

实例化前 --》 bpp InstantiationAwareBeanPostProcessor 只有他有 postProcessBeforeInstantiation 这边返回bean了就直接执行初始化后的方法
初始化后 --》 bpp postProcessAfterInitialization
// 实例化前
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	// beforeInstantiationResolved为null或true
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
				// 实例化前
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

// 2、实例化
if (instanceWrapper == null) {
// 创建bean实例 new USerSerive()
instanceWrapper = createBeanInstance(beanName, mbd, args); 这里回进行推造构造方法，我们要选哪一个构造方法呢后面会将
}

实例化前返回对象就不会填充属性
实例化后返回false 就不会填充属性

@Component
public class LubanMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    if (beanName.equals("userService")) {
        beanDefinition.setBeanClass(User.class); // 没用
		 beanDefinition.setInitMethodName("initLuBan");
        beanDefinition.getPropertyValues().add("name","xxx");
    }
}

}

@component
public class UserService{
public void initLuBan(){
sout("initLuBan");
}

}

在初始化的方法中
invokeInitMethods(beanName, wrappedBean, mbd);

西面这段代码在初始化的最后

if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd); // init-method=""
}
}
就会执行这段代码很六六六。。

初始化的过程可以做验证。。。。。 spring提供了各种钩子函数。。。。