Spring IOC與DI核心重點分析

2022-10-26 14:01:49

1. Spring 是什麼

我們通常所說的 Spring 指的是 Spring Framework（Spring 框架），它是一個開源框架，有著活躍而龐大的社群，這就是它之所以能長久不衰的原因。Spring 支援廣泛的應用場景，它可以讓 Java 企業級的應用程式開發起來更簡單。

一句話概括 Spring ：Spring 是包含了眾多工具方法的 IOC 容器

那麼什麼是 IOC 呢

2. IOC 是什麼

IOC (Inversion of Control 控制反轉)，就是說 Spring 是一個控制反轉的容器

既然提到了控制反轉，那麼就來看看什麼是正向控制，什麼是反向控制

2.1 正向控制

在我們之前的大部分程式碼中，當我們要用到一個物件時，我們就需要自己構造這個物件，自己 new 物件，自己造，自己用，典型的自給自足生產模式

2.2 反向控制

在 Spring 的大部分程式碼中，我們只需要宣告我們需要一個什麼樣的物件，物件的構造我們不管，這裡的物件就是 Spring 幫我們注入進來的，物件就來自於 IOC 容器

3. DI 概念說明

說到 IoC 不得不提的一個詞就是“DI”，DI 是 Dependency Injection 的縮寫，翻譯成中文是“依賴注入”的意思。

所謂依賴注入，就是由 IoC 容器在執行期間，動態地將某種依賴關係注入到物件之中。所以，依賴注入（DI）和控制反轉（IoC）是從不同的角度的描述的同一件事情，就是指通過引入 IoC 容器，利用依賴關係注入的方式，實現物件之間的解耦。

4. Spring 的工作模式可以理解成一個買賣物件的市場

Spring 容器就是這個市場，我們既可以是賣家，也可以是買家

當我們是賣家時，將我們的物件注入到 Spring 庫

當我們是買家時，宣告我們需要的物件，Spring 從庫中將物件取出來給我們

5. 以一個小程式來理解 IOC 和 DI

當我們需要造一輛車時，就需要得到一個四個部分，才能造成一輛車

以程式碼實現時，我們就需要這四個物件，先手動將這四個物件注入到庫中

@Component：將被修飾的類註冊到庫中

@Autowired：自動注入，在這裡可以理解成從庫中拿到所修飾的元素

這裡重寫 toSpring() 只是為了列印物件，沒有其他特殊意義

使用 context.getBeanDefinitionNames() 得到庫中所有物件並列印後，可以清楚的看到，這四個物件已經被注入到庫中

後續 car 物件也成功列印

@Component
public class Car {
    @Autowired
    private Framework framework;
    @Override
    public String toString() {
        return "Car{" +
                "framework=" + framework +
                '}';
    }
}

@Component
public class Framework {
    @Autowired
    private Bottom bottom;
    @Override
    public String toString() {
        return "Framework{" +
                "bottom=" + bottom +
                '}';
    }
}

@Component
public class Bottom {
    @Autowired
    private Tire t1;
    @Autowired
    private Tire t2;
    @Autowired
    private Tire t3;
    @Autowired
    private Tire t4;
    @Override
    public String toString() {
        return "Bottom{" +
                "t1=" + t1 +
                ", t2=" + t2 +
                ", t3=" + t3 +
                ", t4=" + t4 +
                '}';
    }
}

@Component
public class Tire {
    @Override
    public String toString() {
        return "輪子";
    }
}

主類

@SpringBootApplication
public class IocApplication {
   public static void main(String[] args) {
      ConfigurableApplicationContext context = SpringApplication.run(IocApplication.class, args);
      Car car = context.getBean(Car.class);
      // 得到庫中所有的 bean(物件)
      String[] beanDefinitionNames = context.getBeanDefinitionNames();
      for (String beanDefinitionName : beanDefinitionNames) {
         System.out.println(beanDefinitionName);
      }
      System.out.println(car);
   }
}

當有一個物件沒有被 @Component 修飾，即庫中沒有這個物件，那麼其他物件就不能用@Autowired 得到這個物件，則就會出現以下異常

6. 以 XML 檔案的方式將物件注入到我們自己建立的庫中

6.1 新建一個 XML 檔案

現在這個 XML 檔案就可以看成是一個空的 Spring 庫

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

6.2 在 Main 中操作這個庫

用 FileSystemXmlApplicationContext() 開啟這個 XML 檔案之後，就可以在這裡對剛剛建立的 Spring 進行一些操作

public class Main {
    public static void main(String[] args) {
        //1. 以 XML 組態檔手動建立 Spring 容器
        FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("spring-config.xml");
        // 2. 列印容器中所有物件的 bean-id
        String[] names = context.getBeanDefinitionNames();
        System.out.println("所有物件陳列：");
        for (String name : names) {
            Object bean = context.getBean(name);
            // 得到此類的全名，即包含包名的名稱
            String canonicalName = bean.getClass().getCanonicalName();
            System.out.println(name + "      " + canonicalName);
        }
        int count = context.getBeanDefinitionCount();
        System.out.println("一共有" + count + "個");
    }
}

6.3 XML 檔案的方式注入 bean(物件)

以 bean 標籤來對物件進行注入，以下 XML 用不同的三種方法注入了三個物件

列印後可以清楚的看到，三個物件成功注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    xml的方式注入類，new 的過程也交給 Spring-->
    <bean id="empty-class" class="com.hsq.ioc2.EmptyClass"/>
<!--    構造方法注入類-->
    <bean id="second-class" class="com.hsq.ioc2.SecondClass">
<!--        依賴 EmptyClass 注入 SecondClass-->
        <constructor-arg ref="empty-class"/>
    </bean>
<!--    set 方法注入類-->
    <bean id="third-class" class="com.hsq.ioc2.ThirdClass">
        <property name="EmptyClass" ref="empty-class"/>
        <property name="SecondClass" ref="second-class"/>
    </bean>
</beans>

public class EmptyClass {
    public EmptyClass() {
        System.out.println("被呼叫");
    }
}

public class SecondClass {
    public SecondClass(EmptyClass emptyClass) {
        System.out.println("second 被呼叫");
    }
}

public class ThirdClass {
    public EmptyClass emptyClass;
    public SecondClass secondClass;
    public void setEmptyClass(EmptyClass emptyClass) {
        System.out.println("setEmptyClass() " + emptyClass);
        this.emptyClass = emptyClass;
    }
    public void setSecondClass(SecondClass secondClass) {
        System.out.println("setSecondClass() " + secondClass);
        this.secondClass = secondClass;
    }
    public ThirdClass() {
        System.out.println("third 被呼叫");
    }
}