用java的spring实现一个简单的IOC容器示例代码

发布时间:2020-09-20 20:39:08 作者:我叫了了
来源:脚本之家 阅读:165

要想深入的理解IOC的技术原理,没有什么能比的上我们自己实现它。这次我们一起实现一个简单IOC容器。让大家更容易理解Spring IOC的基本原理。

这里会涉及到一些java反射的知识,如果有不了解的,可以自己去找些资料看看。

注意

在上一篇文章,我说,启动IOC容器时,Spring会将xml文件里面配置的bean扫描并实例化,其实这种说法不太准确,所以我在这里更正一下,xml文件里面配置的非单利模式的bean,会在第一次调用的时候被初始化,而不是启动容器的时候初始化。但是我们这次要做的例子是容器启动的时候就将bean初始化。特此说明一下,害怕误导初学者。

现在我们开始做一个简单的IOC容器

思路:

1,启动容器时,加载xml文件。

2,读取xml文件内的bean信息,并使用反射技术将bean实例化,并装入容器。

3,确认bean之间的以来关系,进行注入。

下面直接上代码,先看配置文件,与上一篇文章中使用的例子是一样的,我们这次继续使用上一篇文章的吃苹果和吃橘子的例子,只不过这次我们用我们自己写的IOC容器,所以,我只粘贴了关键代码。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" 
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--这是吃橘子的Bean -->
  <bean id="eatOrange" class="it.spring.liao.com.EatOrange"></bean>
    <!--这是吃苹果的Bean -->
  <bean id="eatApple" class="it.spring.liao.com.EatApple"></bean>
  <bean id="person" class="it.spring.liao.com.Person">
    <!-- 这里我们注入的是吃橘子的bean-->
    <property name="eat" ref="eatOrange"/>
  </bean>
</beans>

此处为关键代码

package it.spring.liao.com;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class BeanFactory {

  // 用于存放bean实例的集合
  private Map<String, Object> beanMap = new HashMap<String, Object>();

  /**
   * bean工厂的初始化. <br>
   * 
   * @param xml
   *      配置文件路径
   */
  public void init(String xml) {
    try {
      // 1.创建读取配置文件的reader对象
      SAXReader reader = new SAXReader();
      // 2.获取当前线程中的类装载器对象
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      // 3.从class目录下获取指定的xml文件
      InputStream ins = classLoader.getResourceAsStream(xml);
      // 4.使用dom4j 解析xml文件
      Document doc = reader.read(ins);
      Element root = doc.getRootElement();
      // 5.初始化bean
      setBean(root);
      // 6.注入bean的依赖关系
      setPv(root);
    } catch (Exception e) {
      System.out.println(e.toString());
    }
  }

  /**
   * 初始化bean
   * 
   * @param root
   *      xml文件
   * @throws Exception
   */
  public void setBean(Element root) throws Exception {
    // 1.遍历xml文件当中的Bean实例
    for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
      Element foo = (Element) i.next();
      // 2.针对每个Bean实例,获取bean的属性id和class
      String id = foo.attribute("id").getText();
      String cls = foo.attribute("class").getText();
      // 3.利用Java反射机制,通过class的名称获取Class对象
      Class bean = Class.forName(cls);
      // 4.创建对象
      Object obj = bean.newInstance();
      // 5.将对象放入beanMap中,其中key为bean的id值,value为bean的实例
      beanMap.put(id, obj);
    }
  }

  /**
   * 注入bean的依赖关系
   * 
   * @param root
   *      xml文件
   * @throws Exception
   */
  public void setPv(Element root) throws Exception {
    for (Iterator it = root.elementIterator("bean"); it.hasNext();) {
      Element foo = (Element) it.next();

      // 1.针对每个Bean实例,获取bean的属性id和class
      String cls = foo.attribute("class").getText();
      String id = foo.attribute("id").getText();

      // 2.利用Java反射机制,通过class的名称获取Class对象
      Class bean1 = Class.forName(cls);

      // 3.获取对应class的信息
      java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean1);

      // 4.获取其属性描述
      java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();

      // 5遍历该bean的property属性
      for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
        Element foo2 = (Element) ite.next();

        // 6.获取该property的name属性
        String name = foo2.attribute("name").getText();
        String ref = foo2.attribute("ref").getText();

        // 7.在类中寻找与xml配置文件中该bean的property属性名相同的属性
        for (int k = 0; k < pd.length; k++) {
          // 8.如果相等,证明已经找到对应得属性
          if (pd[k].getName().equalsIgnoreCase(name)) {
            Method mSet = null;
            // 9.利用反射,获取该属性的set方法
            mSet = pd[k].getWriteMethod();
            // 10.用原beanMap中该bean的实例,执行该属性的set方法,并从原beanMap中获取该属性的依赖值
            mSet.invoke(beanMap.get(id), beanMap.get(ref));
          }
        }
        break;
      }
    }
  }

  /**
   * 通过bean的id获取bean的实例
   * 
   * @param beanName
   *      bean的id
   * @return 返回对应对象
   */
  public Object getBean(String beanName) {
    Object obj = beanMap.get(beanName);
    return obj;
  }

}




  /**
   * 测试方法.
   * 
   * @param args
   */
  public static void main(String[] args) {
    //使用我们自己写的 BeanFactory
    BeanFactory factory = new BeanFactory();
    factory.init("eat.xml");
    Person javaBean = (Person) factory.getBean("person");
    System.out.println(javaBean.eat()); 
  }

详细的解释都在代码的注释中,这个例子可以帮助你更深刻的理解spring的基本技术原理。但Spring的复杂程度远远高于这个例子,再说一次,spring IOC中使用懒加载机制,在启动spring IOC时,只会实例化单例模式的bean,不会实例化普通的bean,关于单例模式还是其他模式,是可以自己配置的,我们会在后面的文章中讲解,非单例模式bean的实例化,发生在第一次调用的时候,与我们这个例子不太一样。这个例子只供了解Spring IOC的基本原理,真实情况要复杂的多,需要我们一点点的去学习,不积跬步无以至千里。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持亿速云。

推荐阅读:
  1. Spring ioc容器介绍
  2. Spring中IoC容器的介绍

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

spring ioc ava

上一篇:安装TMG后内网访问外网FTP权限受限的解决方法

下一篇:Python @property及getter setter原理详解

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》