一起学源码——Spring篇（3）

已于 2022-08-19 21:34:23 修改
阅读量221 收藏
点赞数
分类专栏： 一起学源码 文章标签： spring java
于 2022-08-19 21:30:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32909613/article/details/126235471
版权

一、简介

上篇文章写的有些混乱，可以略过，这篇文章开始对我们的简单spring进行改造，构建出一个BeanFactory的基本框架

二、正文

在这里插入图片描述
首先直接看图，我们先来学习低级容器BeanFactory。
DefaultListableBeanFactory的整个类继承关系中大概包含上面五块体系
1.BeanFactory体系
2.注册单例Bean
3.别名相关
4.FactoryBean相关
5.注册BeanDefinition
我们主要关注 1，2，5三块内容，别名不需要关注，FactoryBean的作用虽然比较重要的，但是更多的是在实例化对象，也先放在一边。
在这里插入图片描述
整个改造后的文件结构如图所示，其实也就是按照DefaultListableBeanFactory的结构体系去创建就可以了。
代码如下，有兴趣的同学可以一起创建，可以加深Spring的结构体系了解。
首先是BeanDefinition

package support;

public class BeanDefinition {
    private Class beanClass;
    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }
    public Class getBeanClass() {
        return beanClass;
    }
}

然后是BeanFactory

package Factory.Interface;

/**
 * 最顶层接口，提供getBean方法
 */
public interface BeanFactory {

    Object getBean(String beanName) throws Exception;
}


package Factory.Interface;

/**
 *扩展BeanFactory使其支持迭代Ioc容器持有的Bean对象 （先不关注）
 */
public interface ListableBeanFactory extends BeanFactory{
}


package Factory.Interface;

import Register.Interface.SingletonBeanRegistry;

/**
 * 扩展BeanFactory，扩展了父类容器的方法(先不关注)
 */
public interface HierarchicalBeanFactory extends BeanFactory {
}


package Factory.Interface;

/**
 * 扩展BeanFactory，能够被那些支持自动装配功能的Bean工厂实现（先不关注）
 */
public interface AutowireCapableBeanFactory extends BeanFactory{
}

创建SingletonBeanRegistry接口和他的实现类DefaultSingletonBeanRegistry

package Register.Interface;

/**
 * 注册单例Bean接口
 */
public interface SingletonBeanRegistry {
    /**
     * 注册Bean
     * @param beanName
     * @param singletonObject
     */
    void registerSingleton(String beanName, Object singletonObject);

    /**
     * 获取Bean
     * @param beanName
     * @return
     */
    Object getSingleton(String beanName);
}


package Register.Impl;

import Register.Interface.SingletonBeanRegistry;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
    @Override
    public void registerSingleton(String beanName, Object singletonObject) {
        addSingleton(beanName,singletonObject);
    }

    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.put(beanName,singletonObject );
        }
    }

    @Override
    public Object getSingleton(String beanName) {
        return this.singletonObjects.get(beanName);
    }
}


package Register.Abstract;

import Register.Impl.DefaultSingletonBeanRegistry;

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
}

回到BeanFactory

package Factory.Interface;

import Register.Interface.SingletonBeanRegistry;

/**
 * 继承HierarchicalBeanFactory的同时继承了 注册单例Bean的SingletonBeanRegistry
 */
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
}


package Factory.Interface;

/**
 * BeanFactory集大成的接口，汇聚了所有接口的方法
 */
public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory{
}


package Factory.Abstract;

import Factory.Interface.ConfigurableBeanFactory;
import Register.Abstract.FactoryBeanRegistrySupport;
import support.BeanDefinition;

/**
 * 继承FactoryBeanRegistrySupport,实现ConfigurableBeanFactory
 */
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    @Override
    public Object getBean(String beanName) throws Exception {
        //调用doGetBean
        return doGetBean(beanName);
    }

    protected Object doGetBean(String beanName) throws Exception {
        //获取Bean，获取到直接返回，获取不到调用createBean抽象方法，实际会调用到子类AbstractAutowireCapableBeanFactory中createBean
        Object singleton = getSingleton(beanName);
        if(singleton!=null){
            return singleton;
        }
        return createBean(beanName);
    }

    protected abstract Object createBean(String beanName) throws Exception;

    protected abstract BeanDefinition getBeanDefinition(String beanName) throws Exception;
}


package Factory.Abstract;

import Factory.Interface.AutowireCapableBeanFactory;
import InstantiationStrategy.Impl.SimpleInstantiationStrategy;
import InstantiationStrategy.Interface.InstantiationStrategy;
import MyAnnotation.MyAutowired;
import cn.hutool.core.bean.BeanUtil;
import support.BeanDefinition;

import java.lang.reflect.Field;

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    private InstantiationStrategy instantiationStrategy = new SimpleInstantiationStrategy();
    //createBean方法
    @Override
    protected Object createBean(String beanName) throws Exception {
        //调用doCreateBean
        Object beanInstance = doCreateBean(beanName);
        return beanInstance;
    }
    protected Object doCreateBean(String beanName) throws Exception{
        //调用createBeanInstance
        Object beanInstance = createBeanInstance(beanName);
        //注册Bean
        registerSingleton(beanName,beanInstance);
        //填充Bean属性
        populateBean(beanInstance);
        return beanInstance;

    }
    protected Object createBeanInstance(String beanName) throws Exception{
        //实例化Bean
        return instantiateBean(beanName);
    }

    protected Object instantiateBean(String beanName) throws Exception {
        //调用getBeanDefinition抽象方法,实际调用子类DefaultListableBeanFactory的getBeanDefinition
        BeanDefinition beanDefinition = getBeanDefinition(beanName);
        //获取实例化策略创建对象
        return getInstantiationStrategy().instantiate(beanName,beanDefinition);
    }

    protected void populateBean(Object bean) throws Exception {
        //此段代码通过注解填充属性,和Spring真实处理有些不同
        Class<?> aClass = bean.getClass();
        //获取所有声明字段
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            //是否被MyAutowired注解修饰
            MyAutowired annotation = declaredField.getAnnotation(MyAutowired.class);
            if(annotation!=null){
                Class<?> type = declaredField.getType();
                //获取该对象，如果有则返回，没有则会创建，递归的跳出条件为两个对象都创建完成（解决循环依赖的代码的一部分）
                Object o = getBean(type.getSimpleName());
                //设置属性
                BeanUtil.setFieldValue(bean,declaredField.getName(),o);
            }
        }
    }
    protected InstantiationStrategy getInstantiationStrategy() {
        return this.instantiationStrategy;
    }

}

实例化策略的接口和两个实现类

package InstantiationStrategy.Interface;

import support.BeanDefinition;

public interface InstantiationStrategy {
    Object instantiate(String beanName, BeanDefinition beanDefinition)throws Exception;
}


package InstantiationStrategy.Impl;

import InstantiationStrategy.Interface.InstantiationStrategy;
import net.sf.cglib.proxy.Enhancer;
import support.BeanDefinition;

import java.lang.reflect.Constructor;

public class CglibSubclassingInstantiationStrategy implements InstantiationStrategy {
    @Override
    public Object instantiate(String beanName, BeanDefinition beanDefinition) throws Exception {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(beanDefinition.getBeanClass());
        Class clazz = beanDefinition.getBeanClass();
        Constructor constructorToUse = clazz.getDeclaredConstructor();
        if (null == constructorToUse) return enhancer.create();
        return enhancer.create(constructorToUse.getParameterTypes(), null);
    }
}

package InstantiationStrategy.Impl;

import InstantiationStrategy.Interface.InstantiationStrategy;
import support.BeanDefinition;

import java.lang.reflect.Constructor;

public class SimpleInstantiationStrategy implements InstantiationStrategy {
    @Override
    public Object instantiate(String beanName, BeanDefinition beanDefinition) throws Exception {
        Class clazz = beanDefinition.getBeanClass();
        Constructor constructorToUse = clazz.getDeclaredConstructor();
        if(null != constructorToUse){
            return clazz.getDeclaredConstructor(constructorToUse.getParameterTypes()).newInstance(null);
        }
        return constructorToUse.newInstance();
    }
}

回到BeanFactory

package InstantiationStrategy.Interface;

import support.BeanDefinition;

/**
 * 注册BeanDefinition接口
 */
public interface BeanDefinitionRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws Exception;
}

DefaultListableBeanFactory
BeanFactory的最终实现类

package Factory.Impl;

import Factory.Abstract.AbstractAutowireCapableBeanFactory;
import Factory.Interface.ConfigurableListableBeanFactory;
import InstantiationStrategy.Interface.BeanDefinitionRegistry;
import MyAnnotation.MyComponent;
import cn.hutool.core.util.ClassUtil;
import support.BeanDefinition;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * BeanFactory的最终实现类
 */
public class DefaultListableBeanFactory  extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

    /**
     * getBeanDefinition 获取BeanDefinition
     * @param beanName
     * @return
     * @throws Exception
     */
    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        BeanDefinition bd = this.beanDefinitionMap.get(beanName);
        if (bd == null) {
            throw new Exception(beanName);
        }
        return bd;
    }

    /**
     * registerBeanDefinition 注册BeanDefinition
     * @param beanName
     * @param beanDefinition
     * @throws Exception
     */
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws Exception {
        this.beanDefinitionMap.put(beanName,beanDefinition);
    }

    //此方法Spring对应类中无，此处用来加载MyComponent修饰类的BeanDefinition
    public void loadBeanDefinition(){
        //扫描包，获取MyConponent注解标记的类
        Set<Class<?>> com = ClassUtil.scanPackageByAnnotation("com", MyComponent.class);
        //将扫描到的class放入BeanDefiniton，存入集合
        for (Class<?> aClass : com) {
            BeanDefinition definition = new BeanDefinition();
            definition.setBeanClass(aClass);
            this.beanDefinitionMap.put(aClass.getSimpleName(),definition);
        }
    }
}

三、测试

package com;

import MyAnnotation.MyAutowired;
import MyAnnotation.MyComponent;


@MyComponent
public class DeptService {
    @MyAutowired
    UserService userService;

}

package com;

import MyAnnotation.MyAutowired;
import MyAnnotation.MyComponent;


@MyComponent
public class UserService {
    @MyAutowired
    DeptService deptService;
}

package com;

import Factory.Impl.DefaultListableBeanFactory;
import org.junit.Test;

public class test {
    @Test
    public void test() throws Exception {
        DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
        defaultListableBeanFactory.loadBeanDefinition();
        Object userService = defaultListableBeanFactory.getBean("UserService");
        System.out.println("");
    }

}

在这里插入图片描述
结果是可以成功创建

本次改造主要将原来一个文件中的代码拆分到了整个BeanFactory体系代码中，不过关于其中较为核心的加载BeanDefinition 和填充对象属性部分和Spring的做法有所出入，后续会逐步改造，另外增加了实例化策略相关的内容。

本人水平有限，如有错漏，欢迎指正。
本文用作学习记录分享，如有违规请联系作者删除！

枫叶千
关注
专栏目录
Spring源码——Spring MVC
等一杯咖啡的博客
11-22 1639
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第十一章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework Spring框架提供了构建Web应用程序的全功能MVC模...
Spring学习总结——Spring实现IoC的多种方式
m0_68850571的博客
04-19 3237
一、Spring框架概述 1.1、资源 1.2、Spring历史 1.3、框架特征与功能 1.4、Spring组成 1.5、Spring Boot与Spring Cloud 二、IoC基础 三、使用XML配置的方式实现IOC 3.1、使用无参构造方法创建对象 3.2、使用有参构造方法创建对象 3.3、通过属性赋值 3.4、对象引用 3.5、对象作用域 3.6、延迟初始化bean 四、使用Spring注解配置IOC 4.1、修改BookDAO 4.2
一起学源码——Spring篇（2）
qq_32909613的博客
08-07 461
一起学源码
学习分享——Spring validation验证框架
Lee_92的博客
08-01 1547
在我们创建Springboot项目时，可以在开始时添加很多依赖项，勾选几个复选框就可以完成依赖的添加，这些依赖中的框架可以极大地提高我们的开发效率，简直是老6一般的存在。在做web项目开发时，我们经常会苦于去写各种分支判断去验证客户端发过来的request请求是否符合我们的业务标准及要求，各种正则表达式会让你累感不爱。那么请记住在java中只要你觉得繁琐重复的代码，一定有大佬帮你写好了！！！！！@Validated注解，表示此参数是需要通过SpringValidation进行检查的和。......
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day15】—— Spring框架1
热门推荐
陈哈哈的菜园子
06-28 2万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！看什么看？快上车！
Spring——Spring设计模式总结
庄小焱
03-21 3266
设计模式作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记忆。Spring作为业界的经典框架，无论是在架构设计方面，还是在代码编写方面，都堪称行内典范。spring中常用的设计模式达到九种，我们举例说明。以后再也不怕面试官问我：Spring中用了哪些设计模式了。
SpringCloud基础3——Docker
vincewm的博客
09-10 2317
docker镜像、容器、安装、数据卷、Dockerfile自定义镜像、Docker-Compose部署分布式项目、Docker镜像仓库
Spring基础3——AOP，事务管理
vincewm的博客
08-17 2927
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
Spring Security 认证源码超详细分析
緑水長流*z
08-30 3049
AbstractAuthenticationProcessingFilter 为处理认证请求提供了一个基础框架。这个抽象类主要用于处理 HTTP 请求，并将其转换为 Authentication 对象，然后提交给 AuthenticationManager 进行认证。这不就是我们前面介绍的 UsernamePasswordAuthenticationFilter 吗？
Spring Cloud 学习系列：（十四）消息总线自动刷新配置——Spring Cloud Bus
2301_76352849的博客
04-20 725
1、看视频进行系统学习这几年的Crud经历，让我明白自己真的算是菜鸡中的战斗机，也正因为Crud，导致自己技术比较零散，也不够深入不够系统，所以重新进行学习是很有必要的。我差的是系统知识，差的结构框架和思路，所以通过视频来学习，效果更好，也更全面。关于视频学习，个人可以推荐去B站进行学习，B站上有很多学习视频，唯一的缺点就是免费的容易过时。2、读源码，看实战笔记，学习大神思路“编程语言是程序员的表达的方式，而架构是程序员对世界的认知”。所以，程序员要想快速认知并学习架构，读源码是必不可少的。
JSP实例开发源码——会员管理系统(struts+hibernate+spring).zip
10-25
在本实例中，Spring将Struts和Hibernate集成在一起，提供了一个统一的入口点，协调整个应用的运行。 文件名称列表虽未给出具体文件名，但通常会包含以下几个关键部分： 1. **配置文件**：如struts-config.xml、...
JSP实例开发源码——车辆管理系统(struts+hibernate+spring+oracle).zip
10-25
该压缩包文件“JSP实例开发源码——车辆管理系统(struts+hibernate+spring+oracle).zip”是一个基于Java Web技术实现的车辆管理系统的完整源代码。这个系统利用了四大框架——Struts、Hibernate、Spring和Oracle...
JSP源码——移动ssh项目(struts+spring+hibernate+oracle).zip
10-06
其次，Spring框架作为“胶水”，将各个组件紧密联系在一起。它提供了依赖注入（DI）和面向切面编程（AOP）的功能，解耦了应用的各个部分。在本项目中，Spring可能用于管理Struts的Action实例，处理事务，以及管理...
一起学源码——Spring篇（1）
qq_32909613的博客
07-30 511
一起学源码
在 Spring 中使用 @EhCache 注解作为缓存
龚小帅的博客
10-15 1376
Spring 有一个内置的 EhCache 缓存管理器。这适用于大多数缓存情况，但我发现定义自定义缓存管理器非常有用，因为它允许我使用相同的缓存管理器以编程方式或通过注释控制缓存。本文重点介绍 annotations，但让我们继续定义一个自定义缓存管理器，以便在需要时做好准备。如果您更喜欢坚持使用 默认缓存管理器 ，您可以跳过此步骤。我们将在 ：super();
【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter
wendao76的专栏
10-14 1372
首先，我们创建一个类，继承自@Override> clazz) {@Override// 假设MyObject的构造函数接受一个字符串@Override// 假设我们要将MyObject转换成字符串进行输出接下来，我们需要在Spring MVC的配置中注册我们的自定义转换器。如果你使用的是Java配置，可以像下面这样实现@Override// 如何自定义的转换器与默认转换器冲突，可以将自己的转换器放到默认转换器前面。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 910
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
车辆管理的SpringBoot技术革新
最新发布
2401_85760095的博客
10-18 836
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。B/S架构给使用管理系统的用户带来极大的便利。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。
快速构建SpringBoot项目
qq_38527427的博客
10-14 739
下文将简述如何快速构建一个SpringBoot项目，使用SpringData JPA实现持久层访问，集成lombok、swagger2及集成thymeleaf进行页面展示。
学生学籍管理系统源码——SpringBoot&Mybatis&SSM整合
SSM是Spring、SpringMVC和Mybatis三个框架整合在一起的简称，它是一种常见的Java EE项目的基础框架。Spring负责业务对象管理，SpringMVC负责控制层的实现，Mybatis则负责数据访问层的操作。SSM框架组合利用各自框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值