手写一个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://cowtransfer.com/s/fbed14f0c22a4d 。

我是 Guide 哥，一 Java 后端开发，会一点前端，自由的少年。我们下期再见！微信搜“JavaGuide”回复“面试突击”领取我整理的 4 本原创PDF