Spring 實例化方式有幾種？爲何會用到 Cglib？

做者：小傅哥
博客：https://bugstack.cn

沉澱、分享、成長，讓本身和他人都能有所收穫！😄

《Spring 手擼專欄》目錄

• [x] 第 1 章：開篇介紹，我要帶你擼 Spring 啦！
• [x] 第 2 章：小試牛刀，實現一個簡單的Bean容器
• [x] 第 3 章：初顯身手，運用設計模式，實現 Bean 的定義、註冊、獲取
• [x] 第 4 章：嶄露頭角，基於Cglib實現含構造函數的類實例化策略
• [ ] 第 5 章：給 Bean 對象填充屬性信息
• [ ] 第 6 章：待歸檔...

1、前言

技術成長，是對場景設計細節不斷的雕刻！

你以爲本身的技術何時獲得了快速的提升，是CRUD寫的多了之後嗎？想都不要想，絕對不可能！CRUD寫的再多也只是能知足你做爲一個搬磚工具人，敲擊少邏輯流水代碼的速度而已，而編程能力這一塊，除了最開始的從不熟練到熟練之外，就不多再有其餘提高了。

那你可能會想什麼纔是編程能力提高？其實更多的編程能力的提高是你對複雜場景的架構把控以及對每個技術實現細節點的不斷用具備規模體量的流量衝擊驗證時，是否能保證系統穩定運行從而決定你見識了多少、學到了多少、提高了多少！

最終當你在接一個產品需求時，開始思考程序數據結構的設計、核心功能的算法邏輯實現、總體服務的設計模式使用、系統架構的搭建方式、應用集羣的部署結構，那麼也就是的編程能力真正提高的時候！

2、目標

這一章節的目標主要是爲了解決上一章節咱們埋下的坑，那是什麼坑呢？其實就是一個關於 Bean 對象在含有構造函數進行實例化的坑。

在上一章節咱們擴充了 Bean 容器的功能，把實例化對象交給容器來統一處理，但在咱們實例化對象的代碼裏並無考慮對象類是否含構造函數，也就是說若是咱們去實例化一個含有構造函數的對象那麼就要拋異常了。

怎麼驗證？其實就是把 UserService 添加一個含入參信息的構造函數就能夠，以下：

public class UserService {

    private String name;

    public UserService(String name) {
        this.name = name;
    }  

    // ...
}

報錯以下：

java.lang.InstantiationException: cn.bugstack.springframework.test.bean.UserService

    at java.lang.Class.newInstance(Class.java:427)
    at cn.bugstack.springframework.test.ApiTest.test_newInstance(ApiTest.java:51)
    ...

發生這一現象的主要緣由就是由於 beanDefinition.getBeanClass().newInstance(); 實例化方式並無考慮構造函數的入參，因此就這個坑就在這等着你了！那麼咱們的目標就很明顯了，來把這個坑填平！

3、設計

填平這個坑的技術設計主要考慮兩部分，一個是串流程從哪合理的把構造函數的入參信息傳遞到實例化操做裏，另一個是怎麼去實例化含有構造函數的對象。

• 參考 Spring Bean 容器源碼的實現方式，在 BeanFactory 中添加 Object getBean(String name, Object... args) 接口，這樣就能夠在獲取 Bean 時把構造函數的入參信息傳遞進去了。
• 另一個核心的內容是使用什麼方式來建立含有構造函數的 Bean 對象呢？這裏有兩種方式能夠選擇，一個是基於 Java 自己自帶的方法 DeclaredConstructor，另一個是使用 Cglib 來動態建立 Bean 對象。Cglib 是基於字節碼框架 ASM 實現，因此你也能夠直接經過 ASM 操做指令碼來建立對象

4、實現

1. 工程結構

small-spring-step-03
└── src
    ├── main
    │   └── java
    │       └── cn.bugstack.springframework.beans
    │           ├── factory
    │           │   ├── factory
    │           │   │   ├── BeanDefinition.java
    │           │   │   └── SingletonBeanRegistry.java
    │           │   ├── support
    │           │   │   ├── AbstractAutowireCapableBeanFactory.java
    │           │   │   ├── AbstractBeanFactory.java
    │           │   │   ├── BeanDefinitionRegistry.java
    │           │   │   ├── CglibSubclassingInstantiationStrategy.java
    │           │   │   ├── DefaultListableBeanFactory.java
    │           │   │   ├── DefaultSingletonBeanRegistry.java
    │           │   │   ├── InstantiationStrategy.java
    │           │   │   └── SimpleInstantiationStrategy.java
    │           │   └── BeanFactory.java
    │           └── BeansException.java
    └── test
        └── java
            └── cn.bugstack.springframework.test
                ├── bean
                │   └── UserService.java
                └── ApiTest.java

工程源碼：公衆號「bugstack蟲洞棧」，回覆：Spring 專欄，獲取完整源碼

Spring Bean 容器類關係，如圖 4-2

本章節「填坑」主要是在現有工程中添加 InstantiationStrategy 實例化策略接口，以及補充相應的 getBean 入參信息，讓外部調用時能夠傳遞構造函數的入參並順利實例化。

2. 新增 getBean 接口

cn.bugstack.springframework.beans.factory.BeanFactory

public interface BeanFactory {

    Object getBean(String name) throws BeansException;

    Object getBean(String name, Object... args) throws BeansException;

}

• BeanFactory 中咱們重載了一個含有入參信息 args 的 getBean 方法，這樣就能夠方便的傳遞入參給構造函數實例化了。

3. 定義實例化策略接口

cn.bugstack.springframework.beans.factory.support.InstantiationStrategy

public interface InstantiationStrategy {

    Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor ctor, Object[] args) throws BeansException;

}

• 在實例化接口 instantiate 方法中添加必要的入參信息，包括：beanDefinition、 beanName、ctor、args
• 其中 Constructor 你可能會有一點陌生，它是 java.lang.reflect 包下的 Constructor 類，裏面包含了一些必要的類信息，有這個參數的目的就是爲了拿到符合入參信息相對應的構造函數。
• 而 args 就是一個具體的入參信息了，最終實例化時候會用到。

4. JDK 實例化

cn.bugstack.springframework.beans.factory.support.SimpleInstantiationStrategy

public class SimpleInstantiationStrategy implements InstantiationStrategy {

    @Override
    public Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor ctor, Object[] args) throws BeansException {
        Class clazz = beanDefinition.getBeanClass();
        try {
            if (null != ctor) {
                return clazz.getDeclaredConstructor(ctor.getParameterTypes()).newInstance(args);
            } else {
                return clazz.getDeclaredConstructor().newInstance();
            }
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            throw new BeansException("Failed to instantiate [" + clazz.getName() + "]", e);
        }
    }

}

• 首先經過 beanDefinition 獲取 Class 信息，這個 Class 信息是在 Bean 定義的時候傳遞進去的。
• 接下來判斷 ctor 是否爲空，若是爲空則是無構造函數實例化，不然就是須要有構造函數的實例化。
• 這裏咱們重點關注有構造函數的實例化，實例化方式爲 clazz.getDeclaredConstructor(ctor.getParameterTypes()).newInstance(args);，把入參信息傳遞給 newInstance 進行實例化。

5. Cglib 實例化

cn.bugstack.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy

public class CglibSubclassingInstantiationStrategy implements InstantiationStrategy {

    @Override
    public Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor ctor, Object[] args) throws BeansException {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(beanDefinition.getBeanClass());
        enhancer.setCallback(new NoOp() {
            @Override
            public int hashCode() {
                return super.hashCode();
            }
        });
        if (null == ctor) return enhancer.create();
        return enhancer.create(ctor.getParameterTypes(), args);
    }

}

• 其實 Cglib 建立有構造函數的 Bean 也很是方便，在這裏咱們更加簡化的處理了，若是你閱讀 Spring 源碼還會看到 CallbackFilter 等實現，不過咱們目前的方式並不會影響建立。

6. 建立策略調用

cn.bugstack.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {

    private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
        Object bean = null;
        try {
            bean = createBeanInstance(beanDefinition, beanName, args);
        } catch (Exception e) {
            throw new BeansException("Instantiation of bean failed", e);
        }

        addSingleton(beanName, bean);
        return bean;
    }

    protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) {
        Constructor constructorToUse = null;
        Class<?> beanClass = beanDefinition.getBeanClass();
        Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
        for (Constructor ctor : declaredConstructors) {
            if (null != args && ctor.getParameterTypes().length == args.length) {
                constructorToUse = ctor;
                break;
            }
        }
        return getInstantiationStrategy().instantiate(beanDefinition, beanName, constructorToUse, args);
    }

}

• 首先在 AbstractAutowireCapableBeanFactory 抽象類中定義了一個建立對象的實例化策略屬性類 InstantiationStrategy instantiationStrategy，這裏咱們選擇了 Cglib 的實現類。
• 接下來抽取 createBeanInstance 方法，在這個方法中須要注意 Constructor 表明了你有多少個構造函數，經過 beanClass.getDeclaredConstructors() 方式能夠獲取到你全部的構造函數，是一個集合。
• 接下來就須要循環比對出構造函數集合與入參信息 args 的匹配狀況，這裏咱們對比的方式比較簡單，只是一個數量對比，而實際 Spring
  源碼中還須要比對入參類型，不然相同數量不一樣入參類型的狀況，就會拋異常了。

5、測試

1. 事先準備

cn.bugstack.springframework.test.bean.UserService

public class UserService {

    private String name;

    public UserService(String name) {
        this.name = name;
    }

    public void queryUserInfo() {
        System.out.println("查詢用戶信息：" + name);
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("");
        sb.append("").append(name);
        return sb.toString();
    }
}

• 這裏惟一多在 UserService 中添加的就是一個有 name 入參的構造函數，方便咱們驗證這樣的對象是否能被實例化。

2. 測試用例

cn.bugstack.springframework.test.ApiTest

@Test
public void test_BeanFactory() {
    // 1.初始化 BeanFactory
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

    // 2. 注入bean
    BeanDefinition beanDefinition = new BeanDefinition(UserService.class);
    beanFactory.registerBeanDefinition("userService", beanDefinition);

    // 3.獲取bean
    UserService userService = (UserService) beanFactory.getBean("userService", "小傅哥");
    userService.queryUserInfo();
}

• 在這次的單元測試中除了包括；Bean 工廠、註冊 Bean、獲取 Bean，三個步驟，還額外增長了一次對象的獲取和調用。這裏主要測試驗證單例對象的是否正確的存放到了緩存中。
• 此外與上一章節測試過程當中不一樣的是，咱們把 UserService.class 傳遞給了 BeanDefinition 而不是像上一章節那樣直接 new UserService() 操做。

3. 測試結果

查詢用戶信息：小傅哥

Process finished with exit code 0

• 從測試結果來看，最大的變化就是能夠知足帶有構造函數的對象，能夠被實例化了。
• 你能夠嘗試分別使用兩種不一樣的實例化策略，來進行實例化。SimpleInstantiationStrategy、CglibSubclassingInstantiationStrategy

4. 操做案例

這裏咱們再把幾種不一樣方式的實例化操做，放到單元測試中，方便你們比對學習。

4.1 無構造函數

@Test
public void test_newInstance() throws IllegalAccessException, InstantiationException {
    UserService userService = UserService.class.newInstance();
    System.out.println(userService);
}

• 這種方式的實例化也是咱們在上一章節實現 Spring Bean 容器時直接使用的方式

4.2 驗證有構造函數實例化

@Test
public void test_constructor() throws Exception {
    Class<UserService> userServiceClass = UserService.class;
    Constructor<UserService> declaredConstructor = userServiceClass.getDeclaredConstructor(String.class);
    UserService userService = declaredConstructor.newInstance("小傅哥");
    System.out.println(userService);
}

• 從最簡單的操做來看，若是有構造函數的類須要實例化時，則須要使用 getDeclaredConstructor 獲取構造函數，以後在經過傳遞參數進行實例化。

4.3 獲取構造函數信息

@Test
public void test_parameterTypes() throws Exception {
    Class<UserService> beanClass = UserService.class;
    Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
    Constructor<?> constructor = declaredConstructors[0];
    Constructor<UserService> declaredConstructor = beanClass.getDeclaredConstructor(constructor.getParameterTypes());
    UserService userService = declaredConstructor.newInstance("小傅哥");
    System.out.println(userService);

• 這個案例中其實最核心的點在於獲取一個類中全部的構造函數，其實也就是這個方法的使用 beanClass.getDeclaredConstructors()

4.4 Cglib 實例化

@Test
public void test_cglib() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(UserService.class);
    enhancer.setCallback(new NoOp() {
        @Override
        public int hashCode() {
            return super.hashCode();
        }
    });
    Object obj = enhancer.create(new Class[]{String.class}, new Object[]{"小傅哥"});
    System.out.println(obj);
}

• 此案例演示使用很是簡單，但關於 Cglib 在 Spring 容器中的使用很是多，也能夠深刻的學習一下 Cglib 的擴展知識。

6、總結

• 本章節的主要以完善實例化操做，增長 InstantiationStrategy 實例化策略接口，並新增了兩個實例化類。這部分類的名稱與實現方式基本是 Spring 框架的一個縮小版，你們在學習過程當中也能夠從 Spring 源碼找到對應的代碼。
• 從咱們不斷的完善增長需求能夠看到的，當你的代碼結構設計的較爲合理的時候，就能夠很是容易且方便的進行擴展不一樣屬性的類職責，而不會由於需求的增長致使類結構混亂。因此在咱們本身業務需求實現的過程當中，也要儘量的去考慮一個良好的擴展性以及拆分好類的職責。
• 動手是學習起來最快的方式，不要讓眼睛是感受看會了，但上手操做就廢了。也但願有須要的讀者能夠親手操做一下，把你的想法也融入到可落地實現的代碼裏，看看想的和作的是否一致。

7、系列推薦

• 面經手冊 · 第1篇《認知本身的技術棧盲區》)
• 剛火了的中臺轉頭就拆，一大波公司放不下又拿不起來！
• 工做兩三年了，整不明白架構圖都畫啥？
• 初識領域驅動設計DDD落地
• 面試現場：小夥伴美團一面的分享和分析(含解答)