手寫一個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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/172115.html

標籤：Java

上一篇：高效、深度學習技術-摘自極客時間左耳朵耗子

下一篇：Java 合并Word檔案