0


【spring源码系列-01】spring底层源码整体概述

JVM系列整体栏目


内容链接地址【一】spring源码整体概述https://blog.csdn.net/zhenghuishengq/article/details/130940885

初识虚拟机与java虚拟机

一,spring源码整体概述

1,初步概述

在分析这个源码之前,首先需要去官网下载这个spring的源码包,建议下载5.x.x的版本。我这里安装的是:https://github.com/spring-projects/spring-framework/tree/5.2.x

spring框架在我们的认知中,是一个框架,也是一个生态。在spring中,最主要的就是两部分:一个是IOC,另一个是AOP。 IOC由被称为控制反转,是一种思想,就是将对象交给容器管理,而与其对应的是DI,被称为依赖注入,是IOC的一种具体实现。AOP是在IOC基础的一个升华,因此需要透彻的了解IOC之后,再来了解AOP。

IOC一般是作为bean对象的容器,其构建对象的基本流程如下,中间省略部分扩展点,如一些后置处理器,增强器等,后序会一一补上。下面这张图主要是针对于注解的方式获取bean的流程图。
在这里插入图片描述

1,获取上下文一般会通过两种方式获取,一种是通过XML的方式获取,一种是通过注解的方式获取,XML在现在流行的如日中天的springboot中很少使用,因此这里也选择通过注解的方式获取这个上下文ApplicationContext。

publicclassMainClass{publicstaticvoidmain(String[] args){AnnotationConfigApplicationContext context =newAnnotationConfigApplicationContext(MainCofig.class);User user =(User)context.getBean("user");System.out.println("user的类型:"+user.getClass());}}@Configuration@ComponentScan(basePackages ={"com.zhs.study"})publicclassMainCofig{}

当然,也可以通过这个XML的方式来获取上下文,在最初接触spring的时候,就是将bean卸载xml文件中的。

ClassPathXmlApplicationContext ctx =newClassPathXmlApplicationContext("xxx.xml");

2,而不管是使用这个XML的配置文件还是使用这个注解的方式获取到上下文,他们在调用getBean之前,都得生成一个BeanDefinition的bean定义,有了具体的bean定义之后,才能通过这个bean工厂去生产或者获取这个bean对象。而在获取到一个统一的BeanDefinition之前,那么就需要通过实现这个BeanDefinitionReader接口来将不同的上下文配置信息转换成统一的BeanDefinition

publicinterfaceBeanDefinitionReader{...}

BeanDefinitionReader接口有着具体的实现类,如下图所示,有着上面所说的xml和注解生成bean定义的读取器等,相当于作为一个统一的解析器,

在这里插入图片描述

随后通过一个BeanDefinitionRegistry的注册器,将读取到的东西注册成一个BeanDefinition,这样就能统一的生成一个bean工厂可以识别的一个BeanDefinition对象了

protectedintdoLoadBeanDefinitions(InputSource inputSource,Resource resource)throwsBeanDefinitionStoreException{try{Document doc =doLoadDocument(inputSource, resource);returnregisterBeanDefinitions(doc, resource);}}

由于生成的beanDefinition的数量比较多,因此会先将这个bean定义先加入到这个beanDefinitionMap里面。

privatefinalMap<String,BeanDefinition> beanDefinitionMap =newConcurrentHashMap<>(256);

3,随后会调用这个getBean()方法,从这个bean工厂中获取值,如果这个bean定义存在则直接获取,不存在则先创建再将值返回。

Student student =(Student) context.getBean("student");

在获取这个bean的过程中,主要会经历实例化,属性填充和初始化三个主要的过程,分别是实例化、属性填充、初始化 这三个主要的步骤。实例化就是在堆内存中开辟一块空间,并且给对象的属性值赋予默认值;属性填充就是往这个对象中set最终的值;最后再执行init初始化方法。并且这三个步骤的顺序不能改变。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tqAi96hL-1685408227594)(img/1685340071844.png)]

在填充属性到这个初始化的过程中,可以设置一些Aware接口的属性,实现这些Aware接口可以获取上下文等。如某个对象想获取整个上下文的信息,就可以实现

ApplicationContextAware

,外部获取到这个实例之后,就可以直接通过getApplicationContext方法获取上下文。

//实现上下文的aware接口@ComponentpublicclassFirstimplementsApplicationContextAware{privateApplicationContext applicationContext;//实现方法@OverridepublicvoidsetApplicationContext(ApplicationContext applicationContext)throwsBeansException{this.applicationContext = applicationContext;}//将值返回privateApplicationContextgetApplicationContext(){return applicationContext;}}

Aware的作用就是:当Spring容器创建的bean对象在进行具体操作的时候,如果需要容器中的其他对象,此时可以将对象实现这个Aware接口,从而满足当前的需要。

除了设置Aware,还可以设置一些

BeanPostProcessor

处理器,首先会调用BeanPostProcessor.before()方法,最后会调用这个BeanPostProcessor.after() 方法,在这两个处理器中间,执行的就是上面说的init初始化方法。而这两个处理器的方法如下

//前置处理器@NullabledefaultObjectpostProcessBeforeInitialization(Object bean,String beanName)throwsBeansException{return bean;}//后置处理器@NullabledefaultObjectpostProcessAfterInitialization(Object bean,String beanName)throwsBeansException{return bean;}

4,随后生成一个完整的bean对象,存储在这个concurrentHashMap一级缓存中,后续直接在map中获取实例即可。这就是一个粗略的的ioc流程。

5,在spring容器中,又将spring bean对象分为普通对象和容器对象,容器对象相当于一个内置的对象,而普通对象相当于自定义对象。内置对象就是类似于一些需要提前加载的类,并没有显式的自定义一些对象,自定义对象就是一些自定义在xml中或者注解中的一些实例对象。

2,扩展点机制

在上述粗略的描述了一下IOC的整体流程,除了上面这些组件之外,还存在的一些扩展点机制,如一些

PostProcessor

后置处理器,主要有BeanFactoryPostProcessor和BeanPostProcessor处理器,前者主要是用来增强beanDefinition信息的,后者可以用来增强bean信息的,如aop等。

BeanFactoryPostProcessor的接口信息如下,并且该接口是一个函数式接口,在spring容器中,该接口是以集合的形式存在,就是会有多个这种bean工厂的后置处理器。

//函数式接口@FunctionalInterfacepublicinterfaceBeanFactoryPostProcessor{voidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException;}

BeanPostProcessor的接口信息如下,里面有两个方法,被称为后置处理器的前置方法和后置处理器的后置方法

publicinterfaceBeanPostProcessor{@NullabledefaultObjectpostProcessBeforeInitialization(Object bean,String beanName)throwsBeansException{return bean;}@NullabledefaultObjectpostProcessAfterInitialization(Object bean,String beanName)throwsBeansException{return bean;}}

如下面这段BeanFactoryPostProcessor的举例,在实现这个接口之后,重写里面的postProcessBeanFactory方法就可以获取到beanDefination,并且对这个bean定义做一个增强的功能。里面可以设置一些bean的描述,加一些描述信息,是否设置成类加载等等。

/**
 * 自定义bean工厂的后置处理器类
 * 对beanDefinition做增强功能
 * @author zhenghuisheng
 * @date : 2023/5/25
 */@ComponentpublicclassBeanFactoryTestimplementsBeanFactoryPostProcessor{/**
     * @param beanFactory : beanDefinition
     * @throws BeansException
     */@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{BeanDefinition beanDefinition = beanFactory.getBeanDefinition("taskTestController");
        taskTestController.setDescription("hhhhha");System.out.println("=================taskTestController增强完成!");System.out.println(taskTestController.getDescription());}}

3,核心方法refresh

除此之外,xml方式的构造方法和注解的构造方法里面,里面都有一个重要的方法

refresh

,他们的构造方法如下

//XML的方式获取到上下文publicClassPathXmlApplicationContext(String[] configLocations,boolean refresh,@NullableApplicationContext parent)throwsBeansException{super(parent);// 初始化父类 ,获得xml路径资源解析器setConfigLocations(configLocations);// 通过环境变量解析 xml路径if(refresh){refresh();// 这个方法时spring是最终要的一个方法,甚至体系整个ioc的声明周期}}//注解的方式获取上下文publicAnnotationConfigApplicationContext(Class<?>... annotatedClasses){//调用构造函数this();//注册我们的配置类register(annotatedClasses);//IOC容器刷新接口refresh();}

而在这个refresh方法中,可以说是整个spring底层的核心,其代码如下,因此后文的spring源码的继续分析,基本就是围绕下面的这些方法。

@Overridepublicvoidrefresh()throwsBeansException,IllegalStateException{synchronized(this.startupShutdownMonitor){//1:准备刷新上下文环境prepareRefresh();//2:获取告诉子类初始化Bean工厂  不同工厂不同实现ConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();//3:对bean工厂进行填充属性prepareBeanFactory(beanFactory);try{// 第四:留个子类去实现该接口,bean工厂的后置处理器postProcessBeanFactory(beanFactory);// 调用我们的bean工厂的后置处理器. //1. 会在此将class扫描成beanDefinition  2.bean工厂的后置处理器调用invokeBeanFactoryPostProcessors(beanFactory);// 注册我们bean的后置处理器registerBeanPostProcessors(beanFactory);// 初始化国际化资源处理器.initMessageSource();// 创建事件多播器initApplicationEventMulticaster();// 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomcat的.onRefresh();//把我们的事件监听器注册到多播器上registerListeners();// 实例化我们剩余的单实例bean.finishBeanFactoryInitialization(beanFactory);// 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)finishRefresh();}}}

4,BeanFactory和FactoryBean的区别

BeanFactoy是一个大的容器接口,ApplicationContext是其具体的实现接口,主要用于创建和获取对象,使用这个BeanFacory的时候必须遵循完整的创建的过程,这个过程是由spring来控制管理的。

FactoryBean只需要调用getObject就可以返回具体的对象,整个对象的创建过程是由用户自己来控制的,更加灵活,也可以用来创建一些特殊的bean,更加复杂的bean。在这个FactoryBean对象中,主要有三个方法,分别是:IsSingleton、getObject、getObjectType 这三个方法,使用的最频繁的就是getObject这个方法。

preInstantiateSingletons 的这个方法中,有一段判断逻辑如下,判断这个bean是不是工厂bean

//是不是工厂beanif(isFactoryBean(beanName)){...}

如果不获取该对象,那么该对象具体的值是看不见的,因为该对象没有提前创建。接下来再看一段代码,一个实体类实现这个bean工厂,再创建一个老师对象和学生对象的实体类

/**
 * @author zhenghuisheng
 * @date : 2023/5/29
 */@ComponentpublicclassTeacherFactoryimplementsFactoryBean<Teacher>{@OverridepublicTeachergetObject()throwsException{returnnewTeacher();}@OverridepublicClass<?>getObjectType(){returnTeacher.class;}}

接下来通过上下文获取这个工厂中的实体类,查看结果如下

//获取上下文容器对象ApplicationContext context =newAnnotationConfigApplicationContext(MainCofig.class);//返回的是学生对象Student stu =(Student)context.getBean("teacherFactory");//返回的是老师的对象,不能强转成学生,代码运行会报错Student stu =(Student)context.getBean("&teacherFactory");
//获取上下文容器对象ApplicationContext context =newAnnotationConfigApplicationContext(MainCofig.class);//返回的是学生对象Student stu =(Student)context.getBean("teacherFactory");//返回的是老师的对象,不能强转成学生,代码运行会报错Student stu =(Student)context.getBean("&teacherFactory");

也就是说可以通过这个FactoryBean返回的对象不是当前对象,也可以通过这个

&

获取原来的值,可以使得获取值的方式更加的灵活。而使用这个FactoryBean的意义就是:只需要通过重写这个getObject方法就可以获取到对应的bean对象,而不需要完全遵守这个bean的生命周期


本文转载自: https://blog.csdn.net/zhenghuishengq/article/details/130940885
版权归原作者 huisheng_qaq 所有, 如有侵权,请联系我们删除。

“【spring源码系列-01】spring底层源码整体概述”的评论:

还没有评论