通过实例浅谈春运作机制

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

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

最后它将这个类的实例返回给我们,我们就可以用了。我们还是以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,可以直接运行。

posted @ 2014-12-23 22:40  JAVA之迷  阅读(100)  评论(0编辑  收藏  举报