【帶你手撸Spring】沒有哪個架構開發，能離開 Spring 的 FactoryBean！

作者：小傅哥

部落格：https://bugstack.cn

沉澱、分享、成長，讓自己和他人都能有所收獲！😄

一、前言

老司機，你的磚怎麼搬的那麼快？

是有勁？是技巧？是後門？總之，那個老司機的代碼總是可以很快的完成産品每次新增的需求，就像他倆是一家似的！而你就不一樣了，不隻産品經理還有營運、測試的小姐姐，都得給你買吃的，求着你趕緊把Bug修修，否則都來不及上線了。

那為啥别人的代碼總是可以很快的擴充新功能，而你的代碼從來不能被重構隻能被重寫，小需求小改、大需求大改，沒需求呢？沒需求自己跑着跑着也能崩潰，半夜被運維薅起來：“你這怎麼又有資料庫慢查詢，把别人業務都拖拉胯了！”

有人說30歲的人都，還和剛畢業的做一樣的活，是沒進步的！這太扯淡了，同樣是同樣的活，但做出來的結果可不一定是一樣的，有人能用

ifelse

把産品功能湊出來，也有人可以把需求拆解成各個功能子產品，定義接口、抽象類、實作和繼承，運用設計模式建構出一套新增需求時候能快速實作，出現問題能準确定位的代碼邏輯。這就像有人問：“樹上有十隻鳥，一槍打死一隻，還有幾隻？”，你會想到什麼？槍聲大嗎、鳥籠了嗎、鳥被綁樹上了嗎、有鳥殘疾的嗎、鳥被打死了嗎、打鳥的人眼睛好使嗎、算肚子裡懷孕的鳥嗎、打鳥犯法嗎、邊上樹還有其他鳥嗎等等，這些都是一個職業技術人在一個行業磨練出來的經驗，不是1天2天看幾本書，刷幾個洗腦文章能吸收的。

二、目标

交給 Spring 管理的 Bean 對象，一定就是我們用類建立出來的 Bean 嗎？建立出來的 Bean 就永遠是單例的嗎，沒有可能是原型模式嗎？

在集合 Spring 架構下，我們使用的 MyBatis 架構中，它的核心作用是可以滿足使用者不需要實作 Dao 接口類，就可以通過 xml 或者注解配置的方式完成對資料庫執行 CRUD 操作，那麼在實作這樣的 ORM 架構中，是怎麼把一個資料庫操作的 Bean 對象交給 Spring 管理的呢。

因為我們在使用 Spring、MyBatis 架構的時候都可以知道，并沒有手動的去建立任何操作資料庫的 Bean 對象，有的僅僅是一個接口定義，而這個接口定義竟然可以被注入到其他需要使用 Dao 的屬性中去了，那麼這一過程最核心待解決的問題，就是需要完成把複雜且以代理方式動态變化的對象，注冊到 Spring 容器中。而為了滿足這樣的一個擴充元件開發的需求，就需要我們在現有手寫的 Spring 架構中，添加這一能力。

三、方案

關于提供一個能讓使用者定義複雜的 Bean 對象，功能點非常不錯，意義也非常大，因為這樣做了之後 Spring 的生态種子孵化箱就此提供了，誰家的架構都可以在此标準上完成自己服務的接入。

但這樣的功能邏輯設計上并不複雜，因為整個 Spring 架構在開發的過程中就已經提供了各項擴充能力的

接茬

，你隻需要在合适的位置提供一個接茬的處理接口調用和相應的功能邏輯實作即可，像這裡的目标實作就是對外提供一個可以二次從 FactoryBean 的 getObject 方法中擷取對象的功能即可，這樣所有實作此接口的對象類，就可以擴充自己的對象功能了。MyBatis 就是實作了一個 MapperFactoryBean 類，在 getObject 方法中提供 SqlSession 對執行 CRUD 方法的操作整體設計結構如下圖：

整個的實作過程包括了兩部分，一個解決單例還是原型對象，另外一個處理 FactoryBean 類型對象建立過程中關于擷取具體調用對象的 getObject 操作。
SCOPE_SINGLETON 、 SCOPE_PROTOTYPE ，對象類型的建立擷取方式，主要區分在于 AbstractAutowireCapableBeanFactory#createBean 建立完成對象後是否放入到記憶體中，如果不放入則每次擷取都會重新建立。
createBean 執行對象建立、屬性填充、依賴加載、前置後置處理、初始化等操作後，就要開始做執行判斷整個對象是否是一個 FactoryBean 對象，如果是這樣的對象，就需要再繼續執行擷取 FactoryBean 具體對象中的 getObject 對象了。整個 getBean 過程中都會新增一個單例類型的判斷 factory.isSingleton() ，用于決定是否使用記憶體存放對象資訊。

四、實作

1. 工程結構

small-spring-step-09
└── src
    ├── main
    │   └── java
    │       └── cn.bugstack.springframework
    │           ├── beans
    │           │   ├── factory
    │           │   │   ├── config
    │           │   │   │   ├── AutowireCapableBeanFactory.java
    │           │   │   │   ├── BeanDefinition.java
    │           │   │   │   ├── BeanFactoryPostProcessor.java
    │           │   │   │   ├── BeanPostProcessor.java
    │           │   │   │   ├── BeanReference.java
    │           │   │   │   ├── ConfigurableBeanFactory.java
    │           │   │   │   └── SingletonBeanRegistry.java
    │           │   │   ├── support
    │           │   │   │   ├── AbstractAutowireCapableBeanFactory.java
    │           │   │   │   ├── AbstractBeanDefinitionReader.java
    │           │   │   │   ├── AbstractBeanFactory.java
    │           │   │   │   ├── BeanDefinitionReader.java
    │           │   │   │   ├── BeanDefinitionRegistry.java
    │           │   │   │   ├── CglibSubclassingInstantiationStrategy.java
    │           │   │   │   ├── DefaultListableBeanFactory.java
    │           │   │   │   ├── DefaultSingletonBeanRegistry.java
    │           │   │   │   ├── DisposableBeanAdapter.java
    │           │   │   │   ├── FactoryBeanRegistrySupport.java
    │           │   │   │   ├── InstantiationStrategy.java
    │           │   │   │   └── SimpleInstantiationStrategy.java  
    │           │   │   ├── support
    │           │   │   │   └── XmlBeanDefinitionReader.java
    │           │   │   ├── Aware.java
    │           │   │   ├── BeanClassLoaderAware.java
    │           │   │   ├── BeanFactory.java
    │           │   │   ├── BeanFactoryAware.java
    │           │   │   ├── BeanNameAware.java
    │           │   │   ├── ConfigurableListableBeanFactory.java
    │           │   │   ├── DisposableBean.java
    │           │   │   ├── FactoryBean.java
    │           │   │   ├── HierarchicalBeanFactory.java
    │           │   │   ├── InitializingBean.java
    │           │   │   └── ListableBeanFactory.java
    │           │   ├── BeansException.java
    │           │   ├── PropertyValue.java
    │           │   └── PropertyValues.java 
    │           ├── context
    │           │   ├── support
    │           │   │   ├── AbstractApplicationContext.java 
    │           │   │   ├── AbstractRefreshableApplicationContext.java 
    │           │   │   ├── AbstractXmlApplicationContext.java 
    │           │   │   ├── ApplicationContextAwareProcessor.java 
    │           │   │   └── ClassPathXmlApplicationContext.java 
    │           │   ├── ApplicationContext.java 
    │           │   ├── ApplicationContextAware.java 
    │           │   └── ConfigurableApplicationContext.java
    │           ├── core.io
    │           │   ├── ClassPathResource.java 
    │           │   ├── DefaultResourceLoader.java 
    │           │   ├── FileSystemResource.java 
    │           │   ├── Resource.java 
    │           │   ├── ResourceLoader.java 
    │           │   └── UrlResource.java
    │           └── utils
    │               └── ClassUtils.java
    └── test
        └── java
            └── cn.bugstack.springframework.test
                ├── bean
                │   ├── UserDao.java
                │   └── UserService.java
                └── ApiTest.java

工程源碼：

公衆号「bugstack蟲洞棧」，回複：Spring 專欄，擷取完整源碼

Spring 單例、原型以及

FactoryBean

功能實作類關系，如圖 10-2

以上整個類關系圖展示的就是添加 Bean 的執行個體化是單例還是原型模式以及 FactoryBean 的實作。
其實整個實作的過程并不複雜，隻是在現有的 AbstractAutowireCapableBeanFactory 類以及繼承的抽象類 AbstractBeanFactory 中進行擴充。
不過這次我們把 AbstractBeanFactory 繼承的 DefaultSingletonBeanRegistry 類，中間加了一層 FactoryBeanRegistrySupport，這個類在 Spring 架構中主要是處理關于 FactoryBean 注冊的支撐操作。

2. Bean的作用範圍定義和xml解析

cn.bugstack.springframework.beans.factory.config.BeanDefinition

public class BeanDefinition {

    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

    private Class beanClass;

    private PropertyValues propertyValues;

    private String initMethodName;

    private String destroyMethodName;

    private String scope = SCOPE_SINGLETON;

    private boolean singleton = true;

    private boolean prototype = false;
    
    // ...get/set
}

singleton、prototype，是本次在 BeanDefinition 類中新增加的兩個屬性資訊，用于把從 spring.xml 中解析到的 Bean 對象作用範圍填充到屬性中。

cn.bugstack.springframework.beans.factory.xml.XmlBeanDefinitionReader

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    protected void doLoadBeanDefinitions(InputStream inputStream) throws ClassNotFoundException {
      
        for (int i = 0; i < childNodes.getLength(); i++) {
            // 判斷元素
            if (!(childNodes.item(i) instanceof Element)) continue;
            // 判斷對象
            if (!"bean".equals(childNodes.item(i).getNodeName())) continue;

            // 解析标簽
            Element bean = (Element) childNodes.item(i);
            String id = bean.getAttribute("id");
            String name = bean.getAttribute("name");
            String className = bean.getAttribute("class");
            String initMethod = bean.getAttribute("init-method");
            String destroyMethodName = bean.getAttribute("destroy-method");
            String beanScope = bean.getAttribute("scope");

            // 擷取 Class，友善擷取類中的名稱
            Class<?> clazz = Class.forName(className);
            // 優先級 id > name
            String beanName = StrUtil.isNotEmpty(id) ? id : name;
            if (StrUtil.isEmpty(beanName)) {
                beanName = StrUtil.lowerFirst(clazz.getSimpleName());
            }

            // 定義Bean
            BeanDefinition beanDefinition = new BeanDefinition(clazz);
            beanDefinition.setInitMethodName(initMethod);
            beanDefinition.setDestroyMethodName(destroyMethodName);

            if (StrUtil.isNotEmpty(beanScope)) {
                beanDefinition.setScope(beanScope);
            }
            
            // ...
            
            // 注冊 BeanDefinition
            getRegistry().registerBeanDefinition(beanName, beanDefinition);
        }
    }

}

在解析 XML 處理類 XmlBeanDefinitionReader 中，新增加了關于 Bean 對象配置中 scope 的解析，并把這個屬性資訊填充到 Bean 定義中。 beanDefinition.setScope(beanScope)

3. 建立和修改對象時候判斷單例和原型模式

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

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {

    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);
            // 給 Bean 填充屬性
            applyPropertyValues(beanName, bean, beanDefinition);
            // 執行 Bean 的初始化方法和 BeanPostProcessor 的前置和後置處理方法
            bean = initializeBean(beanName, bean, beanDefinition);
        } catch (Exception e) {
            throw new BeansException("Instantiation of bean failed", e);
        }

        // 注冊實作了 DisposableBean 接口的 Bean 對象
        registerDisposableBeanIfNecessary(beanName, bean, beanDefinition);

        // 判斷 SCOPE_SINGLETON、SCOPE_PROTOTYPE
        if (beanDefinition.isSingleton()) {
            addSingleton(beanName, bean);
        }
        return bean;
    }

    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, BeanDefinition beanDefinition) {
        // 非 Singleton 類型的 Bean 不執行銷毀方法
        if (!beanDefinition.isSingleton()) return;

        if (bean instanceof DisposableBean || StrUtil.isNotEmpty(beanDefinition.getDestroyMethodName())) {
            registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, beanDefinition));
        }
    }
    
    // ... 其他功能
}

單例模式和原型模式的差別就在于是否存放到記憶體中，如果是原型模式那麼就不會存放到記憶體中，每次擷取都重新建立對象，另外非 Singleton 類型的 Bean 不需要執行銷毀方法。
是以這裡的代碼會有兩處修改，一處是 createBean 中判斷是否添加到 addSingleton(beanName, bean);，另外一處是 registerDisposableBeanIfNecessary 銷毀注冊中的判斷 if (!beanDefinition.isSingleton()) return; 。

4. 定義 FactoryBean 接口

cn.bugstack.springframework.beans.factory.FactoryBean

public interface FactoryBean<T> {

    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();

}

FactoryBean 中需要提供3個方法，擷取對象、對象類型，以及是否是單例對象，如果是單例對象依然會被放到記憶體中。

5. 實作一個 FactoryBean 注冊服務

cn.bugstack.springframework.beans.factory.support.FactoryBeanRegistrySupport

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

    /**
     * Cache of singleton objects created by FactoryBeans: FactoryBean name --> object
     */
    private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>();

    protected Object getCachedObjectForFactoryBean(String beanName) {
        Object object = this.factoryBeanObjectCache.get(beanName);
        return (object != NULL_OBJECT ? object : null);
    }

    protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName) {
        if (factory.isSingleton()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                object = doGetObjectFromFactoryBean(factory, beanName);
                this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
            }
            return (object != NULL_OBJECT ? object : null);
        } else {
            return doGetObjectFromFactoryBean(factory, beanName);
        }
    }

    private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName){
        try {
            return factory.getObject();
        } catch (Exception e) {
            throw new BeansException("FactoryBean threw exception on object[" + beanName + "] creation", e);
        }
    }

}

FactoryBeanRegistrySupport 類主要處理的就是關于 FactoryBean 此類對象的注冊操作，之是以放到這樣一個單獨的類裡，就是希望做到不同領域子產品下隻負責各自需要完成的功能，避免因為擴充導緻類膨脹到難以維護。
同樣這裡也定義了緩存操作 factoryBeanObjectCache，用于存放單例類型的對象，避免重複建立。在日常使用用，基本也都是建立的單例對象
doGetObjectFromFactoryBean 是具體的擷取 FactoryBean#getObject() 方法，因為既有緩存的處理也有對象的擷取，是以額外提供了 getObjectFromFactoryBean 進行邏輯包裝，這部分的操作方式是不和你日常做的業務邏輯開發非常相似。從Redis取資料，如果為空就從資料庫擷取并寫入Redis

6. 擴充 AbstractBeanFactory 建立對象邏輯

cn.bugstack.springframework.beans.factory.support.AbstractBeanFactory

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

    protected <T> T doGetBean(final String name, final Object[] args) {
        Object sharedInstance = getSingleton(name);
        if (sharedInstance != null) {
            // 如果是 FactoryBean，則需要調用 FactoryBean#getObject
            return (T) getObjectForBeanInstance(sharedInstance, name);
        }

        BeanDefinition beanDefinition = getBeanDefinition(name);
        Object bean = createBean(name, beanDefinition, args);
        return (T) getObjectForBeanInstance(bean, name);
    }  
   
    private Object getObjectForBeanInstance(Object beanInstance, String beanName) {
        if (!(beanInstance instanceof FactoryBean)) {
            return beanInstance;
        }

        Object object = getCachedObjectForFactoryBean(beanName);

        if (object == null) {
            FactoryBean<?> factoryBean = (FactoryBean<?>) beanInstance;
            object = getObjectFromFactoryBean(factoryBean, beanName);
        }

        return object;
    }
        
    // ...
}

首先這裡把 AbstractBeanFactory 原來繼承的 DefaultSingletonBeanRegistry，修改為繼承 FactoryBeanRegistrySupport。因為需要擴充出建立 FactoryBean 對象的能力，是以這就想一個鍊條服務上，截出一個段來處理額外的服務，并把鍊條再連結上。
此處新增加的功能主要是在 doGetBean 方法中，添加了調用 (T) getObjectForBeanInstance(sharedInstance, name) 對擷取 FactoryBean 的操作。
在 getObjectForBeanInstance 方法中做具體的 instanceof 判斷，另外還會從 FactoryBean 的緩存中擷取對象，如果不存在則調用 FactoryBeanRegistrySupport#getObjectFromFactoryBean，執行具體的操作。

五、測試

1. 事先準備

cn.bugstack.springframework.test.bean.IUserDao

public interface IUserDao {

    String queryUserName(String uId);

}

這個章節我們删掉 UserDao，定義一個 IUserDao 接口，之所這樣做是為了通過 FactoryBean 做一個自定義對象的代理操作。

cn.bugstack.springframework.test.bean.UserService

public class UserService {

    private String uId;
    private String company;
    private String location;
    private IUserDao userDao;

    public String queryUserInfo() {
        return userDao.queryUserName(uId) + "," + company + "," + location;
    }

    // ...get/set
}

在 UserService 新修改了一個原有 UserDao 屬性為 IUserDao，後面我們會給這個屬性注入代理對象。

2. 定義 FactoryBean 對象

cn.bugstack.springframework.test.bean.ProxyBeanFactory

public class ProxyBeanFactory implements FactoryBean<IUserDao> {

    @Override
    public IUserDao getObject() throws Exception {
        InvocationHandler handler = (proxy, method, args) -> {

            Map<String, String> hashMap = new HashMap<>();
            hashMap.put("10001", "小傅哥");
            hashMap.put("10002", "八杯水");
            hashMap.put("10003", "阿毛");
            
            return "你被代理了 " + method.getName() + "：" + hashMap.get(args[0].toString());
        };
        return (IUserDao) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{IUserDao.class}, handler);
    }

    @Override
    public Class<?> getObjectType() {
        return IUserDao.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

}

這是一個實作接口 FactoryBean 的代理類 ProxyBeanFactory 名稱，主要是模拟了 UserDao 的原有功能，類似于 MyBatis 架構中的代理操作。
getObject() 中提供的就是一個 InvocationHandler 的代理對象，當有方法調用的時候，則執行代理對象的功能。

3. 配置檔案

<?xml version="1.0" encoding="UTF-8"?>
<beans>

    <bean id="userService" class="cn.bugstack.springframework.test.bean.UserService" scope="prototype">
        <property name="uId" value="10001"/>
        <property name="company" value="騰訊"/>
        <property name="location" value="深圳"/>
        <property name="userDao" ref="proxyUserDao"/>
    </bean>

    <bean id="proxyUserDao" class="cn.bugstack.springframework.test.bean.ProxyBeanFactory"/>

</beans>

在配置檔案中，我們把 proxyUserDao 這個代理對象，注入到 userService 的 userDao 中。與上一章節相比，去掉了 UserDao 實作類，轉而用代理類替換

4. 單元測試(單例&原型)

@Test
public void test_prototype() {
    // 1.初始化 BeanFactory
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
    applicationContext.registerShutdownHook();   

    // 2. 擷取Bean對象調用方法
    UserService userService01 = applicationContext.getBean("userService", UserService.class);
    UserService userService02 = applicationContext.getBean("userService", UserService.class);
    
    // 3. 配置 scope="prototype/singleton"
    System.out.println(userService01);
    System.out.println(userService02);    

    // 4. 列印十六進制哈希
    System.out.println(userService01 + " 十六進制哈希：" + Integer.toHexString(userService01.hashCode()));
    System.out.println(ClassLayout.parseInstance(userService01).toPrintable());

}

在 spring.xml 配置檔案中，設定了 scope="prototype" 這樣就每次擷取到的對象都應該是一個新的對象。
這裡判斷對象是否為一個會看到列印的類對象的哈希值，是以我們把十六進制哈希列印出來。

測試結果

cn.bugstack.springframework.test.bean.UserService$$EnhancerByCGLIB$$4cabb984@1b0375b3
cn.bugstack.springframework.test.bean.UserService$$EnhancerByCGLIB$$4cabb984@2f7c7260
cn.bugstack.springframework.test.bean.UserService$$EnhancerByCGLIB$$4cabb984@1b0375b3 十六進制哈希：1b0375b3
cn.bugstack.springframework.test.bean.UserService$$EnhancerByCGLIB$$4cabb984 object internals:
 OFFSET  SIZE                                             TYPE DESCRIPTION                                               VALUE
      0     4                                                  (object header)                                           01 b3 75 03 (00000001 10110011 01110101 00000011) (58045185)
      4     4                                                  (object header)                                           1b 00 00 00 (00011011 00000000 00000000 00000000) (27)
      8     4                                                  (object header)                                           9f e1 01 f8 (10011111 11100001 00000001 11111000) (-134094433)
     12     4                                 java.lang.String UserService.uId                                           (object)
     16     4                                 java.lang.String UserService.company                                       (object)
     20     4                                 java.lang.String UserService.location                                      (object)
     24     4   cn.bugstack.springframework.test.bean.IUserDao UserService.userDao                                       (object)
     28     1                                          boolean UserService$$EnhancerByCGLIB$$4cabb984.CGLIB$BOUND        true
     29     3                                                  (alignment/padding gap)                                  
     32     4                          net.sf.cglib.proxy.NoOp UserService$$EnhancerByCGLIB$$4cabb984.CGLIB$CALLBACK_0   (object)
     36     4                                                  (loss due to the next object alignment)
Instance size: 40 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total


Process finished with exit code 0

對象後面的這一小段字元串就是16進制哈希值，在對象頭哈希值存放的結果上看，也有對應的數值。隻不過這個結果是倒過來的。
另外可以看到 cabb984@1b0375b3、cabb984@2f7c7260，這兩個對象的結尾16進制哈希值并不一樣，是以我們的原型模式是生效的。

5. 單元測試(代理對象)

@Test
public void test_factory_bean() {
    // 1.初始化 BeanFactory
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
    applicationContext.registerShutdownHook(); 

    // 2. 調用代理方法
    UserService userService = applicationContext.getBean("userService", UserService.class);
    System.out.println("測試結果：" + userService.queryUserInfo());
}

關于 FactoryBean 的調用并沒有太多不一樣，因為所有的不同都已經被 spring.xml 配置進去了。當然你可以直接調用 spring.xml 配置的對象 cn.bugstack.springframework.test.bean.ProxyBeanFactory

測試結果：你被代理了 queryUserName：小傅哥,騰訊,深圳

Process finished with exit code 0

從測試結果來看，我們的代理類 ProxyBeanFactory 已經完美替換掉了 UserDao 的功能。
雖然看上去這一點實作并不複雜，甚至有點簡單。但就是這樣一點點核心内容的設計了，解決了所有需要和 Spring 結合的其他架構互動連結問題。如果對此類内容感興趣，也可以閱讀小傅哥《中間件設計和開發》

六、總結

在 Spring 架構整個開發的過程中，前期的各個功能接口類擴充的像膨脹了似的，但到後期在完善功能時，就沒有那麼難了，反而深入了解後會覺得功能的補充，都比較簡單。隻需要再所遇領域範圍内進行擴充相應的服務實作即可。
當你仔細閱讀完關于 FactoryBean 的實作以及測試過程的使用，以後再需要使用 FactoryBean 開發相應的元件時候，一定會非常清楚它是如何建立自己的複雜 Bean 對象以及在什麼時候初始化和調用的。遇到問題也可以快速的排查、定位和解決。
如果你在學習的過程中感覺這些類、接口、實作、繼承，穿梭的很複雜，一時半會腦子還反應不過來。那麼你最好的方式是動手去畫畫這些類關系圖，梳理下實作的結構，看看每個類在幹什麼。看隻能是知道，動手才能學會！

七、系列推薦

你說，怎麼把Bean塞到Spring容器？
《Java 面經手冊》PDF，全書 417 頁 11.5 萬字，完稿&發版！
數學，離一個程式員有多近？
工作3年，看啥資料能月薪30K？
PPT畫成這樣，述職答辯還能過嗎？

公衆号：bugstack蟲洞棧 | 作者小傅哥多年從事一線網際網路 Java 開發的學習曆程技術彙總，旨在為大家提供一個清晰詳細的學習教程，側重點更傾向編寫Java核心内容。如果能為您提供幫助，請給予支援(關注、點贊、分享)！

【帶你手撸Spring】沒有哪個架構開發，能離開 Spring 的 FactoryBean！

一、前言

二、目标

三、方案

四、實作

1. 工程結構

2. Bean的作用範圍定義和xml解析

3. 建立和修改對象時候判斷單例和原型模式

4. 定義 FactoryBean 接口

5. 實作一個 FactoryBean 注冊服務

6. 擴充 AbstractBeanFactory 建立對象邏輯

五、測試

1. 事先準備

2. 定義 FactoryBean 對象

3. 配置檔案

4. 單元測試(單例&原型)

5. 單元測試(代理對象)

六、總結

七、系列推薦

繼續閱讀

MyBatis-Plus 之AR模式

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法