Spring bean 创建过程源码解析
在上一篇文件 Spring 中 bean 注册的源码解析 中分析了 Spring 中 bean 的注册过程，就是把配置文件中配置的 bean 的信息加载到内存中，以 BeanDefinition 对象的形式存放，该对象中存放了 bean 的相关属性，下面就以 debug 的形式一步步来看下 bean 是如何创建的。
Spring 中 bean 的创建可以说是非常的复杂，方法嵌套很多，为了更好的理清创建过程，画了下面的 UML 图：
从上述 UML 图中，可以看出 bean 的创建主要分为以下几步：
1. 根据 bean 的 name 解析对应的 class
2. 处理 lookup-metod 和 replace-method 子标签
3. 处理初始化前的后置处理器
4. 真正的创建 bean
4.1 创建 bean 实例
4.1.1 工厂方法创建
4.1.2 带参数的构造方法创建
4.1.3 默认的构造方法创建
4.2
4.3 添加单例对象的工厂缓存
4.4 填充对象的各种属性
4.4.1 名称注入
4.4.2 类型注入
4.5 处理 init-method 方法
4.5.1 处理 bean 的前置处理器
4.5.2 执行 init-method 方法
4.5.3 处理 bean 的后置处理器
创建过程
创建 bean 的代码是在 AbstractAutowireCapableBeanFactory 类中开始创建的，在分析的过程中，会把一些代码省略掉，如异常处理等：
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
// 表示 <bean> 标签，里面有各种属性
RootBeanDefinition mbdToUse = mbd;
// 根据设置的 class 属性或 className 来解析 class，
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 处理 lookup-method 和 replace-method 子标签
mbdToUse.prepareMethodOverrides();
// 给 BeanPostProcessors 机会返回一个代理来代替bean的实例
// 即在初始化前，应用后置处理器，解析指定的bean是否存在初始化前的短路操作
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
// 创建 bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
处理 lookup-method 和 replace-method 子标签
这两个标签虽然不常用，但是是很有用的，这里不再细说；在 Spring 中 bean 注册的源码解析 中 这两个标签会被解析放到 BeanDefinition 对象的 methodOverrides 属性中，表示需要覆盖的方法；所以在创建bean之前需要解析这两个标签，但是只是预处理：
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
// Check that lookup methods exists.
MethodOverrides methodOverrides = getMethodOverrides();
if (!methodOverrides.isEmpty()) {
Set<MethodOverride> overrides = methodOverrides.getOverrides();
synchronized (overrides) {
for (MethodOverride mo : overrides) {
prepareMethodOverride(mo);
}
}
}
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
// 获取对应类的方法的个数
int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
if (count == 0) {
throw new BeanDefinitionValidationException("...");
}
// 标记 MethodOverride 未被覆盖，避免了后面参数类型检查的开销
else if (count == 1) {
mo.setOverloaded(false);
}
}
在处理 prepareMethodOverride(MethodOverride mo) 方法为什么只处理方法个数为 1 的情况呢？如果一个类中有多个重载的方法，则调用或增强的时候，还需要进行参数类型的解析才能确定调用的是哪个方法，Spring 把部分功能放在这里提前进行预处理，如果方法只有一个，即没有重载的方法，在后面调用的时候，直接找到该方法调用，不用再去解析参数来确定方法了，这样就可以避免的一些参数类型检查的开销。
实例化的前置处理
如果经过前置处理后的结果不为空，则直接返回，不再进行bean的创建过程，AOP功能就是在这里判断的：
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// bean 的前置处理器
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// bean 的后置处理器
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
创建 bean
当经过 resolveBeforeInstantiation 方法后，如果程序创建了代理，或者执行了 applyBeanPostProcessorsBeforeInstantiation 和 applyBeanPostProcessorsAfterInitialization 方法后，bean 被改变了，则直接返回，否则，会进行创建bean操作：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {
// 最终返回的 bean 的包装类
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 如果是单例，则检查工厂缓存中以前是否创建过
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建bean，工厂方法创建，构造方法创建，默认构造方法创建等
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
// 应用 MergedBeanDefinitionPostProcessors
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// 检查循环依赖：是否是单例 && 是否允许循环依赖 && 当前bean是否正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 为了避免后期的循环依赖，在bean初始化完成前，将创建bean的工厂添加到缓存中，如果其他的bean依赖该bean，直接从缓存中获取对应的工厂创建集合，解决循环依赖，注意是只有单例情况才能这么做
addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 初始化 bean
Object exposedObject = bean;
// 填充属性
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 执行初始化方法，如 init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
if (earlySingletonExposure) {
// 只有在检测到循环依赖时才不会为空
Object earlySingletonReference = getSingleton(beanName, false);
// 存在循环依赖
if (earlySingletonReference != null) {
// 如果 exposedObject 在初始化方法中没有被改变，即没有被增强
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 检测依赖
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// 因为bean创建后，所依赖的bean一定是已经创建完毕的，actualDependentBeans 不为空则表示所依赖的bean还没有创建完，即存在循环依赖
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException("");
}
}
}
}
// 根据 score 注册 bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
}
上面创建 bean 的过程很复杂，分为很多步骤，下面再来看看这些步骤：
创建bean实例
创建 bean 的实例，会根据策略使用不同的创建方法，比如说 构造方法创建， 工厂方法创建，默认的构造方法创建等：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 获取 bean 对应的 class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 如果工厂方法不为空，则使用工厂方法创建
if (mbd.getFactoryMethodName(www.mcyllpt.com) != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 一个类有多个构造方法，带有不同的参数，所以调用前，需要根据参数解析出需要调用的构造方法，
// 这里使用了缓存，如果以前解析过构造方法，则在这里直接使用即可。
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
// 构造方法自动注入
return autowireConstructor(www.furggw.com beanName, mbd, null, null);
}
else {
// 默认构造方法自动注入
return instantiateBean(beanName, mbd);
}
}
// 解析构造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues(www.yigouyule2.cn) || !ObjectUtils.isEmpty(args)) {
// 构造方法自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// 默认构造方法自动注入
return instantiateBean(beanName, mbd);
}
参数的构造方法注入
先来看下带参数的构造方法自动注入,
public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
Constructor<?>[] chosenCtors, final Object[www.wanmeiyuele.cn] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(www.michenggw.com);
Constructor<www.dasheng178.com/> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// explicitArgs 参数通过 getBean() 方法传入，Object getBean(String name, Object... args)
if (explicitArgs !=www.gcyL157.com null) {
// 如果 getBean 方法传入了参数，则直接使用
argsToUse = explicitArgs;
}
else {
// 如果 getBean 方法没有传入参数，则从配置文件进行解析
Object[] argsToResolve = null;
// 从缓存中获取
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
// 配置的构造方法参数
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
}
}
// 该构造没有被缓存，则需要进行解析
if (constructorToUse == null) {
boolean autowiring = (chosenCtors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
// 参数个数
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}
else {
// 获取配置文件中配置的构造方法参数
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
// 获取参数个数
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
// 排序构造方法，按照参数个数进行排序
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
for (Constructor<?> candidate : candidates) {
Class<?>[] paramTypes = candidate.getParameterTypes();
if (constructorToUse != null && argsToUse.length > paramTypes.length) {
// 如果已经找到满足条件的构造方法，则终止
break;
}
if (paramTypes.length < minNrOfArgs) {
continue;
}
ArgumentsHolder argsHolder;
if (resolvedValues != null) {
// 构造方法参数的名字
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
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);
}
else {
// 构造方法没有参数
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 检查是否有不确定性构造方法的存在，如参数为父子关系
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
if (typeDiffWeight < minTypeDiffWeight) {
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<Constructor<?>>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
if (constructorToUse == null) {
throw new BeanCreationException("...")
}
// 将解析的构造方法加入缓存
if (explicitArgs == null) {
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
// 实例化
Object beanInstance;
if (System.getSecurityManager() != null) {
final Constructor<?> ctorToUse = constructorToUse;
final Object[] argumentsToUse = argsToUse;
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
return beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
}
}, beanFactory.getAccessControlContext());
}
else {
beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
}
bw.setBeanInstance(beanInstance);
return bw;
}
上面的方法就是使用构造方法进行实例化bean的过程，很复杂，也有很多的辅助方法，下面来看下实例化的过程：
实例化有两种方式，CGLIB 和 反射：
beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, ctorToUse);
先来看下 getInstantiationStrategy 方法返回什么？
protected InstantiationStrategy getInstantiationStrategy() {
return this.instantiationStrategy;
}
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
它返回的是 InstantiationStrategy 接口，而接口由两个实现类：
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
final Constructor<?> ctor, Object... args) {
// 如果没有需要动态改变的方法，则直接使用反射进行实例化
if (bd.getMethodOverrides().isEmpty()) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
ReflectionUtils.makeAccessible(ctor);
return null;
}
});
}
// 使用 反射 实例化
return BeanUtils.instantiateClass(ctor, args);
}
else {
// 如果需要覆盖或者动态替换的方法，则需要使用 CGLIB 来动态代理，在创建代理的时候，可以增强植入我们的代码
return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
}
}
使用工厂方法创建实例和构造方法参不多，使用默认的构造方法实例化比较简单，这里就不列出来了。
属性填充
在上面分析 doCreateBean 方法的时候，当通过 工厂方法，带参数的构造方法或默认的构造方法创建了 bean 实例后，需要对 bean 的属性进行设置
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
// 给 InstantiationAwareBeanPostProcessor 最后一次机会在属性设置前来改变 bean
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// postProcessAfterInstantiation 返回值为是否继续填充 bean
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 名称注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 类型注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 后处理器已经初始化
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 对所有需要依赖检查的属性进行后置处理
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(),beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 将属性应用到 bean 中
applyPropertyValues(beanName, mbd, bw, pvs);
}
关于 名称 注入和类型注入，后面单独分析
将属性应用到 bean 中：
到这里，已经完成了对注入属性的获取，但是获取的是 PropereyValues 的形式存在，现在将他们应用到 bean 中去:
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs == null || pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
// 如果 mpvs 中的值已经被转换为对应的类型，则可以直接设置到 beanWapper 中
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
bw.setPropertyValues(mpvs);
return;
}
original = mpvs.getPropertyValueList();
}
else {
// 如果 pvs 不是 MutablePropertyValues 封装的类，则直接使用原始的属性获取方法
original = Arrays.asList(pvs.getPropertyValues());
}
// 获取用户自定义的类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
/ 获取对应的解析器
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
// 遍历属性，将属性转换为对应类的对应属性的类型
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
执行初始化方法
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
// 执行用户自定义的各种 aware 方法
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 在执行 init 方法之前，先执行 前置处理器 applyBeanPostProcessorsBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// 执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
// 执行后置处理器 applyBeanPostProcessorsAfterInitialization
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
// 执行用户自定义的各种 aware 方法
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
到这里，bean 创建的大致过程就结束了
Spring bean 创建过程源码解析的更多相关文章
- Spring IOC容器启动流程源码解析(四)——初始化单实例bean阶段
目录 1. 引言 2. 初始化bean的入口 3 尝试从当前容器及其父容器的缓存中获取bean 3.1 获取真正的beanName 3.2 尝试从当前容器的缓存中获取bean 3.3 从父容器中查找b ...
- Spring加载流程源码分析03【refresh】
前面两篇文章分析了super(this)和setConfigLocations(configLocations)的源代码,本文来分析下refresh的源码, Spring加载流程源码分析01[su ...
- springboot 事务创建流程源码分析
springboot 事务创建流程源码分析 目录 springboot 事务创建流程源码分析 1. 自动加载配置 2. InfrastructureAdvisorAutoProxyCreator类 3 ...
- Hadoop中Yarnrunner里面submit Job以及AM生成 至Job处理过程源码解析
参考 http://blog.csdn.net/caodaoxi/article/details/12970993 Hadoop中Yarnrunner里面submit Job以及AM生成 至Job处理 ...
- 基于Spring注解的上下文初始化过程源码解析（一）
最近工作之余有时间和精力,加上平时对源码比较感兴趣,就开始啃起了Spring源码.为加深印象写了这篇博客,如有错误,望各位大佬不吝指正. 我看的是Spring5的源码,从同性社区download下来后 ...
- 【Spring】Spring IOC原理及源码解析之scope=request、session
一.容器 1. 容器 抛出一个议点:BeanFactory是IOC容器,而ApplicationContex则是Spring容器. 什么是容器?Collection和Container这两个单词都有存 ...
- Spring中AOP相关源码解析
前言 在Spring中AOP是我们使用的非常频繁的一个特性.通过AOP我们可以补足一些面向对象编程中不足或难以实现的部分. AOP 前置理论 首先在学习源码之前我们需要了解关于AOP的相关概念如切点切 ...
- Spring Boot系列（三）：Spring Boot整合Mybatis源码解析
一.Mybatis回顾 1.MyBatis介绍 Mybatis是一个半ORM框架,它使用简单的 XML 或注解用于配置和原始映射,将接口和Java的POJOs(普通的Java 对象)映射成数据库中的记 ...
- Spring Boot @Enable*注解源码解析及自定义@Enable*
Spring Boot 一个重要的特点就是自动配置,约定大于配置,几乎所有组件使用其本身约定好的默认配置就可以使用,大大减轻配置的麻烦.其实现自动配置一个方式就是使用@Enable*注解,见其名知 ...
随机推荐
- ThinkPHP路由去掉隐藏URL中的index.php
官方默认的.htaccess文件 <IfModule mod_rewrite.c> Options +FollowSymlinks -Multiviews RewriteEngine On ...
- PHP处理mysql事务
MYSQL的事务处理主要有两种方法.1.用begin,rollback,commit来实现begin 开始一个事务rollback 事务回滚commit 事务确认2.直接用set来改变mysql的自动 ...
- [Codeforces86D]Powerful array(莫队算法)
题意:定义K[x]为元素x在区间[l,r]内出现的次数,那么它的贡献为K[x]*K[x]*x 给定一个序列,以及一些区间询问,求每个区间的贡献 算是莫队算法膜版题,不带修改的 Code #includ ...
- sparkStreaming统计各平台最近一分钟实时注册收入 时间段，平台，金额，订单数
样例数据: __clientip=10.10.9.153&paymentstatus=0&__opip=&memberid=89385239&iamount=1& ...
- java线程安全总结 - 2 （转载）
原文地址:http://www.jameswxx.com/java/%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E6%80%BB%E7%BB%93%EF%BC%88%E4 ...
- Android 时间计算工具 通用类TimeUtil
1.整体分析 1.1.源代码如下,可以直接Copy. public class TimeUtil { private static final String TAG = "TimeUtil& ...
- Windows系统安装测试redis
因本人电脑是windows系统,从https://github.com/ServiceStack/redis-windows下载了兼容windows系统的redis 下载后直接解压到D:\redis目 ...
- JavaSE总结--异常
throwable Error: Exception: 编译型异常: 运行时异常:
- 找出Xcode没有使用的图片
#! /bin/sh PROJ=`find . -name '*.xib' -o -name '*.[mh]'` for png in ` find . -name '*.png'` do name ...
- atomic integer 实现
public final int getAndAddInt(Object o, long offset, int delta) { int v; do { v = getIntVolatile(o, ...