目录
目录
四、聊一下@PostConstruct和@PreDestroy注解的原理
2、MergedBeanDefinitionPostProcessors方法
3、处理@PostConstruct和@PreDestroy注解
一、前言
这篇文章主要是聊到以下几个比较重要的点
一、多例情况下构造器的缓存，主要作用：同一个线程里面多次获取Bean，不用重新寻找构造器进行实例化
① 默认构造器的缓存
② 有参构造器的缓存
③ Autowirte指定构造器缓存
注意点：指定多个Autowirte或报错，反正与xml的构造方法配置一致就可以（这里不需要纠结，自己去尝试多几次就可以了）
构造器的选择两个亮点
①根据排序
②使用缓存
二、实例化的五种策略-InstantiationStrategy-SimpleInstantiationStrategy-CgbliSimpleInstatiationStrategy
① 默认无参实例化
② 有参数实例化
③ 工厂实例化
④ 代理模式无参实例化
⑤ 代理模式有参数实例化
三、实例化完成后把对象封装成Wrapper包装类对象
① 封装编辑器
② 封装转化器
四、MergedBeanDefinitionBeanPostProcessor 之@PostConstruct和 @PreDestroy 和@Resource原理
① 获取元数据类
② 注册到BeanDefinition里面去，供后面使用
关于BeanPostProcess的四个实现类
① InstantiationAwareBeanPostProcessor -之前通过该类生成代理类的时候实现路过
② SmartInstantiationAwareBeanPostProcessor -AutoWirte指定构造器的时候使用过
③ MergedBeanDefinitionBeanPostProcessor -实例化完成后 修改合并BeanDefinition的时候使用过
④ DestructAwareBeanPostProcessor
二、Bean实例化构造器的选择
1、createBeanInstance方法解读
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 确认需要创建的bean实例的类可以实例化
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 确保class不为空，并且访问权限是public
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
// 判断当前beanDefinition中是否包含实例供应器，此处相当于一个回调方法，利用回调方法来创建bean
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果工厂方法不为空则使用工厂方法初始化策略
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 一个类可能有多个构造器，所以Spring得根据参数个数、类型确定需要调用的构造器
// 在使用构造器创建实例后，Spring会将解析过后确定下来的构造器或工厂方法保存在缓存中，避免再次创建相同bean时再次解析
// Shortcut when re-creating the same bean...
// 标记下，防止重复创建同一个bean
boolean resolved = false;
// 是否需要自动装配
boolean autowireNecessary = false;
// 如果没有参数
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 因为一个类可能由多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数。
// 因为判断过程会比较，所以spring会将解析、确定好的构造函数缓存到BeanDefinition中的resolvedConstructorOrFactoryMethod字段中。
// 在下次创建相同时直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值获取，避免再次解析
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 有构造参数的或者工厂方法
if (resolved) {
// 构造器有参数
if (autowireNecessary) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 使用默认构造函数构造
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
// 从bean后置处理器中为自动装配寻找构造方法, 有且仅有一个有参构造或者有且仅有@Autowired注解构造
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 以下情况符合其一即可进入
// 1、存在可选构造方法
// 2、自动装配模型为构造函数自动装配
// 3、给BeanDefinition中设置了构造参数值
// 4、有参与构造函数参数列表的参数
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
// 找出最合适的默认构造方法
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有@AutoWired注解构造，会报错
return instantiateBean(beanName, mbd);
}2、autowireConstructor
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
// 实例化BeanWrapper。是包装bean的容器
BeanWrapperImpl bw = new BeanWrapperImpl();
// 给包装对象设置一些属性
this.beanFactory.initBeanWrapper(bw);
// spring对这个bean进行实例化使用的构造函数
Constructor<?> constructorToUse = null;
// spring执行构造函数使用的是参数封装类
ArgumentsHolder argsHolderToUse = null;
// 参与构造函数实例化过程的参数
Object[] argsToUse = null;
// 如果传入参数的话，就直接使用传入的参数
if (explicitArgs != null) {
//让argsToUse引用explicitArgs
argsToUse = explicitArgs;
}
// 没有传入参数的话就走else
else {
//声明一个要解析的参数值数组，默认为null
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
// 获取BeanDefinition中解析完成的构造函数
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
// BeanDefinition中存在构造函数并且存在构造函数的参数，赋值进行使用
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
// 从缓存中找到了构造器，那么继续从缓存中寻找缓存的构造器参数
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
// 没有缓存的参数，就需要获取配置文件中配置的参数
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
// 如果缓存中没有缓存的参数的话，即argsToResolve不为空，就需要解析配置的参数
if (argsToResolve != null) {
// 解析参数类型，比如将配置的String类型转换为list、boolean等类型
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
}
}
//如果constructorToUse为null或者argsToUser为null
if (constructorToUse == null || argsToUse == null) {
// Take specified constructors, if any.
// 如果传入的构造器数组不为空，就使用传入的过后早期参数，否则通过反射获取class中定义的构造器
Constructor<?>[] candidates = chosenCtors;
//如果candidates为null
if (candidates == null) {
//获取mbd的Bean类
Class<?> beanClass = mbd.getBeanClass();
try {
// 使用public的构造器或者所有构造器
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
//捕捉获取beanClass的构造函数发出的异常
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
}
//如果candidateList只有一个元素 且 没有传入构造函数值 且 mbd也没有构造函数参数值
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
//获取candidates中唯一的方法
Constructor<?> uniqueCandidate = candidates[0];
//如果uniqueCandidate不需要参数
if (uniqueCandidate.getParameterCount() == 0) {
//使用mdb的构造函数字段的通用锁【{@link RootBeanDefinition#constructorArgumentLock}】进行加锁以保证线程安全
synchronized (mbd.constructorArgumentLock) {
//让mbd缓存已解析的构造函数或工厂方法
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
//让mbd标记构造函数参数已解析
mbd.constructorArgumentsResolved = true;
//让mbd缓存完全解析的构造函数参数
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
//使用constructorToUse生成与beanName对应的Bean对象,并将该Bean对象保存到bw中
bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
//将bw返回出去
return bw;
}
}
// Need to resolve the constructor.
// 自动装配标识，以下有一种情况成立则为true，
// 1、传进来构造函数，证明spring根据之前代码的判断，知道应该用哪个构造函数，
// 2、BeanDefinition中设置为构造函数注入模型
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
//定义一个用于存放解析后的构造函数参数值的ConstructorArgumentValues对象
ConstructorArgumentValues resolvedValues = null;
// 构造函数的最小参数个数
int minNrOfArgs;
// 如果传入了参与构造函数实例化的参数值，那么参数的数量即为最小参数个数
if (explicitArgs != null) {
//minNrOfArgs引用explitArgs的数组长度
minNrOfArgs = explicitArgs.length;
}
else {
// 提取配置文件中的配置的构造函数参数
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
// 用于承载解析后的构造函数参数的值
resolvedValues = new ConstructorArgumentValues();
// 能解析到的参数个数
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// 对候选的构造函数进行排序，先是访问权限后是参数个数
// public权限参数数量由多到少
AutowireUtils.sortConstructors(candidates);
// 定义一个差异变量，变量的大小决定着构造函数是否能够被使用
int minTypeDiffWeight = Integer.MAX_VALUE;
// 不明确的构造函数集合，正常情况下差异值不可能相同
Set<Constructor<?>> ambiguousConstructors = null;
//定义一个用于UnsatisfiedDependencyException的列表
LinkedList<UnsatisfiedDependencyException> causes = null;
// 循环候选的构造函数
for (Constructor<?> candidate : candidates) {
// 获取参数的个数
int parameterCount = candidate.getParameterCount();
// 如果已经找到选用的构造函数或者需要的参数个数小于当前的构造函数参数个数则终止，前面已经经过了排序操作
if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
// Already found greedy constructor that can be satisfied ->
// do not look any further, there are only less greedy constructors left.
break;
}
//如果本构造函数的参数列表数量小于要求的最小数量，则遍历下一个
if (parameterCount < minNrOfArgs) {
// 参数个数不相等
continue;
}
// 存放构造函数解析完成的参数列表
ArgumentsHolder argsHolder;
// 获取参数列表的类型
Class<?>[] paramTypes = candidate.getParameterTypes();
// 存在需要解析的构造函数参数
if (resolvedValues != null) {
try {
// 获取构造函数上的ConstructorProperties注解中的参数
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
// 如果没有上面的注解，则获取构造函数参数列表中属性的名称
if (paramNames == null) {
// 获取参数名称探索器
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 获取指定构造函数的参数名称
paramNames = pnd.getParameterNames(candidate);
}
}
// 根据名称和数据类型创建参数持有者
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
}
catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next constructor.
// 吞下并尝试下一个重载的构造函数
// 如果cause为null
if (causes == null) {
//对cause进行实例化成LinkedList对象
causes = new LinkedList<>();
}
//将ex添加到causes中
causes.add(ex);
continue;
}
}
// 不存在构造函数参数列表需要解析的参数
else {
// Explicit arguments given -> arguments length must match exactly.
// 如果参数列表的数量与传入进来的参数数量不相等，继续遍历，否则构造参数列表封装对象
if (parameterCount != explicitArgs.length) {
continue;
}
// 构造函数没有参数的情况
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 计算差异量，根据要参与构造函数的参数列表和本构造函数的参数列表进行计算
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this constructor if it represents the closest match.
// 本次的构造函数差异值小于上一个构造函数，则进行构造函数更换
if (typeDiffWeight < minTypeDiffWeight) {
// 将确定使用的构造函数设置为本构造
constructorToUse = candidate;
// 更换使用的构造函数参数封装类
argsHolderToUse = argsHolder;
// 更换参与构造函数实例化的参数
argsToUse = argsHolder.arguments;
// 差异值更换
minTypeDiffWeight = typeDiffWeight;
// 不明确的构造函数列表清空为null
ambiguousConstructors = null;
}
// 差异值相等，则表明构造函数不正常，放入异常集合
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
//如果ambiguousFactoryMethods为null
if (ambiguousConstructors == null) {
//初始化ambiguousFactoryMethods为LinkedHashSet实例
ambiguousConstructors = new LinkedHashSet<>();
//将constructorToUse添加到ambiguousFactoryMethods中
ambiguousConstructors.add(constructorToUse);
}
//将candidate添加到ambiguousFactoryMethods中
ambiguousConstructors.add(candidate);
}
}
//以下两种情况会抛异常
// 1、没有确定使用的构造函数
// 2、存在模糊的构造函数并且不允许存在模糊的构造函数
if (constructorToUse == null) {
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Could not resolve matching constructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous constructor matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousConstructors);
}
/**
* 没有传入参与构造函数参数列表的参数时，对构造函数缓存到BeanDefinition中
* 1、缓存BeanDefinition进行实例化时使用的构造函数
* 2、缓存BeanDefinition代表的Bean的构造函数已解析完标识
* 3、缓存参与构造函数参数列表值的参数列表
*/
if (explicitArgs == null && argsHolderToUse != null) {
// 将解析的构造函数加入缓存
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 将构造的实例加入BeanWrapper中
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}二、BeanPostProcess四个实现中的哪里会用到
@Autowired注解构造使用注意
SmartInstantiationAwareBeanPostProcess
* 获取构造器集合 * 如果有多个Autowired，required为true，不管有没有默认构造方法，会报异常 * 如果只有一个Autowired，required为false，没有默认构造方法，会报警告 * 如果没有Autowired注解，定义了两个及以上有参数的构造方法，没有无参构造方法，就会报错 ??? * 其他情况都可以，但是以有Autowired的构造方法优先，然后才是默认构造方法
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
throws BeanCreationException {
// Let's check for lookup methods here...
// 处理包含@Loopup注解的方法，如果集合中没有beanName，则走一遍bean中的所有方法，过滤是否含有lookup方法
if (!this.lookupMethodsChecked.contains(beanName)) {
if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
try {
Class<?> targetClass = beanClass;
do {
// 遍历当前类以及所有父类，找出lookup注解的方法进行处理
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// 获取method上的Lookup注解
Lookup lookup = method.getAnnotation(Lookup.class);
// 存在此注解的话，就将方法和注解中的内容构建LookupOverride对象，设置进BeanDefinition中
if (lookup != null) {
Assert.state(this.beanFactory != null, "No BeanFactory available");
LookupOverride override = new LookupOverride(method, lookup.value());
try {
RootBeanDefinition mbd = (RootBeanDefinition)
this.beanFactory.getMergedBeanDefinition(beanName);
mbd.getMethodOverrides().addOverride(override);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(beanName,
"Cannot apply @Lookup to beans without corresponding bean definition");
}
}
});
targetClass = targetClass.getSuperclass();
}
//遍历父类，直到Object
while (targetClass != null && targetClass != Object.class);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
}
}
// 无论对象中是否含有@Lookup方法，过滤完成后都会放到集合中，证明此bean已经检查完@Lookup注解
this.lookupMethodsChecked.add(beanName);
}
// Quick check on the concurrent map first, with minimal locking.
// 从缓存中拿构造函数，不存在的话就进入代码块中再拿一遍，还不存在的话就进行下方的逻辑，
Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
// 没找到再同步
if (candidateConstructors == null) {
// Fully synchronized resolution now...
synchronized (this.candidateConstructorsCache) {
//再检测一遍，双重检测
candidateConstructors = this.candidateConstructorsCache.get(beanClass);
if (candidateConstructors == null) {
Constructor<?>[] rawCandidates;
try {
//获取bean中所有的构造函数
rawCandidates = beanClass.getDeclaredConstructors();
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
// 暂时候选构造函数集合，
List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
// 带有依赖项的构造函数
Constructor<?> requiredConstructor = null;
// 默认使用的构造函数
Constructor<?> defaultConstructor = null;
// 获取主构造函数
Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
// 标识，表示不是合成构造函数的数量
// 合成构造函数->有方法参数并对实例进行赋值的构造函数
int nonSyntheticConstructors = 0;
// 遍历所有的构造函数
for (Constructor<?> candidate : rawCandidates) {
// 构造函数不是合成构造函数，标识累加
if (!candidate.isSynthetic()) {
nonSyntheticConstructors++;
}
else if (primaryConstructor != null) {
continue;
}
// 查找构造函数上@Autowired注解的属性，
MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
// 注解不存在，则再通过方法获取用户类，如果是用户类则返回用户类，还判断了cglib的情况，cglib情况则返回目标类
// 然后获取参数一致的构造函数再获取注解
if (ann == null) {
Class<?> userClass = ClassUtils.getUserClass(beanClass);
// 如果是有代理的，找到被代理
if (userClass != beanClass) {
try {
// 获取构造方法
Constructor<?> superCtor =
userClass.getDeclaredConstructor(candidate.getParameterTypes());
//继续寻找Autowired和value的注解
ann = findAutowiredAnnotation(superCtor);
}
catch (NoSuchMethodException ex) {
// Simply proceed, no equivalent superclass constructor found...
}
}
}
// 构造函数上存在注解
if (ann != null) {
//有两个Autowired注解，冲突了
if (requiredConstructor != null) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructor: " + candidate +
". Found constructor with 'required' Autowired annotation already: " +
requiredConstructor);
}
// 获取@Autowired注解中required属性的值
boolean required = determineRequiredStatus(ann);
// 为true则将这个构造函数设置为带有依赖项的构造函数并进行判断，不可存在多个带有依赖项的构造函数
if (required) {
//如果已经有required=false了，又来了一个required=true的方法就报异常了，这样两个可能就不知道用哪个了
if (!candidates.isEmpty()) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructors: " + candidates +
". Found constructor with 'required' Autowired annotation: " +
candidate);
}
requiredConstructor = candidate;
}
// 加入集合
candidates.add(candidate);
}
// 如果构造函数的参数为零，则是默认构造函数
else if (candidate.getParameterCount() == 0) {
defaultConstructor = candidate;
}
}
// 存在@Autowired注解的函数，并且required值为false，则此注解不起作用，但是存在默认构造函数
// 则将默认构造函数添加到集合中，并将集合变为数组使用
if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
if (requiredConstructor == null) {
if (defaultConstructor != null) {
//添加默认构造函数
candidates.add(defaultConstructor);
}
else if (candidates.size() == 1 && logger.isInfoEnabled()) {
logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
"': single autowire-marked constructor flagged as optional - " +
"this constructor is effectively required since there is no " +
"default constructor to fall back to: " + candidates.get(0));
}
}
candidateConstructors = candidates.toArray(new Constructor<?>[0]);
}
// 如果只存在一个构造函数，且这个构造函数有参数列表，则使用这个构造函数
else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
//只有一个函数且有参数
candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
}
// 如果非合成构造存在两个且有主构造和默认构造，且主构造和默认构造不相等，则这两个一块使用
else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
//有两个非合成方法，有优先方法和默认方法，且不相同
candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
}
// 如果只有一个非合成构造且有主构造，使用主构造
else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
//只有一个优先的
candidateConstructors = new Constructor<?>[] {primaryConstructor};
}
// 否则没有能够直接使用的构造
else {
//大于2个没注解的构造方法就不知道要用什么了，所以就返回null
candidateConstructors = new Constructor<?>[0];
}
this.candidateConstructorsCache.put(beanClass, candidateConstructors);
}
}
}
// 使用构造列表中没有值，则返回null
return (candidateConstructors.length > 0 ? candidateConstructors : null);
}三、实例化几种策略
1、instantiateBean入口
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(
(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
getAccessControlContext());
}
else {
// 获取实例化策略并且进行实例化操作
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
}
// 包装成BeanWrapper
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}2、获取实例化策略并且进行实例化操作主要有以下几种
四、聊一下@PostConstruct和@PreDestroy注解的原理
1、入口代码：doCreateBean下
// Allow post-processors to modify the merged bean definition.
// 允许beanPostProcessor去修改合并的beanDefinition
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// MergedBeanDefinitionPostProcessor后置处理器修改合并bean的定义
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}2、MergedBeanDefinitionPostProcessors方法
/**
* 应用MergedBeanDefinitionPostProcessors类型的beanPostProcessor到指定的beanDefinition中，
* 执行postProcessMergedBeanDefinition方法
*
* Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
* invoking their {@code postProcessMergedBeanDefinition} methods.
* @param mbd the merged bean definition for the bean
* @param beanType the actual type of the managed bean instance
* @param beanName the name of the bean
* @see MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
*/
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}3、处理@PostConstruct和@PreDestroy注解
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
// 处理@PostConstruct和@PreDestroy注解
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
//找出beanType所有被@Resource标记的字段和方法封装到InjectionMetadata中
InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}五、小总结
小编熬夜写这篇文章写得比较急，就不做总结了，hhhhh
1045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
