2. 程式人生 > 其它 >簡單實現Spring依賴注入以及控制反轉

簡單實現Spring依賴注入以及控制反轉

阿新 • • 發佈：2022-05-28

執行流程

從上一章分析可得，spring建立bean的流程如下所示
獲取class資訊 -> 根據class資訊呼叫構造方法建立物件 -> 判斷成員變數中是否有依賴注入註解並進行注入操作 -> 初始化前(@PostConstruct) -> 初始化(實現InitializingBean介面) -> 初始化後(AOP) -> 生成代理物件 -> Bean

掃描bean

掃描bean主要根據包名獲取類資訊以及判斷使用者建立的類是否繼承BeanProcessor介面以及將該介面放入到spring容器中，並將該資訊儲存到map集合中。
類資訊包含bean名稱、單例還是原型、是否懶載入。
BeanProcessor介面用於處理初始化前和初始化後的方法。

首先根據傳入的類class判斷該類是否有ComponentScan註解，如果有就根據該註解獲取要掃描的包。
掃描類時載入的並不是.java檔案而是編譯後的二進位制位元組碼class檔案，想要載入該檔案需要找到編譯後的檔案目錄，可以根據應用程式類載入器獲取該目錄，呼叫resouces方法獲取包目錄下的url，獲取前得先將包名.替換成'/'，這樣才能表示目錄，可以根據該url來建立file物件，之後判斷file物件是否為目錄，如果是目錄就掃描該目錄下的所有檔案，如下程式碼所示

        if (aClass.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScan = (ComponentScan) aClass.getAnnotation(ComponentScan.class);
            String packagePath = componentScan.value();
            packagePath = packagePath.replace(".", "/");

            URL resource = LyraApplicationContext.class.getClassLoader().getResource(packagePath);

            assert resource != null;
            File file = new File(URLDecoder.decode(resource.getFile(), StandardCharsets.UTF_8));

            if (file.isDirectory()) {
			}
	}

之後遍歷該目錄下的所有檔案，然後判斷檔案中是否有Component註解，如果有該註解那麼就表示這個類是一個bean，在然後判斷包中的類是否實現BeanProcessor介面，如果有類實現了則將該類例項化並存儲到map中。

                 if (aClass1.isAnnotationPresent(Component.class)) {
                            if (BeanProcessor.class.isAssignableFrom(aClass1)) {
                                BeanProcessor instance = (BeanProcessor) aClass1.getDeclaredConstructor().newInstance();
                                beanProcessorList.add(instance);
                            }
                        }

之後就該獲取類資訊了，類資訊所在類具體由下所示，類中儲存的資料由bean的class、是否為單例和bean名稱，單獨抽出BeanDefinition的原因是在掃描階段和獲取bean階段都需要掃描類從而獲取類是否為單例，這樣使程式碼重複且效率較低，不如建立個類資訊類，在掃描類時獲取類資訊儲存，之後獲取bean時直接從BeanDefinition中獲取即可。

public class BeanDefinition {
    private Class<?> clazz;
    private BeanScopeConstant scope;

    private String beanName;

    @Override
    public String toString() {
        return "BeanDefinition{" +
                "clazz=" + clazz +
                ", scope=" + scope +
                ", beanName='" + beanName + '\'' +
                '}';
    }

    public String getBeanName() {
        return beanName;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    public Class<?> getClazz() {
        return clazz;
    }

    public void setClazz(Class<?> clazz) {
        this.clazz = clazz;
    }

    public BeanScopeConstant getScope() {
        return scope;
    }

    public void setScope(BeanScopeConstant scope) {
        this.scope = scope;
    }
}

獲取類資訊時判斷是否有Scope註解，如果有該註解則將該註解的資訊儲存到BeanDefinition中，如果沒有則預設為單例，之後將bean名稱和class資訊儲存到BeanDefinition中即可，再然後將BeanDefinition儲存到map中，map的key為beanName。bean掃描的整體程式碼如下所示

    private void scanPackage() {
        // 判斷類是否有componentScan註解
        if (aClass.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScan = (ComponentScan) aClass.getAnnotation(ComponentScan.class);
            String packagePath = componentScan.value();
            packagePath = packagePath.replace(".", "/");

            URL resource = LyraApplicationContext.class.getClassLoader().getResource(packagePath);

            assert resource != null;
            File file = new File(URLDecoder.decode(resource.getFile(), StandardCharsets.UTF_8));

            // 判斷類檔案是否為目錄
            if (file.isDirectory()) {
                for (File file1 : Objects.requireNonNull(file.listFiles())) {
                    try {
                        // 將包名.替換為/
                        String componentPackagePath = file1.getAbsolutePath().substring(file1.getAbsolutePath().indexOf("com"), file1.getAbsolutePath().indexOf(".class")).replace("\\", ".");
                        BeanDefinition beanDefinition = new BeanDefinition();
                        // 獲取類編譯目錄
                        Class<?> aClass1 = LyraApplicationContext.class.getClassLoader().loadClass(componentPackagePath);
                        // 載入類 判斷類是否有component註解
                        if (aClass1.isAnnotationPresent(Component.class)) {
                            // 判斷當前類是否實現了BeanProcessor介面
                            if (BeanProcessor.class.isAssignableFrom(aClass1)) {
                                BeanProcessor instance = (BeanProcessor) aClass1.getDeclaredConstructor().newInstance();
                                beanProcessorList.add(instance);
                            }
                            // 在類資訊中儲存類scope 單例/原型
                            if (aClass1.isAnnotationPresent(Scope.class)) {
                                Scope annotation = aClass1.getAnnotation(Scope.class);

                                beanDefinition.setScope(annotation.value());
                            } else {
                                beanDefinition.setScope(BeanScopeConstant.SINGLETON);
                            }
                            // 設定類資訊
                            beanDefinition.setBeanName(aClass1.getAnnotation(Component.class).value());
                            beanDefinition.setClazz(aClass1);

                            beanDefinitionMap.put(aClass1.getAnnotation(Component.class).value(), beanDefinition);
                        }
                    } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException |
                             InstantiationException | InvocationTargetException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

bean建立

單例

掃描類完畢之後會根據掃描類的scope來建立bean，如果類的scope為單例則立即建立則儲存到儲存到單例池中。

    public LyraApplicationContext(Class<ApplicationConfig> applicationConfigClass) {
        this.aClass = applicationConfigClass;

        scanPackage();

        for (Map.Entry<String, BeanDefinition> stringBeanDefinitionEntry : beanDefinitionMap.entrySet()) {
            String beanName = stringBeanDefinitionEntry.getKey();
            BeanScopeConstant scope = stringBeanDefinitionEntry.getValue().getScope();

            if (scope == BeanScopeConstant.SINGLETON) {
                Object singletonBean = createBean(beanName, stringBeanDefinitionEntry.getValue());
                singletonMap.put(beanName, singletonBean);
            }
        }

    }

原型

如果類的scope為原型則每次呼叫 getBean方法都會建立不同的bean返回
獲取bean中首先從bean資訊map中根據bean名稱獲取bean資訊，如果不存在則表示該類沒有被掃描到容器中，獲取單例bean時，如果單例bean還未建立則呼叫getbean建立bean並掃描到單例池中

    public Object getBean(String beanName) {
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);

        if (beanDefinition == null) {
            throw new NullPointerException();
        }

        if (beanDefinition.getScope() == BeanScopeConstant.PROTOTYPE) {
            return createBean(beanName, beanDefinition);
        } else {
            Object bean = singletonMap.get(beanName);
            if (bean == null) {
                bean = createBean(beanName, beanDefinition);
                singletonMap.put(beanName, bean);
            }
            return bean;
        }

    }

建立bean

建立bean的流程為
獲取class資訊 -> 根據class資訊呼叫構造方法建立物件 -> 判斷成員變數中是否有依賴注入註解並進行注入操作 -> 初始化前(@PostConstruct) -> 初始化(實現InitializingBean介面) -> 初始化後(AOP) -> 生成代理物件 -> Bean

  1. 獲取類資訊
    掃描時已經將類資訊儲存到beanDefinition中，直接從map中獲取beanDefinition即可
       Class<?> clazz = beanDefinition.getClazz();
  1. 利用反射呼叫構造方法建立bean
    這裡呼叫的是無參構造方法，沒有構造方法推理，還略微有些問題
            Object instance = clazz.getConstructor().newInstance();
  1. 檢視bean欄位中有沒有被Autowired註解標識，如果有則呼叫geatBean方法為欄位注入值，這裡有個坑，如果掃描的bean為單例bean，雖然標識了Component註解，建立bean在注入之前，容器還沒來得及建立就已經執行注入操作，肯定會注入失敗的，這就在getBean方法獲取單例bean時獲取，如果單例bean還未建立則呼叫getbean建立bean並掃描到單例池中
        for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    field.set(instance, getBean(field.getName()));
                }
            }
  1. 呼叫初始化前方法
    BeanProcessor中封裝了兩個方法，初始化前和初始化後的方法，這個介面很重要，因為AOP代理物件就是從這個介面的實現類建立的，通過對bean的處理，然後返回代理物件
public interface BeanProcessor {
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("before");
        return bean;
    }

    default Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("after");
        return bean;
    }
}

執行初始化前方法，這個list填充是由掃描bean時完成的，所以不為空

            beanProcessorList.forEach((beanProcessor -> {
                beanProcessor.postProcessBeforeInitialization(instance, beanName);
            }));
  1. 呼叫初始化方法
    初始化方法是由實現InitializingBean介面的bean完成的，直接判斷當前bean是否實現了InitializingBean介面即可，如果實現了之江將bean強轉為InitializingBean然後呼叫初始化方法即可。
        if (instance instanceof InitializingBean) {
                ((InitializingBean) instance).afterPropertiesSet();
            }
  1. 呼叫初始化後方法

            beanProcessorList.forEach((beanProcessor -> {
                beanProcessor.postProcessAfterInitialization(instance, beanName);
            }));

建立bean完整程式碼

    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Class<?> clazz = beanDefinition.getClazz();

        try {
            Object instance = clazz.getConstructor().newInstance();

            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {
                    field.setAccessible(true);
                    field.set(instance, getBean(field.getName()));
                }
            }

            beanProcessorList.forEach((beanProcessor -> {
                beanProcessor.postProcessBeforeInitialization(instance, beanName);
            }));

            if (instance instanceof InitializingBean) {
                ((InitializingBean) instance).afterPropertiesSet();
            }

            beanProcessorList.forEach((beanProcessor -> {
                beanProcessor.postProcessAfterInitialization(instance, beanName);
            }));


            return instance;

        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

相關推薦

簡單實現Spring依賴注入以及控制反轉

執行流程 從上一章分析可得，spring建立bean的流程如下所示 獲取class資訊 -> 根據class資訊呼叫構造方法建立物件 -> 判斷成員變數中是否有依賴注入註解並進行注入操作 -> 初始化前(@PostConstruct) ->

Spring的依賴注入、控制反轉

依賴注入和控制反轉 從spring的角度來說是控制反轉，把類例項化的權力給了spring框架。

03依賴注入--01控制反轉、IoC模式

控制反轉Inversion of Control DI和IoC幾乎都是成對出現的，我們在理解依賴注入之前首先要弄明白什麼是IoC，也就是控制反轉，體現的就是控制權的轉移，即控制權原來在A中，現在需要B來接管。那麼在軟體中是如何實現

為什麼使用依賴注入和控制反轉

控制反轉（Inversion of Control，縮寫為IoC），是面向物件程式設計中的一種設計原則，可以用來減低計算機程式碼之間的耦合度。

依賴注入和控制反轉

控制反轉（IOC） Ioc意味著將你設計好的物件交給容器控制，而不是傳統的在你的物件內部直接控制

Spring依賴注入基礎以及實現原理

>>> 一、Spring簡介 1.Spring簡化Java開發 Spring Framework是一個應用框架，框架一般是半成品，我們在框架的基礎上可以不用每個專案自己實現架構、基礎設施和常用功能性元件，而是可以專注業

Spring 依賴注入實現示例

【注】本文譯自：https://springframework.guru/...   在本文中，我將向你展示如何在 Spring Framework 的依賴項注入中使用 Project Lombok 以獲得最佳實踐。

Spring依賴注入的兩種實現方式

技術標籤：框架學習筆記 控制反轉 依賴注入和控制反轉含義相同，他們是從兩個角度描述的同一個概念 當某個java例項需要另一個java例項時，傳統的方法是由呼叫者建立被呼叫者的例項（使用new關鍵字獲得被呼叫者例

spring依賴注入知識點分享

spring與IoC IoC：控制反轉，將由程式碼操縱的物件控制權，交給第三方容器，反轉給第三方容器。這種物件依賴的關係管理方式，稱作

spring依賴注入原理與用法例項分析

本文例項講述了spring依賴注入原理與用法。分享給大家供大家參考，具體如下：

java後端開發三年！你還不瞭解Spring 依賴注入，憑什麼給你漲薪

前言 前兩天和一個同學吃飯的時候同學跟我說了一件事，說他公司有個做了兩年的人向他提出要漲薪資，他就順口問了一個問題關於spring依賴注入的，那個要求漲薪的同學居然被問懵了。。。事後回家想了想這一塊確實有點難

.Net 依賴注入以及AOP切面

.Net 依賴注入 參考地址 https://www.cnblogs.com/webapi/p/10563735.html https://www.cnblogs.com/xyh9039/archive/2019/08/07/11318247.html

spring——依賴注入的三種方式

1 構造器注入(與構造器有直接關係) 預設無參構造 3種構造方式:通過<contructor-arg>呼叫類中的構造器

IoC思想的實現：依賴注入（一）

IoC介紹： IoC是什麼？ IoC控制反轉（Inversion of control）：是一種理論思想。其實就是把物件的建立、賦值和管理交給容器來實現。

Spring 依賴注入

spring中 的依賴往入 依賴注入:Dependency Injection IOC的作用: 降低程式間的耦合(依賴關係)

Spring 依賴注入的幾種方式

一、實體類1 package com.alipay.sofa.XX; import java.util.*; public class Student { private String name;

Spring xml注入 以及 xml配置

xml 配置 <?xml version=\"1.0\" encoding=\"UTF-8\"?> <beans xmlns=\"http://www.springframework.org/schema/beans\"

Spring 依賴注入最佳實踐

【注】本文譯自：https://springframework.guru/best-practices-for-dependency-injection-with-spring/

Spring依賴注入的方式

一、依賴注入方式 　　依賴注入就是通過spring將bean所需要的引數傳遞到bean例項物件的過程

spring依賴注入

技術標籤：筆記spring 依賴注入：是spring框架核心的IOC的具體實現 在編寫程式中，通過控制反轉，把物件建立交給了Spring，但是在程式碼中不會出現沒有依賴的情況，只能說減少耦合性,畢竟如果service層需要呼叫d