通过实例浅谈春运作机制

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

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

Java的代码

公共静态无效的主要（字串[] args）{

ApplicationContext的 背景 = 新 FileSystemXmlApplicationContext来（

“的applicationContext.xml”）;

动物 动物 =（动物）context.getBean（“动物”）;

animal.say（）;

}

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

Java的代码

< bean的 ID = “动物” 类= “phz.springframework.test.Cat” >

< 属性 名= “姓名” >

< 值>的小猫</ 值>

</ 属性>

</ 豆>

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

Java的代码

公共类Cat实现动物{

私人字符串名称;

公共无效的发言权（）{

的System.out.println（“我”+姓名+“！”）;

}

公共无效setname可以（字符串名称）{

this.name =名称;

}

}

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

Java的代码

公共接口动物{

公共无效说（）;

}

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

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

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

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

Java的代码

/ *豆ID * /

私人字符串ID;

/ * Bean类* /

私人字符串类型;

/ * Bean属性* /

私人地图< 字符串，对象> 属性 = 新 的HashMap < 字符串，对象>（）;

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

接下来春天 的标识，HasMap

地图配置可以像下面的

Java的代码

< bean的 ID = “测试” 级= “测试” >

< 属性 名= “testMap” >

< 图>

< 进入 关键= “A” >

< 值> 1 </ 值>

</ 入门>

< 进入 关键= “B” >

< 值> 2 </ 值>

</ 入门>

</ 图>

</ 属性>

</ 豆>

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

Java的代码

如果（beanProperty.element（“映射”）！= NULL）{

地图< 字符串，对象> propertiesMap = 新 的HashMap < 字符串，对象>（）;

元素 propertiesListMap =（元素）的BeanProperty

.elements（）得到（0）。

迭代器<？> propertiesIterator = propertiesListMap

。.elements（）迭代器（）;

而（propertiesIterator.hasNext（））{

元素 兽医 =（元）propertiesIterator.next（）;

如果（vet.getName（）。等于（“入口”））{

字符串 键 = 兽医.attributeValue（“钥匙”）;

迭代器<？> valuesIterator = 兽医.elements（）

.iterator（）;

而（values​​Iterator.hasNext（））{

元素 值 =（元素）valuesIterator.next（）;

如果（value.getName（）。等于（“价值”））{

propertiesMap.put（键，value.getText（））;

}

如果（value.getName（）。等于（“参考”））{

propertiesMap.put（键，新的String [] {值

.attributeValue（“豆”）}）;

}

}

}

}

。bean.getProperties（）摆（姓名，propertiesMap）;

}

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

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

Java的代码

公共静态对象的newInstance（弦乐的className）{

类<？> CLS = 空;

对象 的obj = 空;

尝试{

CLS = 类.forName（类名）;

OBJ = CLS .newInstance（）;

}赶上（ClassNotFoundException异常E）{

抛出新的RuntimeException（五）;

}赶上（InstantiationException五）{

抛出新的RuntimeException（五）;

}赶上（IllegalAccessException五）{

抛出新的RuntimeException（五）;

}

返回的obj;

}

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

Java的代码

公共静态无效的SetProperty（obj对象，字符串名称，字符串值）{

类<？ 扩展 对象> clazz所 = OBJ .getClass（）;

尝试{

字符串 方法名 = returnSetMthodName （名称）;

方法[] 毫秒 = clazz所.getMethods（）;

对于（方法M：毫秒）{

如果（m.getName（）。等于（方法名））{

如果（m.getParameterTypes（）.length ==
1）{

类<？> clazzParameterType =
m.getParameterTypes（）[0];

setFieldValue（clazzParameterType.getName（），价值，男，

OBJ）;

打破;

}

}

}

}赶上（SecurityException异常E）{

抛出新的RuntimeException（五）;

}赶上（抛出：IllegalArgumentException五）{

抛出新的RuntimeException（五）;

}赶上（IllegalAccessException五）{

抛出新的RuntimeException（五）;

}赶上（的InvocationTargetException五）{

抛出新的RuntimeException（五）;

}

}

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

Java的代码

如果（值的instanceof地图）{

迭代器<？> entryIterator =（（地图<？ ， ？>）值）.entrySet（）

.iterator（）;

地图< 字符串，对象> 图 = 新 的HashMap < 字符串，对象>（）;

而（entryIterator.hasNext（））{

进入<？ ， ？> entryMap =（进入<？ ， ？>）entryIterator.next（）;

如果（entryMap.getValue（）的instanceof的String []）{

map.put（（弦乐）entryMap.getKey（）

的getBean（（（字符串[]）entryMap.getValue（））[0]））;

}

}

BeanProcesser.setProperty（OBJ，财产，地图）;

}

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

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

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