要想深入的理解IOC的技术原理，没有什么能比的上我们自己实现它。这次我们一起实现一个简单IOC容器。让大家更容易理解Spring IOC的基本原理。
这里会涉及到一些java反射的知识，如果有不了解的，可以自己去找些资料看看。
注意
在上一篇文章，我说，启动IOC容器时，Spring会将xml文件里面配置的bean扫描并实例化，其实这种说法不太准确，所以我在这里更正一下，xml文件里面配置的非单利模式的bean，会在第一次调用的时候被初始化，而不是启动容器的时候初始化。但是我们这次要做的例子是容器启动的时候就将bean初始化。特此说明一下，害怕误导初学者。
思路：
1，启动容器时，加载xml文件。
2，读取xml文件内的bean信息，并使用反射技术将bean实例化，并装入容器。
3，确认bean之间的以来关系，进行注入。
下面直接上代码，先看配置文件，与上一篇文章中使用的例子是一样的，我们这次继续使用上一篇文章的吃苹果和吃橘子的例子，只不过这次我们用我们自己写的IOC容器，所以，我只粘贴了关键代码。
?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!--这是吃橘子的Bean -->
<bean id="eatOrange" class="it.spring.liao.com.EatOrange"></bean>
<!--这是吃苹果的Bean -->
<bean id="eatApple" class="it.spring.liao.com.EatApple"></bean>
<bean id="person" class="it.spring.liao.com.Person">
<!-- 这里我们注入的是吃橘子的bean-->
<property name="eat" ref="eatOrange"/>
</bean>
</beans>
|
此处为关键代码
?
|
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
|
package it.spring.liao.com;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class BeanFactory {
// 用于存放bean实例的集合
private Map<String, Object> beanMap = new HashMap<String, Object>();
/**
* bean工厂的初始化. <br>
*
* @param xml
* 配置文件路径
*/
public void init(String xml) {
try {
// 1.创建读取配置文件的reader对象
SAXReader reader = new SAXReader();
// 2.获取当前线程中的类装载器对象
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
// 3.从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);
// 4.使用dom4j 解析xml文件
Document doc = reader.read(ins);
Element root = doc.getRootElement();
// 5.初始化bean
setBean(root);
// 6.注入bean的依赖关系
setPv(root);
} catch (Exception e) {
System.out.println(e.toString());
}
}
/**
* 初始化bean
*
* @param root
* xml文件
* @throws Exception
*/
public void setBean(Element root) throws Exception {
// 1.遍历xml文件当中的Bean实例
for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
Element foo = (Element) i.next();
// 2.针对每个Bean实例，获取bean的属性id和class
String id = foo.attribute("id").getText();
String cls = foo.attribute("class").getText();
// 3.利用Java反射机制，通过class的名称获取Class对象
Class bean = Class.forName(cls);
// 4.创建对象
Object obj = bean.newInstance();
// 5.将对象放入beanMap中，其中key为bean的id值，value为bean的实例
beanMap.put(id, obj);
}
}
/**
* 注入bean的依赖关系
*
* @param root
* xml文件
* @throws Exception
*/
public void setPv(Element root) throws Exception {
for (Iterator it = root.elementIterator("bean"); it.hasNext();) {
Element foo = (Element) it.next();
// 1.针对每个Bean实例，获取bean的属性id和class
String cls = foo.attribute("class").getText();
String id = foo.attribute("id").getText();
// 2.利用Java反射机制，通过class的名称获取Class对象
Class bean1 = Class.forName(cls);
// 3.获取对应class的信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean1);
// 4.获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
// 5遍历该bean的property属性
for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
Element foo2 = (Element) ite.next();
// 6.获取该property的name属性
String name = foo2.attribute("name").getText();
String ref = foo2.attribute("ref").getText();
// 7.在类中寻找与xml配置文件中该bean的property属性名相同的属性
for (int k = 0; k < pd.length; k++) {
// 8.如果相等，证明已经找到对应得属性
if (pd[k].getName().equalsIgnoreCase(name)) {
Method mSet = null;
// 9.利用反射，获取该属性的set方法
mSet = pd[k].getWriteMethod();
// 10.用原beanMap中该bean的实例，执行该属性的set方法，并从原beanMap中获取该属性的依赖值
mSet.invoke(beanMap.get(id), beanMap.get(ref));
}
}
break;
}
}
}
/**
* 通过bean的id获取bean的实例
*
* @param beanName
* bean的id
* @return 返回对应对象
*/
public Object getBean(String beanName) {
Object obj = beanMap.get(beanName);
return obj;
}
}
/**
* 测试方法.
*
* @param args
*/
public static void main(String[] args) {
//使用我们自己写的 BeanFactory
BeanFactory factory = new BeanFactory();
factory.init("eat.xml");
Person javaBean = (Person) factory.getBean("person");
System.out.println(javaBean.eat());
}
|
详细的解释都在代码的注释中，这个例子可以帮助你更深刻的理解spring的基本技术原理。但Spring的复杂程度远远高于这个例子，再说一次，spring IOC中使用懒加载机制，在启动spring IOC时，只会实例化单例模式的bean，不会实例化普通的bean，关于单例模式还是其他模式，是可以自己配置的，我们会在后面的文章中讲解，非单例模式bean的实例化，发生在第一次调用的时候，与我们这个例子不太一样。这个例子只供了解Spring IOC的基本原理，真实情况要复杂的多，需要我们一点点的去学习，不积跬步无以至千里。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持快网idc。
原文链接：http://www.jianshu.com/p/d6991030d84d
相关文章
猜你喜欢
- 64M VPS建站：怎样优化以提高网站加载速度？ 2025-06-10
- 64M VPS建站：是否适合初学者操作和管理？ 2025-06-10
- ASP.NET自助建站系统中的用户注册和登录功能定制方法 2025-06-10
- ASP.NET自助建站系统的域名绑定与解析教程 2025-06-10
- 个人服务器网站搭建：如何选择合适的服务器提供商？ 2025-06-10
