手写Spring

已于 2024-09-23 13:31:28 修改
阅读量1.1k 收藏 30
点赞数 15
分类专栏： Spring 文章标签： spring
于 2024-09-20 09:55:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65186476/article/details/142097193
版权

简单实现Spring基于注解配置

 

ComponentScan

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

相当于component-scan 

HspSpringConfig

@ComponentScan(value = "spring.write.component")
public class HspSpringConfig {
}

替代bean.xml文件，添加@ComponentScan，获得扫描的包

AppMain

public class AppMain {
    public static void main(String[] args) {
        HspApplicationContext ioc = new HspApplicationContext(HspSpringConfig.class);
        Object userDao = ioc.getBean("userDao");
        System.out.println(userDao);
    }
}

HspApplicationContext

public class HspApplicationContext {
    private Class configClass;
    private final ConcurrentHashMap<String, Object> ioc = new ConcurrentHashMap<>();

    public HspApplicationContext(Class configClass) {
        //1、获得扫描包路径
        //得到config文件的.class类型
        this.configClass = configClass;
        //反射得到ComponentScan注解
        ComponentScan componentScan =
                (ComponentScan)configClass.getDeclaredAnnotation(ComponentScan.class);
        //获取注解的value就是扫描的包路径
        String path = componentScan.value();
        System.out.println(path);
        //spring.write.component





        //2、得到包下的所有.class
        //得到类的加载器,获取实际目录下的(out)，
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();

        //URL必须按照斜杠/来写
        //path = spring.write.component
        path = path.replace(".","/");
        URL resource = classLoader.getResource(path);
        System.out.println(resource);
        //file:/D:/Atest/spring/out/production/spring/spring/write/component

        //对路径下的文件进行遍历
        File file = new File(resource.getFile());
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                //只处理.class文件（java文件）
                String fileAbsolutePath = f.getAbsolutePath();
                if(fileAbsolutePath.endsWith(".class")) {
                    System.out.println(fileAbsolutePath);
                    //D:\Atest\spring\out\production\spring\spring\write\component\UserDao.class
                    //前面已经有了path，还需要具体的类名进行反射,放入容器
                    String className = fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
                    String classFullName = path.replace("/", ".") + "." + className;
                    //判断该类是不是需要注入到容器，有无注解
                    try {
                        Class<?> aClass = classLoader.loadClass(classFullName);
                        //判断该类的实例是否有注解
                        if(aClass.isAnnotationPresent(Component.class) ||
                                aClass.isAnnotationPresent(Controller.class) ||
                                aClass.isAnnotationPresent(Service.class) ||
                                aClass.isAnnotationPresent(Repository.class)) {
                            //查看是否指定了id
                            if(aClass.isAnnotationPresent(Component.class)) {
                                //只演示了Component
                                Component component = aClass.getDeclaredAnnotation(Component.class);
                                String id = component.value();
                                if(! "".endsWith(id)) {
                                    className = id;
                                }
                            }
                            //放入容器
                            Class<?> clazz = Class.forName(classFullName);
                            Object instance = clazz.newInstance();
                            //类名首字母小写存入，springframework下的工具类
                            ioc.put(StringUtils.uncapitalize(className),instance);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public Object getBean(String name) {
        return ioc.get(name);
    }
}

Spring整体架构分析

 

没有加@Scope(value="prototype")就是单例
ioc.getBean("name")，先到BeanDefinition Map获取，未找到异常处理，
如果是单例（single）就从单例Bean Map获取
如果是多例（prototype）就创建bean对象并返回（到BeanDefinition Map中，得到Bean的clazz对象，使用反射，创建bean返回）

1、实现扫描包，得到bean的class对象

Spring基于注解配置已经写过

HspApplicationContext

public class HspApplicationContext {
    private Class configClass;
    public HspApplicationContext(Class configClass) {
        this.configClass = configClass;
        ComponentScan componentScan =
                (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        String path = componentScan.value();
        System.out.println(path);//com.spring.component

        ClassLoader classLoader =
                HspApplicationContext.class.getClassLoader();
        path = path.replace(".", "/");
        System.out.println(path);//com/spring/component

        URL resource =
                classLoader.getResource(path);

        File file = new File(resource.getFile());
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                String fileAbsolutePath = f.getAbsolutePath();
                if(fileAbsolutePath.endsWith(".class")) {
                    String className = fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
                    String classFullName = path.replace("/", ".") + "." + className;
                    try {
                        Class<?> clazz = classLoader.loadClass(classFullName);
                        if(clazz.isAnnotationPresent(Component.class)) {
                            System.out.println("是Spring bean【class对象】= " + clazz + " 【类名】 = " + className);
                        } else {
                            System.out.println("不是Spring bean【class对象】= " + clazz + " 【类名】 = " + className);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

2、扫描bean信息，封装到BeanDefinition对象并放入Map

增加@Scope注解来判断单例（single）或者多例（prototype）

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

BeanDefinition用于封装/记录Bean信息
1、单例/多例
2、多例需要动态生成，存放Bean对应的Class对象，反射生成

public class BeanDefinition {
    private String scope;
    private Class clazz;
    public String getScope() {
        return scope;
    }
    public void setScope(String scope) {
        this.scope = scope;
    }
    public Class getClazz() {
        return clazz;
    }
    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }
    @Override
    public String toString() {
        return "BeanDefinition{" +
                "scope='" + scope + '\'' +
                ", clazz=" + clazz +
                '}';
    }
}

HspApplicationContext

private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap =
            new ConcurrentHashMap<>();
//单例对象类型不确定，用Object
private ConcurrentHashMap<String, Object> singletonObejcts =
            new ConcurrentHashMap<>();

如果有@Component，就放入beanDefinitionMap中

可以将1、2步写成一个方法，在构造器里调用

3、初始化bean单例池并完成getBean、createBean方法

public class HspApplicationContext {
    private Class configClass;
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap =
            new ConcurrentHashMap<>();
    //单例对象类型不确定，用Object
    private ConcurrentHashMap<String, Object> singletonObejcts =
            new ConcurrentHashMap<>();
    public HspApplicationContext(Class configClass) {
        //完成扫描指定包
        beanDefinitionScan(configClass);
        //遍历所有的beanDefinition对象
        Enumeration<String> keys = beanDefinitionMap.keys();
        while(keys.hasMoreElements()) {
            String beanName = keys.nextElement();
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            if("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
                Object bean = createBean(beanDefinition);
                singletonObejcts.put(beanName,bean);
            }
        }
        System.out.println("singletonObejcts单例池=" + singletonObejcts);
        System.out.println("beanDefinitionMap=" + beanDefinitionMap);
    }
    public void beanDefinitionScan(Class configClass) {}

    public Object createBean(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;
    }
    public Object getBean(String name) {
        //判断beanName是否存在
        if(beanDefinitionMap.containsKey(name)) {
            BeanDefinition beanDefinition = beanDefinitionMap.get(name);
            if("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
                return singletonObejcts.get(name);
            } else {
                return createBean(beanDefinition);
            }
        } else {
            throw new NullPointerException("没有该Bean");
        }
    }
}

4、依赖注入

增加@Autowired注解，这里只用名字来进行匹配

 

    public Object createBean(BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getClazz();
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            //遍历所有字段，
            for(Field field : clazz.getDeclaredFields()) {
                //是否有Autowired
                if(field.isAnnotationPresent(Autowired.class)) {
                    String name = field.getName();
                    //通过getBean获取要组装的对象
                    Object bean = getBean(name);
                    //进行组装,private需要暴破
                    field.setAccessible(true);
                    field.set(instance,bean);//将 bean 赋值给 instance 的 field
                }
            }
            return instance;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }

5、bean后置处理器实现

原生Spring接口InitializingBean（初始化），自己实现这个接口，完成初始化方法
接口中有afterPropertiesSet()方法，在Bean的setter方法执行完毕后，被spring容器调用，就是初始化方法

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

应用：选择MonsterService来实现这个接口

@Component("monsterService")
@Scope(value = "property")
public class MonsterService implements InitializingBean {
    @Autowired
    private MonsterDao monsterDao;
    public void m1() {
        monsterDao.hi();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("monsterService初始化方法被调用");
    }
}

在创建好Bean实例后，判断是否需要初始化
容器中常用的一个方法是：根据该类是否实现了某个接口，来判断是否要执行某个业务（接口编程）

在HspApplicationContext的createBean返回instance之前加上判断是否是这个接口的子类型，是的话就执行初始化方法

判断如果返回为null，不变化
加上beanName

public Object createBean(String beanName, BeanDefinition beanDefinition) {
        Class clazz = beanDefinition.getClazz();
        try {
            Object instance = clazz.getDeclaredConstructor().newInstance();
            //遍历所有字段，
            for(Field field : clazz.getDeclaredFields()) {
                //是否有Autowired
                if(field.isAnnotationPresent(Autowired.class)) {
                    String name = field.getName();
                    //通过getBean获取要组装的对象
                    Object bean = getBean(name);
                    //进行组装,private需要暴破
                    field.setAccessible(true);
                    field.set(instance,bean);//将 bean 赋值给 instance 的 field
                }
            }
            System.out.println("======创建好实例======" + instance);
            //初始化方法前，调用before方法，可以对容器的bean实例进行处理，然后返回处理后的bean
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
                if(current != null)
                    instance = current;
            }
            if(instance instanceof InitializingBean) {
                try {
                    ((InitializingBean) instance).afterPropertiesSet();//将instance转成InitializingBean类型,调用方法
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //初始化方法后，调用after方法，可以对容器的bean实例进行处理，然后返回处理后的bean
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                Object current = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
                if(current != null)
                    instance = current;
            }
            return instance;

后置处理器接口BeanPostProcessor

对容器中的所有bean生效

public interface BeanPostProcessor {
    //bean的初始化前调用
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
    //bean的初始化后调用
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

自己写一个类实现后置处理器，通过Component注入到容器中

实现类可以不止一个，放在Arraylist中

private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

@Component
public class HspBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("后置处理器before（）");
         return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("后置处理器after（）");
        return bean;
    }
}

在HspApplicationContext的扫描方法中扫描Component，再判断是否实现了后置处理器接口

6、AOP机制实现 

原生Spring实现方法
A接口写方法，B类实现A接口，给B类加上@Component注入到容器
切面类加上@Component和@Aspect
B类执行后置处理器的After方法后，变成代理对象

public interface SmartAnimalable {
    float getSum(float i, float j);
    float getSub(float i, float j);
}
@Component(value = "smartDog")
public class SmartDog implements SmartAnimalable {
    public float getSum(float i, float j) {
        float res = i + j;
        System.out.println("SmartDog-getSum-res=" + res);
        return res;
    }

    public float getSub(float i, float j) {
        float res = i - j;
        System.out.println("SmartDog-getSub-res=" + res);
        return res;
    }
}
public class SmartAnimalAspect {
    public static void showBeginLog() {
        System.out.println("前置通知..");
    }
    public static void showSuccessLog() {
        System.out.println("返回通知..");
    }
}

在HspBeanPostProcessor的after方法中实现AOP（写死的方法）

public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("后置处理器after（）");
        if("smartDog".equals(beanName)) {
            Object proxyInstance = Proxy.newProxyInstance(HspBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    Object result = null;
                    if("getSum".equals(method.getName())) {
                        SmartAnimalAspect.showBeginLog();
                        result = method.invoke(bean,args);
                        SmartAnimalAspect.showSuccessLog();
                    } else {
                        result = method.invoke(bean,args);
                    }
                    return result;
                }
            });
            return proxyInstance;
        }
        return bean;
    }

_CYX_
关注
专栏目录
手写Spring框架
Tyshawn的博客
01-25 2万+
在学习完Spring框架之后, 我们知道了 Spring容器, IOC, AOP, 事务管理, SpringMVC 这些Spring的核心内容, 也知道了它们底层实现的基本原理, 比如Spring容器就是个Map映射, IOC底层就是反射机制, AOP底层是动态代理, SpringMVC不就是对Servlet进行了下封装嘛! 哈哈, 当然这些只是些皮毛, Spring除此之外还有更加复杂的设计, ...
手写spring
weixin_44235759的博客
03-21 1101
文章目录参考视频目录手写spring模拟扫描模拟BeanDefinition模拟getBeancreateBean方法实现模拟依赖注入Aware回调初始化回调模拟BeanPostProcessor 参考视频 https://www.bilibili.com/video/BV1tR4y1F75R?p=1 目录 手写spring Test package com.zs.service; import com.zs.spring.ZsApplicationContext; public class Tes
手把手教你手写Spring框架
weixin_49849351的博客
12-07 6151
手写spring准备工作： 新建一个maven工程： 架构 新建类： package com.spring; public class keweiqinApplicationContext { private Class configClass; public keweiqinApplicationContext(Class configClass) { this.configClass = configClass; } //解析配
手写Spring简易版源码
weixin_42445418的博客
01-23 999
手写简易版Spring
手写 Spring Aop篇
@Bean
07-19 314
上面三篇文档介绍了bean的生命周期。通知是如何绑定的，代理对象是如何产生的以及aop是如何调用的呢。 一个aop切面包含了哪些内容了 一个切面有多个切入点，每个切入点有不同的通知，通知分为before after around(此环境) around 的通知有两个也是之前和之后，这个之前会在before之前执行，这个之后会在after之前执行。 那么aop是如何调用的呢。比如我们需要增强A类的query方法。如果A是一个接口，代理对象通过jdk动态代理生成，如果是一个类，代理对象通过cglib生成
Spring学习记录----手写Spring框架
m0_63064861的博客
07-20 545
手写Spring框架---在ClassPathXmlApplicationContext的构造方法中解析配置文件，获取所有bean的类名，通过反射机制调用无参数构造方法创建Bean。Map集合的key存储beanId，value存储Bean实例。并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件。打包方式采用jar，并且引入dom4j和jaxen的依赖，因为要使用它解析XML文件，还有junit依赖。通过反射机制调用set方法
[Spring框架] 手写Spring
hljjaaa的博客
05-09 926
手写spring，简易版spring
手写Spring事务框架
飞上云端看彩虹
06-03 1003
编程事务实现 概述 所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 案例 使用编程事务实现手动事务 使用编程事务实现，手动事务 begin、commit、roll...
springSourceCode:手写spring
05-11
《Spring 源码深度解析：手写 Spring》 在 Java 开发领域，Spring 框架无疑是最具影响力和广泛使用的轻量级框架之一。它以其强大的功能、灵活的配置以及面向切面编程（AOP）的支持，极大地简化了企业级应用的开发。...
spring(纯手写spring)
08-03
Spring框架是Java开发中最广泛应用的轻量级框架之一，它以其IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）为核心特性，极大地简化了企业级应用的开发。在本文中，我们...
手写spring框架（仿真版）
04-29
通过对spring框架的理解和学习，手写一套属于自己的spring框架。这里面只是一个最简单的方式，真正的spring比这复杂的多。这里只是帮助喜欢spring的同学，对spring有个更深的理解和学习。
手写Spring框架之: HelloSpring
02-01
在本教程中，我们将深入探讨如何手写Spring框架的核心部分，以实现一个简化的"HelloSpring"示例。Spring框架是Java开发中的一个基石，它提供了依赖注入、面向切面编程（AOP）以及用于构建企业级应用的全面解决方案。...
手把手教你手写Spring框架(附源码)
06-30
帮助广大学员手把手教学，本课程从无到有，循序渐进的手写mvc框架，由于官方的框架比较复杂，为了让同学们能够学懂，先从简单地IOC框架入手，然后不断地升级和迭代，逐渐成为官方比较接近的Spring框架。希望同学们...
【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter
wendao76的专栏
10-14 1378
首先，我们创建一个类，继承自@Override> clazz) {@Override// 假设MyObject的构造函数接受一个字符串@Override// 假设我们要将MyObject转换成字符串进行输出接下来，我们需要在Spring MVC的配置中注册我们的自定义转换器。如果你使用的是Java配置，可以像下面这样实现@Override// 如何自定义的转换器与默认转换器冲突，可以将自己的转换器放到默认转换器前面。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 824
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Springboot api http并发测试请求
nsa65223的专栏
10-11 371
【代码】Springboot api http并发测试请求。
spring task的使用场景
qq_40603125的博客
10-13 366
spring任务调度框架约定的时间。
spring-cloud-alibaba-nacos-config2023.0.1.*启动打印配置文件内容
最新发布
tb_problem的博客
10-17 246
注：我是通过spring.config.import的方式引入配置文件的；如果通过bootstrap.yml则是另一种的配置方式；在开发测试过程中如果可以打印出配置文件的内容，方便确认配置是否准确；那么如何才可以打印出来呢；如果通过bootstrap的配置方式则需要如下配置。本文由博客一文多发平台。
手写spring框架
08-10
手写Spring框架是一个相当复杂的任务，但我可以简要介绍手写Spring框架的一些关键步骤和组成部分。 1. 依赖注入：Spring框架的核心概念之一是依赖注入。我们需要编写一个容器，负责管理和维护各个对象之间的依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值