Spring IOC container parsing and implementation principles

In recent times, "container" two words have been lingering in my ears, even eat, sleep in my mind jumping to jump. As these days of exchanges and discussions, the understanding of the container gradually deepened. In theory, things have to be implemented to practice, today, with the help of spring container implementation principle, simply say it.

To put it simply, spring is putting our beans in its container through Factory + reflection, and when we want to use a bean, we just need to call the Getbean ("Beanid") method.

The principle of simple introduction:

The principle of the spring container is actually to parse the XML file, or fetch the user-configured bean, and then put the beans into the collection by reflection, then provide a Getbean () method for us to get the beans. The following is a simple analog code:

[Java]View PlainCopy 

2. Package com.tgb.spring.factory;
6. Import Java.util.HashMap;
8. Import java.util.List;
10. Import Java.util.Map;
14. Import org.jdom.Document;
16. Import org.jdom.Element;
18. Import Org.jdom.input.SAXBuilder;
20. Import Org.jdom.xpath.XPath;
24. Public class Classpathxmlapplicationcontext implements Beanfactory {
28. //The core of the container, used to store injected beans
30. private map<string, object> container = new hashmap<string, object> ();
34. //Parse XML file, put configured bean into container by reflection
36. Public Classpathxmlapplicationcontext (String fileName) throws exception{
38. Saxbuilder sb = new Saxbuilder ();
40. Document doc = Sb.build (this.getclass (). getClassLoader (). getResourceAsStream (FileName));
42. Element root = Doc.getrootelement ();
44. List List = Xpath.selectnodes (root, "/beans/bean");
48. //Scan the bean in the configuration file
50. For (int i = 0; i < list.size (); i++) {
52. Element bean = (Element) list.get (i);
54. String id = bean.getattributevalue ("id");
56. String clazz = Bean.getattributevalue ("class");
58. Object o = Class.forName (clazz). newinstance ();
60. Container.put (ID, O);
62. }
64. }
68. @Override
70. Public Object Getbean (String id) {
72. return Container.get (ID);
74. }
78. }

First declare a map of the bean, and then through the Jdom parse the configuration file, loop through all the <bean> nodes and put them through reflection into the map we declared earlier. Then provide a method of Getbean (), so that we can find the bean we want through the bean ID.

The following is a simple XML configuration file:

[HTML]View PlainCopy 

2. <? XML version= "1.0" encoding="UTF-8"?>
4. <beans>
8. <Bean id="E" class="Com.tgb.spring.factory.England" />
12. <Bean id="S" class="Com.tgb.spring.factory.Spain" />
16. <Bean id="P" class="Com.tgb.spring.factory.Portugal" />
20. </Beans>

The client loads the above configuration file by invoking the previous Classpathxmlapplicationcontext, and then it can get the bean we need by ID:

[Java]View PlainCopy 

2. Package com.tgb.spring.factory;
6. Public class Test {
10. public static void Main (string[] args) throws Exception {
14. //Load configuration file
16. Beanfactory f = new Classpathxmlapplicationcontext ("Applicationcontext.xml");
20. //England
22. Object oe = F.getbean ("E");
24. Team E = (team) OE;
26. E.say ();
30. //Spain
32. Object OS = F.getbean ("S");
34. Team S = (team) OS;
36. S.say ();
40. //Portugal
42. Object op = F.getbean ("P");
44. Team P = (team) op;
46. P.say ();
48. }
52. }

Output Result:

[Plain]View PlainCopy  

1. England: We are the Chinese team in Europe, do not care about this group is not qualified ...
2. Spain: We are the two European Cup champions and one World Cup winner!
3. Portugal: Our Cristiano Ronaldo is a top 10!

Other code:

[Java]View PlainCopy 

2. Factory interface
4. Package com.tgb.spring.factory;
8. Public interface Beanfactory {
10. Object Getbean (String ID);
12. }
16. Team Interface
18. Package com.tgb.spring.factory;
22. Public interface Team {
24. void Say ();
26. }
30. England
32. Package com.tgb.spring.factory;
36. Public class England implements team{
40. public Void Say () {
42. System.out.println ("England: We are the Chinese team in Europe, do not care if this group is not qualified ...");
44. }
46. }
50. Spain
52. Package com.tgb.spring.factory;
56. Public class Spain implements team{
60. @Override
62. public Void Say () {
64. System.out.println ("Spain: We are the two European Cup champions and one World Cup winner!")  ");
66. }
70. }
74. Portugal
76. Package com.tgb.spring.factory;
80. Public class Portugal implements Team {
84. @Override
86. public Void Say () {
88. System.out.println ("Portugal: Our Cristiano Ronaldo a top 10!  ");
90. }
94. }

The above is a simple simulation of spring, of course, spring is much more complex and powerful than this, and the way to get beans is not only through the factory. This is just a rough demo of a simple understanding of the container and a tribute to spring. Examples humble, express rough, welcome to shoot Brick Exchange.

Spring IOC container parsing and implementation principles