带你手写一个 Spring IoC 容器，原理秒懂

最新推荐文章于 2023-03-19 22:19:16 发布
最新推荐文章于 2023-03-19 22:19:16 发布
阅读量264 收藏
点赞数 1
分类专栏： java 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucien_ma/article/details/120113560
版权
本文详细介绍了如何从头构建一个简易的Spring IoC容器，通过XML配置文件解析和反射机制，动态创建并初始化对象，将其存入Map中，并提供了根据ID获取对象的方法。具体步骤包括创建Maven项目、编写XML配置文件、解析XML、反射创建及初始化对象、存储到Map以及设计getBean方法。最后通过测试类验证了实现的正确性。
摘要由CSDN通过智能技术生成

Spring IoC 底层实现

核心技术点： XML 解析 + 反射

具体的思路：

1、根据需求编写 xml 文件，配置需要创建的 bean

2、编写程序读取 xml 文件，获取 bean 相关信息，类、属性、id。

3、根据第 2 步获取的信息，结合反射机制动态创建对象，同时完成属性的赋值。

4、将创建好的 bean 存入 Map 集合，设置 key - value 映射，key 就是 bean 中 id 值， value 就是 bean 对象。

5、提供方法从 Map 中通过 id 获取对应的 value。

1 前提准备

1、创建一个 maven 项目

2、导入相关依赖，lombok，log4j（需要用 log4j 解析 XML 文件）

<dependencies>
	<!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
        <scope>provided</scope>
    </dependency>
	<!-- dom4j -->
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>

</dependencies>

2 创建一个实体类

Car

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car {

    private Integer num;

    private String brand;

    private Double price;
}

3 根据需求编写 xml 文件，配置需要创建的 bean

在 resources 资源目录下创建 spring-ioc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>

    <bean id="car" class="cc.lucien.entity.Car">
        <property name="num" value="1"></property>
        <property name="brand" value="奥迪"></property>
        <property name="price" value="30.5"></property>
    </bean>

    <bean id="car2" class="cc.lucien.entity.Car">
        <property name="num" value="2"></property>
        <property name="brand" value="奥拓"></property>
    </bean>

</beans>

4 编写程序读取 xml 文件，获取 bean 相关信息，类、属性、id。

模仿 spring，Spring 是有一个 ClassPathXMLApplicationContext 类来读取配置文件，我们创建一个属于自己的 MyClassPathXMLApplicationContext类。

MyClassPathXMLApplicationContext.java

代码上面都有注释，仔细阅读

public class MyClassPathXmlApplicationContext {

    public MyClassPathXmlApplicationContext(String path) {
        // 解析 XML
        parseXML(path);
    }

    public void parseXML(String path) {
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read("src/main/resources/" + path);
            Element root = document.getRootElement();
            Iterator<Element> rootIter = root.elementIterator();
            while (rootIter.hasNext()) {
                // 遍历父节点下的子节点，获取子节点
                Element bean = rootIter.next();
                // 拿到子节点的属性值
                String idStr = bean.attributeValue("id");
                String className = bean.attributeValue("class");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

}

5 根据第 2 步获取的信息，结合反射机制动态创建对象，同时完成属性的赋值。

public class MyClassPathXmlApplicationContext {

    public MyClassPathXmlApplicationContext(String path) {
        // 解析 XML
        parseXML(path);
    }

    public void parseXML(String path) {
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read("src/main/resources/" + path);
            Element root = document.getRootElement();
            Iterator<Element> rootIter = root.elementIterator();
            while (rootIter.hasNext()) {
                // 遍历父节点下的子节点，获取子节点
                Element bean = rootIter.next();
                // 拿到子节点的属性值
                String idStr = bean.attributeValue("id");
                String className = bean.attributeValue("class");
                // 反射动态创建对象
                Class clazz = Class.forName(className);
                // 获取无参构造方法
                Constructor constructor = clazz.getConstructor();
                // 通过无参构造创建对象
                Object object = constructor.newInstance();
                // 给属性赋值
                Iterator<Element> beanIter = bean.elementIterator();
                while (beanIter.hasNext()) {
                    // 获取子节点
                    Element property = beanIter.next();
                    // 获取子节点的属性值
                    String propertyName = property.attributeValue("name");
                    String propertyValue = property.attributeValue("value");
                    // 获取 setter 方法
                    // num --> setNum, brand --> setBrand
                    String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                    // 获取属性
                    Field field = clazz.getDeclaredField(propertyName);
                    // 获取属性的类型，也是setter方法中传参的类型
                    Class<?> type = field.getType();
                    Method method = clazz.getMethod(methodName, type);
                    // 类型转换
                    Object value = propertyValue;
                    switch (type.getName()) {
                        case "java.lang.Integer":
                            value = Integer.parseInt(propertyValue);
                            break;
                        case "java.lang.Double":
                            value = Double.parseDouble(propertyValue);
                            break;
                    }
                    // 调用方法
                    method.invoke(object, value);
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

}

6 将创建好的 bean 存入 Map 集合，设置 key - value 映射，key 就是 bean 中 id 值， value 就是 bean 对象。

public class MyClassPathXmlApplicationContext {

    private Map<String, Object> iocMap;

    public MyClassPathXmlApplicationContext(String path) {
        iocMap = new HashMap<>();
        // 解析 XML
        parseXML(path);
    }

    public void parseXML(String path) {
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read("src/main/resources/" + path);
            Element root = document.getRootElement();
            Iterator<Element> rootIter = root.elementIterator();
            while (rootIter.hasNext()) {
                // 遍历父节点下的子节点，获取子节点
                Element bean = rootIter.next();
                // 拿到子节点的属性值
                String idStr = bean.attributeValue("id");
                String className = bean.attributeValue("class");
                // 反射动态创建对象
                Class clazz = Class.forName(className);
                // 获取无参构造方法
                Constructor constructor = clazz.getConstructor();
                // 通过无参构造创建对象
                Object object = constructor.newInstance();
                // 给属性赋值
                Iterator<Element> beanIter = bean.elementIterator();
                while (beanIter.hasNext()) {
                    // 获取子节点
                    Element property = beanIter.next();
                    // 获取子节点的属性值
                    String propertyName = property.attributeValue("name");
                    String propertyValue = property.attributeValue("value");
                    // 获取 setter 方法
                    // num --> setNum, brand --> setBrand
                    String methodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                    // 获取属性
                    Field field = clazz.getDeclaredField(propertyName);
                    // 获取属性的类型，也是setter方法中传参的类型
                    Class<?> type = field.getType();
                    Method method = clazz.getMethod(methodName, type);
                    // 类型转换
                    Object value = propertyValue;
                    switch (type.getName()) {
                        case "java.lang.Integer":
                            value = Integer.parseInt(propertyValue);
                            break;
                        case "java.lang.Double":
                            value = Double.parseDouble(propertyValue);
                            break;
                    }
                    // 调用方法
                    method.invoke(object, value);
                }
                // 存放到 map 集合中
                iocMap.put(idStr, object);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

}

7 设计一个 getBean 方法用来从 map 中通过 key 来取 value

public class MyClassPathXmlApplicationContext {

    private Map<String, Object> iocMap;

    public MyClassPathXmlApplicationContext(String path) {
        iocMap = new HashMap<>();
        // 解析 XML
        parseXML(path);
    }

    public void parseXML(String path) {
        // 省略....
    }

    public Object getBean(String name) {
        return iocMap.get(name);
    }

}

8 创建测试类，进行测试

Test.java

public class Test {
    public static void main(String[] args) {
        MyClassPathXmlApplicationContext context = new MyClassPathXmlApplicationContext("spring-ioc.xml");
        Car car = (Car) context.getBean("car");
        Car car2 = (Car) context.getBean("car2");
        System.out.println(car);
        System.out.println(car2);
    }
}

运行结果：

Car(num=1, brand=奥迪, price=30.5)
Car(num=2, brand=奥拓, price=null)

9 gitee 源码地址

点击跳转：gitee 地址

完结，散花…

手写一个SpringIoc容器
04-12
仿照Spring写的一个Ioc容器，注释很详细！
手把手教你写一个spring IOC容器
华为云官方博客
04-08 3031
摘要：spring框架的基础核心和起点毫无疑问就是IOC，IOC作为spring容器提供的核心技术，成功完成了依赖的反转：从主类的对依赖的主动管理反转为了spring容器对依赖的全局控制。今天就带大家手写一个spring IOC容器。
Spring的IOC原理
渣渣想逆袭
04-16 778
1. IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 图1：软件系统中耦合的对象 如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，
手写一个IOC容器
cxu123321的博客
03-01 331
手写一个IOC容器 链接：https://pan.baidu.com/s/1MhKJYamBY1ejjjhz3BKoWQ 提取码：e8on 明白什么是IOC容器： IOC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IOC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。 传统的java代码中，...
JAVA反射机制、Class类及动态加载、成员变量构造方法其他方法的反射与调用、代理模式AOP
实干、效率、武功、心法
02-05 285
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意一个方法和属性； 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。 而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。 反射就是把java类中的各种成分映射成一个个的Java对象。 面向切
手写SpringIoc的XML实现方式
01-24
手写Spring IVC的XML实现是一个复杂的过程，涉及到XML解析、反射、依赖管理和生命周期控制等多个方面。通过这个过程，我们可以更深入地理解Spring如何在幕后工作，为我们的应用程序提供灵活的依赖管理和对象管理。...
手写spring ioc(三) 资源org.zip
12-13
总的来说，手写Spring IOC是一个深入理解和实践IoC设计模式的好方法，它能帮助开发者更深入地了解Spring框架的工作原理，提高对依赖注入和对象管理的理解。通过这个过程，我们可以更好地掌握如何在实际项目中应用...
手写SpringIOC注解实现版本
01-25
这个"手写Spring IOC注解实现版本"项目旨在帮助我们深入理解Spring框架的工作原理，通过实际动手实现来增强对IoC容器和注解驱动编程的理解。 在Spring中，IOC意味着应用程序不再直接创建对象，而是将对象的创建和...
手写springIoC
03-19
手写Spring IoC的过程是一个很好的学习机会，它能让你深入理解Spring框架的内部工作原理，提升你的编程技能。通过这个过程，你会明白Spring如何优雅地解决了对象的创建、依赖注入、生命周期管理等问题，这对理解和...
手写IOC容器
最新发布
weixin_53120322的博客
03-19 166
我们知道，IOC(控制反转)和DI(依赖注入)是Spring里面核心的东西，那么，我们如何自己手写IOC。创建UserServiceImp实现类。创建UserService接口。创建UserDaoIm实现。创建UserDao接口。
手写简易IOC容器
adds001的博客
11-01 341
手写简易IOC容器手写简易IOC容器1. IOC介绍2.简单代码实现IOC使用注解区别简介 手写简易IOC容器 1. IOC介绍 Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 谁控制谁，控制什么：传统Java SE程
手写IOC容器（xml，注解）
weixin_47354101的博客
01-21 843
手写IOC容器（xml，注解） 软件设计模式期末作业的设计内容： 在网上参考了资料，将两份资料，再加上自己的理解融合成一份！！ xml的参考资料’君君要上天’手写的IOC容器 注解的参考资料’楠哥教你学Java’手写的IOC容器 1.概念 IOC又称控制反转，把原先我们代码里面需要实现的对象的创建、依赖的代码，反转给容器来帮忙实现。 2.设计思路 A.配置文件配置包扫描路径 B.递归包扫描获取.class文件 C.反射确定需要交给IOC管理的类 D.对需要注入的类进行依赖注入 3.XMl配置 3.1导
手写一个及其简易的 IOC 容器
weixin_50694701的博客
03-17 403
一、前言 采用 xml 的配置方式，仿照 spring 的 ioc 源码实现，手写一个非常简易的 ioc 容器，便于入门 spring 的源码。 二、整体流程介绍 spring ioc 的整体流程，粗略的分为以下几步： 在进行手写之前，需要先明确以下几个功能组件： 三、具体步骤 3.1 搭建项目 搭建一个 maven 项目，引入 dom4j 的依赖，pom 文件如下 <dependencies> <!-- https://mvnrepository.com/artifact/do
用简单代码实现IOC容器
3y
03-26 871
本文作者：加耀 投稿手写IOC容器了解一下！相信每一个java程序员在面试经历中，都被面试官问到过AOP和IOC，用官方的话语来回答AOP和IO...
手写简化Spring IOC容器
WLLTB
11-12 1214
首先他要扫描包下面的所有类，然后得到这些类以后，我要去遍历一下，找到添加了注解的类，如果我添加了这个注解的话，返回的值就不是null（Component componentAnnotation = clazz.getAnnotation(Component.class)），接下来的话，判断一下有没有自定义的beanName吧，如果没有的话，我就给他改一下。现在我可以把beanName和得到的类封装成前面写下的BeanDefinition了，然后放进集合里面，为什么要集合呢，因为要去重.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值