Spring学习----------Spring IoC容器原理分析

在Spring中，通过IOC可以将实现类、参数信息等配置在其对应的配置文件中，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，我们还可以对某对象所需要的其它对象进行注入，这种注入都是在配置文件中做的。

Spring的IOC的实现原理利用的就是Java的反射机制，Spring还充当了工厂的角色，我们不需要自己建立工厂类，Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。

接下来我们自己来创建一个Spring的Bean工厂类来讲述SpringIoC容器的原理

[java] view plain copy

1. public class BeanFactory {  
2.   
3.     private Map<String, Object> beanMap = new HashMap<String, Object>();  
4.   
5.     /** 
6.      * bean工厂的初始化. 
7.      *  
8.      * @param xml xml配置文件 
9.      */  
10.     public void init(String xml) {  
11.         try {  
12.             //1.创建读取配置文件的reader对象  
13.             SAXReader reader = new SAXReader();  
14.             //2.获取当前线程中的类装载器对象  
15.             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();  
16.             //3.从class目录下获取指定的xml文件  
17.             InputStream ins = classLoader.getResourceAsStream(xml);  
18.             Document doc = reader.read(ins);  
19.             Element root = doc.getRootElement();  
20.             Element foo;  
21.               
22.             //4.遍历xml文件当中的Bean实例  
23.             for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
24.                 foo = (Element) i.next();  
25.                   
26.                 //5.针对每个一个Bean实例，获取bean的属性id和class  
27.                 Attribute id = foo.attribute("id");  
28.                 Attribute cls = foo.attribute("class");  
29.                   
30.                 //6.利用Java反射机制，通过class的名称获取Class对象  
31.                 Class bean = Class.forName(cls.getText());  
32.                 //7.获取对应class的信息  
33.                 java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);  
34.                 //8.获取其属性描述  
35.                 java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();  
36.   
37.                 //9.创建一个对象，并在接下来的代码中为对象的属性赋值  
38.                 Object obj = bean.newInstance();  
39.                   
40.                 //10.遍历该bean的property属性  
41.                 for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {  
42.                     Element foo2 = (Element) ite.next();  
43.                       
44.                     //11.获取该property的name属性  
45.                     Attribute name = foo2.attribute("name");  
46.                     String value = null;  
47.                       
48.                     //12.获取该property的子元素value的值  
49.                     for (Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();)   
50.                     {  
51.                         Element node = (Element) ite1.next();  
52.                         value = node.getText();  
53.                         break;  
54.                     }  
55.                       
56.                     //13.利用Java的反射机制调用对象的某个set方法，并将值设置进去   
57.                     for (int k = 0; k < pd.length; k++) {  
58.                         if (pd[k].getName().equalsIgnoreCase(name.getText()))   
59.                         {  
60.                             Method mSet = null;  
61.                             mSet = pd[k].getWriteMethod();  
62.                             mSet.invoke(obj, value);  
63.                         }  
64.                     }  
65.                 }  
66.   
67.                 //14.将对象放入beanMap中，其中key为id值，value为对象  
68.                 beanMap.put(id.getText(), obj);  
69.             }  
70.         } catch (Exception e) {  
71.             System.out.println(e.toString());  
72.         }  
73.     }  
74.   
75.     /** 
76.      * 通过bean的id获取bean的对象. 
77.      *  
78.      * @param beanName 
79.      *            bean的id 
80.      * @return 返回对应对象 
81.      */  
82.     public Object getBean(String beanName) {  
83.         Object obj = beanMap.get(beanName);  
84.         return obj;  
85.     }  
86.   
87.     /** 
88.      * 测试方法. 
89.      *  
90.      * @param args 
91.      */  
92.     public static void main(String[] args) {  
93.         BeanFactory factory = new BeanFactory();  
94.         factory.init("src/conf/config.xml");  
95.         JavaBean javaBean = (JavaBean) factory.getBean("javaBean");  
96.         System.out.println("userName=" + javaBean.getUserName());  
97.         System.out.println("password=" + javaBean.getPassword());  
98.     }  
99. }