java v.5 起点,逐行阅读Spring5.X源码（一） BeanDefinition，起点

最新推荐文章于 2024-06-12 16:06:59 发布

亜恵恵阿由

最新推荐文章于 2024-06-12 16:06:59 发布

阅读量165

点赞数

文章标签： java v.5 起点

本篇博客你讲学到：

1. 如何理解BeanDefinition

2. 准备环境

3. BeanDefinition接口讲解

4. BeanDefinition的类继承关系

5. IOC的引出

6. BeanFactory工厂的引出

7. 后置处理器的引出

8. spring扩展性初探

1、为什么从BeanDefinition讲起？

spring源码太庞大了，精通spring源码确实不容易，讲懂更难。学习spring源码是件浩大的工程。很多读者从spring容器启动开始逐行debug源码进行分析，刚开始很容易理解，但是当你逐层debug源码深处时，就会感慨“身在此山中，不识真面目”。笔者在刚开始的时候也经历过这种痛苦，精读几遍之后笔者觉着spring源码不能从头读起，我们需要先搞懂spring中的基础组件及组件之间的关系，这就好比组装电脑，你得先了解CPU作用、内存的作用、主板的作用、硬盘的作用，然后你才知道如何讲他们组装到一起，从头阅读源码就跟你让一个学金融专业的学生组装电脑一样，效果可想而知。

c5bd8e5f0a66

image

如果我问你spring的作用？想必大部分程序员都会回答“管理对象，方便开发”。中国不缺程序员，缺的是有思想有深度的工程师，别人写的叫程序，你写的那叫BUG。不错，java一切皆对象，spring封装管理你所创建的对象，封装后的对象叫bean，bean扩展了你的对象，你所创建的对象的所有属性和方法是bean中的一个子集。spring所有的功能都是围绕这个bean展开的。这个bean在spring中具体的名字就是BeanDefinition。

怎么理解BeanDefinition?

假如你编写一个Person.java文件，编译成Persion.class文件后，jvm会将这个class文件加载到虚拟机内存(方法区)，程序在当遇到new关键字的时候根据class在堆内生成对象。class文件已经生成了，spring无法更改你的class，但还要扩展你的class怎么办？很简单，spring定义一个BeanDefinition类进一步封装Person类，最后注册到spring容器中。所以， Person只是BeanDefinition中的一个属性，就这么简单。BeanDefinition中还会封装跟Person相关的其他属性，比如bean的作用域，bean的注入模型，bean是否是懒加载等等信息。BeaDefiniton结构类似于：

c5bd8e5f0a66

image

对象和bean的对比如下图，编译对应封装，加载对应注册。Person.class是JVM的class，而BeanDefinition就是Spring中的class。专业一点讲，在JDK中使用java.lang.Class来描述类这个对象，Spring使用BeanDefinition来描述bean。

c5bd8e5f0a66

image

如果你不了解对象这个概念，那你就写不了java程序。同理，如果你不了解BeanDefinition你就读不懂Spring源码。这就是笔者为什么先讲解BeanDefinition。很多读者都下过决心精读spring源码，刚开始热情高涨，读着读着就不耐烦了，什么乱七八糟的不读了，感觉会用就行，你跟架构师就这么越来越远了。我觉着是方法不对。那就跟随笔者的脚步，逐行分析spring源码，毕竟这是你迈向java架构师必须逾越的鸿沟！

在开始之前说清楚，beanDefintion的比较枯燥和晦涩难懂，但是非常非常重要。如果你想精读spring源码，请你一定细读三遍beanDefintion的知识，他是spring framework当中的基石，你避不开！

2、准备环境

开发工具

IDEA + MAVEN + JDK1.8

导入依赖

org.springframework

spring-context

5.1.7.RELEASE

org.projectlombok

lombok

1.16.18

配置类

//包扫描

@ComponentScan("com")

//@ImportResource("applicationContext.xml")//使用xml文件而非注解的方式进行启动

public class Config {

}

xml配置文件applicationContext.xml

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"

xml方式启动属实用的不多了已经，xml最大的作用就是依赖注入(以后再将，可忽略)，笔者在后续讲解中基本以注解方式进行讲解。

业务类

@Component

@Description("业务类")

@Scope("singleton")

public class InterService {

private String name;

private int age;

}

测试类

public class SpringTest {

public static void main(String[] args) throws InterruptedException {

//以下三行代码完成了spring的启动

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

//加载或者刷新当前的配置信息

context.refresh();;

}

以上代码均放在com包下。

3、BeanDefinition讲解

spring启动会完成很多工作，不可能在专题第一篇就把整个启动流程讲清楚，为了引出BeanDefinition，笔者讲解三个过程：

扫描

spring首先根据Config 的注解@ComponentScan("com")扫描com包下符合规则的类，这里只有InterService类；

解析

解析InterService类，主要是拿到所有的注解@Component、@Description("业务类")、@Scope("singleton")

封装

解析完的信息保存到哪里里去呢？就存在BeanDefinition中。不然存哪里？存InterService类中吗？此时回过头读读文章第一节“为什么从BeanDefinition讲起”就知道BeanDefinition的重要性了吧。BeanDefinition就是对你的InterService进行建模。

其实，BeanDefinition只是一个接口：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

//InterService的scope值，单例

String SCOPE_SINGLETON = "singleton";

//InterService的scope值，非单例

String SCOPE_PROTOTYPE = "prototype";

//Bean角色：

//用户

int ROLE_APPLICATION = 0;

//某些复杂的配置

int ROLE_SUPPORT = 1;

//完全内部使用

int ROLE_INFRASTRUCTURE = 2;

//返回此InterService的的父bean定义的名称，如果有的话 (xml配置文件中的bean配置)

String getParentName();

void setParentName(String var1);

//设置或获取业务类全路径名

void setBeanClassName(String var1);

String getBeanClassName();

//InterService的scope值

void setScope(String var1);

String getScope();

//InterService的懒加载设置及获取

void setLazyInit(boolean var1);

boolean isLazyInit();

//InterService的依赖对象，表示InterService实例创建前应该先创建哪个对象

void setDependsOn(String... var1);

String[] getDependsOn();

//是否为被自动装配

void setAutowireCandidate(boolean var1);

boolean isAutowireCandidate();

//如果是被自动装配，是否为主候选bean

void setPrimary(boolean var1);

boolean isPrimary();

//定义创建该Bean对象的工厂类

void setFactoryBeanName(String var1);

String getFactoryBeanName();

//定义创建该Bean对象的工厂方法

void setFactoryMethodName(String var1);

String getFactoryMethodName();

//返回此InterService的构造函数参数值。

ConstructorArgumentValues getConstructorArgumentValues();

//获取普通属性集合

MutablePropertyValues getPropertyValues();

//是否为单例

boolean isSingleton();

//是否为原型

boolean isPrototype();

//是否为抽象类

boolean isAbstract();

//获取这个bean的应用

int getRole();

//返回对bean定义的可读描述。

String getDescription();

//返回该bean定义来自的资源的描述(用于在出现错误时显示上下文)

String getResourceDescription();

BeanDefinition getOriginatingBeanDefinition();

}

通过BeanDefinition接口可以对InterService的附加属性进行设置和获取，虽然目前不能完全搞懂所有属性及方法，但笔者仍然建议读者把这个接口代码都看一遍。在这里建议大家读源码一定要“慢下来”，一点一点的啃，切忌浮躁，这个痛苦的过程过去了你会有种高屋建瓴的感觉！那感觉，指点江山！

光读不行，还得写代码调试从而增加印象，比如上面BeanDefinition接口中的方法我想验证一下，很简单，上代码：

public class SpringTest {

public static void main(String[] args) throws InterruptedException {

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

//加载或者刷新当前的配置信息

context.refresh();;

//获取InterService对应的BeanDefinition ，默认名称为interService，关于名字的更改以后讲。

BeanDefinition interServiceBeanDefinition = context.getBeanDefinition("interService");

System.out.println("——————InterService的附加属性如下：");

System.out.println("父类"+interServiceBeanDefinition.getParentName());

System.out.println("描述"+interServiceBeanDefinition.getDescription());

System.out.println("InterService在spring的名称"+interServiceBeanDefinition.getBeanClassName());

System.out.println("实例范围"+interServiceBeanDefinition.getScope());

System.out.println("是否是懒加载"+interServiceBeanDefinition.isLazyInit());

System.out.println("是否是抽象类"+interServiceBeanDefinition.isAbstract());

System.out.println("——————等等等等，读者自行编写");

}

打印结果：

c5bd8e5f0a66

image.png

注意，这些属性在xml配置文件中都能找到对应匹配的标签，读者可用xml配置文件自行进行配置，只需要将Config配置类上的@ImportResource("applicationContext.xml")注解打开即可。

既然BeanDefinition是个接口，那spring中肯定有他的实现类对不对，好，是时候看一下BeanDefinition的类继承图了。在这里笔者跟大家说一个问题，笔者发现很多人读源码的时候拿来一个类就读或者debug源码跟读，也不管这个类跟其他类的关系，读完后感觉很混乱，甚至吐槽spring源码写的毫无章法，拜托，spring源码是典型的面向接口编程，严格遵循开闭原则、依赖倒置原则和迪米特法则(软件设计7大基本原则，大家自行百度啦)，是spring源码写的差还是你的水平差？spring每一个模块都有一个完整的类继承关系图，不然spring被业界称赞的高扩展性谈何而来？所以我们必须将每个模块的类继承关系了然于胸。初学，我们也不可能将继承体系中的每个类都搞懂，把这个继承图下载下来存到桌面，在以后的源码阅读中这个继承关系会被你一一攻破，学完你也就掌握了，而且不会忘，更能提高你的编程水平，读完spring你会发现的编程风格潜移默化的被spring影响了！对吧。

BeanDefinition的继承关系：

c5bd8e5f0a66

image.png

突然间好想放弃有没有，像这种继承图，spring中太多了，我说了学习spring是项浩大的工程，现在放弃还来得及！说实话笔者文章写到这里停了好久，不知道从哪下手讲！

以前利用spring开发大都通过xml方式进行bean配置，其实spring框架开发之初并不想让程序员通过xml方式进行配置，而是通过代码让我们手动将InterService封装成对应的BeanDefinition，看下面的代码：

//首先，删掉业务类InterService所有的注解，不让他被扫描到(spring根据注解判断是否将类进行包装)

public class InterService {

private String name;

private int age;

}

public class SpringTest {

public static void main(String[] args) throws InterruptedException {

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

GenericBeanDefinition beanDefinition = new GenericBeanDefinition();

beanDefinition.setBeanClassName("com.InterService");

beanDefinition.setScope("singleton");

beanDefinition.setDescription("手动注入");

beanDefinition.setAbstract(false);

//将beanDefinition注册到spring容器中

context.registerBeanDefinition("interService",beanDefinition);

//加载或者刷新当前的配置信息

context.refresh();

BeanDefinition interServiceBeanDefinition = context.getBeanDefinition("interService");

System.out.println("——————InterService的附加属性如下：");

System.out.println("父类"+interServiceBeanDefinition.getParentName());

System.out.println("描述"+interServiceBeanDefinition.getDescription());

System.out.println("InterService在spring的名称"+interServiceBeanDefinition.getBeanClassName());

System.out.println("实例范围"+interServiceBeanDefinition.getScope());

System.out.println("是否是懒加载"+interServiceBeanDefinition.isLazyInit());

System.out.println("是否是抽象类"+interServiceBeanDefinition.isAbstract());

System.out.println("——————等等等等，读者自行编写");

}

其实笔者很喜欢这种代码方式完成spring配置工作，这样能让我们更深入的了解和应用spring，不过这种方式的缺点也很明显-繁琐易出错，spring为了简化我们的工作提供了xml配置方式，直到spring5.x注解方式的稳定成熟，spring全家桶得到了飞速的发展。但通过这个例子读者可以加深对BeanDefinition的理解。

IOC的引出

看上面这么一行代码:

context.registerBeanDefinition("interService",beanDefinition);

这行代码的意思是将我们手动封装的beanDefinition注册到容器中，同时给这个beanDefinition起了个名字“interService”，spring内部生成beanDefinitino时会默认起一个名字，改名字的规则就是业务类名字首字母小写。

那生成的BeanDefinition保存在哪里呢？既然我们是通过上面的方法将BeanDefinition注册到容器中，肯丢是在这个方法底层实现了保存，我们点进去看：

@Override

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

throws BeanDefinitionStoreException {

// 将beanDefinition保存到spring容器中

this.beanFactory.registerBeanDefinition(beanName, beanDefinition);

}

继续跟进registerBeanDefinition方法，找到下面这行代码：

.....以上代码省略，以后详解

this.beanDefinitionMap.put(beanName, beanDefinition);

顾名思义，beanDefinitionMap就是一个Map呀！具体是啥map，我们ctrl+鼠标左键单击找到beanDefinitionMap定义处：

/** Map of bean definition objects, keyed by bean name. */

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

还需要我解释这行代码吗？有人说需要，我不懂ConcurrentHashMap，好吧，这是java并发包java.util.concurrent下的集合类，它就是一个Map，但是支持多线程并发访问，为啥使用ConcurrentHashMap而不是用HashMap，嗨，建议你好好补下java高并发知识(后续我会写一个java高并发编程底层原理，让你吊打面试官，欢迎大家关注)。总之，这就是beanDefinition存储的容器，这行代码所在的类名叫DefaultListableBeanFactory，它是bean的工厂，spring中所有的对象或者说bean都存在这个bean工厂中，业界叫它IOC，很多书或者视频都会讲IOC，相信读者也知道IOC是容器，但它就是一堆Map集合而已，beanDefinitionMap 知识众多Map中的一个而已，以后我会将其他的map容器，今天你只需要只到这么一个存放BeanDefinition的容器即可。

这下你搞懂IOC了吧！全体起立！

有读者问，那DefaultListableBeanFactory这个bean工厂啥时候创建的，我说以后再讲！想必大家都想知道，那就了解一下吧！看代码：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

这是我们创建spring上下文对象，AnnotationConfigApplicationContext 类有一个父类，AnnotationConfigApplicationContext的无参构造函数执行时会默认调用父类无参构造函数(java基础知识)，AnnotationConfigApplicationContext 的父类如下：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

也就是GenericApplicationContext ，我们看一下他的构造函数：

public GenericApplicationContext() {

//初始化一个BeanFactory

this.beanFactory = new DefaultListableBeanFactory();

}

我不说话，静静的看着屏幕前的你思考的样子！也就是说，spring启动的时候就创建好了这个bean工厂！

咦？不是要将BeanDefinitino的继承关系码？怎么跑偏了？这就是spring的特点，太庞大了，没有孤立的知识点！这也是很多读者阅读spring源码时读着读着就蒙圈的原因。

后置处理器的引出

上文我们通过手动将InterService封装成了一个BeanDefinition然后注册(说好听了叫注册，起始就是map.put)到了容器中，我说了现在我们没有这么用的了，都是spring自动帮我们完成扫描注册，在哪完成的扫描注册？回到下面这几行代码：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

//加载或者刷新当前的配置信息

context.refresh();

context.refresh()方法，完成了spring的启动、扫描、解析、实例化等一系列过程，这个方法完成的功能太多了，我们的扫描注册也是在这里完成的，进入到这个方法，找到这么一行代码：

...以上省略

invokeBeanFactoryPostProcessors(beanFactory);

...以下省略

翻译一下名字，执行bean工厂的后置处理器，这行代码完成了扫描与注册，我不带大家分析里面的代码，你只需要知道他的作用就行，这行代码执行完成后，我们只是把业务类InterService封装成了BeanDefinition而已，业务类InterService并没有实例化，在业务类InterService实例化之前我们能不能从beanDefinition中将InterService偷梁换柱呢？或者说，我们能通过BeanDefinition来构建bean，那我们能不能修改bean呢？那必须的！

通过后置处理器完成，什么是后置处理器？可以把它理解成回调，我扫描注册成功后回调后置处理器！BeanDefinition讲完后紧接着就讲后置处理器。我们添加一个后置处理器：

/**

* 扫描注册成功完成后，spring自动调用后置处理器MyBeanFactoryPostProcessor的postProcessBeanFactory方法

@Component

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

@Override

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

throws BeansException {

//通过bean工厂拿到业务类InterService的beanDefinition

GenericBeanDefinition beanDefinition =

(GenericBeanDefinition) beanFactory.getBeanDefinition("interService");

System.out.println("扫描注册成功完成后，spring自动调用次方法");

System.out.println(beanDefinition.getDescription());

}

spring扫描注册完成后，会自动调用MyBeanFactoryPostProcessor的postProcessBeanFactory方法，这个方法给你传递了一个ConfigurableListableBeanFactory类型的bean工厂，ConfigurableListableBeanFactory是一个接口，上文spring启动实例化的DefaultListableBeanFactory工厂是它的实现类。天啊，竟然把bean工厂给你了，相当于敌人把军火库暴露在你面前，你岂不是想干嘛就干嘛！上述代码我们通过bean工厂拿到了业务类InterService的beanDefinition，我都拿到你的beanDefinition了，那么我不但可以get到你的信息，我也可以set你的信息从而改变你的行为来影响你后续的实例化。我们来编写另一个业务类：

public class User {

private int age =31;

private String name="myname";

}

spring启动时也会把这个业务类扫描，接下来，看好了，我在bean工厂中偷梁换柱，在beanDefinition中将你的InterService业务类替换掉：

/**

* 扫描注册成功完成后，spring自动调用后置处理器MyBeanFactoryPostProcessor的postProcessBeanFactory方法

@Component

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

@Override

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

throws BeansException {

GenericBeanDefinition beanDefinition =

(GenericBeanDefinition) beanFactory.getBeanDefinition("interService");

System.out.println(beanDefinition.getBeanClassName());

System.out.println("开始偷梁换柱");

beanDefinition.setBeanClass(User.class);

}

测试一下：

public class Test {

public static void main(String[] args) {

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

context.refresh();

System.out.println("更改后的业务类："+context.getBeanDefinition("interService").getBeanClassName());

}

打印结果：

c5bd8e5f0a66

image.png

what the f...

你以为，spring插件是怎么来的？你以为，为什么那么多框架都能集成到spring，就是利用spring的开放性这么扩展出来的，上文给你展示的只是冰山一角角，你不懂spring源码，你怎么扩展？当然，你会说我又不做框架开发插件开发，恩，我对你的CRUD表示尊重。

既然我们已经偷梁换柱把InterService替换掉了，那么spring在后续实例化过程中就不会实例化InterService，看下面代码：

public class Test {

public static void main(String[] args) {

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

//注册配置类

context.register(Config.class);

context.refresh();

System.out.println("更改后的业务类："+context.getBeanDefinition("interService").getBeanClassName());

//我们尝试获取InterService实例

context.getBean(InterService.class);

}

打印结果报错，因为InterService不存在spring当中了：

c5bd8e5f0a66

image.png

继续，看后置处理器中的这行代码：

GenericBeanDefinition beanDefinition =

(GenericBeanDefinition) beanFactory.getBeanDefinition("interService");

getBeanDefinition方法返回的BeanDefinition类型，为什么强转成GenericBeanDefinition，起始BeanDefinition接口中并没有setBeanClass这个方法，GenericBeanDefinition是他的实现，提供更丰富的功能。不同的BeanDefinition实现具有不同的作用。

下一篇我们详细讲一下不同BeanDefinition的作用，BeanDefinition学精通后你基本迈入了spring源码大门。