手写Spring框架 IOC 和 AOP

代码演示视频：链接：

该项目是博主帮某985大学学生做的一个项目

详细介绍：

一、功能介绍

实现了 IOC 和 AOP 功能，xml 配置和 注解扫描两种

xml 标签如 

beans

bean id class scope(single/prototype) autowired(byType/byName) name

property value ref name

constructor-arg 子标签 List Map Set ref value index type value ref

context:component-scan

等等

注解如

@Component @Service @Repository @Autowired @Qulififier @Value

二、代码结构

IOC

AOP

三、核心代码

1、BeanFactory

2、ApplicationContext

1. package com.liuyanzhao.springframework.context;
3. import com.liuyanzhao.springframework.beans.exception.BeansException;
4. import com.liuyanzhao.springframework.beans.factory.BeanFactory;
6. /**
7. * 应用上下文
8. * @Author: liuyanzhao
9. * @Date: 2022/4/4 11:11
10. * @Version 1.0
11. */
12. public interface ApplicationContext {
14. /**
15. * 刷新容器
16. * 即初始化操作
17. *
18. * @throws BeansException
19. */
20. void refresh() ;
22. /**
23. * 从Bean单例池中获取Bean对象
24. *
25. * @param name
26. * @return
27. * @throws BeansException
28. */
29. Object getBean(String name) throws BeansException;
31. /**
32. * 同上，只是能根据泛型获取Bean对象，无需强制类型转换
33. * *
34. *
35. * @param name
36. * @param requiredType
37. * @param <T>
38. * @return
39. * @throws BeansException
40. */
41. <T> T getBean(String name, Class<T> requiredType) throws BeansException;
43. /**
44. * 同上
45. *
46. * @param requiredType
47. * @param <T>
48. * @return
49. * @throws BeansException
50. */
51. <T> T getBean(Class<T> requiredType) throws BeansException;
54. /**
55. * 也是获取Bean对象，只不过传入了一些成员变量的参数
56. *
57. * @param name
58. * @param args
59. * @return
60. * @throws BeansException
61. */
62. Object getBean(String name, Object... args) throws BeansException;
64. /**
65. * 获得工厂对象
66. * @return
67. */
68. BeanFactory getBeanFactory();
71. /**
72. * 销毁工厂
73. * @throws Exception
74. */
75. void close() ;
76. }

3、ClassPathXmlApplicationContext

1. package com.liuyanzhao.springframework.context;
3. import com.liuyanzhao.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
4. import com.liuyanzhao.springframework.beans.exception.BeansException;
5. import com.liuyanzhao.springframework.beans.factory.BeanFactory;
6. import com.liuyanzhao.springframework.beans.factory.PropertyPlaceholderConfigurer;
7. import com.liuyanzhao.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
8. import com.liuyanzhao.springframework.beans.factory.config.BeanDefinition;
9. import com.liuyanzhao.springframework.beans.factory.support.BeanDefinitionReader;
10. import com.liuyanzhao.springframework.beans.factory.support.DefaultBeanFactory;
11. import com.liuyanzhao.springframework.beans.factory.xml.XmlBeanDefinitionReader;
13. import java.util.Map;
15. /**
16. * classpath下读取XML文件的上下文实现
17. *
18. * @Author: liuyanzhao
19. * @Date: 2022/4/4 11:14
20. * @Version 1.0
21. */
22. public class ClassPathXmlApplicationContext implements ApplicationContext {
24. /**
25. * 配置文件位置，暂时只考虑一个配置文件的情况
26. */
27. private String[] configLocation;
29. /**
30. * Bean工厂
31. */
32. private BeanFactory beanFactory;
34. public ClassPathXmlApplicationContext(String configLocation) {
35. this.configLocation = new String[]{configLocation};
36. // 直接调用初始化
37. this.refresh();
38. }
40. public ClassPathXmlApplicationContext(String[] configLocation) {
41. this.configLocation = configLocation;
42. // 直接调用初始化
43. this.refresh();
44. }
46. @Override
47. public void refresh() {
48. try {
49. // 1.创建BeanFactory 工厂
50. beanFactory = new DefaultBeanFactory();
51. // 2.加载Bean定义
52. BeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
53. beanDefinitionReader.loadBeanDefinitions(this.configLocation);
55. // 3. Bean工厂后置处理器，即对Bean工厂做一些后置的处理
56. // 获取配置文件里的属性值，如获取jdbc.proerties里的jdbc.name的值
57. PropertyPlaceholderConfigurer placeholderConfigurer = (PropertyPlaceholderConfigurer) beanFactory.getBean("propertyPlaceholderConfigurer");
58. if (placeholderConfigurer != null) {
59. placeholderConfigurer.postProcessBeanFactory(beanFactory);
60. }
62. // 4.注册Bean工厂
63. beanFactory.registerBeanDefinition("autowiredAnnotationBeanPostProcessor", new BeanDefinition(AutowiredAnnotationBeanPostProcessor.class));
64. beanFactory.registerBeanDefinition("defaultAdvisorAutoProxyCreator", new BeanDefinition(DefaultAdvisorAutoProxyCreator.class));
65. beanFactory.addBeanPostProcessor(beanFactory.getBean(AutowiredAnnotationBeanPostProcessor.class));
66. beanFactory.addBeanPostProcessor(beanFactory.getBean(DefaultAdvisorAutoProxyCreator.class));
68. // 5.提前实例化单例Bean（可选）
69. Map<String, BeanDefinition> beanDefinitionMap = beanFactory.getBeanDefinitionMap();
70. // for (String beanName : beanDefinitionMap.keySet()) {
71. // Object bean = beanFactory.getBean(beanName);
72. // System.out.println(bean);
73. // }
75. // 6.创建成功
76. System.out.println("My-Spring容器初始化完成");
77. System.out.println("共扫描到了 " + beanDefinitionMap.size() + " 个Bean定义，如下(Bean名称 --> Class)");
78. System.out.println("--------------------------------------------------------------------------------------------------------------------------------------");
79. for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
80. System.out.println(entry.getKey() + " --> " + entry.getValue().getBeanClass().getName());
81. }
82. System.out.println("--------------------------------------------------------------------------------------------------------------------------------------\n");
83. } catch (Exception e) {
84. e.printStackTrace();
85. // 发生异常时，关闭上下文
86. this.close();
87. System.exit(0);
88. }
89. }
91. @Override
92. public Object getBean(String name) throws BeansException {
93. return beanFactory.getBean(name);
94. }
96. @Override
97. public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
98. return beanFactory.getBean(name, requiredType);
99. }
101. @Override
102. public <T> T getBean(Class<T> requiredType) throws BeansException {
103. return beanFactory.getBean(requiredType);
104. }
106. @Override
107. public Object getBean(String name, Object... args) throws BeansException {
108. return beanFactory.getBean(name, args);
109. }
111. @Override
112. public BeanFactory getBeanFactory() {
113. return beanFactory;
114. }
116. @Override
117. public void close() {
118. System.out.println("开始关闭上下文");
119. beanFactory.close();
120. System.out.println("关闭上下文结束");
122. }
123. }

4、DefaultBeanFactory

1. package com.liuyanzhao.springframework.beans.factory.support;
3. import cn.hutool.core.bean.BeanUtil;
4. import com.liuyanzhao.springframework.beans.exception.BeansException;
5. import com.example.springframework.beans.factory.*;
6. import com.liuyanzhao.springframework.beans.factory.config.BeanDefinition;
7. import com.liuyanzhao.springframework.beans.factory.config.BeanPostProcessor;
8. import com.liuyanzhao.springframework.beans.factory.config.BeanReference;
9. import com.liuyanzhao.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
10. import com.liuyanzhao.springframework.util.StringValueResolver;
11. import com.liuyanzhao.springframework.beans.factory.*;
13. import java.lang.reflect.Constructor;
14. import java.lang.reflect.InvocationTargetException;
15. import java.util.*;
17. /**
18. * bean工厂默认实现类
19. * 继承单例Bean注册器类
20. *
21. * @Author: liuyanzhao
22. * @Date: 2022/4/3 15:42
23. * @Version 1.0
24. */
25. public class DefaultBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {
27. /**
28. * 定义一个Bean定义池子，维护Bean名称和Bean定义的关系(即名称和类类型的关系)
29. */
30. public Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
32. /**
33. * @Value的属性值集合
34. */
35. public List<StringValueResolver> embeddedValueResolvers = new ArrayList<>();
37. /**
38. * BeanPostProcessors to apply in createBean
39. */
40. public List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();
42. @Override
43. public Object getBean(String name) throws BeansException {
44. return doGetBean(name, null);
45. }
47. @Override
48. public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
49. return (T) this.getBean(name);
50. }
52. @Override
53. public Object getBean(String name, Object... args) throws BeansException {
54. return doGetBean(name, args);
55. }
57. @Override
58. public <T> T getBean(Class<T> requiredType) throws BeansException {
59. List<String> beanNames = new ArrayList<>();
60. for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
61. Class beanClass = entry.getValue().getBeanClass();
62. // 判断是否为子类或者接口实现的类
63. // 如 Dog 是 Animal 的子类，为true；CCServiceImpl是CCService的接口实现，也为true
64. if (requiredType.isAssignableFrom(beanClass)) {
65. beanNames.add(entry.getKey());
66. }
67. }
68. if (1 == beanNames.size()) {
69. return getBean(beanNames.get(0), requiredType);
70. }
72. return null;
73. }
75. /**
76. * 获取Bean
77. *
78. * @param name
79. * @param args
80. * @param <T>
81. * @return
82. */
83. private <T> T doGetBean(final String name, final Object[] args) {
84. // 先从单例池里拿，拿不到再创建
85. Object bean = getSingleton(name);
86. if (bean != null) {
87. return (T) bean;
88. }
90. BeanDefinition beanDefinition = getBeanDefinition(name);
91. if (beanDefinition == null) {
92. return null;
93. }
94. return (T) createBean(name, beanDefinition, args);
95. }
97. @Override
98. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
99. beanDefinitionMap.put(beanName, beanDefinition);
100. }
102. @Override
103. public BeanDefinition getBeanDefinition(String beanName) throws BeansException {
104. return beanDefinitionMap.get(beanName);
105. }
107. @Override
108. public boolean containsBeanDefinition(String beanName) {
109. return beanDefinitionMap.containsKey(beanName);
110. }
112. @Override
113. public void autowireBean(Object existingBean) {
114. String className = existingBean.getClass().getName();
115. BeanDefinition beanDefinition = new BeanDefinition(existingBean.getClass());
116. beanDefinitionMap.put(className, beanDefinition);
117. this.createBean(className, existingBean, beanDefinition, new Object[]{});
118. }
120. @Override
121. public Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
122. return this.createBean(beanName, null, beanDefinition, args);
123. }
125. @Override
126. public Object createBean(String beanName, Object existingBean, BeanDefinition beanDefinition, Object[] args) throws BeansException {
127. Object bean;
128. try {
129. // 判断是否返回代理 Bean 对象
130. bean = resolveBeforeInstantiation(beanName, beanDefinition);
131. if (null != bean) {
132. return bean;
133. }
135. // 实例化 Bean，如果已经提供了对象，直接使用
136. bean = existingBean != null ? existingBean : this.createBeanInstance(beanDefinition, args);
138. // 处理循环依赖，将实例化后的Bean对象提前放入缓存中暴露出来
139. if (BeanDefinition.SCORE_SINGLETON.equals(beanDefinition.getScope())) {
140. Object finalBean = bean;
141. addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, beanDefinition, finalBean));
142. }
144. // 实例化后判断
145. boolean continueWithPropertyPopulation = applyBeanPostProcessorsAfterInstantiation(beanName, bean);
146. if (!continueWithPropertyPopulation) {
147. return bean;
148. }
150. // 在设置 Bean 属性之前，允许 BeanPostProcessor 修改属性值
151. applyBeanPostProcessorsBeforeApplyingPropertyValues(beanName, bean, beanDefinition);
153. // 给 Bean 填充属性
154. applyPropertyValues(beanName, bean, beanDefinition);
156. // 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法
157. bean = initializeBean(beanName, bean, beanDefinition);
159. } catch (Exception e) {
160. e.printStackTrace();
161. throw new BeansException("Bean属性设置失败", e);
162. }
163. // 如果要求作用域为单例，则放到单例池中
164. if (BeanDefinition.SCORE_SINGLETON.equals(beanDefinition.getScope())) {
165. addSingleton(beanName, bean);
166. }
167. return bean;
168. }
171. protected Object getEarlyBeanReference(String beanName, BeanDefinition beanDefinition, Object bean) {
172. Object exposedObject = bean;
173. for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
174. exposedObject = beanPostProcessor.getEarlyBeanReference(exposedObject, beanName);
175. if (null == exposedObject) {
176. return exposedObject;
177. }
178. }
179. return exposedObject;
180. }
182. /**
183. * 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法
184. *
185. * @param beanName
186. * @param bean
187. * @param beanDefinition
188. * @return
189. */
190. private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
193. // 给 BeanPostProcessor 设置 BeanFactory
194. if (bean instanceof BeanPostProcessor) {
195. ((BeanPostProcessor) bean).setBeanFactory(this);
196. }
198. // 2. 执行 BeanPostProcessor Before 处理
199. Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
201. // 3. 执行 BeanPostProcessor After 处理
202. wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
203. return wrappedBean;
204. }
207. /**
208. * 在设置 Bean 属性之前，允许 BeanPostProcessor 修改属性值
209. *
210. * @param beanName
211. * @param bean
212. * @param beanDefinition
213. */
214. protected void applyBeanPostProcessorsBeforeApplyingPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
215. for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
216. PropertyValues pvs = beanPostProcessor.postProcessPropertyValues(beanDefinition.getPropertyValues(), bean, beanName);
217. if (null != pvs) {
218. for (PropertyValue propertyValue : pvs.getPropertyValues()) {
219. beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
220. }
221. }
223. }
224. }
226. /**
227. * // 判断是否返回代理 Bean 对象
228. *
229. * @param beanName
230. * @param beanDefinition
231. * @return
232. */
233. private Object resolveBeforeInstantiation(String beanName, BeanDefinition beanDefinition) {
234. Object bean = applyBeanPostProcessorsBeforeInstantiation(beanDefinition.getBeanClass(), beanName);
235. if (null != bean) {
236. bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
237. }
238. return bean;
239. }
241. /**
242. * 在 Bean 对象执行实例化方法之前，执行此方法
243. *
244. * @param beanClass
245. * @param beanName
246. * @return
247. */
248. private Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
249. for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
250. Object result = beanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName);
251. if (null != result) {
252. return result;
253. }
255. }
256. return null;
257. }
260. /**
261. * 在 Bean 对象执行实例化方法之后，执行此方法
262. * Bean 实例化后对于返回 false 的对象，不在执行后续设置 Bean 对象属性的操作
263. *
264. * @param beanName
265. * @param bean
266. * @return
267. */
268. private boolean applyBeanPostProcessorsAfterInstantiation(String beanName, Object bean) {
269. boolean continueWithPropertyPopulation = true;
270. for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
271. if (beanPostProcessor instanceof AutowiredAnnotationBeanPostProcessor) {
272. if (!beanPostProcessor.postProcessAfterInstantiation(bean, beanName)) {
273. continueWithPropertyPopulation = false;
274. break;
275. }
276. }
277. }
278. return continueWithPropertyPopulation;
279. }
282. /**
283. * 在 Bean 对象执行初始化方法之前，执行此方法
284. *
285. * @param existingBean
286. * @param beanName
287. * @return
288. * @throws BeansException
289. */
290. public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
291. Object result = existingBean;
292. for (BeanPostProcessor processor : getBeanPostProcessors()) {
293. Object current = processor.postProcessBeforeInitialization(result, beanName);
294. if (null == current) return result;
295. result = current;
296. }
297. return result;
298. }
300. /**
301. * 在 Bean 对象执行初始化方法之后，执行此方法
302. *
303. * @param existingBean
304. * @param beanName
305. * @return
306. * @throws BeansException
307. */
308. private Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
309. Object result = existingBean;
310. for (BeanPostProcessor processor : getBeanPostProcessors()) {
311. Object current = processor.postProcessAfterInitialization(result, beanName);
312. if (null == current) {
313. return result;
314. }
315. result = current;
316. }
317. return result;
318. }
321. @Override
322. public String[] getBeanDefinitionNames() {
323. return beanDefinitionMap.keySet().toArray(new String[0]);
324. }
326. @Override
327. public Map<String, BeanDefinition> getBeanDefinitionMap() {
328. return beanDefinitionMap;
329. }
331. @Override
332. public void addEmbeddedValueResolver(StringValueResolver valueResolver) {
333. this.embeddedValueResolvers.add(valueResolver);
334. }
336. @Override
337. public String resolveEmbeddedValue(String value) {
338. String result = value;
339. for (StringValueResolver resolver : this.embeddedValueResolvers) {
340. result = resolver.resolveStringValue(result);
341. }
342. return result;
343. }
345. @Override
346. public <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
347. Map<String, T> result = new HashMap<>();
348. beanDefinitionMap.forEach((beanName, beanDefinition) -> {
349. Class beanClass = beanDefinition.getBeanClass();
350. if (type.isAssignableFrom(beanClass)) {
351. result.put(beanName, (T) getBean(beanName));
352. }
353. });
354. return result;
355. }
357. @Override
358. public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
359. this.beanPostProcessors.remove(beanPostProcessor);
360. this.beanPostProcessors.add(beanPostProcessor);
361. }
363. @Override
364. public void close() {
365. System.out.println("开始关闭Bean工厂");
366. // 清空单例池
367. Map<String, Object> singletonObjects = getSingletonObjects();
368. for (Map.Entry<String, Object> entry : singletonObjects.entrySet()) {
369. Object value = entry.getValue();
370. String key = entry.getKey();
371. value = null;
372. singletonObjects.remove(key);
373. }
374. System.out.println("关闭Bean工厂结束");
375. }
377. /**
378. * Bean 属性填充
379. */
380. protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
381. try {
382. PropertyValues propertyValues = beanDefinition.getPropertyValues();
383. for (PropertyValue propertyValue : propertyValues.getPropertyValues()) {
385. String name = propertyValue.getName();
386. Object value = propertyValue.getValue();
388. if (value instanceof BeanReference) {
390. // A 依赖 B，获取 B 的实例化
391. // 判断注入类型是 byType 还是 byName
392. BeanReference beanReference = (BeanReference) value;
393. if (BeanDefinition.AUTOWIRED_BY_NAME.equals(beanDefinition.getAutowired())) {
394. // 根据 name 获取Bean
395. value = getBean(beanReference.getBeanName());
396. } else if (BeanDefinition.AUTOWIRED_BY_TYPE.equals(beanDefinition.getAutowired())) {
397. // 根据 类类型即class 获取Bean
398. value = getBean(beanReference.getBeanClass());
399. } else {
400. // 先根据 name 获取，获取不到再根据 class 获取
401. value = getBean(beanReference.getBeanName(), beanReference.getBeanClass());
402. }
404. value = getBean(beanReference.getBeanName());
406. }
407. // 属性填充
408. BeanUtil.setFieldValue(bean, name, value);
409. }
410. } catch (Exception e) {
411. throw new BeansException("Error setting property values：" + beanName);
412. }
413. }
415. /**
416. * 创建Bean对象
417. *
418. * @param beanDefinition
419. * @param args
420. * @return
421. */
422. private Object createBeanInstance(BeanDefinition beanDefinition, Object[] args) {
423. ConstructorArgValue[] constructorValues = {};
424. ConstructorArgValues constructorArgValues = beanDefinition.getConstructorArgValues();
425. if (constructorArgValues != null) {
426. constructorValues = beanDefinition.getConstructorArgValues().getConstructorValues();
427. }
428. if (constructorValues != null && constructorValues.length > 0) {
429. args = new Object[constructorValues.length];
430. }
431. Constructor constructorToUse = null;
432. Class<?> beanClass = beanDefinition.getBeanClass();
433. Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
434. for (Constructor ctor : declaredConstructors) {
435. if (null != args && ctor.getParameterTypes().length == args.length) {
436. constructorToUse = ctor;
437. // 处理下 args
438. this.handlerConstructorArgValues(ctor, constructorArgValues, args);
439. break;
440. }
441. }
443. Class clazz = beanDefinition.getBeanClass();
444. try {
445. if (null != constructorToUse) {
446. // 调用有参构造器，传参数
447. return clazz.getDeclaredConstructor(constructorToUse.getParameterTypes()).newInstance(args);
448. } else {
449. // 调用无参构造器
450. return clazz.getDeclaredConstructor().newInstance();
451. }
452. } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
453. throw new BeansException("创建Bean失败 [" + clazz.getName() + "]", e);
454. }
456. }
458. /**
459. * 处理构造器参数
460. *
461. * @param ctor
462. * @param constructorArgValues
463. * @param args
464. */
465. private void handlerConstructorArgValues(Constructor ctor, ConstructorArgValues constructorArgValues, Object[] args) {
466. ConstructorArgValue[] constructorValues = constructorArgValues.getConstructorValues();
467. int i = 0;
468. for (Class parameterType : ctor.getParameterTypes()) {
469. // 先根据构造方法参数里的index找参数
470. ConstructorArgValue constructorValue = constructorArgValues.getConstructorValueByIndex(String.valueOf(i));
471. if (constructorValue == null) {
472. // 找不到，直接当前这个参数
473. constructorValue = constructorValues[i];
475. }
476. // 目前只支持String类型、常见基本类型
477. if (parameterType == String.class) {
478. args[i] = constructorValue.getValue();
479. } else if (parameterType == Byte.class) {
480. args[i] = Byte.valueOf(constructorValue.getValue());
481. } else if (parameterType == Short.class) {
482. args[i] = Short.valueOf(constructorValue.getValue());
483. } else if (parameterType == Integer.class) {
484. args[i] = Integer.valueOf(constructorValue.getValue());
485. } else if (parameterType == Long.class) {
486. args[i] = Long.valueOf(constructorValue.getValue());
487. } else if (parameterType == Double.class) {
488. args[i] = Double.valueOf(constructorValue.getValue());
489. } else if (parameterType == Float.class) {
490. args[i] = Float.valueOf(constructorValue.getValue());
491. } else if (parameterType == Boolean.class) {
492. args[i] = Boolean.valueOf(constructorValue.getValue());
493. }
494. i++;
495. }
496. }
498. public List<StringValueResolver> getEmbeddedValueResolvers() {
499. return embeddedValueResolvers;
500. }
502. public List<BeanPostProcessor> getBeanPostProcessors() {
503. return beanPostProcessors;
504. }
505. }

等等

需要完整代码可以联系博主