通过实例浅谈春运作机制

看到这个标题大家可能又想：哎，又一个重新发明轮子的人。在这里很想先声明一下，写这篇文章只是想让大家了解一下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，可以直接运行。