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

时间：2022-04-02 16:54:31

一、前言

一共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 循环依赖，咱们可以看看实际执行效果：

 1 package com.ckl.littlespring;  2 
 3 import com.ckl.littlespring.annotation.Autowired;  4 import com.ckl.littlespring.annotation.Component;  5 import lombok.Getter;  6 import lombok.Setter;  7 
 8 @Getter  9 @Setter 10 @Component 11 public class Coder { 12     private String name = "xiaoming"; 13 
14     private String sex; 15 
16     private String love; 17     /**
18  * 女朋友 19      */
20  @Autowired 21     private com.ckl.littlespring.Girl girl; 22 
23 
24 }

 

 1 package com.ckl.littlespring;  2 
 3 import com.ckl.littlespring.annotation.Autowired;  4 import com.ckl.littlespring.annotation.Component;  5 import com.coder.SaxTest;  6 import lombok.Data;  7 
 8 
 9 @Data 10 @Component 11 public class Girl { 12     private String name = "catalina"; 13     private String height; 14     private String breast; 15     private String legLength; 16 
17     private Boolean isPregnant; 18 
19  @Autowired 20     private com.ckl.littlespring.Coder coder; 21 
22 
23 
24 }

 

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

 

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

 

2、BeanDefinitionRegistry 初始化

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

 

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

 

3、 BeanDefinitionParser 初始化

 1 @Data  2 public class BeanDefinitionParser {  3     /**
 4  * xml 解析器  5      */
 6     private Digester digester;  7 　　
 8     private String configFileLocation;  9 
10     
11     private List<MyBeanDefiniton> myBeanDefinitonList = new ArrayList<>(); 12 
13 
14 
15     public BeanDefinitionParser(String configFileLocation) { 16         this.configFileLocation = configFileLocation; 17         digester = new Digester(); 18  } 19 }

 

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

 

4、refresh 方法解析

初始化完成后，调用BeanDefinitionRegistry 的 refresh 解析：

 1     public void refresh() {  2         /**
 3  * 判断是否已经解析完成bean定义。如果没有完成，则先进行解析  4          */
 5         if (!hasBeanDefinitionParseOver) {  6 parser.parse();  7             hasBeanDefinitionParseOver = true;  8  }  9 
10         /**
11  * 初始化所有的bean，完成自动注入 12          */
13         for (MyBeanDefiniton beanDefiniton : getBeanDefinitions()) { 14  getBean(beanDefiniton); 15  } 16     }

 

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

 1 /**
 2  * 根据指定规则，解析xml  3      */
 4     public void parse() {  5         digester.setValidating(false);  6         digester.setUseContextClassLoader(true);  7 
 8         // Configure the actions we will be using
 9         digester.addRule("beans/component-scan", 10 new ComponentScanRule(this)); 11 
12         InputSource inputSource = null; 13         InputStream inputStream = null; 14         try { 15             inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(configFileLocation); 16             inputSource = new InputSource(inputStream); 17  inputSource.setByteStream(inputStream); 18 Object o = digester.parse(inputSource); 19  System.out.println(o); 20         } catch (Exception e) { 21  e.printStackTrace(); 22  } 23     }

 

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

我们看看 ComponentScanRule 的实现：

 1 package com.ckl.littlespring.parser;  2 
 3 import org.apache.commons.digester3.Rule;  4 import org.xml.sax.Attributes;  5 
13 public class ComponentScanRule extends Rule { 14 
15     private String basePackage; 16 
17     private BeanDefinitionParser beanDefinitionParser; 18 
19     public ComponentScanRule(BeanDefinitionParser beanDefinitionParser) { 20         this.beanDefinitionParser = beanDefinitionParser; 21  } 22 
23  @Override 24     public void begin(String namespace, String name, Attributes attributes) throws Exception { 25 basePackage = attributes.getValue("base-package"); 26 beanDefinitionParser.doScanBasePackage(basePackage); 27  } 28 
29  @Override 30     public void end(String namespace, String name) throws Exception { 31 
32  } 33 }

 

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

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

 

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

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

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

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

 

先看看 BeanDefinition 的定义：

 1 package com.ckl.littlespring.parser;  2 
 3 import lombok.Data;  4 
 5 import java.lang.reflect.Field;  6 import java.util.List;  7 
 8 
 9 @Data 10 public class MyBeanDefiniton { 11 
12     /**
13  * bean的名字，默认使用类名，将首字母变成小写 14      */
15     private String beanName; 16 
17     /**
18  * bean的类型 19      */
20     private String beanType; 21 
22     /**
23  * bean的class 24      */
25     private Class<?> beanClazz; 26 
27     /**
28  * field依赖的bean 29      */
30     private List<Field> dependencysByField; 31 
32 
33 }

 

就几个属性，相当简单，下面看 BeanDefinitionUtil.convert2BeanDefinition：

 1  public static MyBeanDefiniton convert2BeanDefinition(Class<?> clazz){  2         MyBeanDefiniton definiton = new MyBeanDefiniton();  3         String name = clazz.getName();  4         definiton.setBeanName(name.substring(0,1).toLowerCase() + name.substring(1));  5  definiton.setBeanType(clazz.getCanonicalName());  6  definiton.setBeanClazz(clazz);  7 
 8         Field[] fields = clazz.getDeclaredFields();  9         if (fields == null || fields.length == 0){ 10             return definiton; 11  } 12 
13         ArrayList<Field> list = new ArrayList<>(); 14  list.addAll(Arrays.asList(fields)); 15         List<Field> dependencysField = list.stream().filter(field -> field.getAnnotation(Autowired.class) != null).collect(Collectors.toList()); 16 definiton.setDependencysByField(dependencysField); 17 
18         return definiton; 19     }

 

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

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

 

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

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

 1 public void refresh() {  2         /**
 3  * 判断是否已经解析完成bean定义。如果没有完成，则先进行解析  4          */
 5         if (!hasBeanDefinitionParseOver) {  6  parser.parse();  7             hasBeanDefinitionParseOver = true;  8  }  9 
10         /**
11  * 初始化所有的bean，完成自动注入 12          */
13         for (MyBeanDefiniton beanDefiniton : getBeanDefinitions()) { 14  getBean(beanDefiniton); 15  } 16     }

 

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

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

 

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

 1 /**
 2  * 根据bean 定义获取bean  3  * 1、先查bean容器，查到则返回  4  * 2、生成bean，放进容器（此时，依赖还没注入，主要是解决循环依赖问题）  5  * 3、注入依赖  6  *  7  * @param beanDefiniton  8  * @return
 9      */
10     private Object getBean(MyBeanDefiniton beanDefiniton) { 11         Class<?> beanClazz = beanDefiniton.getBeanClazz(); 12         Object bean = beanMapByClass.get(beanClazz); 13         if (bean != null) { 14             return bean; 15  } 16 
17         //没查到的话，说明还没有，需要去生成bean，然后放进去
18         try { 19             bean = beanClazz.newInstance(); 20         } catch (InstantiationException | IllegalAccessException e) { 21  e.printStackTrace(); 22             return null; 23  } 24 
25         // 先行暴露，解决循环依赖问题
26  beanMapByClass.put(beanClazz, bean); 27 
28         //注入依赖，如果没有依赖的field，直接返回
29         List<Field> dependencysByField = beanDefiniton.getDependencysByField(); 30         if (dependencysByField == null) { 31             return bean; 32  } 33 
34         for (Field field : dependencysByField) { 35             try { 36 autowireField(beanClazz, bean, field); 37             } catch (Exception e) { 38                 throw new RuntimeException(beanClazz.getName() + " 创建失败",e); 39  } 40  } 41 
42         return bean; 43     }

 

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

 1 private void autowireField(Class<?> beanClazz, Object bean, Field field) {  2         Class<?> fieldType = field.getType();  3         List<MyBeanDefiniton> beanDefinitons = getBeanDefinitions();  4         if (beanDefinitons == null) {  5             return;  6  }  7 
 8         // 根据类型去所有beanDefinition看，哪个类型是该类型的子类;把满足的都找出来
 9         List<MyBeanDefiniton> candidates = beanDefinitons.stream().filter(myBeanDefiniton -> { 10 return fieldType.isAssignableFrom(myBeanDefiniton.getBeanClazz()); 11  }).collect(Collectors.toList()); 12 
13         if (candidates == null || candidates.size() == 0) { 14             throw new RuntimeException(beanClazz.getName() + "根据类型自动注入失败。field:" + field.getName() + " 无法注入，没有候选bean"); 15  } 16         if (candidates.size() > 1) { 17             throw new RuntimeException(beanClazz.getName() + "根据类型自动注入失败。field:" + field.getName() + " 无法注入，有多个候选bean" + candidates); 18  } 19 
20         MyBeanDefiniton candidate = candidates.get(0); 21  Object fieldBean; 22         try { 23             // 递归调用
24 fieldBean = getBean(candidate); 25             field.setAccessible(true); 26  field.set(bean, fieldBean); 27         } catch (Exception e) { 28             throw new RuntimeException("注入属性失败:" + beanClazz.getName() + "##" + field.getName(), e); 29  } 30 
31 
32     }

 

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

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

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

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

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

 

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

1     /**
2  * 根据类型获取bean对象 3  * 4  * @param clazz 5  * @return
6      */
7     public Object getBeanByType(Class clazz) { 8         return beanMapByClass.get(clazz); 9     }

 

 

 四、总结

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

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

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

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

标签：

相关文章