手写一个HTTP框架：两个类实现基本的IoC功能

时间  2020-11-16
标签 html 前端 java git github 面试 编程 json 后端 微信 栏目 HTTP/TCP 繁體版
原文   原文链接

jsoncat： 仿 Spring Boot 但不一样于 Spring Boot 的一个轻量级的 HTTP 框架html

国庆节的时候，我就已经把 jsoncat 的 IoC 功能给写了，具体能够看这篇文章《手写“SpringBoot”近况：IoC模块已经完成》 。前端

今天这篇文章就来简单分享一下本身写 IoC 的思路与具体的代码实现。java

在这里插入图片描述

IoC （Inverse of Control:控制反转） 和 AOP(Aspect-Oriented Programming:面向切面编程) 能够说是 Spring 框架提供的最核心的两个功能。但凡是了解过 Spring 的小伙伴，那确定对这个两个概念很是很是了解。不了解的小伙伴，能够查看《面试被问了几百遍的 IoC 和 AOP ，还在傻傻搞不清楚？》这篇通俗易懂的文章。git

考虑到这篇文章要手写 Spring 框架的 IoC 功能，因此，我这里仍是简单介绍一下 IoC 。若是你不太清楚 IoC 这个概念，必定要搞懂以后再看后面具体的代码实现环节。github

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 的话，你只须要配置好，而后在须要的地方引用就好了，这大大增长了项目的可维护性且下降了开发难度。json

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 的思路，搞清楚了思路以后，实现起来就很是简单了。

  1. 扫描指定包下的特定注解好比@Component标记的类，并将这些类保存起来。
  2. 遍历全部被特定注解好比@Component标记的类，而后将这些类经过反射实例化并经过一个 Map 保存起来，Map 的 key 为类名，value为类对象。
  3. 再一次遍历全部被特定注解好比@Component标记的类，并获取类中全部的字段，若是类被 @Autowired 注解标记的话，就进行第 4 步。
  4. 经过字段名 key，从bean容器中获取对应的对象 value。
  5. 判断获取到的对象是否为接口。若是是接口的话，须要获取接口对应的实现类，而后再将指定的实现类的实例化对象经过反射赋值给指定对象。若是不是接口的话，就直接将获取到的对象经过反射赋值给指定对象。

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个后面会用到的方法：

  1. scanAnnotatedClass() ：扫描指定包下的被指定注解标记的类(使用Reflections这个反射框架一行代码便可解决扫描获取指定注解的类)。
  2. newInstance() : 传入 Class 便可返回 Class 对应的对象。
  3. 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资源免费分享给你们，大部份内容都是个人原创，少部分来自朋友。

<img src="https://cdn.jsdelivr.net/gh/javaguide-tech/blog-images/2020-10/image-20201012105544846.png" style="zoom:50%;" />

<img src="https://cdn.jsdelivr.net/gh/javaguide-tech/blog-images/2020-10/image-20201012105608336.png" alt="image-20201012105608336" style="zoom:50%;" />

下载地址：https://cowtransfer.com/s/fbed14f0c22a4d 。 我是 Guide 哥，一 Java 后端开发，会一点前端，自由的少年。咱们下期再见！微信搜“JavaGuide”回复“面试突击”领取我整理的 4 本原创PDF

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程