手把手写一个简单IOC（基于XML配置文件）

Myth丶恋晨 2023-10-10 17:52 2阅读 0赞

**目录**

创建模块

准备测试阶段测试用的Bean

编写ApplicationContext接口

编写ClassPathXmlApplicationContext

确定采用Map集合存储Bean

解析配置文件实例化所有Bean

测试阶段1(实例化bean)

Bean的属性赋值

测试阶段2(为bean对象进行赋值)

--------------------

**Spring IoC容器的实现原理：工厂模式 + 解析XML + 反射机制。**

#### 创建模块 ####

采用Maven方式新建Module：myIocSpring

![406fd1ad26b14c61b731927e10a12341.png][]

引入dom4j和jaxen的依赖，因为要使用它解析XML文件，还有junit依赖。

<dependencies>
            <dependency>
                <groupId>org.dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>2.1.3</version>
            </dependency>
            <dependency>
                <groupId>jaxen</groupId>
                <artifactId>jaxen</artifactId>
                <version>1.2.0</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <properties>
            <maven.compiler.source>17</maven.compiler.source>
            <maven.compiler.target>17</maven.compiler.target>
        </properties>

#### 准备测试阶段测试用的Bean ####

> 这里我们准备2个bean，一个是学生类，一个是班级类，在本文中我们就书写简单的ref和基本数据类型的IOC（即使用value给简单属性赋值。使用ref给非简单属性赋值。）。放在com.study包下

public class Clazz {
        private  String name;
        private  Integer total;
    
        @Override
        public String toString() {
            return "Clazz{" +
                    "name='" + name + '\'' +
                    ", total=" + total +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getTotal() {
            return total;
        }
    
        public void setTotal(Integer total) {
            this.total = total;
        }
    }

public class Student {
        private  String name;
        private  Integer age;
        private Clazz clazz;
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", clazz=" + clazz +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Clazz getClazz() {
            return clazz;
        }
    
        public void setClazz(Clazz clazz) {
            this.clazz = clazz;
        }
    }

准备测试阶段测试用的XML配置文件：IOC.xml文件放在类路径当中即可，我们这里把文件放到类的根路径下。

<?xml version="1.0" encoding="UTF-8"?>
    <beans>
    
        <bean id="clazz" class="com.study.Clazz">
            <property name="name" value="21软件工程c"/>
            <property name="total" value="59"/>
        </bean>
    
        <bean id="student" class="com.study.Student">
            <property name="name" value="zzh"/>
            <property name="age" value="19"/>
            <property name="clazz" ref="clazz"/>
        </bean>
    
    </beans>

这时的目录结构如下：

![a8d5ca21b08241138bd1d1fbdf572b59.png][]

#### 编写ApplicationContext接口 ####

ApplicationContext接口中提供一个getBean()方法，通过该方法可以获取Bean对象。

public interface ApplicationContext {
        /**
         * 根据bean的id获取bean实例。
         * @param beanId bean的id
         * @return bean实例
         */
        Object getBean(String beanId);
    }

#### 编写ClassPathXmlApplicationContext ####

ClassPathXmlApplicationContext是ApplicationContext接口的实现类。该类从类路径当中加载myspring.xml配置文件。

public class ClassPathXmlApplicationContext implements ApplicationContext{
        @Override
        public Object getBean(String beanId) {
            return null;
        }
    }

#### 采用Map集合存储Bean ####

采用Map集合存储Bean实例。Map集合的key存储beanId，value存储Bean实例。Map<String,Object>在ClassPathXmlApplicationContext类中添加Map<String,Object>属性。并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件。同时实现getBean方法。

/**
         * 存储bean的Map集合
         */
        private Map<String,Object> beanMap = new HashMap<>();
    
        /**
         * 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
         * @param resource 配置文件路径（要求在类路径当中）
         */
        public ClassPathXmlApplicationContext(String resource) {
    
        }
    
        @Override
        public Object getBean(String beanId) {
            return beanMap.get(beanId);
        }

#### 解析配置文件实例化所有Bean ####

在ClassPathXmlApplicationContext的构造方法中解析配置文件，获取所有bean的类名，通过反射机制调用**无参数构造方法创建Bean**。并且将Bean对象存放到Map集合中。

#### 解析配置文件实例化所有Bean ####

#### 测试阶段1(实例化bean) ####

public class test {
        public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("IOC.XML");
            Object clazz = applicationContext.getBean("clazz");
            Object student = applicationContext.getBean("student");
            System.out.println(clazz);
            System.out.println(student);
        }
    }

![27ccd258c8e14c78aa77d2888875f5e7.png][]

> 通过测试Bean已经实例化成功了，属性的值是null，因为我们调用的都是无参构造方法，所以属性值都是默认值，接下来给bean赋值即可。

#### Bean的属性赋值 ####

通过反射机制调用set方法，给Bean的属性赋值。

> 对每个bean标签下的所有property 标签，对标签内容进行解析，这里需要注意点的是判断是引用数据类型还是简单数据类型。

public class ClassPathXmlApplicationContext implements ApplicationContext{
        /**
         * 存储bean的Map集合
         */
        private Map<String,Object> beanMap = new HashMap<>();
    
        /**
         * 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
         * @param resource 配置文件路径（要求在类路径当中）
         */
        public ClassPathXmlApplicationContext(String resource) {
            SAXReader reader=new SAXReader();
            try {
                //读取配置文件
                Document document = reader.read(ClassLoader.getSystemClassLoader()
                        .getResourceAsStream(resource));
                //拿到所有的bean标签
                List<Node> beanNodes = document.selectNodes("//bean");
                //遍历集合拿到对bean进行处理
                beanNodes.forEach(beanNode->{
                  Element beanElt=  (Element)beanNode;
                  //获取id
                    String id = beanElt.attributeValue("id");
                    //获取className
                    String className = beanElt.attributeValue("class");
                    try {
                        //反射获取对象
                        Class<?> clazz = Class.forName(className);
                        Constructor<?> constructor = clazz.getDeclaredConstructor();
                        Object bean = constructor.newInstance();
                        //存储到Map集合中
                        beanMap.put(id,bean);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                });
            beanNodes.forEach(beanNode->{
               Element beanElt=  (Element)beanNode;
                //获取bean的id
                String beanId = beanElt.attributeValue("id");
                //获取所有的property标签
                List<Element> propertyEls = beanElt.elements("property");
                propertyEls.forEach(propertyElt->{
                    try {
                        //获取属性名
                        String propertyName = propertyElt.attributeValue("name");
                        //获取属性类型
                        Class<?> propertyType = beanMap.get(beanId).getClass().getDeclaredField(propertyName).getType();
                        //获取set方法名
                      String setMethodName=  "set"+propertyName.toUpperCase().charAt(0)+  propertyName.substring(1);
                        //获取set方法
                        Method setMethod = beanMap.get(beanId).getClass().getDeclaredMethod(setMethodName, propertyType);
                        //获取value的值
                        String propertyValue = propertyElt.attributeValue("value");
                        //获取ref
                        String propertyRef=propertyElt.attributeValue("ref");
                        Object propertyVal=null;
                        //如果不是简单属性
                        if(propertyValue!=null){
                            //获取属性类型名
                            String simpleName = propertyType.getSimpleName();
                            switch (simpleName) {
                                case "byte": case "Byte":
                                    propertyVal = Byte.valueOf(propertyValue);
                                    break;
                                case "short": case "Short":
                                    propertyVal = Short.valueOf(propertyValue);
                                    break;
                                case "int": case "Integer":
                                    propertyVal = Integer.valueOf(propertyValue);
                                    break;
                                case "long": case "Long":
                                    propertyVal = Long.valueOf(propertyValue);
                                    break;
                                case "float": case "Float":
                                    propertyVal = Float.valueOf(propertyValue);
                                    break;
                                case "double": case "Double":
                                    propertyVal = Double.valueOf(propertyValue);
                                    break;
                                case "boolean": case "Boolean":
                                    propertyVal = Boolean.valueOf(propertyValue);
                                    break;
                                case "char": case "Character":
                                    propertyVal = propertyValue.charAt(0);
                                    break;
                                case "String":
                                    propertyVal = propertyValue;
                                    break;
                            }
                            setMethod.invoke(beanMap.get(beanId),propertyVal);
                        }
                        //如果不是简单属性
                        if(propertyRef!=null){
                            setMethod.invoke(beanMap.get(beanId),beanMap.get(propertyRef));
                        }
    
                    }catch ( Exception e){
                        e.printStackTrace();
                    }
                });
    
            });
    
            } catch (DocumentException e) {
                e.printStackTrace();
            }
    
        }
    
        @Override
        public Object getBean(String beanId) {
            return beanMap.get(beanId);
        }
    }

> 思考：为什么不在上面的循环中给Bean的属性赋值，而在这里再重新遍历一次呢？
> 
> 解答：很简单为了解决循环依赖问题，先生成bean对象进行曝光再赋值，实例化和属性赋值分开。

#### 测试阶段2(为bean对象进行赋值) ####

![85346b698b3c4b28a23f6217cf88ef16.png][]

到这里一个简单的IOC已经实现，只实现的基本数据类型和ref类型。还是不能对LIst map等类型进行注入。

[406fd1ad26b14c61b731927e10a12341.png]: https://img-blog.csdnimg.cn/406fd1ad26b14c61b731927e10a12341.png
[a8d5ca21b08241138bd1d1fbdf572b59.png]: https://img-blog.csdnimg.cn/a8d5ca21b08241138bd1d1fbdf572b59.png
[27ccd258c8e14c78aa77d2888875f5e7.png]: https://img-blog.csdnimg.cn/27ccd258c8e14c78aa77d2888875f5e7.png
[85346b698b3c4b28a23f6217cf88ef16.png]: https://img-blog.csdnimg.cn/85346b698b3c4b28a23f6217cf88ef16.png