通过实例浅谈春运作机制

看到这个标题大家可能又想：哎，又一个重新发明轮子的人。在这里很想先声明一下，写这篇文章只是想让大家了解一下Spring到底是怎么运行的，并不是想重造轮子噢，希望大家看完这篇文章后能对Spring运作机制有更深入的了解，希望这篇文章对你有所帮助喔！好，言归正传，让我们来一起探索吧！

我们先从最常见的例子开始吧

Java的代码

1. 公共静态无效的主要（字串[] args）{     
2.         ApplicationContext的  背景 =  新 FileSystemXmlApplicationContext来（     
3.                 “的applicationContext.xml”）;     
4.         动物  动物 =（动物）context.getBean（“动物”）;     
5.         animal.say（）;     
6.     }    
7.  

这段代码你一定很熟悉吧，不过还是让我们分析一下它吧，首先是applicationContext.xml

Java的代码

1. < bean的  ID = “动物”  类= “phz.springframework.test.Cat” >     
2.         < 属性 名= “姓名” >     
3.             < 值>的小猫</ 值>     
4.         </ 属性>     
5. </ 豆>    
6.  

他有一个类phz.springframework.test.Cat =

Java的代码

1. 公共类Cat实现动物{     
2.     私人字符串名称;     
3.     公共无效的发言权（）{     
4.         的System.out.println（“我”+姓名+“！”）;     
5.     }     
6.     公共无效setname可以（字符串名称）{     
7.         this.name  =名称;     
8.     }     
9. }    
10.  

实现了phz.springframework.test.Animal接口

Java的代码

1. 公共接口动物{     
2.     公共无效说（）;     
3. }    
4.  

很明显上面的代码输出，我的小猫！

那么到底春天是如何做到的呢？

接下来就让我们自己写个春天来看看春天运作机制吧！

首先，我们定义一个Bean的类，这个类用来存放一个豆拥有的属性

Java的代码 

1. / *豆ID * /    
2.    私人字符串ID;     
3.    / * Bean类* /    
4.    私人字符串类型;     
5.    / * Bean属性* /    
6. 私人地图< 字符串，对象> 属性 =  新 的HashMap < 字符串，对象>（）;    

一个豆包括编号，类型，和属性。

接下来春天 的标识，HasMap

地图配置可以像下面的

Java的代码

1. < bean的  ID = “测试”  级= “测试” >     
2.         < 属性 名= “testMap” >     
3.             < 图>     
4.                 < 进入 关键= “A” >     
5.                     < 值> 1 </ 值>     
6.                 </ 入门>     
7.                 < 进入 关键= “B” >     
8.                     < 值> 2 </ 值>     
9.                 </ 入门>     
10.             </ 图>     
11.         </ 属性>     
12.     </ 豆>    
13.  

春天的运作机制中是怎样保存上面的配置呢，代码如下？

Java的代码  

1.  
2. 如果（beanProperty.element（“映射”）！= NULL）{  
3.      地图< 字符串，对象>  propertiesMap  =  新 的HashMap < 字符串，对象>（）;  
4.      元素  propertiesListMap  =（元素）的BeanProperty  
5.        .elements（）得到（0）。  
6.      迭代器<？>  propertiesIterator  =  propertiesListMap 
7.        。.elements（）迭代器（）;  
8.      而（propertiesIterator.hasNext（））{  
9.       元素  兽医 =（元）propertiesIterator.next（）;  
10.       如果（vet.getName（）。等于（“入口”））{  
11.        字符串  键 =  兽医.attributeValue（“钥匙”）;  
12.        迭代器<？>  valuesIterator  =  兽医.elements（）  
13.          .iterator（）;  
14.        而（values​​Iterator.hasNext（））{  
15.         元素  值 =（元素）valuesIterator.next（）;  
16.         如果（value.getName（）。等于（“价值”））{  
17.          propertiesMap.put（键，value.getText（））;  
18.         }  
19.         如果（value.getName（）。等于（“参考”））{  
20.          propertiesMap.put（键，新的String [] {值  
21.            .attributeValue（“豆”）}）;  
22.         }  
23.        }  
24.       }  
25.      }  
26.      。bean.getProperties（）摆（姓名，propertiesMap）;  
27.     } 

接下来就进入最核心部分了，让我们看看春天到底是怎么依赖注入的吧，其实依赖注入的思想也很简单，它是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。让我们看看具体它是怎么做的吧。

首先实例化一个类，像这样

Java的代码

1. 公共静态对象的newInstance（弦乐的className）{     
2.         类<？>  CLS  =  空;     
3.         对象  的obj  =  空;     
4.         尝试{     
5.             CLS  =  类.forName（类名）;     
6.             OBJ  =  CLS .newInstance（）;     
7.         }赶上（ClassNotFoundException异常E）{     
8.             抛出新的RuntimeException（五）;     
9.         }赶上（InstantiationException五）{     
10.             抛出新的RuntimeException（五）;     
11.         }赶上（IllegalAccessException五）{     
12.             抛出新的RuntimeException（五）;     
13.         }     
14.         返回的obj;     
15.     }    
16.  

接着它将这个类的依赖注入进去，像这样

Java的代码

2. 公共静态无效的SetProperty（obj对象，字符串名称，字符串值）{  
3.   类<？ 扩展 对象>  clazz所 =  OBJ .getClass（）;  
4.   尝试{  
5.    字符串  方法名 =  returnSetMthodName （名称）;  
6.    方法[]  毫秒 =  clazz所.getMethods（）;  
7.    对于（方法M：毫秒）{  
8.     如果（m.getName（）。等于（方法名））{  
9.      如果（m.getParameterTypes（）.length  == 1）{  
10.       类<？>  clazzParameterType  = m.getParameterTypes（）[0];  
11.       setFieldValue（clazzParameterType.getName（），价值，男，  
12.         OBJ）;  
13.       打破;  
14.      }  
15.     }  
16.    }  
17.   }赶上（SecurityException异常E）{  
18.    抛出新的RuntimeException（五）;  
19.   }赶上（抛出：IllegalArgumentException五）{  
20.    抛出新的RuntimeException（五）;  
21.   }赶上（IllegalAccessException五）{  
22.    抛出新的RuntimeException（五）;  
23.   }赶上（的InvocationTargetException五）{  
24.    抛出新的RuntimeException（五）;  
25.   }  
26. } 

最后它将这个类的实例返回给我们，我们就可以用了。我们还是以Map为例看看它是怎么做的，我写的代码里面是创建一个HashMap并把该HashMap注入到需要注入的类中，像这样，

Java的代码

1.  
2. 如果（值的instanceof地图）{  
3.     迭代器<？>  entryIterator  =（（地图<？ ，  ？>）值）.entrySet（）  
4.       .iterator（）;  
5.     地图< 字符串，对象> 图 =  新 的HashMap < 字符串，对象>（）;  
6.     而（entryIterator.hasNext（））{  
7.      进入<？ ，  ？>  entryMap  =（进入<？ ，  ？>）entryIterator.next（）;  
8.      如果（entryMap.getValue（）的instanceof的String []）{  
9.       map.put（（弦乐）entryMap.getKey（）  
10.         的getBean（（（字符串[]）entryMap.getValue（））[0]））;  
11.      }  
12.     }  
13.     BeanProcesser.setProperty（OBJ，财产，地图）;  
14.    } 

好了，这样我们就可以用春给我们创建的类了，是不是也不是很难啊？当然Spring能做到的远不止这些，这个示例程序仅仅提供了Spring最核心的依赖注入功能中的一部分。这也是Spring运作机制中的一部分。

本文参考了大量文章无法一一感谢，在这一起感谢，如果侵犯了你的版权深表歉意，很希望对大家有帮助！

附件中包含该山寨Spring的源码，核心只有五个类，还有一个测试程序，phz.springframework.test.AnimalSayApp，可以直接运行。