摘要：從而能夠進(jìn)一步深入了解框架。至此我們框架開發(fā)完成。雖然說閱讀源碼是了解框架的最終手段。但是框架作為一個生產(chǎn)框架，為了保證通用和穩(wěn)定，源碼必定是高度抽象，且處理大量細(xì)節(jié)。下一篇文章應(yīng)該會是徒手?jǐn)]框架實現(xiàn)。

原文地址：https://www.xilidou.com/2018/...

Spring 作為 J2ee 開發(fā)事實上的標(biāo)準(zhǔn)，是每個Java開發(fā)人員都需要了解的框架。但是Spring 的 IoC 和 Aop 的特性，對于初級的Java開發(fā)人員來說還是比較難于理解的。所以我就想寫一系列的文章給大家講解這些特性。從而能夠進(jìn)一步深入了解 Spring 框架。

讀完這篇文章，你將會了解：

什么是依賴注入和控制反轉(zhuǎn)

Ioc有什么用

Spring的 Ioc 是怎么實現(xiàn)的

按照Spring的思路開發(fā)一個簡單的Ioc框架

wiki百科的解釋是：

控制反轉(zhuǎn)（Inversion of Control，縮寫為IoC），是面向?qū)ο缶幊讨械囊环N設(shè)計原則，可以用來減低計算機(jī)代碼之間的耦合度。其中最常見的方式叫做依賴注入（Dependency Injection，簡稱DI）。通過控制反轉(zhuǎn)，對象在被創(chuàng)建的時候，由一個調(diào)控系統(tǒng)內(nèi)所有對象的外界實體，將其所依賴的對象的引用傳遞給它。也可以說，依賴被注入到對象中。

看完上面的解釋你一定沒有理解什么是 Ioc，因為是第一次看見上面的話也覺得云里霧里。

不過通過上面的描述我們可以大概的了解到，使用IoC的目的是為了解耦。也就是說IoC 是解耦的一種方法。

我們知道Java 是一門面向?qū)ο蟮恼Z言，在 Java 中 Everything is Object，我們的程序就是由若干對象組成的。當(dāng)我們的項目越來越大，合作的開發(fā)者越來越多的時候，我們的類就會越來越多，類與類之間的引用就會成指數(shù)級的增長。如下圖所示：

這樣的工程簡直就是災(zāi)難，如果我們引入 Ioc 框架。由框架來維護(hù)類的生命周期和類之間的引用。我們的系統(tǒng)就會變成這樣：

這個時候我們發(fā)現(xiàn)，我們類之間的關(guān)系都由 IoC 框架負(fù)責(zé)維護(hù)類，同時將類注入到需要的類中。也就是類的使用者只負(fù)責(zé)使用，而不負(fù)責(zé)維護(hù)。把專業(yè)的事情交給專業(yè)的框架來完成。大大的減少開發(fā)的復(fù)雜度。

用一個類比來理解這個問題。Ioc 框架就是我們生活中的房屋中介，首先中介會收集市場上的房源，分別和各個房源的房東建立聯(lián)系。當(dāng)我們需要租房的時候，并不需要我們四處尋找各類租房信息。我們直接找房屋中介，中介就會根據(jù)你的需求提供相應(yīng)的房屋信息。大大提升了租房的效率，減少了你與各類房東之間的溝通次數(shù)。

了解Spring框架最直接的方法就閱讀Spring的源碼。但是Spring的代碼抽象的層次很高，且處理的細(xì)節(jié)很高。對于大多數(shù)人來說不是太容易理解。我讀了Spirng的源碼以后以我的理解做一個總結(jié),Spirng IoC 主要是以下幾個步驟。

1. 初始化 IoC 容器。
2. 讀取配置文件。
3. 將配置文件轉(zhuǎn)換為容器識別對的數(shù)據(jù)結(jié)構(gòu)（這個數(shù)據(jù)結(jié)構(gòu)在Spring中叫做 BeanDefinition） 
4. 利用數(shù)據(jù)結(jié)構(gòu)依次實例化相應(yīng)的對象
5. 注入對象之間的依賴關(guān)系

為了方便，我們參考 Spirng 的 IoC 實現(xiàn)，去除所有與核心原理無關(guān)的邏輯。極簡的實現(xiàn) IoC 的框架。 項目使用 json 作為配置文件。使用 maven 管理 jar 包的依賴。

在這個框架中我們的對象都是單例的，并不支持Spirng的多種作用域?？蚣艿膶崿F(xiàn)使用了cglib 和 Java 的反射。項目中我還使用了 lombok 用來簡化代碼。

下面我們就來編寫 IoC 框架吧。

首先我們看看這個框架的基本結(jié)構(gòu)：

從宏觀上觀察一下這個框架，包含了3個package、在包 bean 中定義了我們框架的數(shù)據(jù)結(jié)構(gòu)。core 是我們框架的核心邏輯所在。utils 是一些通用工具類。接下來我們就逐一講解一下：

BeanDefinition 是我們項目的核心數(shù)據(jù)結(jié)構(gòu)。用于描述我們需要 IoC 框架管理的對象。

@Data
@ToString
public class BeanDefinition {

    private String name;

    private String className;

    private String interfaceName;

    private List constructorArgs;

    private List propertyArgs;

}

包含了對象的 name，class的名稱。如果是接口的實現(xiàn)，還有該對象實現(xiàn)的接口。以及構(gòu)造函數(shù)的傳參的列表 constructorArgs 和需要注入的參數(shù)列表 `propertyArgs。

ClassUtils 負(fù)責(zé)處理 Java 類的加載,代碼如下：

public class ClassUtils {
    public static ClassLoader getDefultClassLoader(){
        return Thread.currentThread().getContextClassLoader();
    }
    public static Class loadClass(String className){
        try {
            return getDefultClassLoader().loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

我們只寫了一個方法，就是通過 className 這個參數(shù)獲取對象的 Class。

BeanUtils 負(fù)責(zé)處理對象的實例化，這里我們使用了 cglib 這個工具包，代碼如下：

public class BeanUtils {
    public static  T instanceByCglib(Class clz,Constructor ctr,Object[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clz);
        enhancer.setCallback(NoOp.INSTANCE);
        if(ctr == null){
            return (T) enhancer.create();
        }else {
            return (T) enhancer.create(ctr.getParameterTypes(),args);
        }
    }
}

ReflectionUtils 主要通過 Java 的反射原理來完成對象的依賴注入：

public class ReflectionUtils {

    public static void injectField(Field field,Object obj,Object value) throws IllegalAccessException {
        if(field != null) {
            field.setAccessible(true);
            field.set(obj, value);
        }
    }
}

injectField(Field field,Object obj,Object value) 這個方法的作用就是，設(shè)置 obj 的 field 為 value。

JsonUtils 的作用就是為了解析我們的json配置文件。代碼比較長，與我們的 IoC 原理關(guān)系不大，感興趣的同學(xué)可以自行從github上下載代碼看看。

有了這幾個趁手的工具，我們就可以開始完成 Ioc 框架的核心代碼了。

我的 IoC 框架，目前只支持一種 ByName 的注入。所以我們的 BeanFactory 就只有一個方法：

public interface BeanFactory {
    Object getBean(String name) throws Exception;
}

然后我們實現(xiàn)了這個方法：

public class BeanFactoryImpl implements BeanFactory{

    private static final ConcurrentHashMap beanMap = new ConcurrentHashMap<>();

    private static final ConcurrentHashMap beanDefineMap= new ConcurrentHashMap<>();

    private static final Set beanNameSet = Collections.synchronizedSet(new HashSet<>());

    @Override
    public Object getBean(String name) throws Exception {
        //查找對象是否已經(jīng)實例化過
        Object bean = beanMap.get(name);
        if(bean != null){
            return bean;
        }
        //如果沒有實例化，那就需要調(diào)用createBean來創(chuàng)建對象
        bean =  createBean(beanDefineMap.get(name));
        
        if(bean != null) {

            //對象創(chuàng)建成功以后，注入對象需要的參數(shù)
            populatebean(bean);
            
            //再把對象存入Map中方便下次使用。
            beanMap.put(name,bean;
        }

        //結(jié)束返回
        return bean;
    }

    protected void registerBean(String name, BeanDefinition bd){
        beanDefineMap.put(name,bd);
        beanNameSet.add(name);
    }

    private Object createBean(BeanDefinition beanDefinition) throws Exception {
        String beanName = beanDefinition.getClassName();
        Class clz = ClassUtils.loadClass(beanName);
        if(clz == null) {
            throw new Exception("can not find bean by beanName");
        }
        List constructorArgs = beanDefinition.getConstructorArgs();
        if(constructorArgs != null && !constructorArgs.isEmpty()){
            List