自制简易Spring框架

最新推荐文章于 2023-02-05 14:42:16 发布
最新推荐文章于 2023-02-05 14:42:16 发布
阅读量338 收藏 1
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woyaottk/article/details/125571891
版权

1. 注解类

Spring有三个常用注解分别是@Component、@ComponentScan、@Autowired

1.1 @Component

@Component注解的作用是给要注入SpringIOC容器的类做标记

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String name() default "";
}

1.2 @ComponentScan

@ComponentScan用来扫描指定路径下的类是否包含@Component注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    String basePackages() default "";
}

1.3 @Autowired

@Autowired用来自动给某个属性注入被Component标记的类对象

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

2. ApplicationContext

ApplicationContext因此也称之为Spring上下文。Spring容器负责管理Bean与Bean之间的依赖关系。

这个类需要做两件事情

  1. 扫描配置信息中指定包下的类
  2. 实例化扫描到的类

在这里插入图片描述

2.1 扫描类信息

首先我们先做扫描类信息的功能，扫描类信息需要做两件事

  1. 解析配置类获取到我指定的扫描包路径
  2. 使用获取到的扫描包路径进行文件遍历操作如果是目录则递归进行2否则进入3
  3. 被Component注解标识的类进行注册
// 1.扫描配置信息中指定包下的类
private void scan(Class<?> configClass) {
    // 解析配置类，获取到扫描包路径
    String basePackages = this.getBasePackages(configClass);
    // 使用扫描包路径进行文件遍历操作
    this.doScan(basePackages);
}

2.1.1 解析配置类，获取到扫描包路径

这个就是简单获取配置类中@ComponentScan注解的basePackages值

使用反射机制解析注解的步骤：

  1. 获取被注解注释的类对象
    Class<Annotation> annotationClass = Annotation.class;
  2. 获取这个类对象中的注解对象
    MyAnnotation myAnnotation = annotationClass.getAnnotation(MyAnnotation.class);
  3. 调用注解对象的方法获取属性值
    myAnnotation.num()

第一步不用做因为注解类是作为参数直接传入的，所以我们只需要做后两步

// 解析配置类，获取到扫描包路径
private String getBasePackages(Class<?> configClass) {
    // 获取这个类对象中的注解对象
    ComponentScan componentScan = configClass.getAnnotation(ComponentScan.class);
    // 调用注解对象的方法获取属性值
    String basePackages = componentScan.basePackages();
    return basePackages;
}

2.1.2 使用扫描包路径进行文件遍历操作

// 使用扫描包路径进行文件遍历操作
private void doScan(String basePackages) {
    // 将.转化为/
    String[] split = basePackages.split("\\.");
    String filePath = System.getProperty("user.dir") + "/src/" +  split[0];
    for (int i = 1; i < split.length; i++) {
        filePath += "/" + split[i];
    }


    // 获取资源信息
    File dir = new File(filePath);
    for (File file : dir.listFiles()) {
        if (file.isDirectory()) {
            // 递归扫描
            doScan(basePackages + "." + file.getName());
        }
        else {
            // com.my.spring.example + . + Boy.class -> com.my.spring.example.Boy
            String className = basePackages + "." + file.getName().replace(".java", "");
            // 将class存放到classMap中
            this.registerClass(className);
        }
    }
}

2.1.3 注册含有Component注解的类

我们需要注册也就是存储含有Component的类，这里为了保证线程安全采用了ConcurrentHashMap

步骤：

  1. 使用类加载器通过类名加载类信息
  2. 获取这个类的Component注解
  3. 如果存在Component注解则将其放入类信息池中
// 如果该类含有Component注解那么就将其加入到classMap中
private void registerClass(String className){
    // 使用类加载器通过类名加载类信息
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    try {
        Class<?> clazz = classLoader.loadClass(className);
        // 获取这个类的Component注解
        Component component = clazz.getAnnotation(Component.class);
        // 如果存在Component注解则将其放入类信息池中
        if (component != null) {
            classPool.put(className,clazz);
        }
    } catch (ClassNotFoundException e) {
        System.out.println("类加载失败");
        e.printStackTrace();
    }
}

2.2 实例化扫描到的类

首先我们要用一个ConcurrentHashMap来存储bean对象

// 定义一个线程安全的类对象池
private Map<String, Object> beanPool = new ConcurrentHashMap<>();

流程图：

在这里插入图片描述

2.2.1 实例化扫描到的类

// 2. 实例化扫描到的类
private void instantiateBean() {
    // 将classPool中的所有值都实例化，并获取
    for (Class<?> clazz : classPool.values()) {
        getBean(clazz);
    }
}

2.2.2 获取bean对象

private Object getBean(Class<?> clazz) {
    // 先从缓存中获取
    Object bean = beanPool.get(clazz.getName());
    if (bean != null) return bean;
    // 如果没有则创建
    return createBean(clazz);
}

2.2.3 创建bean对象

// 创建bean对象
private Object createBean(Class<?> clazz) {
    // 1. 实例化bean
    Object bean = this.newInstance(clazz);
    // 2. 填充字段，将含有Autowired注解的字段注入bean对象
    try {
        this.populateBean(bean, clazz);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    // 3. 实例好并且注入完的bean放入beanPool中
    beanPool.put(clazz.getName(),bean);
    return bean;
}

2.2.4 实例化bean

private Object newInstance(Class<?> clazz) {
    Object bean = null;
    try {
        bean = clazz.getDeclaredConstructor().newInstance();
    } catch (InstantiationException e) {
        System.out.println("bean实例化失败");
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        System.out.println("bean实例化失败");
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        System.out.println("bean实例化失败");
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        System.out.println("bean实例化失败");
        e.printStackTrace();
    }
    return bean;
}

2.2.5 填充字段，将含有Autowired注解的字段注入bean对象

// 填充字段，将含有Autowired注解的字段注入bean对象
private void populateBean(Object bean, Class<?> clazz) throws IllegalAccessException {
    // 解析class信息，判断类中是否有需要进行依赖注入的字段
    Field[] fields = clazz.getDeclaredFields();
    // 遍历每一个属性
    for (Field field : fields) {
        // 获取属性的Autowired注解
        Autowired autowired = field.getAnnotation(Autowired.class);
        // 如果有Autowired这个注解
        if (autowired != null) {
            // 解析这个属性对应的类
            Object value = resolveBean(field.getType());
            // 爆破，因为属性可能是private
            field.setAccessible(true);
            // 将value值保存到bean对象的属性中
            field.set(bean,value);
        }
    }
}

2.2.6 解析bean用来实现声明接口时注入其子类对象

// 解析bean用来实现声明接口时注入其子类对象
private Object resolveBean(Class<?> clazz){
    // 判断clazz是不是一个接口
    if (clazz.isInterface()) {
        // 遍历classPool
        for (Map.Entry<String,Class<?>> entry : classPool.entrySet()) {
            // 如果clazz对应的类是entry对应的类的父类或接口
            if (clazz.isAssignableFrom(entry.getValue())) {
                return getBean(entry.getValue());
            }
        }
        throw new RuntimeException("找不到可以注入的bean");
    }
    else {
        return getBean(clazz);
    }
}

2.3 组合

public class ApplicationContext {

    // 定义一个线程安全的类信息池
    private Map<String, Class<?>> classPool = new ConcurrentHashMap<>();
    // 定义一个线程安全的类对象池
    private Map<String, Object> beanPool = new ConcurrentHashMap<>();

    public ApplicationContext(Class<?> configClass) {
        // 1.扫描配置信息中指定包下的类
        this.scan(configClass);
        // 2.实例化扫描到的类
        this.instantiateBean();
    }



    // 1.扫描配置信息中指定包下的类
    private void scan(Class<?> configClass) {
        // 解析配置类，获取到扫描包路径
        String basePackages = this.getBasePackages(configClass);
        // 使用扫描包路径进行文件遍历操作
        this.doScan(basePackages);
    }

    // 解析配置类，获取到扫描包路径
    private String getBasePackages(Class<?> configClass) {
        // 获取这个类对象中的注解对象
        ComponentScan componentScan = configClass.getAnnotation(ComponentScan.class);
        // 调用注解对象的方法获取属性值
        String basePackages = componentScan.basePackages();
        return basePackages;
    }

    // 使用扫描包路径进行文件遍历操作
    private void doScan(String basePackages) {
        // 将.转化为/
        String[] split = basePackages.split("\\.");
        String filePath = System.getProperty("user.dir") + "/src/" +  split[0];
        for (int i = 1; i < split.length; i++) {
            filePath += "/" + split[i];
        }


        // 获取资源信息
        File dir = new File(filePath);
        for (File file : dir.listFiles()) {
            if (file.isDirectory()) {
                // 递归扫描
                doScan(basePackages + "." + file.getName());
            }
            else {
                // com.my.spring.example + . + Boy.class -> com.my.spring.example.Boy
                String className = basePackages + "." + file.getName().replace(".java", "");
                // 将class存放到classMap中
                this.registerClass(className);
            }
        }
    }

    // 如果该类含有Component注解那么就将其加入到classMap中
    private void registerClass(String className){
        // 使用类加载器通过类名加载类信息
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        try {
            Class<?> clazz = classLoader.loadClass(className);
            // 获取这个类的Component注解
            Component component = clazz.getAnnotation(Component.class);
            // 如果存在Component注解则将其放入类信息池中
            if (component != null) {
                classPool.put(className,clazz);
            }
        } catch (ClassNotFoundException e) {
            System.out.println("类加载失败");
            e.printStackTrace();
        }
    }

    // 2. 实例化扫描到的类
    private void instantiateBean() {
        // 将classPool中的所有值都实例化，并获取
        for (Class<?> clazz : classPool.values()) {
            getBean(clazz);
        }
    }

    // 获取bean对象
    private Object getBean(Class<?> clazz) {
        // 先从缓存中获取
        Object bean = beanPool.get(clazz.getName());
        if (bean != null) return bean;
        // 如果没有则创建
        return createBean(clazz);
    }

    // 创建bean对象
    private Object createBean(Class<?> clazz) {
        // 1. 实例化bean
        Object bean = this.newInstance(clazz);
        // 2. 填充字段，将含有Autowired注解的字段注入bean对象
        try {
            this.populateBean(bean, clazz);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        // 3. 实例好并且注入完的bean放入beanPool中
        beanPool.put(clazz.getName(),bean);
        return bean;
    }

    // 实例化bean
    private Object newInstance(Class<?> clazz) {
        Object bean = null;
        try {
            bean = clazz.getDeclaredConstructor().newInstance();
        } catch (InstantiationException e) {
            System.out.println("bean实例化失败");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.out.println("bean实例化失败");
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            System.out.println("bean实例化失败");
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            System.out.println("bean实例化失败");
            e.printStackTrace();
        }
        return bean;
    }

    // 填充字段，将含有Autowired注解的字段注入bean对象
    private void populateBean(Object bean, Class<?> clazz) throws IllegalAccessException {
        // 解析class信息，判断类中是否有需要进行依赖注入的字段
        Field[] fields = clazz.getDeclaredFields();
        // 遍历每一个属性
        for (Field field : fields) {
            // 获取属性的Autowired注解
            Autowired autowired = field.getAnnotation(Autowired.class);
            // 如果有Autowired这个注解
            if (autowired != null) {
                // 解析这个属性对应的类
                Object value = resolveBean(field.getType());
                // 爆破，因为属性可能是private
                field.setAccessible(true);
                // 将value值保存到bean对象的属性中
                field.set(bean,value);
            }
        }
    }

    // 解析bean用来实现声明接口时注入其子类对象
    private Object resolveBean(Class<?> clazz){
        // 判断clazz是不是一个接口
        if (clazz.isInterface()) {
            // 遍历classPool
            for (Map.Entry<String,Class<?>> entry : classPool.entrySet()) {
                // 如果clazz对应的类是entry对应的类的父类或接口
                if (clazz.isAssignableFrom(entry.getValue())) {
                    return getBean(entry.getValue());
                }
            }
            throw new RuntimeException("找不到可以注入的bean");
        }
        else {
            return getBean(clazz);
        }
    }
}

3. 包结构以及测试结果

在这里插入图片描述

梭梭子
关注
SSM持久层框架MyBatis，看这一篇就够了
m0_74674454的博客
03-23 1269
是一个基于Java的半自动的ORM（Object Relation Mapping）持久层框架iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO支持存储过程以及高级映射不需要手动写jdbc代码、不需要手动设置参数和获取结果集使用简单的XML或注解用于配置和原始映射SQL 和 Java 编码分开，SQL语句专注于数据，java代码专注于业务逻辑封装了jdbc，简化操作为什么需要自定义映射？无疑，自动映射解决不了问题了,因为字段名和属性名不一致了。
智能开发框架 JEECG 作者张代浩专访
qq_43667070的博客
11-14 429
智能开发框架 JEECG 作者张代浩专访
自定义MVC框架（spring）
04-17
自定义MVC框架，原文：https://blog.csdn.net/weixin_43075298/article/details/89359169
设计模式（六）自定义Spring框架
LeslieGuGu的博客
03-02 287
目录4 自定义Spring框架4.1 spring使用回顾4.2 spring核心功能结构4.1.1 bean概述4.3 Spring IOC相关接口分析4.3.1 BeanFactory解析4.3.2 BeanDefinition解析4.3.3 BeanDefinitionReader解析4.3.4 BeanDefinitionRegistry解析4.3.5 创建容器4.4 自定义SpringIOC4.4.1 定义bean相关的pojo类4.4.1.1 PropertyValue类4.4.1.2 Muta
浅入浅出Spring架构设计
敖丙
01-12 8750
从没想过面试官会问spring架构设计，也没想过我会学的这么深入
自定义Spring框架
Hello World
02-05 571
自定义Spring
设计模式-自定义Spring框架
Eriksen的博客
02-04 519
设计模式-自定义Spring框架
thinker:自制j2ee快速开发框架，mystyle2.0升级版
07-11
springmvc、spring、hibernate为基础框架 mysql数据库 前端使用基于bootstrap的metronic组件库 ##模块 ###common 泛型封装dao、service、controller基类，包含分页，查询条件封装，从而达到快速crud操作(参考") 简易...
毕设项目基于SpringBoot+Vue开发的简易后台管理系统源码+数据库+项目说明.zip
最新发布
07-02
- 基础框架：Spring Boot 2.3.1.RELEASE - 持久层框架：Mybatis-plus_3.3.2 - 安全框架：Apache Shiro 1.5.3，Jwt_3.10.3 - 数据库连接池：阿里巴巴Druid 1.1.17 - 缓存框架：redis? - 日志打印：logback - ...
自制云盘，类似百度云盘
04-27
- **SpringMVC**：是Spring框架的一部分，用于构建Web应用程序，它将请求映射到处理方法，并提供了模型-视图-控制器（MVC）架构模式。 - **MyBatis**：是一个持久层框架，它简化了数据库操作，通过XML或注解方式...
自定义Spring框架+Struts框架（内有详细注释）
03-09
适合框架研究者，已经自定义框架感兴趣的麻油
模拟spring依赖注入
qq_28852755的博客
09-21 169
1.依赖注入可能会造成循环依赖 解决办法为构造2个map 1个是完整的bean对象 一个是早期暴露出的bean对象 private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>(); private ConcurrentHashMap<String, Object> earlySingletonObjects = new ConcurrentHashM
一个简陋的自定义Spring权限框架
qq_42059426的博客
03-08 134
权限控制 认证授权 概念 认证:系统提供的用于识别用户身份的功能,通常提供用户名和密码进行登录操作其实就是在进行认证,认证的目的是让系统知道是谁 授权:用户认证成功后,需要为用户授权,其实就是指定当前用户可以操作哪些功能 分析 权限控制的基本实现思路: 先通过用户名和密码对用户进行认证,认证就是判断当前用户是否是系统用户 然后再根据用户ID或用户名获取权限信息,即授权信息 授权信息...
我的自定义Spring框架 | Spring核心功能结构
李阿昀的博客
10-12 2639
在上一讲中，我们对Spring的基本使用进行了一个简单的回顾，接下来，我们就来看一下Spring核心功能结构。 Spring核心功能结构 Spring大约有20个模块，由1300多个不同的文件构成，而这些模块可以分为下面几部分： 核心容器 AOP和设备支持 数据访问与集成 Web组件 通信报文 集成测试 ······ 下面这张图就是Spring框架的总体架构图。 接下来，我就带领着大家逐一看一下Spring里面的这些模块。 核心容器 核心容器由Beans、Core、Context和Expression
自定义的springMvc框架简单实现
小老弟的博客
11-01 1824
最近通过学习前辈们的自定义的mini版springMvc框架实现案例，自己也模仿着学习了一遍，以此记录下来： SpringMVC运行流程  执行过程如图所示：  ⑴用户发送请求至前端控制器DispatcherServlet。  ⑵ DispatcherServlet收到请求调用HandlerMapping处理器映射器。  ⑶ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理...
手写一个简易版的Spring框架
endwas
12-26 386
Spring框架很庞大和复杂，为了更好的理解其实现，尝试去模仿其功能手写一个简易版本，暂时只包括简略的几个功能，为了看情况更新。 1. 包含功能 @ComponentScan包体扫描 @Autowire依赖注入 @Scope单例实现 BeanPostProcessor后置处理器 InitializingBean初始化bean接口 BeanNameAware名字资源设置 BeanDefinition定义 SingletonObjects单例池 BeanDefinitionMap池 基于注解配置的Appl.
我的自定义Spring框架 | 回顾Spring框架的基本使用
李阿昀的博客
10-11 674
从现在开始，大家可以跟随着我的脚步来自定义一个属于自己的Spring框架。但是，在学习自定义Spring框架之前，我们得先来回顾一下Spring框架的基本使用。知晓了Spring框架的基本使用之后，我们将会在此基础上分析Spring的核心，即IoC，最后我们会对该核心进行一个模拟。 相信大家都使用过Spring框架，现在恐怕是无人不知Spring了吧！因为我相信你在实际项目开发中肯定用到过它，一般在实际项目中用到它的话，都会采用Java EE的三层架构，这三层架构是： 数据访问层，也即Dao层 业务逻辑层
自制简易Spring IoC容器
haohulala的博客
12-28 761
什么是IoC 我们知道，Spring主要是由IoC和AOP两个部分组成，这篇文章只讨论IoC。 IoC的中文翻译是“控制反转”，我觉得这个名称特别唬人，看起来好像非常厉害，但是又不知道具体是做什么的。其实用大白话说，IoC容器就是一段用来控制和管理Java中bean对象实例化以及调用的程序。 我们使用IoC容器大体上有两个需求： 其一，使得我们的程序的耦合性降低，当需求发生变更的时候，只需要修改配置文件即可（即尽量少地在原来的程序中做修改）。 其二，每一个类我们只需要其中的一个实例，比如我们的Co
手写简易Spring框架
hwp_ing的博客
11-12 916
b站图灵学院up周瑜手写简易Spring课程笔记视频配套代码。
简易Spring.Net框架：DI核心技术解析
在本文档中，我们探讨了如何利用Spring.Net框架技术来打造一个简易的依赖注入框架。Spring.Net是一个基于.NET平台的轻量级IoC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值