Spring中Bean的创建过程一

Bean在完成创建的时候会经过getBean——→ doGetBean ——→ createBean ——→ doCreateBean这一系列方法调用链来完成。

入口方法preInstantiateSingletons：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public void preInstantiateSingletons() throws BeansException {
    if (logger.isDebugEnabled()) {
        logger.debug("Pre-instantiating singletons in " + this);
    }
    //所有bean的名字
    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 触发所有非延迟加载单例beans的初始化，主要步骤为调用getBean
    for (String beanName : beanNames) {
        //合并父BeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                //如果是FactoryBean则加上&
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);  // getBean的逻辑后面有介绍
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

getBean方法

1
2
3
4
5
6
@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

// doGetBean()

doGetBean()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    /**
     * 通过 name 获取 beanName。这里不使用 name 直接作为 beanName 有两个原因
     * 1、name 可能会以 & 字符开头，表明调用者想获取 FactoryBean 本身，而非 FactoryBean
     *   实现类所创建的 bean。在 BeanFactory 中，FactoryBean 的实现类和其他的 bean 存储
     *   方式是一致的，即 <beanName, bean>，beanName 中是没有 & 这个字符的。所以我们需要
     *   将 name 的首字符 & 移除，这样才能从缓存里取到 FactoryBean 实例。
     * 2、还是别名的问题，转换需要
     * &beanName
     */
    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    /**
     * 这个方法在初始化的时候会调用，在getBean的时候也会调用
     * 为什么需要这么做呢？
     * 也就是说spring在初始化的时候先获取这个对象
     * 判断这个对象是否被实例化好了(普通情况下绝对为空====有一种情况可能不为空)
     * 从spring的bean容器中获取一个bean，由于spring中bean容器是一个map（singletonObjects）
     * 所以你可以理解getSingleton(beanName)等于beanMap.get(beanName)
     * 由于方法会在spring环境初始化的时候（就是对象被创建的时候调用一次）调用一次
     * 还会在getBean的时候调用一次
     * lazy
     */
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {

        /**
         * 如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果
         * sharedInstance 是 FactoryBean 类型的，则需调用 getObject 工厂方法获取真正的
         * bean 实例。如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回
         * 即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
         */
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 当独享都是单例的时候，会尝试解决循环依赖的问题，但是原型模式下如果存在循环依赖情况，那么直接抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 获取父类容器
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 如果beanDefinitionMap 中也就是在所有已经加载的类中不包含beanName，那么久尝试从父容器中获取
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        // 如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录。
        if (!typeCheckOnly) {
            //添加到alreadyCreated set集合当中，表示他已经创建过了
            markBeanAsCreated(beanName);
        }

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException("");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException("");
                    }
                }
            }

            // Create bean instance.
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // Explicitly remove instance from singleton cache: It might have been put there
                        // eagerly by the creation process, to allow for circular reference resolution.
                        // Also remove any beans that received a temporary reference to the bean.
                        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("");
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // Check if required type matches the type of the actual bean instance.
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

createBean方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	if (logger.isDebugEnabled()) {
		logger.debug("Creating instance of bean '" + beanName + "'");
	}
	RootBeanDefinition mbdToUse = mbd;

	// 锁定class，根据设置的class属性或者根据className 来解析 class
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	// 进行条件筛选，重新复制RootBeanDefinition，并设置BeanClass属性
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		// 设置beanClass属性值
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides. 
	// 后面有介绍 
	// 处理 lookup-method 和 replace-method 配置，Spring 将这两个配置统称为 override method
	try {
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// 在 bean 初始化前应用后置处理，如果后置处理返回的 bean 不为空，则直接返回
		// 给BeanPostProcessors一个机会来返回代理来替代真正的实例，应用实例化前的前置处理器
		// InstanitionAwarePostProcessor
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "", ex);
	}

	try {
		// 调用doCreateBean 创建bean 
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

lookup-method

spring中默认的对象都是单例的，spring会在一级缓存中持有该独享，方便下次直接获取，如果是原型作用域的话，会创建一个新的对象

如果想在一个单例模式的bean下引用一个原型模式的bean应该怎么办？

在此时就需要引用 lookup-method 来解决此问题（lookup 解决单例引用原型问题）

通过拦截器的方式每次需要的时候去创建新的对象，而不会吧原型对象缓存起来

说明：

  • 假设一个单例对象A引用了一个多例对象B
  • 如果要使得 A 对象每次获取到的 B 都是最新创建的，这个情况下就要用到 lookup了
  • 否则就会把每次第一个创建的 B 对象缓冲到 A中再获取，这样获取的就不是最新的了

参考：https://blog.csdn.net/jerry010101/article/details/84997062

replace-method

作用：替换Spring管理的Bean

参考：https://www.codetd.com/article/10038755

https://www.cnblogs.com/ocean234/p/12320633.html

doCreateBean 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

	// 这个beanWrapper 是用来持有创建出来的bean对象的
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		// 如果是单例，从factoryBean实例缓存中一处当前bean定义信息
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		/**
		 * 根据执行bean使用对应的策略创建新的实例，如 工厂方法、构造函数、主动注入，简单初始化
		 * 创建 bean 实例，并将实例包裹在 BeanWrapper 实现类对象中返回。
		 * createBeanInstance中包含三种创建 bean 实例的方式：
		 *   1. 通过工厂方法创建 bean 实例
		 *   2. 通过构造方法自动注入（autowire by constructor）的方式创建 bean 实例
		 *   3. 通过无参构造方法方法创建 bean 实例
		 *
		 * 若 bean 的配置信息中配置了 lookup-method 和 replace-method，则会使用 CGLIB
		 * 增强 bean 实例。关于lookup-method和replace-method后面再说。
		 * lookup   单例中获取多例对象的解决方式
     * replace  资环spring管理的bean
		 */
		instanceWrapper = createBeanInstance(beanName, mbd, args);  // 后面有介绍
	}
	// 从包装类中获取原始bean
	final Object bean = instanceWrapper.getWrappedInstance();
	// 获取具体bean对象的Class属性
	Class<?> beanType = instanceWrapper.getWrappedClass();
	// 如果不等于NullBean类型，那么修改目标类型
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 允许beanPostProcessor 去修改合并的beanDefinition
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				// MergedBeanDefinitionPostProcessor 后置处理器修改合并bean的定义
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,"", ex);
			}
			mbd.postProcessed = true;
		}
	}
	//===========================创建对象 结束==================================
	
	//===========================初始化   开始==================================
	// 判断当前bean是否需要提前曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isDebugEnabled()) {
			logger.debug("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 {
		//设置属性，非常重要
		populateBean(beanName, mbd, instanceWrapper);  // 后面有介绍
		//执行后置处理器，aop就是在这里完成的处理
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			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,"");
				}
			}
		}
	}

	// Register bean as disposable.
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}
	return exposedObject;
}

createBeanInstance 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    /**
     * 检测一个类的访问权限spring默认情况下对于非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市再次解析
    /**
     * 从spring的原始注释可以知道这个是一个Shortcut，什么意思呢？
     * 当多次构建同一个 bean 时，可以使用这个Shortcut，
     * 也就是说不在需要次推断应该使用哪种方式构造bean
     *  比如在多次构建同一个prototype类型的 bean 时，就可以走此处的hortcut
     * 这里的 resolved 和 mbd.constructorArgumentsResolved 将会在 bean 第一次实例  化的过程中被设置
     */
    // 标记下，防止重复创建同一个bean
    boolean resolved = false;
    // 是否需要自动装配
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            //因为一个类可能有多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数
            // 因为判断过程会比较，所以Spring会将解析、确定好的构造函数缓冲到BeanDefinition中的resolvedConstructorOrFactoryMethod 字段中
            // 在下次创建相同时直接从RootBeanDefinition中的属性resolvedConstructoryOrFactoryMethod缓存的值获取，避免再次解析
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    // 有构造参数的或者工厂方法
    if (resolved) {
        // 构造器有参数
        if (autowireNecessary) {
            // 通过构造方法自动装配的方式构造 bean 对象
            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);
    }
    
    // No special handling: simply use no-arg constructor.
    //使用默认的无参构造方法进行初始化
    return instantiateBean(beanName, mbd);    // 后面介绍
    }

instantiateBean方法

作用：实例化bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        final BeanFactory parent = this;
        // 安全管理器、权限控制
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
                    getInstantiationStrategy().instantiate(mbd, beanName, parent),
                    getAccessControlContext());
        }
        else {
            //getInstantiationStrategy()得到类的实例化策略
            //默认情况下是得到一个反射的实例化策略（CGLIB）
            // 拿到对应的策略之后，就会进行相应的初始化操作，通过构造器初始化或者通过CGLIB动态代理初始化
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
        }
        // 包装成BeanWrapper
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
}

BeanWrapper 的父接口有 PropertyEditerRegister、TypeConversion

主要是一些自定义的编辑器、和类型转换器

用于属性编辑、类型转换等等 eg：number—→ string string——> number 等等等

可以直接使用，不需要其它的工具栏进行对属性编辑或者类型转换

Spring
#Spring
Spring中Bean的创建过程一
http://yoursite.com/post/139c4c92.html/
Author
Chase Wang
Posted on
October 22, 2021
Licensed under