GetBean源码全面解读
前言
在上篇文章刨坑的过程中，顺便研究了一波spring源码，初始看的也是头晕，后面逐渐捋好了思路。个人感觉spring还是个大工程的，这篇文章解读的肯定也有自己理解不到位的部分，希望各位看官能多讨论讨论。最后会附上一副getBean方法的流程图，希望能打开大家看这部分源码的思路。(本文基于spring 5.1.2版本)
GetBean源码部分
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//会包括解析别名等操作
final String beanName = transformedBeanName(name);
Object bean;
// 先检查单例列表中是否已经注册了这个bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 检查bean是否并发被创建
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查是否在父类工厂中,逻辑和这个差不多,这里省略....
//标记bean正在被创建
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//合并父类中的方法及属性,下面会细讲
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查这个bean是否为抽象类
checkMergedBeanDefinition(mbd, beanName, args);
// 这里是为了保证获取的bean的依赖都需要先生成
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex){
throw ex;
}
}
}
// 创建单例的bean,看下方的createBean方法
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查需要的类型和实际传参类型是否一致. 这里省略....
return (T) bean;
}
复制代码
整个操作大概是以下几步:
- 获取实际的beanName,其中会处理带&号前缀的beanName，并解析别名。
- 检查单例列表中是否存在该beanName的bean，若存在则无需走下面的创建bean的流程。
- 若单例列表中并不存在此bean，则检查是否有并发创建。这里的判断只针对scope为prototype类型的bean。
- 检查bean是否存在于父类工厂中，若存在，则走父类工厂的getBean流程。向上委托，保证容器中只会存在一个同名的bean。
- 标记bean正在被创建。
- 如果有父类，这里会递归合并父类的方法以及属性。并会用自己重写的方法覆盖其父类的方法。合并完成并检查这个bean的是否是抽象类。
- 如果该bean上有注解@DependsOn,或者配置文件上配置有该属性,则需保证该bean的所有依赖需要先在容器内注册。
- 分单例和原型以及其他scope类型来创建bean。
- 检查需要的类型和生成的bean类型是否一致。
- 返回创建好的bean。
getSingleton源码部分（beanName，allowEarlyReference）
- 这里的singletonObjects是一个缓存了beanName和bean的Map,若存在，直接返回。
- 不存在，则检查是否这个bean是否正在创建的过程中，先检查earlySingletonObjects这个容器,这个容器里面放着的是已经构造完成但是没有注入属性的对象，若存在，也会直接返回。
- 尝试着从singletonFactories中获取，然后调用getObject方法去获取对象。并将获取到的对象放到earlySingletonObjects容器中，然后从singletonFactories容器中移除。
这里这么设计是为了解决循环依赖的问题。若A依赖B，B依赖C，C又依赖A，这样三个bean就形成了一个环（这里只是针对set方法注入的bean,构造器注入还是会有循环依赖的问题而抛出异常的），spring会将创建的bean实例提前暴露在缓存中，一旦下一个bean创建的时候需要依赖上个bean，则直接使用ObjectFactory来获取bean。
这里举个生活中的例子阐述下：就拿建一个小区房来说，建房子是一个很复杂的工序，但是咱们只要把架子搭好，告诉大家这块地是用来建这个房子的就行。至于其他装修，家私等等东西都可以后面再进行补充。咱们不能搭架子的时候去放家具吧，这样整个都会乱套，也不符合常理。（这里房子的框架是咱们程序中的一个对象A，家具是另一个对象B，A依赖B，B依赖A）
循环依赖
相关的逻辑有用到以下代码段：
每次singleton bean创造之前都会调用的方法，在singletonsCurrentlyInCreation容器中加入这个bean的beanName,标记这个bean正在创建中，供后期生成ObjectFactory。这里有个inCreationCheckExclusions容器，在这里我理解为属于该容器的bean必须要初始化完成才允许被获取。也就是说，添加进该容器后bean便不会允许早期的循环依赖了。
上面的代码片段的调用在doCreateBean源码中（排在bean对象创建之后和属性注入之前），可以观察到要执行addSingletonFactory方法需要满足三个条件：
- 这个bean是单例的，
- 允许循环依赖，
- 这个bean正在被创建的过程中。
在满足这三个条件的情况下，会在singletonFactories容器中缓存一个生成该bean的工厂，将其提前暴露出去。这里关注下 getEarlyBeanReference(beanName, mbd, bean) 这个方法，实际上ObjectFactory中getObject方法调用的也是这个方法。
getMergedBeanDefinition源码部分
看这部分之前，首先得明白BeanDefinition是用来干什么的，这个类会在整个源码解析过程中出现无数次。Spring把BeanDefinition定义成IOC容器的内部数据结构，实际上它也就是POJO对象在IOC容器中的抽象，通过这个对象，IOC容器能很方便的对Bean进行管理，包括利用它进行属性的注入等等…
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
// 重新去获取一次，有可能该BeanDefinition已经生成
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null) {
if (bd.getParentName() == null) {
// 没有父类则深拷贝一个RootBeanDefinition
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
else {
// 有父类则需要先获取父类的BeanDefinition，流程和获取子类的BeanDefinition一致
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
//这里进行深拷贝，并将子类重写的方法和属性进行覆盖
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// 若前面没配置scope类型，这里设置为单例范围
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
}
// 这里对内部类做了一些处理，若包含它的bean不是单例的，则该bean也将不会是单例的
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 将生产的BeanDefinition 缓存起来
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}
}
复制代码
- 在mergedBeanDefinitions同步的情况下再次读取缓存，防止该BeanDefinition已经被合并过了。
- 检查是否有父类，若有父类，则必须递归去合并BeanDefinition。
- 将子类重写后的方法覆盖到定义的BeanDefinition中。
- 设置scope类型。
- 将生成的BeanDefinition缓存起来。
registerDependentBean源码部分
这一部分应该还是很容易理解的，这里面出现了两个Map,一个是 dependentBeanMap ，它主要用来装载键为beanName值为dependentBeanName的容器，另一个 dependenciesForBeanMap 是用来装载键为dependentBeanName值为beanName的容器，这样可以方便我们观察一个类需要组装哪些依赖，然后这个类同时是哪些类的依赖。
getSingleton源码部分（beanName，singletonFactory）
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//先去singletonObjects容器中去获取，能获取到就直接返回了
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//调用destroySingletons方法singletonsCurrentlyInDestruction属性才会变成true
if (this.singletonsCurrentlyInDestruction) {
throw new Exception("xx"));
}
//这里会将beanName缓存到singletonsCurrentlyInCreation集合中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//这里会触发下面的createBean方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// 如果是与此同时被创建了，则直接获取，如果能获取到值不为null，则正常返回。
//（注意这里捕获异常正常返回的话就不会走下面的addSingleton方法了。）
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//这里会将beanName从singletonsCurrentlyInCreation集合中移除
afterSingletonCreation(beanName);
}
if (newSingleton) {
//添加到singletonObjects和registeredSingletons缓存中，并从singletonFactories和earlySingletonObjects中移除
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
复制代码
- 直接去singletonObjects中获取，获取到了便直接返回。
- 获取不到，先将beanName缓存到singletonsCurrentlyInCreation集合中，作为标记表示该bean正在被创建的过程中。
- 触发createBean方法去创建bean，这里可以去看一下ObjectFactory这个接口工厂，这里是对getObject方法的一个回调（AbstractAutowireCapableBeanFactory中的createBean方法）。
- 创建bean的过程中在不出异常的情况下便会进行下图的操作后并返回，也就操作了几个容器的缓存而已。
createBean源码部分
这一块不是很复杂，复杂的地方在doCreateBean这个方法中。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// 要保证RootBeanDefinition的beanClass是存在的
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 这一块没什么研究，注解意思是（检查所有带有override的方法是否都是存在的）
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
}
try {
//这一块我猜测大概是看咱们自己有提供实例化的方法不，若有，则不会走下面的doCreateBean方法。
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
}
try {
//创建bean的真正方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}
return beanInstance;
}
catch (Exception e){
throw e;
}
}
复制代码
doCreateBean源码部分
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建这个bean,真正构建时有分两种情况，jdk反射和cglib动态代理
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 允许后置处理器来修改这个BeanDefinition
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 用来解决循环依赖问题的，上面已经有过详细解释了。看上面循环依赖模块
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//进行属性的注入，调用bean的set方法进行字段的初始化
populateBean(beanName, mbd, instanceWrapper);
//进行一些初始化方法的调用，比如afterPropertiesSet等等。
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//在出现循环依赖后，从earlySingletonObjects中获取的bean对象和initializeBean后
//的不一致，证明被后置处理器处理过了，前后bean不一致，需要抛出异常
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 注册bean的销毁方法
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
复制代码
doCreateBean大概有以下步骤：
- 调用createBeanInstance方法初始化bean实例，这里不包括属性的注入。
- 调用合并bean的后置处理器修改这个bean的BeanDefinition的一些定义。即调用MergedBeanDefinitionPostProcessor的实现类的postProcessMergedBeanDefinition方法对BeanDefinition进行一些额外的处理。
- 为早期的循环依赖做准备，将包装了bean的工厂方法塞到singletonFactories中。
- 调用populateBean方法进行一些属性的注入。
- 执行initializeBean方法进行一些初始化方法的调用，例如：afterPropertiesSet方法的调用。与此同时，其后置处理器有可能对指定的bean进行增强。
- 如果出现了bean的增强，然后又有依赖它的类先生成，则需抛出异常。例如：对象A被增强了，得到A+对象，而此时对象B有依赖对象A，循环依赖时通过singletonFactories获取到的对象却是增强前的A对象，这时就会出现问题。如果不抛出异常，spring容器缓存的是A+对象，但是B引用的却是A，这样就会出现不可预测的问题。
instantiateBean源码
这里是createBeanInstance方法中最终调用的方法，这里有三个流程：
- 进行对象的构造，这里关注下CglibSubclassingInstantiationStrategy这个策略类，有继承SimpleInstantiationStrategy类，调用其instantiate可以调用对象的构造器进行对象的初始化，在BeanDefinition属性MethodOverrides不存在时，可以用jdk的反射进行获取对象，否则则必须使用cglib动态代理。（这里的MethodOverrides的存在需要对象中某个方法用@Lookup注解修饰，或者XML定义中有 lookup-method属性，这一块的详情可以参考详情;）
- 用BeanWrapperImpl对生成的对象进行包装，并激活注册默认编辑器的属性。
- 注册默认的编辑器，然后将ConversionService这个类的引用设置到BeanWrapper对象上。ConversionService是用来进行类型转换的，里面的属性converters用一个map维护着各种类型的转换器。
populateBean源码部分
下面关注几个重点代码，省略了一些代码，可以自己去翻阅下：
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
......
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 这里是根据bean名称进行依赖注入的
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 这里是根据bean的类型进行依赖注入的
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
......
if (pvs != null) {
//实际上注入属性值的方法，这里是populateBean方法的重点
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
复制代码
这里注释下applyPropertyValues的部分源码：
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// 这里可以迅速返回。当这个PropertyValues对象中的值都是处理过后便可以触发。状态值会在下面几行代码设置。
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
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<>(original.size());
boolean resolveNecessary = false;
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
}
else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
//这里的resolveValueIfNecessary是一个需要关注的方法，有兴趣的小伙伴可以点进去看看，
//里面封装了针对各种类型的属性的解析，例如List,Map,Set等等类型。
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) {
//这里的触发条件必须为该属性得是有写权限的，并且里面不能带有“.”和“[”这个符号，这里我的理解是
//teacher.name以及student[1].name这样的propertyName便不能触发这个条件
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
//这一块的条件比上一个多了几个，源值必须是string类型，且不能是动态的，并且不能是集合和数组中的任意一个。
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
//条件在这里触发后就不会打开快捷返回的开关了
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
//设置converted状态值，供其组装属性时快捷返回。
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// 将我们深拷贝出来的值设置到包装类BeanWrapperImpl包装的对象上
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
复制代码
setPropertyValues方法的源码最终调用的是AbstractNestablePropertyAccessor类的setPropertyValue方法，在这里BeanWrapperImpl是它的实现类，从名字上看也能猜出来这个类是个处理嵌套属性的访问器。
public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
AbstractNestablePropertyAccessor nestedPa;
try {
//这里可以解析嵌套的属性
nestedPa = getPropertyAccessorForPropertyPath(propertyName);
}
catch (NotReadablePropertyException ex) {
throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
"Nested property in path '" + propertyName + "' does not exist", ex);
}
//这里获取到了最终解析到的属性名
PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
//给最终解析到的属性名赋值操作
nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
}
复制代码
上面有个getPropertyAccessorForPropertyPath方法，点进去会发现他会有个解析“.”和“[]”的方法getNestedPropertySeparatorIndex，它的作用我举个例子来说明一下：一个班级有多个学生，我想设置某个学生的名字，班级是个Class对象,里面有属性： private Student[] students 这里我想修改下student[2]的name属性，我就必须先用getStudent方法取出 Student[] 数组，然后再在 Student[] 数组中找到索引为2的Student，最后修改Student身上的name属性。（这一块不是很理解的可以参考下BeanWrapper 源码分析）
GetBean流程图
End
正文到此结束
- 本文标签： synchronized struct UI App 同步 处理器 IO equals ip 配置 CTO final 文章 cache ArrayList 递归 map CEO dependencies ACE ORM 索引 HashSet db cat 注释 list strace ioc token 并发 tab 学生 代码 value http bean id 缓存 源码 description 管理 XML src Service 希望 cglib root tar IDE 实例 lib Property Collection Proxy spring https 数据 解析 example BeanDefinition
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
你这基本没有更新呀，最近文章显示还是2019年的文章。不符合要求哈
-
关键词：慕云博客 链接：https://www.lilun.me 描述：分享原创文字的个人博客
-
-
-
可以提供一下源码吗
-
不是商业站，鸡娃学习笔记
-
-
-
-
听他们说很厉害的样子
Loading...
![[HBLOG]公众号](http://www.liuhaihua.cn/img/qrcode_gzh.jpg)
