spring容器IOC原理解析

原理简单介绍：

Spring容器的原理，其实就是通过解析xml文件，或取到用户配置的bean，然后通过反射将这些bean挨个放到集合中，然后对外提供一个getBean()方法，以便我们获得这些bean。下面是一段简单的模拟代码：

1. package com.tgb.spring.factory;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. import org.jdom.Document;
6. import org.jdom.Element;
7. import org.jdom.input.SAXBuilder;
8. import org.jdom.xpath.XPath;
9. public class ClassPathXmlApplicationContext implements BeanFactory  {
10. //容器的核心，用来存放注入的Bean
11. private Map<String, Object> container = new HashMap<String, Object>();
12. //解析xml文件，通过反射将配置的bean放到container中
13. public ClassPathXmlApplicationContext(String fileName) throws Exception{
14. SAXBuilder sb = new SAXBuilder();
15. Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream(fileName));
16. Element root = doc.getRootElement();
17. List list = XPath.selectNodes(root, "/beans/bean");
18. //扫描配置文件中的bean
19. for (int i = 0; i < list.size(); i++) {
20. Element bean = (Element) list.get(i);
21. String id = bean.getAttributeValue("id");
22. String clazz = bean.getAttributeValue("class");
23. Object o = Class.forName(clazz).newInstance();
24. container.put(id, o);
25. }
26. }
27. @Override
28. public Object getBean(String id) {
29. return container.get(id);
30. }
31. }

首先声明一个存放bean的Map，然后通过jdom解析配置文件，循环遍历所有的<bean>节点，并通过反射将它们放到我们之前声明的Map中。然后提供一个getBean()的方法，让我们可以通过bean的Id来找到我们想要的bean。

下面是一个简单的xml配置文件：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans>
3. <bean id="E" class="com.tgb.spring.factory.England" />
4. <bean id="S" class="com.tgb.spring.factory.Spain" />
5. <bean id="P" class="com.tgb.spring.factory.Portugal" />
6. </beans>

客户端通过调用前面的ClassPathXmlApplicationContext，来加载上面的配置文件，然后就可以通过Id来获得我们需要的bean了：

1. package com.tgb.spring.factory;
2. public class Test {
3. public static void main(String[] args) throws Exception {
4. //加载配置文件
5. BeanFactory f = new ClassPathXmlApplicationContext("applicationContext.xml");
6. //英格兰
7. Object oe = f.getBean("E");
8. Team e = (Team)oe;
9. e.say();
10. //西班牙
11. Object os = f.getBean("S");
12. Team s = (Team)os;
13. s.say();
14. //葡萄牙
15. Object op = f.getBean("P");
16. Team p = (Team)op;
17. p.say();
18. }
19. }

输出结果：

1. England ：我们是欧洲的中国队，不在乎这次小组没出线...
2. Spain   ：我们是两届欧洲杯冠军、一届世界杯冠军！
3. Portugal：我们的C罗一个顶十个！

其他代码：

1. //工厂接口
2. package com.tgb.spring.factory;
3. public interface BeanFactory {
4. Object getBean(String id);
5. }
6. //Team接口
7. package com.tgb.spring.factory;
8. public interface Team {
9. void say();
10. }
11. //英格兰
12. package com.tgb.spring.factory;
13. public class England implements Team{
14. public void say() {
15. System.out.println("England：我们是欧洲的中国队，不在乎这次小组没出线...");
16. }
17. }
18. //西班牙
19. package com.tgb.spring.factory;
20. public class Spain implements Team{
21. @Override
22. public void say() {
23. System.out.println("Spain：我们是两届欧洲杯冠军、一届世界杯冠军！");
24. }
25. }
26. //葡萄牙
27. package com.tgb.spring.factory;
28. public class Portugal implements Team {
29. @Override
30. public void say() {
31. System.out.println("Portugal：我们的C罗一个顶十个！");
32. }
33. }

以上内容是对Spring的一个简单模拟，当然Spring远比这个要复杂的多，也强大的多，而且获取bean的方式也不止通过工厂这一种。这里只是做一个粗略的Demo说说自己对容器的简单理解，向Spring致敬。例子简陋，表达粗糙，欢迎拍砖交流。