曹工说Tomcat4:利用 Digester 手撸一个轻量的 Spring IOC容器

时间:2022-03-10 01:42:21

一、前言

一共8个类,撸一个IOC容器。当然,我们是很轻量级的,但能够满足基本需求。想想典型的 Spring 项目,是不是就是各种Service/DAO/Controller,大家互相注入,就组装成了我们的业务bean,然后再加上 Spring MVC,再往容器里一放,基本齐活。

我们这篇文章,就是要照着 spring 来撸一个 相当简单的 IOC 容器,这个容器可以完成以下功能:

1、在 xml 配置文件里配置 bean 的扫描路径,语法目前只支持 component-scan,但基本够用了;

2、Bean 用 Component 注解,bean 中属性可以用 Autowired 来进行自动注入。

3、可以解决循环依赖问题。

bean的长相,基本就是下面这样:

@Data
@Component
public class Girl {
private String name = "catalina";
private String height;
private String breast;
private String legLength; private Boolean isPregnant; @Autowired
private com.ckl.littlespring.Coder coder;
}

  

xml,长下面这样:

<?xml version="1.0" encoding="UTF-8"?>
<beans>
<component-scan base-package="com.ckl.littlespring"/>
</beans>

二、思路

1、要解析xml,这个可以用Tomcat Digester 实现,这个是神器,用这个基本解决了读配置文件的问题;

2、读取xml配置的包名下的所有class,这个可以参考Spring,我是在网上找的一个工具类,反正就是利用类加载器获取classpath下的jar、class等,然后根据包名来过滤;

3、从第二步获取的class集合中,过滤出来注解了 @Component 的类,并利用反射读取其name、type、field集合等,其中field集合需要把带有 @Autowired 的过滤出来,用所有这些信息,构造一个 BeanDefinition 对象,放到 BeanDefinition 集合;

4、遍历第三步的BeanDefinition集合,根据 BeanDefinition 生成 Bean,如果该 BeanDefinition 中的field依赖了其他bean,则递归处理,获取到 field 后,反射设置到 bean中。

三、实现

1、代码结构、效果展示

强烈建议大家直接把代码拉下来跑,跑一跑,打个断点,几乎都不用看我写的了。源码路径:

https://github.com/cctvckl/tomcat-saxtest/blob/master/src/main/java/com/ckl/littlespring/TestLittleSpring.java

代码结构如下图:

曹工说Tomcat4:利用 Digester 手撸一个轻量的 Spring IOC容器

大家看上图,测试类中,主要是 new了 BeanDefinitionRegistry,这个就是我们的 bean 容器,可理解为 Spring 里面的 org.springframework.beans.factory.support.DefaultListableBeanFactory,当然,我们的是玩具而已。该类的构造函数,接收一个参数,就是配置文件的位置,默认会去classpath下查找该文件。bean 容器生成后,我们手动调用 refresh 来初始化容器,并生成 bean。 最后,我们既可以通过  getBeanByType(Class clazz) 来获取想要的 bean了。

在测试代码中,Girl 和 Coder 循环依赖,咱们可以看看实际执行效果:

 package com.ckl.littlespring;

 import com.ckl.littlespring.annotation.Autowired;
import com.ckl.littlespring.annotation.Component;
import lombok.Getter;
import lombok.Setter; @Getter
@Setter
@Component
public class Coder {
private String name = "xiaoming"; private String sex; private String love;
/**
* 女朋友
*/
@Autowired
private com.ckl.littlespring.Girl girl; }
 package com.ckl.littlespring;

 import com.ckl.littlespring.annotation.Autowired;
import com.ckl.littlespring.annotation.Component;
import com.coder.SaxTest;
import lombok.Data; @Data
@Component
public class Girl {
private String name = "catalina";
private String height;
private String breast;
private String legLength; private Boolean isPregnant; @Autowired
private com.ckl.littlespring.Coder coder; }

曹工说Tomcat4:利用 Digester 手撸一个轻量的 Spring IOC容器

可以看到,没什么问题,好了,接下来,看实现,我们按初始化--》使用的步骤来。

2、BeanDefinitionRegistry 初始化

    /**
* bean定义解析器
*/
private BeanDefinitionParser parser; public BeanDefinitionRegistry(String configFileLocation) {
parser = new BeanDefinitionParser(configFileLocation);
}

该bean容器中,构造函数中,将配置文件直接传给了解析器,解析器 BeanDefinitionParser 会真正负责从 xml 文件内读取 BeanDefinition。

3、 BeanDefinitionParser 初始化

 @Data
public class BeanDefinitionParser {
/**
* xml 解析器
*/
private Digester digester;
  
private String configFileLocation; private List<MyBeanDefiniton> myBeanDefinitonList = new ArrayList<>(); public BeanDefinitionParser(String configFileLocation) {
this.configFileLocation = configFileLocation;
digester = new Digester();
}
}

BeanDefinitionParser 中一共三个field,一个为配置文件位置,一个为Tomcat Digester,一个用于存储解析到的 BeanDefinition。Tomcat Digester用于解析 xml,这个一会实际的解析过程我们再说它。构造函数中,主要是给配置文件赋值,以及生成 Digester实例。

4、refresh 方法解析

初始化完成后,调用BeanDefinitionRegistry 的 refresh 解析:

     public void refresh() {
/**
* 判断是否已经解析完成bean定义。如果没有完成,则先进行解析
*/
if (!hasBeanDefinitionParseOver) {
6 parser.parse();
hasBeanDefinitionParseOver = true;
} /**
* 初始化所有的bean,完成自动注入
*/
for (MyBeanDefiniton beanDefiniton : getBeanDefinitions()) {
getBean(beanDefiniton);
}
}

这里,关注第6行,因为是首次解析,所以要进入BeanDefinitionParser .parse方法。

 /**
* 根据指定规则,解析xml
*/
public void parse() {
digester.setValidating(false);
digester.setUseContextClassLoader(true); // Configure the actions we will be using
digester.addRule("beans/component-scan",
10 new ComponentScanRule(this)); InputSource inputSource = null;
InputStream inputStream = null;
try {
inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(configFileLocation);
inputSource = new InputSource(inputStream);
inputSource.setByteStream(inputStream);
18 Object o = digester.parse(inputSource);
System.out.println(o);
} catch (Exception e) {
e.printStackTrace();
}
}

先关注第9、10行,配置解析规则,在解析xml时,遇到 beans元素下的component-scan时,则回调 ComponentScanRule 的规则。第18行,真正开始解析xml。

我们看看 ComponentScanRule 的实现:

 package com.ckl.littlespring.parser;

 import org.apache.commons.digester3.Rule;
import org.xml.sax.Attributes; public class ComponentScanRule extends Rule { private String basePackage; private BeanDefinitionParser beanDefinitionParser; public ComponentScanRule(BeanDefinitionParser beanDefinitionParser) {
this.beanDefinitionParser = beanDefinitionParser;
} @Override
public void begin(String namespace, String name, Attributes attributes) throws Exception {
25 basePackage = attributes.getValue("base-package");
26 beanDefinitionParser.doScanBasePackage(basePackage);
} @Override
public void end(String namespace, String name) throws Exception { }
}

关注25/26行,这里从xml中获取属性 base-package,然后再调用 com.ckl.littlespring.parser.BeanDefinitionParser#doScanBasePackage 来进行处理。

 /**
* 当遇到component-scan元素时,该函数被回调,解析指定包下面的bean 定义,并加入bean 定义集合
* @param basePackage
*/
public void doScanBasePackage(String basePackage) {
Set<Class<?>> classSet = ClassUtil.getClasses(basePackage); if (classSet == null) {
return;
} //过滤出带有Component注解的类,并将其转换为beanDefinition
List<Class<?>> list = classSet.stream().filter(clazz -> clazz.getAnnotation(Component.class) != null).collect(Collectors.toList()); for (Class<?> clazz : list) {
MyBeanDefiniton myBeanDefiniton = BeanDefinitionUtil.convert2BeanDefinition(clazz);
myBeanDefinitonList.add(myBeanDefiniton);
} }

以上方法执行结束时,basePackage下的被 Component 注解的 class就收集完毕。具体怎么实现的?

1、调用  ClassUtil.getClasses(basePackage); 来获取指定包下面的全部class

2、从第一步的集合中,过滤出带有 Component 注解的class

3、利用 工具类 BeanDefinitionUtil.convert2BeanDefinition,从class 中提取 bean 定义的各类属性。

先看看 BeanDefinition 的定义:

 package com.ckl.littlespring.parser;

 import lombok.Data;

 import java.lang.reflect.Field;
import java.util.List; @Data
public class MyBeanDefiniton { /**
* bean的名字,默认使用类名,将首字母变成小写
*/
private String beanName; /**
* bean的类型
*/
private String beanType; /**
* bean的class
*/
private Class<?> beanClazz; /**
* field依赖的bean
*/
private List<Field> dependencysByField; }

就几个属性,相当简单,下面看 BeanDefinitionUtil.convert2BeanDefinition:

  public static MyBeanDefiniton convert2BeanDefinition(Class<?> clazz){
MyBeanDefiniton definiton = new MyBeanDefiniton();
String name = clazz.getName();
definiton.setBeanName(name.substring(0,1).toLowerCase() + name.substring(1));
definiton.setBeanType(clazz.getCanonicalName());
definiton.setBeanClazz(clazz); Field[] fields = clazz.getDeclaredFields();
if (fields == null || fields.length == 0){
return definiton;
} ArrayList<Field> list = new ArrayList<>();
list.addAll(Arrays.asList(fields));
List<Field> dependencysField = list.stream().filter(field -> field.getAnnotation(Autowired.class) != null).collect(Collectors.toList());
16 definiton.setDependencysByField(dependencysField); return definiton;
}

最重要的就是第 15/16行,从所有的 field 中获取 带有 autowired 注解的field。这些 field 都是需要进行自动注入的。

执行完以上这些后,com.ckl.littlespring.parser.BeanDefinitionParser#myBeanDefinitonList 就持有了所有的 BeanDefinition。 下面就开始进行自动注入了,let's go!

5、bean初始化,完成自动注入

我们接下来,再看一下 BeanDefinitionRegistry 中的refresh,上面我们完成了 parser.parse 方法,此时,BeanDefinitionParser#myBeanDefinitonList 已经准备就绪了。

 public void refresh() {
/**
* 判断是否已经解析完成bean定义。如果没有完成,则先进行解析
*/
if (!hasBeanDefinitionParseOver) {
parser.parse();
hasBeanDefinitionParseOver = true;
} /**
* 初始化所有的bean,完成自动注入
*/
for (MyBeanDefiniton beanDefiniton : getBeanDefinitions()) {
getBean(beanDefiniton);
}
}

我们要关注的是,第13行,getBeanDefinitions()主要是从 parser 中获取 BeanDefinition 集合。因为是内部使用,我们定义为private。

     private List<MyBeanDefiniton> getBeanDefinitions() {
return parser.getBeanDefinitions();
}

然后,我们关注第14行,getBean 会真正完成 bean 的创建,如果有依赖的field,则会进行注入。

 /**
* 根据bean 定义获取bean
* 1、先查bean容器,查到则返回
* 2、生成bean,放进容器(此时,依赖还没注入,主要是解决循环依赖问题)
* 3、注入依赖
*
* @param beanDefiniton
* @return
*/
private Object getBean(MyBeanDefiniton beanDefiniton) {
Class<?> beanClazz = beanDefiniton.getBeanClazz();
Object bean = beanMapByClass.get(beanClazz);
if (bean != null) {
return bean;
} //没查到的话,说明还没有,需要去生成bean,然后放进去
try {
bean = beanClazz.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
return null;
} // 先行暴露,解决循环依赖问题
beanMapByClass.put(beanClazz, bean); //注入依赖,如果没有依赖的field,直接返回
List<Field> dependencysByField = beanDefiniton.getDependencysByField();
if (dependencysByField == null) {
return bean;
} for (Field field : dependencysByField) {
try {
36 autowireField(beanClazz, bean, field);
} catch (Exception e) {
throw new RuntimeException(beanClazz.getName() + " 创建失败",e);
}
} return bean;
}

在这个方法里,我们主要就是,创建了 bean,并且放到了 容器中(一个hashmap,key是class,value就是对应的bean实例)。我们关注第36行,这里会进行field 的注入:

 private void autowireField(Class<?> beanClazz, Object bean, Field field) {
Class<?> fieldType = field.getType();
List<MyBeanDefiniton> beanDefinitons = getBeanDefinitions();
if (beanDefinitons == null) {
return;
} // 根据类型去所有beanDefinition看,哪个类型是该类型的子类;把满足的都找出来
List<MyBeanDefiniton> candidates = beanDefinitons.stream().filter(myBeanDefiniton -> {
10 return fieldType.isAssignableFrom(myBeanDefiniton.getBeanClazz());
}).collect(Collectors.toList()); if (candidates == null || candidates.size() == 0) {
throw new RuntimeException(beanClazz.getName() + "根据类型自动注入失败。field:" + field.getName() + " 无法注入,没有候选bean");
}
if (candidates.size() > 1) {
throw new RuntimeException(beanClazz.getName() + "根据类型自动注入失败。field:" + field.getName() + " 无法注入,有多个候选bean" + candidates);
} MyBeanDefiniton candidate = candidates.get(0);
Object fieldBean;
try {
// 递归调用
24 fieldBean = getBean(candidate);
field.setAccessible(true);
field.set(bean, fieldBean);
} catch (Exception e) {
throw new RuntimeException("注入属性失败:" + beanClazz.getName() + "##" + field.getName(), e);
} }

这里,我们先看第10行,我们要根据field 的 类型,看看当前的bean 容器中有没有 field 类型的bean,比如我们的 field 的类型是个接口,那我们就会去看有没有实现类。

这里有两个异常可能会抛出,如果一个都没找到,无法注入;如果找到了多个,我们也判断为无法注入。(基础版本,暂没考虑 spring 中的 qualifier 注解)

最后,我们在第24行,根据找到的 beanDefinition 查找 bean,这里是个递归调用。 找到之后,会设置到 对应的 field 中。

注意的是,该递归的终结条件就是,该 bean 没有依赖需要注入。 完成所有这些步骤后,我们的 bean 都注册到了 BeanDefinitionRegistry#beanMapByClass 中。

     /**
* map:存储 bean的class-》bean实例
*/
private Map<Class, Object> beanMapByClass = new ConcurrentHashMap<>();

后续,只需要根据class来查找对应的bean即可。

     /**
* 根据类型获取bean对象
*
* @param clazz
* @return
*/
public Object getBeanByType(Class clazz) {
return beanMapByClass.get(clazz);
}

四、总结

一个简易的ioc,大概就是这样子了。后边有时间,再把 aop 的功能加进去。当然,加进去了依然是玩具,我们造*的意义在哪里呢?大概就是让你更懂我们现在在用的*,知道它的核心代码大概是什么样子的。我们虽然大部分时候都是api 调用者,写点胶水,但是真正出问题的时候,当框架不满足的时候,我们还是得有搞定问题和扩展框架的能力。

个人水平也很有限,大家可以批评指正,欢迎加入下发二维码的 Java 交流群一起沟通学习。

源码在github,链接在上文发过了哈。

参考的工具类链接:https://www.cnblogs.com/Leechg/p/10058763.html  其中有可以优化的空间,不过用着还是不错。