手写一个HTTP框架:两个类实现基本的IoC功能
jsoncat: 仿 Spring Boot 但不同于 Spring Boot 的一个轻量级的 HTTP 框架
国庆节的时候,我就已经把 jsoncat 的 IoC 功能给写了,具体可以看这篇文章《手写“SpringBoot”近况:IoC模块已经完成》 。
今天这篇文章就来简单分享一下自己写 IoC 的思路与具体的代码实现。
IoC (Inverse of Control:控制反转) 和 AOP(Aspect-Oriented Programming:面向切面编程) 可以说是 Spring 框架提供的最核心的两个功能。但凡是了解过 Spring 的小伙伴,那肯定对这个两个概念非常非常了解。不了解的小伙伴,可以查看《面试被问了几百遍的 IoC 和 AOP ,还在傻傻搞不清楚?》这篇通俗易懂的文章。
考虑到这篇文章要手写 Spring 框架的 IoC 功能,所以,我这里还是简单介绍一下 IoC 。如果你不太清楚 IoC 这个概念,一定要搞懂之后再看后面具体的代码实现环节。
IoC 介绍
IoC(Inverse of Control:控制反转)是一种设计思想,也就是 将原本在程序中手动创建对象的控制权交由Spring框架来管理。 IoC 在其他语言中也有应用,并非 Spring 特有。
IoC 容器
IoC 容器是用来实现 IoC 的载体,被管理的对象就被存放在IoC容器中。IoC 容器在 Spring 中实际上就是个Map(key,value),Map 中存放了各种被管理的对象。
IoC 解决了什么问题
将对象之间的相互依赖关系交给 IoC 容器来管理,并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发,把应用从复杂的依赖关系中解放出来。 IoC 容器就像是一个工厂一样,当我们需要创建一个对象的时候,只需要配置好配置文件/注解即可,完全不用考虑对象是如何被创建出来的。 在实际项目中一个 Service 类可能有几百甚至上千个类作为它的底层,假如我们需要实例化这个 Service,你可能要每次都要搞清这个 Service 所有底层类的构造函数,这可能会把人逼疯。如果利用 IoC 的话,你只需要配置好,然后在需要的地方引用就行了,这大大增加了项目的可维护性且降低了开发难度。
IoC 和 DI 别再傻傻分不清楚
IoC(Inverse of Control:控制反转)是一种设计思想 或者说是某种模式。这个设计思想就是 将原本在程序中手动创建对象的控制权,交由 Spring 框架来管理。 IoC 在其他语言中也有应用,并非 Spring 特有。IoC 容器是 Spring 用来实现 IoC 的载体, IoC 容器实际上就是个 Map(key,value),Map 中存放的是各种被管理的对象。
IoC 最常见以及最合理的实现方式叫做依赖注入(Dependency Injection,简称 DI)。
并且,老马(Martin Fowler)在一篇文章中提到将 IoC 改名为 DI,原文如下,原文地址:https://martinfowler.com/articles/injection.html 。
IoC实现思路
📝注意 :以下思路未涉及解决循环依赖的问题!
开始代码实现之前,我们先简单聊聊实现 IoC 的思路,搞清楚了思路之后,实现起来就非常简单了。
- 扫描指定包下的特定注解比如
@Component
标记的类,并将这些类保存起来。 - 遍历所有被特定注解比如
@Component
标记的类,然后将这些类通过反射实例化并通过一个 Map 保存起来,Map 的 key 为类名,value为类对象。 - 再一次遍历所有被特定注解比如
@Component
标记的类,并获取类中所有的字段,如果类被@Autowired
注解标记的话,就进行第 4 步。 - 通过字段名 key,从bean容器中获取对应的对象 value。
- 判断获取到的对象是否为接口。如果是接口的话,需要获取接口对应的实现类,然后再将指定的实现类的实例化对象通过反射赋值给指定对象。如果不是接口的话,就直接将获取到的对象通过反射赋值给指定对象。
IoC 实现核心代码
核心注解
@Autowired
:注解对象
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
}
@Component
:声明对象被IoC容器管理
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
String name() default "";
}
@Qualifier
: 指定注入的bean(当接口有多个实现类的时候需要使用)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
String value() default "";
}
工具类
简单封装一个反射工具类。工具类包含3个后面会用到的方法:
scanAnnotatedClass()
:扫描指定包下的被指定注解标记的类(使用Reflections这个反射框架一行代码即可解决扫描获取指定注解的类)。newInstance()
: 传入 Class 即可返回 Class 对应的对象。setField()
:为对象的指定字段赋值。
@Slf4j
public class ReflectionUtil {
/**
* scan the classes marked by the specified annotation in the specified package
*
* @param packageName specified package name
* @param annotation specified annotation
* @return the classes marked by the specified annotation in the specified package
*/
public static Set<Class<?>> scanAnnotatedClass(String packageName, Class<? extends Annotation> annotation) {
Reflections reflections = new Reflections(packageName, new TypeAnnotationsScanner());
Set<Class<?>> annotatedClass = reflections.getTypesAnnotatedWith(annotation, true);
log.info("The number of class Annotated with @RestController :[{}]", annotatedClass.size());
return annotatedClass;
}
/**
* create object instance through class
*
* @param cls target class
* @return object created by the target class
*/
public static Object newInstance(Class<?> cls) {
Object instance = null;
try {
instance = cls.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
log.error("new instance failed", e);
}
return instance;
}
/**
* set the value of a field in the object
*
* @param obj target object
* @param field target field
* @param value the value assigned to the field
*/
public static void setField(Object obj, Field field, Object value) {
field.setAccessible(true);
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
log.error("set field failed", e);
e.printStackTrace();
}
}
}
根据实现思路写代码
📝注意 :以下代码未涉及解决循环依赖的问题!以下是 IoC 实现的核心代码,完整代码地址:https://github.com/Snailclimb/jsoncat 。
1.扫描指定包下的特定注解比如@Component
标记的类,并将这些类保存起来。
扫描指定注解@RestController
和@Component
并保存起来:
public class ClassFactory {
public static final Map<Class<? extends Annotation>, Set<Class<?>>> CLASSES = new ConcurrentHashMap<>();
//1.扫描指定包下的特定注解比如`@Component`标记的类,并将这些类保存起来
public static void loadClass(String packageName) {
Set<Class<?>> restControllerSets = ReflectionUtil.scanAnnotatedClass(packageName, RestController.class);
Set<Class<?>> componentSets = ReflectionUtil.scanAnnotatedClass(packageName, Component.class);
CLASSES.put(RestController.class, restControllerSets);
CLASSES.put(Component.class, componentSets);
}
}
2.遍历所有被特定注解比如@Component
标记的类,然后将这些类通过反射实例化并通过一个 Map 保存起来,Map 的 key 为类名,value为类对象。
public final class BeanFactory {
public static final Map<String, Object> BEANS = new ConcurrentHashMap<>(128);
public static void loadBeans() {
// 2.遍历所有被特定注解比如 @Component 标记的类,然后将这些类通过反射实例化并通过一个 Map 保存起来,Map 的 key 为类名,value为类对象
ClassFactory.CLASSES.forEach((annotation, classes) -> {
if (annotation == Component.class) {
//将bean实例化, 并放入bean容器中
for (Class<?> aClass : classes) {
Component component = aClass.getAnnotation(Component.class);
String beanName = "".equals(component.name()) ? aClass.getName() : component.name();
Object obj = ReflectionUtil.newInstance(aClass);
BEANS.put(beanName, obj);
}
}
if (annotation == RestController.class) {
for (Class<?> aClass : classes) {
Object obj = ReflectionUtil.newInstance(aClass);
BEANS.put(aClass.getName(), obj);
}
}
});
}
}
3.再一次遍历所有被特定注解比如@Component
标记的类,并获取类中所有的字段,如果类被 @Autowired
注解标记的话,就进行第 4 步。
public class DependencyInjection {
public static void dependencyInjection(String packageName) {
Map<String, Object> beans = BeanFactory.BEANS;
if (beans.size() == 0) return;
//3.再一次遍历所有被特定注解比如 @Component 标记的类,并获取类中所有的字段,如果类被 `@Autowired` 注解标记的话,就进行第 4 步。
// 3.1.遍历bean容器中的所有对象
beans.values().forEach(bean -> {
// 3.2.获取对象所属的类声明的所有字段/属性
Field[] beanFields = bean.getClass().getDeclaredFields();
if (beanFields.length == 0) return;
//3.3.遍历对象所属的类声明的所有字段/属性
for (Field beanField : beanFields) {
//3.4.判断字段是否被 @Autowired 注解标记
if (beanField.isAnnotationPresent(Autowired.class)) {
//4.通过字段名 key,从bean容器中获取对应的对象 value。
//4.1.字段对应的类型
Class<?> beanFieldClass = beanField.getType();
//4.2.字段对应的类名
String beanName = beanFieldClass.getName();
if (beanFieldClass.isAnnotationPresent(Component.class)) {
Component component = beanFieldClass.getAnnotation(Component.class);
beanName = "".equals(component.name()) ? beanFieldClass.getName() : component.name();
}
//4.3.从bean容器中获取对应的对象
Object beanFieldInstance = beans.get(beanName);
//5.判断获取到的对象是否为接口。如果是接口的话,需要获取接口对应的实现类,然后再将指定的实现类的实例化对象通过反射赋值给指定对象。如果不是接口的话,就直接将获取到的对象通过反射赋值给指定对象。
if (beanFieldClass.isInterface()) {
//如果是接口,获取接口对应的实现类
Set<Class<?>> subClasses = getSubClass(packageName, beanFieldClass);
//没有实现类的话就抛出异常
if (subClasses.size() == 0) {
throw new InterfaceNotHaveImplementedClassException("interface does not have implemented class exception");
}
//实现类只有一个话,直接获取
if (subClasses.size() == 1) {
Class<?> aClass = subClasses.iterator().next();
beanFieldInstance = ReflectionUtil.newInstance(aClass);
}
//实现类多与一个的话,根据 Qualifier 注解的值获取
if (subClasses.size() > 1) {
Class<?> aClass = subClasses.iterator().next();
Qualifier qualifier = beanField.getDeclaredAnnotation(Qualifier.class);
beanName = qualifier == null ? aClass.getName() : qualifier.value();
beanFieldInstance = beans.get(beanName);
}
}
// 如果最后获取到的字段对象为null,就抛出异常
if (beanFieldInstance == null) {
throw new CanNotDetermineTargetBeanException("can not determine target bean");
}
//通过反射设置指定对象中的指定字段的值
ReflectionUtil.setField(bean, beanField, beanFieldInstance);
}
}
});
}
/**
* 获取接口对应的实现类
*/
@SuppressWarnings("unchecked")
public static Set<Class<?>> getSubClass(String packageName, Class<?> interfaceClass) {
Reflections reflections = new Reflections(packageName);
return reflections.getSubTypesOf((Class<Object>) interfaceClass);
}
}
我整理了一份优质原创PDF资源免费分享给大家,大部分内容都是我的原创,少部分来自朋友。
![](https://cdn.jsdelivr.net/gh/javaguide-tech/blog-images/2020-10/image-20201012105544846.png)
![image-20201012105608336](https://cdn.jsdelivr.net/gh/javaguide-tech/blog-images/2020-10/image-20201012105608336.png)
下载地址:https://cowtransfer.com/s/fbed14f0c22a4d 。
我是 Guide 哥,一 Java 后端开发,会一点前端,自由的少年。我们下期再见!微信搜“JavaGuide”回复“面试突击”领取我整理的 4 本原创PDF