spring容器IOC原理解析

时间:2023-03-08 16:20:50
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致敬。例子简陋,表达粗糙,欢迎拍砖交流。