SpringIOC容器Bean对象的实例化模拟

思路:
1. 定义 Bean ⼯⼚接⼝，提供获取 bean ⽅法
2. 定义 Bean ⼯⼚接⼝实现类，解析配置⽂件，实例化Bean对象
3. 实现获取 Bean ⽅法

1、定义 Bean 属性对象

package org.example.spring;

/**
 * Bean属性对象：用来封装Spring配置文件中bean标签的id和class属性值
 */
public class MyBean {
    private String id;  //存放bean标签的id值
    private String clazz;  //存放bean标签的class属性值

    public MyBean() {
    }

    public MyBean(String id, String clazz) {
        this.id = id;
        this.clazz = clazz;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

2、添加 dom4j和xpath依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>spring02</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>spring02</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- dom4j -->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    
    <!-- XPath -->
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>jaxen</artifactId>
      <version>1.1.6</version>
    </dependency>
  </dependencies>
</project>

3、准备自定义的spring配置文件

<?xml version="1.0" encoding="utf-8" ?>
<beans>
    <bean id="userDao" class="org.example.service.UserDao"></bean>
    <bean id="userService" class="org.example.service.UserService"></bean>
</beans>

4、定义 Bean 工厂接口

package org.example.spring;

/**
 * Bean工厂接口的定义
 */
public interface MyFactory {
    //根据id属性值获取bean对象
    public Object getBean(String id);
}

5、定义 Bean 接口的实现类

package org.example.spring;

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

import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 模拟Spring的实现
 * 1.通过有参构造方法获得对应的配置文件
 * 2.使用dom4j解析配置文件(spring配置文件),得到一个List集合(这个List集合存放了一系列bean标签的id和class属性值)
 * 3.通过反射机制创建对应的实例化对象并存入到一个Map集合中(遍历List集合，通过获取对应的class属性值，利用反射机制实例化对象)
 * 4.根据id值获取bean对象
 */
public class MyClassPathXmlApplicationContext implements MyFactory{
    //存放从spring配置文件中获取到的bean标签的信息
    private List<MyBean> beanList;
    //使用Map集合存放实例化好的bean对象
    private Map<String,Object> beanMap = new HashMap<>();

    //1.通过有参构造方法获得对应的配置文件
    public MyClassPathXmlApplicationContext(String fileName) {
        //2.使用dom4j解析配置文件(spring配置文件),然后得到一个List集合(这个List集合存放了一系列bean标签的id和class属性值)
        this.parseXml(fileName);
        //3.通过反射机制创建对应的实例化对象并存入到一个Map集合中
        this.instanceBean();
    }

    /**
     * 通过反射机制创建对应的实例化对象并存入到一个Map集合中
     */
    private void instanceBean() {
        //1.判断对象集合是否为空，如果不为空则遍历集合，获取对应的id和class属性
        if (beanList != null && beanList.size()>0){
            for (MyBean bean:beanList){
                String id = bean.getId();
                String clazz = bean.getClazz();
                try {
                    //2.通过反射机制根据类的全路径名实例化对象
                    Object object = Class.forName(clazz).newInstance();
                    //3.将对应的id和实例化好的bean对象放入Map集合中
                    beanMap.put(id,object);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 使用dom4j解析spring配置文件，得到List集合
     * @param fileName
     */
    private void parseXml(String fileName) {
        //1.获取解析器
        SAXReader saxReader = new SAXReader();
        //2.获取配置文件的URL
        URL url = this.getClass().getClassLoader().getResource(fileName);
        try{
            //3.通过解析器解析spring配置文件
            Document document = saxReader.read(url);
            //4.通过xpath语法解析，获取beans标签下的所有bean标签
            XPath xPath = document.createXPath("beans/bean");
            //5.通过指定的解析语法解析文档对象，返回元素集合
            List<Element> elementList = xPath.selectNodes(document);
            //6.判断元素集合是否为空
            if (elementList != null && elementList.size()>0){
                //实例化List集合
                beanList = new ArrayList<>();
                //7.如果元素集合不为空，就遍历集合
                for (Element e:elementList){
                    //8.获取bean标签元素的属性(id和class属性值)
                    String id = e.attributeValue("id");
                    String clazz = e.attributeValue("class");
                    //9.获取MyBean对象，将id和class属性值设置到对象中，再将对象添加到List集合中
                    MyBean myBean = new MyBean(id,clazz);
                    beanList.add(myBean);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 通过id获取对应bean对象
     * @param id
     * @return
     */
    public Object getBean(String id) {
        Object object = beanMap.get(id);
        return object;
    }
}

6、测试自定义的IOC容器

先定义用于测试的两个类：

package org.example.dao;

public class UserDao {
    public void test(){
        System.out.println("UserDao Test...");
    }
}


package org.example.service;

public class UserService {
    public void test(){
        System.out.println("UserService Test...");
    }
}

编写测试程序：

package org.example;

import org.example.dao.UserDao;
import org.example.service.UserService;
import org.example.spring.MyClassPathXmlApplicationContext;
import org.example.spring.MyFactory;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        //得到工厂的实现对象
        MyFactory factory = new MyClassPathXmlApplicationContext("spring.xml");
        //得到对应的实例化对象
        UserDao userDao = (UserDao)factory.getBean("userDao");
        userDao.test();

        UserService userService = (UserService)factory.getBean("userService");
        userService.test();
    }
}