spring IOC原理诠释的比较好的例子--perfect

最新推荐文章于 2024-10-08 14:02:50 发布

洪文聊架构

最新推荐文章于 2024-10-08 14:02:50 发布

阅读量2.8k

点赞数

分类专栏：【Java EE 后台开发】

【Java EE 后台开发】专栏收录该内容

88 篇文章 0 订阅

订阅专栏

IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类、参数信息等配置在其对应的配置文件中，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入，这种注入都是在配置文件中做的，Spring的IOC的实现原理利用的就是Java的反射机制，Spring还充当了工厂的角色，我们不需要自己建立工厂类。Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。下面让我们看看如下的模拟Spring的bean工厂类：

1、BeanFactory.java

    Java代码   
    
  
 package com.yt.manager.spring;  
   
 import java.io.InputStream;  
 import java.lang.reflect.Method;  
 import java.util.HashMap;  
 import java.util.Iterator;  
 import java.util.Map;  
 import org.apache.log4j.Logger;  
 import org.dom4j.Attribute;  
 import org.dom4j.Document;  
 import org.dom4j.Element;  
 import org.dom4j.io.SAXReader;  
   
 /** 
  * @ClassName: BeanFactory 
  * @Project: base-info 
  * @Author: zxf 
  * @Date: 2011-5-19 
  */  
 public class BeanFactory {  
       
     Logger log = Logger.getLogger(BeanFactory.class);  
     private Map<String, Object> beanMap = new HashMap<String, Object>();  
   
     /** 
      * bean工厂的初始化 
      *  
      * @param xml 
      */  
     public void init(String xml) {  
         try {  
             //读取指定的配置文件  
             SAXReader reader = new SAXReader();  
             //从class目录下获取指定的配置文件  
             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();  
             InputStream inputStream = classLoader.getResourceAsStream(xml);  
             //读取xml文件  
             Document document = reader.read(inputStream);  
             //获取跟节点  
             Element root = document.getRootElement();  
             //遍历bean节点  
             Element foo;  
             for(Iterator iteBean = root.elementIterator("bean");iteBean.hasNext();){  
                 foo = (Element)iteBean.next();  
                 //获取bean的属性id和class  
                 Attribute id = foo.attribute("id");  
                 Attribute cls = foo.attribute("class");  
                 //利用java反射机制，通过class的名称获取Class对象  
                 Class bean = Class.forName(cls.getText());  
                 //获取对应class信息  
                 java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);  
                 //获取其属性描述  
                 java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();  
                 //设置值的方法  
                 Method mSet = null;  
                 //创建一个对象(创建此 Class 对象所表示的类的一个新实例。如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。)  
                 Object obj = bean.newInstance();  
                   
                 //遍历该bean的property属性  
                 for(Iterator iteProperty = foo.elementIterator("property");iteProperty.hasNext();){  
                     Element elementProperty = (Element)iteProperty.next();  
                     //获取该property的name属性  
                     Attribute name = elementProperty.attribute("name");  
                     String value = null;  
                     //获取该property的子元素value的值  
                     for(Iterator iteValue = elementProperty.elementIterator("value");iteValue.hasNext();){  
                         Element elementValue = (Element)iteValue.next();  
                         value = elementValue.getText();  
                         break;  
                     }  
                       
                     for (int k = 0; k < pd.length; k++) {  
                         log.info(pd[k].getName());  
                         if (pd[k].getName().equalsIgnoreCase(name.getText())) {  
                                mSet = pd[k].getWriteMethod();  
                                //利用Java的反射机制调用对象的某个set方法，并将值设置进去  
                                mSet.invoke(obj, value);  
                         }  
                  }  
                 }  
                //将对象放入beanMap中，其中key为id值，value为对象  
                 beanMap.put(id.getText(), obj);  
             }  
   
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
       
     /** 
      * 通过bean的id获取bean的对象. 
      * @param beanName bean的id 
      * @return 返回对应对象 
      */  
      public Object getBean(String beanName) {  
            Object obj = beanMap.get(beanName);  
            return obj;  
      }  
   
      public static void main(String[] args) {  
          BeanFactory factory = new BeanFactory();  
          factory.init("config.xml");  
          JavaBean javaBean = (JavaBean) factory.getBean("javaBean");  
          System.out.println("userName=" + javaBean.getUserName());  
          System.out.println("password=" + javaBean.getPassWord());  
      }  
 }  

2、JavaBean.java

    Java代码   
    
  
 package com.yt.manager.spring;  
   
 /** 
  * @Description: 
  * @ClassName: JavaBean 
  * @Project: base-info 
  * @Author: zxf 
  * @Date: 2011-5-19 
  */  
 public class JavaBean {  
     private String userName;  
     private String passWord;  
   
     public String getUserName() {  
         return userName;  
     }  
   
     public void setUserName(String userName) {  
         this.userName = userName;  
     }  
   
     public String getPassWord() {  
         return passWord;  
     }  
   
     public void setPassWord(String passWord) {  
         this.passWord = passWord;  
     }  
   
 }  

3、config.xml

    Xml代码   
    
  
 <?xml version="1.0" encoding="UTF-8"?>  
 <beans>  
     <bean id = "javaBean" class="com.yt.manager.spring.JavaBean">  
         <property name="userName">  
             <value>这是姓名</value>  
         </property>  
         <property name="passWord">  
             <value>这是密码</value>  
         </property>  
     </bean>  
 </beans>  

可以看到，虽然在main()方法中没有对属性赋值，但属性值已经被注入，在BeanFactory类中的Class bean = Class.forName(cls.getText()); 通过类名来获取对应的类，mSet.invoke(obj, value);通过invoke方法来调用特定对象的特定方法，实现的原理都是基于Java的反射机制，在此我们有一次见证了Java反射机制的强大。当然，这只是对IOC的一个简单演示，在Spring中，情况要复杂得多，例如，可以一个bean引用另一个bean，还可以有多个配置文件、通过多种方式载入配置文件等等。不过原理还是采用Java的反射机制来实现IOC的。
在本文中，笔者通过讲述Java反射机制概述与初探、IOC使用的背景、IOC粉墨登场等内容，演示了Java反射机制API的强大功能，并通过编写自己的简单的IOC框架，让读者更好的理解了IOC的实现原理。本文通过IOC的一个简要实现实例，模拟了Spring中IOC的实现，虽然只是完成了Spring中依赖注入的一小部分工作，但是很好的展现了Java反射机制在Spring中的应用，能使我们能更好的从原理上了解IOC的实现，也能为我们实现自己的准Spring框架提供方案，有兴趣的朋友可以通过Spring的源码进行IOC的进一步的学习。

附：通过java反射机制获取指定类的属性和方法

    Java代码   
    
  
 package com.yt.manager.spring;  
   
 import java.beans.BeanInfo;  
 import java.beans.Introspector;  
 import java.beans.MethodDescriptor;  
 import java.beans.PropertyDescriptor;  
   
 /** 
  * @Description:java.beans包的使用 
  * @ClassName: JavaBeans 
  * @Project: base-info 
  * @Author: zxf 
  * @Date: 2011-5-19 
  */  
 public class JavaBeans {  
   
     /** 
      * @param args 
      * @throws Exception 
      */  
     @SuppressWarnings("rawtypes")  
     public static void main(String[] args) throws Exception {  
         // 返回与带有给定字符串名的类或接口相关联的 Class 对象  
         Class bean = Class.forName("com.yt.manager.spring.JavaBean");  
         // 获取指定类的信息  
         BeanInfo info = Introspector.getBeanInfo(bean);  
         // 遍历指定类的方法  
         MethodDescriptor[] methods = info.getMethodDescriptors();  
         for (int i = 0; i < methods.length; i++) {  
             System.out.println("方法："+methods[i].getDisplayName());  
         }  
         // 遍历指定类的属性  
         PropertyDescriptor[] propertys = info.getPropertyDescriptors();  
         for (int j = 0; j < propertys.length; j++) {  
             System.out.println("属性："+propertys[j].getName());  
         }  
     }  
   
 }  

    Java代码   
    
  
 package com.yt.manager.spring;  
   
 import java.lang.reflect.Method;  
   
 /** 
  * @Description: java.lang.reflect.method类中invoke方法的使用 
  * @ClassName: MethodInvoke 
  * @Project: base-info 
  * @Author: zxf 
  * @Date: 2011-5-19 
  */  
 public class MethodInvoke {  
   
     /**  
      * @param args 
      * @throws ClassNotFoundException 
      */  
     public static void main(String[] args) throws Exception {  
           
         JavaBean javaBean = new JavaBean();  
         //获取指定类的指定方法，  
         Class c = Class.forName("com.yt.manager.spring.JavaBean");  
         Method method = c.getMethod("setUserName", new Class[] { String.class });  
         //对带有指定参数的指定对象调用由此 Method 对象表示的底层方法,调用对象javaBean的setuserName方法，参数为"testName"  
         method.invoke(javaBean, "testName");  
           
         System.out.println(javaBean.getUserName());  
     }  
   
 }  