手写Spring（一）：启动和扫描

最新推荐文章于 2023-08-26 22:55:11 发布
最新推荐文章于 2023-08-26 22:55:11 发布
阅读量586 收藏 1
点赞数 2
文章标签： spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41433002/article/details/125118286
版权

文章目录

1. 内容大纲

  1. 手写Spring启动及扫描流程
  2. 手写getBean()流程
  3. 手写Bean生命周期流程
  4. 手写依赖注入流程
  5. 手写BeanPostProcessor机制
  6. 手写AOP机制
  7. 手写BeanFactory
  8. 手写事务

……

2. Spring用法复习

入门spring时，都是用ClassPathXmlApplicationContext这个容器来学习spring。

但是现在一般都会使用AnnotationConfigApplicationContext。

二者区别：

  1. ClassPathXmlApplicationContext需要传入spring.xml文件，即配置文件。通过ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml")，创建一个spring容器，就可以从中拿到某一个bean对象。
  2. AnnotationConfigApplicationContext传入的配置文件参数为java类。本项目手写的方式为AnnotationConfigApplicationContext

3. 准备工作

3.1 项目结构

  1. 创建一个maven工程，pom.xml里什么都不用写
  2. main.java.com下创建包spring，存储我们手写的spring源码类
  3. main.java.com下创建包psy，可以创建main方法中的test类，测试源码

在这里插入图片描述

3.2 Spring包下源码类

  1. spring下创建PsyApplicationContext，表示spring里面的容器类，添加相关API：
    1. 添加属性configClass及其有参构造器
    2. 添加方法getBean，参数为String类型beanName，返回值为Object类型，该方法先返回null
  2. spring下创建ComponentScan，文件扫描类，添加属性Sting类型value()，定义扫描路径。添加注解@Retention(RetentionPolicy.RUNTIME)和@Target(ElementType.TYPE)
  3. spring下创建Component，添加属性Sting类型value()，定义bean的名字，默认值为空，因为这个不一定非要写，如果没写spring会把首字母小写。注解同上。
package com.spring;

public class PsyApplicationContext {

    private Class configClass;

    public PsyApplicationContext(Class configClass){
        this.configClass = configClass;

        // 解析配置类
        // ComponemtScan注解---->拿到扫描路径---->扫描
    }

    public Object getBean(String beanName){
        return null;
    }
}

package com.spring;

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ComponentScan {

    String value();
}

package com.spring;

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {

    String value() default "";

}

3.3 psy包下模拟项目类

  1. psy.service包下新建UserService，添加注解@Component("userService")
  2. psy下创建配置类AppConfig，添加注解@ComponentScan("com.psy.service")，定义扫描路径。
  3. psy下创建Test类，实现main方法，使用PsyApplicationContext传入配置类AppConfig
package com.psy.service;

import com.spring.Component;

@Component("userService")
public class UserService {
    
}

package com.psy;

import com.spring.ComponentScan;

@ComponentScan("com.psy.service")
public class AppConfig {
    
}

package com.psy;

import com.spring.PsyApplicationContext;

public class Test {

    public static void main(String[] args){
        PsyApplicationContext applicationContext = new PsyApplicationContext(AppConfig.class);

        Object userService = applicationContext.getBean("userService");
    }
}

4. Spring扫描逻辑

4.1 得到扫描路径下的所有bean

  1. 获取配置文件上的ComponentScan.class注解
  2. 通过注解得到扫描路径（包）
  3. 通过类加载器得到扫描路径（包）下所有的文件类，遍历所有类
    1. 去掉类名com前文本以及.class后文本
    2. 再次通过类加载器得到class对象
    3. 判断当前class是否有注解Component
public PsyApplicationContext(Class configClass){
    this.configClass = configClass;

    // 解析配置类
    // ComponemtScan注解---->拿到扫描路径---->扫描
    // 1. 获取配置文件类上的ComponentScan.class注解
    ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
    // 2. 拿到扫描路径 com.psy.service （包名）
    String path = componentScanAnnotation.value();
    path = path.replace(".", "/");
    System.out.println("扫描路径为：" + path);
    // 3. 扫描：通过包名得到包下所有的类———>通过类加载器得到
    // Bootsstrap--->jre/lib
    // Ext---------->jre/ext/lib
    // App---------->classpath
    ClassLoader classLoader = PsyApplicationContext.class.getClassLoader(); //app
    URL resource = classLoader.getResource(path);
    File file = new File(resource.getFile());
    if(file.isDirectory()) {
        File[] files = file.listFiles();
        for (File f : files) {
            //System.out.println(f);
            //System.out.println(f.getAbsolutePath());
            String fileName = f.getAbsolutePath();
            if (fileName.endsWith(".class")) {
                String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
                className = className.replace("\\", ".");
                System.out.println(className);

                try {

                    Class<?> clazz = classLoader.loadClass(className);
                    if (clazz.isAnnotationPresent(Component.class)) {
                        // 表示当前这个类是一個bean
                        // Class ---> bean？ 不一定需要在这一步做

                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

4.2 根据scope创建bean

  1. spring下创建BeanDefinition，其中包含bean的定义，属性目前有bean的类private Class clazz;，以及bean是否为单例或其他private String Scope;

  2. 通过ConcurrentHashMap创建单例池（存储所有单例bean）和bean定义集合（存储所有bean的定义）

  3. PsyApplicationContext下创建方法creatBean，可以使用beanDefinition创建bean。调用无参的构造方法反射得到实例对象Object instance = clazz.getDeclaredConstructor().newInstance();

  4. 提取扫描配置类逻辑为单独方法scan。得到扫描路径下所有类后，选择带有Component注解的类，

    1. 通过注解得到类名beanName
    2. 实例化一个新的BeanDefinition
    3. 将先前得到的clazz通过set方法赋予BeanDefinition
    4. 如果当前类有scope注解，将scope注解的值赋予BeanDefinition
    5. 如果没有scope注解，将scope设为singleton
    6. 将当前bean的BeanDefinition存入beanDefinitionMap

  5. 扫描完配置类后，遍历beanDefinitionMap，如果当前``beanDefinitionMap`的Scope为singleton，即单例，就创建bean并将其放入单例池。

  6. 修改getBean方法：

    1. 如果当前bean是单例的，就从单例池map里拿
    2. 如果不是单例的，调用creatBean方法创建bean
    package com.spring;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class PsyApplicationContext {

    private Class configClass;

    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>(); //单例池
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); //所有的bean的定义

    public PsyApplicationContext(Class configClass){
        this.configClass = configClass;

        // 解析配置类
        // ComponemtScan注解--->拿到扫描路径--->扫描--->BeanDefinition--->ConcurrentHashMap
        scan(configClass);

        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if (beanDefinition.getScope().equals("singleton")){
                Object bean = creatBean(beanDefinition); // 单例bean对象
                singletonObjects.put(beanName, bean); // 放入单例池
            }

        }
    }

    // 根据bean的定义创建bean的对象
    public Object creatBean(BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getClazz();
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();// 调用无参的构造方法反射得到实例对象

            return instance;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }

    private void scan(Class configClass) {
        // 1. 获取配置文件类上的ComponentScan.class注解
        ComponentScan componentScanAnnotation = (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        // 2. 拿到扫描路径 com.psy.service （包名）
        String path = componentScanAnnotation.value();
        path = path.replace(".", "/");
        System.out.println("扫描路径为：" + path);
        // 3. 扫描：通过包名得到包下所有的类———>通过类加载器得到
        // Bootsstrap--->jre/lib
        // Ext---------->jre/ext/lib
        // App---------->classpath
        ClassLoader classLoader = PsyApplicationContext.class.getClassLoader(); //app
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //System.out.println(f);
                //System.out.println(f.getAbsolutePath());
                String fileName = f.getAbsolutePath();
                if (fileName.endsWith(".class")) {
                    String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
                    className = className.replace("\\", ".");
                    System.out.println(className);

                    try {

                        Class<?> clazz = classLoader.loadClass(className);
                        if (clazz.isAnnotationPresent(Component.class)) {
                            // 有Component注解表示当前这个类是一个bean
                            // 解析类----->BeanDefinition
                            // BeanDefinition：bean的定义

                            Component componentAnnotation = clazz.getDeclaredAnnotation(Component.class);
                            String beanName = componentAnnotation.value();

                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setClazz(clazz);
                            if (clazz.isAnnotationPresent(Scope.class)) {
                                //有scope注解
                                Scope scopeAnnotation = clazz.getDeclaredAnnotation(Scope.class);
                                beanDefinition.setScope(scopeAnnotation.value()); //用户设置的值配入beanDefinition
                            } else {
                                //没有scope注解
                                beanDefinition.setScope("singleton");
                            }

                            beanDefinitionMap.put(beanName, beanDefinition);

                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    public Object getBean(String beanName){
        if (beanDefinitionMap.containsKey(beanName)) {
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if (beanDefinition.getScope().equals("singleton")){
                // 如果是单例的，就从单例池里拿
                Object o = singletonObjects.get(beanName);
                return o;
            } else {
                // 创建Bean对象
                Object bean = creatBean(beanDefinition);
                return bean;
            }
        } else {
            // 不存在对应的bean
            throw new NullPointerException();
        }
    }
}
手写Mini版的Spring
Serendipity的博客
05-03 1751
这段时间有想法去学习手写Spring源码，在此记录一下自己手写的Spring的迭代版本趴。 1. Spring的启动扫描到容器 @Component @ComponentScan @Scope // 判断Bean对象是不是单例，值为singleton是单例， 上述注解需要手写出来来实现简单实现Spring中的功能 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Component {
Spring启动扫描流程（伪代码）
yangcx
06-17 322
Spring启动，类扫描流程伪代码记录
详解-手写Spring框架（2）-Spring的扫描逻辑
qq_18884633的博客
07-28 443
通过扫描逻辑，Spring能够根据注解自动创建和管理Bean对象。开发人员只需在需要的类上添加相应的扫描注解，而无需手动配置每个Bean。这样大大简化了配置工作，并提高了代码的可维护性和可扩展性。
手写Spring扫描逻辑（带图好理解）
devops
02-24 321
【代码】Spring扫描逻辑原码解析（带图好理解）
[手写spring](1)构建框架，实现包扫描
秃头披风侠的博客
06-30 816
目录基本说明基本思路框架搭建自定义注解创建路径配置类搭建ApplicationContext容器定义config成员属性获取包扫描，得到目标bean测试总结 为了加强自己对于spring的认识，决定看下spring源码，但是看完还是有点模糊，于是就决定自己来写一个简易的spring，实现IOC，AOP的基本功能。 手写spring准备分5篇文章进行说明，代码总计1000多行，里面的各种注解，容器，全部都是自定义的。在写完之后确实对spring有了一个清晰的认识！！！
手写模拟spring扫描底层实现
z318913的博客
08-31 364
模拟spring扫描底层实现
Spring源码简易篇，通过手写模拟了解Spring的底层源码启动和扫描逻辑，依赖注入等等过程
02-27
通过手写模拟，了解扫描逻辑和依赖注入等底层源码工作流程 通过手写模拟，了解初始化机制工作流程 通过手写模拟，了解BeanDefinition、BeanPostProcessor的概念 通过手写模拟，了解Spring AOP的底层源码工作流程
深入剖析Spring源码：手写模拟核心启动与依赖注入
资源摘要信息:"本文旨在通过手动模拟Spring源码的启动、扫描逻辑、依赖注入、初始化机制、BeanDefinition与BeanPostProcessor概念以及Spring AOP的工作流程，来深入理解Spring框架的底层原理。" 知识点: 1. Spring...
手写spring ioc(三) 资源org.zip
12-13
总的来说，手写Spring IOC是一个深入理解和实践IoC设计模式的好方法，它能帮助开发者更深入地了解Spring框架的工作原理，提高对依赖注入和对象管理的理解。通过这个过程，我们可以更好地掌握如何在实际项目中应用...
简单手写springIOC注解模式
02-16
以上就是关于“简单手写springIOC注解模式”的主要知识点。通过这些注解，我们可以实现灵活、简洁的Spring应用配置，使得代码更加易于维护和扩展。在实际项目中，这些知识可以帮助我们更高效地构建和管理应用程序的...
手写springioc注解注入对象基本实现
Leon_Jinhai_Sun的博客
05-27 651
还是要养成写注释的习惯,首先一个代码想让人家看懂的情况下,记住一点,重构加设计模式,其实设计模式也比较好, 达到别人可易读性,这是我要跟你讲的,而且你们不写注释是一个不好的习惯,你们一定要养成我善于重构代码,善于写注释, 把这样的思想学会的情况下,我相信你以后是一个非常好的程序员,所以不要说别人不写注释的程序员就很牛,这不一定的, 这个注解方式要怎么实现,在这个地方我们来看一段代码,手写注...
springboot启动类扫描路径
m0_67401153的博客
04-26 1742
springboot启动类的默认扫描路径是该类所在的包下面的所有java类。如：启动类在“cn.com.test.app”包下，那么只有cn.com.test.app包下的类会被扫描加载。 如果需要加载的类不在启动类的同一包下，可以在启动类处，手动指定扫描包路径，如下： 如图：默认只能扫描app包下的类，如果要扫描controller、config、service等包，需要在启动类处指定扫描路径。 ...
扫描路径_不会吧，有人用了两年Spring, 居然不知道包扫描是怎么实现的
weixin_30332165的博客
01-12 226
Table of Contents如果你曾经使用过 Spring , 那你已经配过 包扫描路径吧，那包扫描是怎么实现的呢？让我们自己写个包扫描用途基于 Java 的反射机制，我们很容易根据 class 去创建一个实例对象，但如果我们根本不知道某个包下有多少对象时，我们应该怎么做呢？在使用 Spring 框架时，会根据包扫描路径来找到所有的 class , 并将其实例化后存入容器中。在我们的项目中也...
spring-包扫描的三种方式
promisessh的博客
01-19 866
1、@Configuration 会告诉spring这是一个配置类，与springmvc中的bean.xml是一个效果；使用如下： @Configuration public class MainConfig { } 2、@ComponentScan 告诉spring要扫描的类路径，与springmvc中的<context:component-scan>一个效果；lazyInit制定是否需要懒加载，默认false，懒加载表示程序第一次访问时才加载，否则在容器初始化时加载，excludeFilt
spring启动流程(二）：包的扫描流程
BASK2312的博客
11-05 2333
本文比较长，主要分析了spring 扫描包路径得到根据包名得到路径Resource；根据路径Resouce得到该路径下所有class文件的Resouce；根据class文件的Resouce通过asm解析得到，注意：这里的还是所有class文件的；从中找到需要spring托管的，将其转化为，为的子类；进一步丰富的信息；将上面得到的添加到中至此，包名转换为完成。spring 在获取类上的注解时，不是通过反射，而是使用asm直接解析class文件，然后再获取类上的注解的。
SpringBoot启动类自动包扫描 三种方式
08-24 4811
请看 example5 案例编辑配置文件 BeanConfigScanConfig@OverrideSystem.out.println("##################################初始化 BeanConfigScan ################################################");}}在resources 文件夹下创建 META-INF 文件夹，在META-INF 文件夹内创建 spring.factories 文件文件内容如下。
Spring学习之——手写Mini版Spring源码
weixin_47082274的博客
07-29 872
Sping的生态圈已经非常大了，很多时候对Spring的理解都是在会用的阶段，想要理解其设计思想却无从下手。前些天看了某某学院的关于Spring学习的相关视频，有几篇讲到手写Spring源码，感觉有些地方还是说的挺好的，让博主对Spring的理解又多了一些，于是在业余时间也按照视频讲解实现一遍SpringIOC、DI、MVC的设计思想，加深巩固记忆，也便于初学者理解，我们不用重复造轮子，但得知道轮子怎么造。 开发工具 环境：jdk8 + IDEA + maven jar包：javax.servlet-2.5
手写Spring源码——实现一个简单的spring framework
最新发布
沐雨橙风ιε的博客
08-26 2082
***//*** bean的类型*//*** bean的作用域*//*** 是否懒加载*/在AnnotationConfigApplicationContext中定义一个list保存所有BeanPostProcessor接口。/*** 保存所有BeanPostProcessor接口实现类的集合*/
Spring框架核心功能手写实现
十八岁讨厌编程的博客
03-07 1887
本文涉及Spring启动以及扫描流程实现、依赖注入实现、BeanNameAware回调实现、初始化机制模拟实现、BeanPostProcessor模拟实现、AOP模拟实现等内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值