一、前言
一共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、代码结构、效果展示
强烈建议大家直接把代码拉下来跑，跑一跑，打个断点，几乎都不用看我写的了。源码路径：
代码结构如下图：
大家看上图，测试类中，主要是 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; }
可以看到，没什么问题，好了，接下来，看实现，我们按初始化--》使用的步骤来。
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 其中有可以优化的空间，不过用着还是不错。