Spring系列（五）案例：模拟手写Spring IoC容器

已于 2023-12-08 12:11:27 修改
阅读量124 收藏
点赞数 5
分类专栏： Spring 文章标签： spring java 后端
于 2023-11-27 21:36:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zw351833699/article/details/134653114
版权

个人技术博客(weigeblog.cn)，欢迎访问！！！
更多技术好文与你分享
欢迎交流学习！！！

模拟手写Spring里面核心的东西：IoC（控制反转）和DI（依赖注入）

1.准备测试bean

  • 创建UserDao接口
package org.example.dao;

public interface UserDao {

}
  • 创建UserDaoImpl实现
package org.example.dao.impl;

import org.example.dao.UserDao;


public class UserDaoImpl implements UserDao {
  public UserDaoImpl() {
        System.out.println("UserDaoImpl创建了...");
    }
}
  • 创建UserService接口
package org.example.service;

public interface UserService {


}
  • 创建UserServiceImpl实现类
package org.example.service.impl;

import org.example.service.UserService;

public class UserServiceImpl implements UserService {

	public UserServiceImpl() {
        System.out.println("UserServiceImpl创建了...");
    }
}

2.定义注解

通过注解的形式加载bean和实现依赖注入

  • 定义bean注解
package org.example.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}
  • 定义依赖注入注解
package org.example.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}

3.定义并实现bean容器接口

  • 定义bean容器接口
package org.example.core;

public interface ApplicationContext {

    Object getBean(Class clazz);
}
  • 注解bean容器接口实现
    AnnotationApplicationContext基于注解扫描bean
package org.example.core;

import java.util.HashMap;

public class AnnotationApplicationContext implements ApplicationContext {

    //存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {
        
    }
}

4.编写扫描bean的逻辑

package org.example.core;

import org.example.annotation.Bean;

import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.io.File;

public class AnnotationApplicationContext implements ApplicationContext {
    //存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     *
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {
        try {
            String packageDirName = basePackage.replaceAll("\\.", "\\\\");
            Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            while (dirs.hasMoreElements()) {
                URL url = dirs.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length() - packageDirName.length());
                loadBean(new File(filePath));
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private void loadBean(File fileParent) {
        if (fileParent.isDirectory()) {
            File[] childrenFiles = fileParent.listFiles();
            if (childrenFiles == null || childrenFiles.length == 0) {
                return;
            }
            for (File child : childrenFiles) {
                if (child.isDirectory()) {
                    //如果是个文件夹就继续调用该方法,使用了递归
                    loadBean(child);
                } else {
                    //通过文件路径转变成全类名,第一步把绝对路径部分去掉
                    String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
                    //选中class文件
                    if (pathWithClass.contains(".class")) {
                        //    com.xinzhi.dao.UserDao
                        //去掉.class后缀，并且把 \ 替换成 .
                        String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullName);
                            //把非接口的类实例化放在map中
                            if (!aClass.isInterface()) {
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if (annotation != null) {
                                    Object instance = aClass.newInstance();
                                    //判断一下有没有接口
                                    if (aClass.getInterfaces().length > 0) {
                                        //如果有接口把接口的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getInterfaces()[0] + "】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0], instance);
                                    } else {
                                        //如果有接口把自己的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getName() + "】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass, instance);
                                    }
                                }
                            }
                        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

}

5.注解标识bean

@Bean
public class UserServiceImpl implements UserService

@Bean
public class UserDaoImpl implements UserDao

6.测试Bean加载

package org.example;


import org.example.core.AnnotationApplicationContext;
import org.example.core.ApplicationContext;
import org.example.service.UserService;


public class ApplicationContextTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationApplicationContext("org.example");
        UserService userService = (UserService)applicationContext.getBean(UserService.class);
        System.out.println("run success");
    }
}

运行成功
在这里插入图片描述

7.依赖注入

package org.example.service.impl;

import org.example.annotation.Bean;
import org.example.annotation.Di;
import org.example.dao.UserDao;
import org.example.service.UserService;

@Bean
public class UserServiceImpl implements UserService {

    @Di
    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("UserServiceImpl创建了...");
    }
}

依赖注入实现

package org.example.core;

import org.example.annotation.Bean;
import org.example.annotation.Di;

import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.HashMap;
import java.io.File;
import java.util.Map;

public class AnnotationApplicationContext implements ApplicationContext {
    //存储bean的容器
    private HashMap<Class, Object> beanFactory = new HashMap<>();
    private static String rootPath;

    @Override
    public Object getBean(Class clazz) {
        return beanFactory.get(clazz);
    }

    /**
     * 根据包扫描加载bean
     *
     * @param basePackage
     */
    public AnnotationApplicationContext(String basePackage) {
        try {
            String packageDirName = basePackage.replaceAll("\\.", "\\\\");
            Enumeration<URL> dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            while (dirs.hasMoreElements()) {
                URL url = dirs.nextElement();
                String filePath = URLDecoder.decode(url.getFile(), "utf-8");
                rootPath = filePath.substring(0, filePath.length() - packageDirName.length());
                loadBean(new File(filePath));
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        loadDi();
    }

    private void loadBean(File fileParent) {
        if (fileParent.isDirectory()) {
            File[] childrenFiles = fileParent.listFiles();
            if (childrenFiles == null || childrenFiles.length == 0) {
                return;
            }
            for (File child : childrenFiles) {
                if (child.isDirectory()) {
                    //如果是个文件夹就继续调用该方法,使用了递归
                    loadBean(child);
                } else {
                    //通过文件路径转变成全类名,第一步把绝对路径部分去掉
                    String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
                    //选中class文件
                    if (pathWithClass.contains(".class")) {
                        //    com.xinzhi.dao.UserDao
                        //去掉.class后缀，并且把 \ 替换成 .
                        String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
                        try {
                            Class<?> aClass = Class.forName(fullName);
                            //把非接口的类实例化放在map中
                            if (!aClass.isInterface()) {
                                Bean annotation = aClass.getAnnotation(Bean.class);
                                if (annotation != null) {
                                    Object instance = aClass.newInstance();
                                    //判断一下有没有接口
                                    if (aClass.getInterfaces().length > 0) {
                                        //如果有接口把接口的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getInterfaces()[0] + "】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass.getInterfaces()[0], instance);
                                    } else {
                                        //如果有接口把自己的class当成key，实例对象当成value
                                        System.out.println("正在加载【" + aClass.getName() + "】,实例对象是：" + instance.getClass().getName());
                                        beanFactory.put(aClass, instance);
                                    }
                                }
                            }
                        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    private void loadDi() {
        for(Map.Entry<Class,Object> entry : beanFactory.entrySet()){
            //就是咱们放在容器的对象
            Object obj = entry.getValue();
            Class<?> aClass = obj.getClass();
            Field[] declaredFields = aClass.getDeclaredFields();
            for (Field field : declaredFields){
                Di annotation = field.getAnnotation(Di.class);
                if( annotation != null ){
                    field.setAccessible(true);
                    try {
                        System.out.println("正在给【"+obj.getClass().getName()+"】属性【" + field.getName() + "】注入值【"+ beanFactory.get(field.getType()).getClass().getName() +"】");
                        field.set(obj,beanFactory.get(field.getType()));
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

运行成功
在这里插入图片描述

8.总结

IoC和DI实现过程总结如下：

  1. 配置包扫描的路径
  2. 依据提供包路径扫描其中的所包含的类
  3. 通过反射判断类中是否包含Bean注解，如有包含通过反射进行实例化
  4. 通过反射判断类中是否包含Di注解，如有包含通过反射将其设置为所对应的成员变量
WEIGE丶
关注
专栏目录
手写一个SpringIoc容器
04-12
本项目"手写一个SpringIoc容器"旨在模仿Spring的IOC（Inversion of Control，控制反转）功能，帮助开发者深入理解Spring的工作原理，提升对依赖注入（Dependency Injection）模式的认识。 在实现自定义的Spring IOC...
springIOC手写框架分析
04-22
springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC...
Spring源码：手写SpringIOC
程序员Forlan的博客
02-19 1102
本文主要介绍如何实现SpringIOC，手撸源码
【Spring系列】- 手写模拟Spring框架
热门推荐
qq_43843951的博客
11-13 21万+
上次已经学习了Java的设计模式，接下来就先来学习一下如何手写模拟简易的Spring，通过动手实践，才会更好的了解spring底层原理，今天就简单的模拟Spring容器是如何创建，bean又是如何注入的。
[源码系列：手写spring] IOC第十四节：容器事件和事件监听器
一辉的博客
09-10 1413
现实中的观察者(Observer)往往是主动方，这是由于目标主题(Subject)缺乏主观能动性造成的，其状态的更新并不能主动地通知观察者，这就造成观察行为的持续往复。而在软件设计中我们可以将目标主题作为主动方角色，将观察者反转为被动方角色，建立反向驱动式的消息响应机制，以此来避免做无用功，优化软件效率，请参看观察者模式的类结构，如图所示。
01.手写Spring的IOC容器
程序员阿红的博客
03-01 384
01.手写Spring的IOC容器 1.需求：实现service层与dao层代码解耦 步骤： 创建java项目，导入自定义IOC相关坐标 编写Dao接口和实现类 编写Service接口和实现类 编写测试代码 2.传统方式实现 1.导入依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifac
Spring框架精髓：带你手写IoC
小新的博客
03-04 3931
原理-手写IoC IoC（Inversion of Control，控制反转）是一种设计原则，它的核心思想是将组件之间的依赖关系从组件内部转移到外部。在传统的程序设计中，组件（如类或模块）通常在内部创建或查找其依赖的其他组件。而在IoC中，这些依赖关系由外部容器或框架在运行时注入，从而实现了解耦。 手写一个简单的IoC容器的基本步骤如下： 定义组件接口：首先，你需要定义一个或多个接口，这些接口将被组件实现，以便容器可以管理它们。 创建容器类：容器类负责管理组件的实例化、配置和依赖注入。 注册组件：允
手写简化Spring IOC容器
WLLTB
11-12 1199
首先他要扫描包下面的所有类，然后得到这些类以后，我要去遍历一下，找到添加了注解的类，如果我添加了这个注解的话，返回的值就不是null（Component componentAnnotation = clazz.getAnnotation(Component.class)），接下来的话，判断一下有没有自定义的beanName吧，如果没有的话，我就给他改一下。现在我可以把beanName和得到的类封装成前面写下的BeanDefinition了，然后放进集合里面，为什么要集合呢，因为要去重.
手写Spring框架---IOC容器&依赖注入实现
汤键的博客
04-25 850
手写Spring框架---IOC容器&依赖注入实现
spring 手写简单的IOC
monkey的博客
11-14 577
spring IOC 控制反转与依赖注入
Spring6--手写简易IOC容器
czy940115的博客
02-28 516
本文主要实现的功能以及思想： 控制反转（IOC）：控制反转是一种思想，即将对象的创建权力和对象与对象之间的关系交出去，给第三方容器负责 依赖注入（DI）：实现了控制反转的思想。 Bean管理：Bean对象的创建，以及Bean对象中属性的赋值（或者叫Bean对象之间关系的维护）。
手写SpringIOC容器框架
weixin_45017862的博客
07-12 382
IoC是什么 　　Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下： 　　谁控制谁，控制什么：传统Java ...
spring ioc模块手写demo
04-22
spring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demo...
手写SpringIoc的XML实现方式
01-24
手写Spring IVC的XML实现是一个复杂的过程，涉及到XML解析、反射、依赖管理和生命周期控制等多个方面。通过这个过程，我们可以更深入地理解Spring如何在幕后工作，为我们的应用程序提供灵活的依赖管理和对象管理。...
手写SpringIOC注解实现版本
01-25
这个"手写Spring IOC注解实现版本"项目旨在帮助我们深入理解Spring框架的工作原理，通过实际动手实现来增强对IoC容器和注解驱动编程的理解。 在Spring中，IOC意味着应用程序不再直接创建对象，而是将对象的创建和...
阿博图书馆管理：SpringBoot实战指南
2402_85761468的博客
09-27 674
MySQL数据库中数据的分表分库存储方式能够最大程度的避免数据同步代码的性能损耗，使得数据库的存取速度有了很大提升，而且同时保持了很大的灵活性。通过对系统功能模块分析可以得知，主要是对项目元素组合、分解和更换做出相应的单元，再通过系统模块来规划出一个原则，系统的设计首先是围绕用户需求进行开发设计的，主要是为了能够更好的管理信息和方便用户，其次就是围绕阿博图书馆管理系统进行设计，最终的设计必须要满足用户的需求，这样才能够实现系统的最大意义和价值，并且在设计的时候一定要避免代码相互重复的情况发生。
springboot+neo4j demo
极客栈
09-27 541
这个简单的示例展示了如何在Spring Boot应用中集成Neo4j，包括创建节点实体、使用Neo4j仓库接口以及创建一个简单的REST控制器。这个示例可以作为开发者学习和实践Spring Boot与Neo4j集成的起点。以下是一个简单的Spring Boot与Neo4j集成的示例代码。
SpringBoot Validation不生效该怎么办？
m0_63164811的博客
09-25 226
SpringBoot Validation不生效该怎么办？
Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架。它是 Spring 项目家族的一员，用于构建安全的 Java 应用程序。
最新发布
weixin_64446270的博客
09-27 1353
Spring Security 是一个强大的和高度可定制的身份验证和访问控制框架。它是 Spring 项目家族的一员，用于构建安全的 Java 应用程序。Spring Security 提供了全面的安全服务，从基本的登录认证到复杂的访问控制，几乎涵盖了所有与安全相关的需求。
手写Spring框架V2.0：30类实战 IOC与DI设计模式
本资源是一门关于纯手写Spring框架V2.0的实战课程，主要目标是通过高仿真方式实现Spring框架的核心功能——依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IOC）。课程强调的是设计模式的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值