面試官：展開說說，Spring中Bean物件是如何通過注解注入的？-有解無憂

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

沉淀、分享、成長，讓自己和他人都能有所識訓！😄

章節目錄(手寫Spring，讓你了解更多)

第 01 章：開篇介紹，我要帶你擼 Spring 啦！
第 02 章：小試牛刀，實作一個簡單的Bean容器
第 03 章：初顯身手，運用設計模式，實作 Bean 的定義、注冊、獲取
第 04 章：嶄露頭角，基于Cglib實作含建構式的類實體化策略
第 05 章：一鳴驚人，為Bean物件注入屬性和依賴Bean的功能實作
第 06 章：氣吞山河，設計與實作資源加載器，從Spring.xml決議和注冊Bean物件
第 07 章：所向披靡，實作應用背景關系，自動識別、資源加載、擴展機制
第 08 章：龍行有風，向虛擬機注冊鉤子，實作Bean物件的初始化和銷毀方法
第 09 章：虎行有雨，定義標記型別Aware介面，實作感知容器物件
第 10 章：橫刀躍馬，關于Bean物件作用域以及FactoryBean的實作和使用
第 11 章：更上層樓，基于觀察者實作，容器事件和事件監聽器
第 12 章：爐火純青，基于JDK和Cglib動態代理，實作AOP核心功能
第 13 章：行云流水，把AOP動態代理，融入到Bean的生命周期
第 14 章：笑傲江湖，通過注解配置和包自動掃描的方式完成Bean物件的注冊
第 15 章：萬人之敵，通過注解給屬性注入配置和Bean物件
第 16 章：待歸檔…

一、前言

寫代碼，就是從能用到好用的不斷折騰！

你聽過擾動函式嗎？你寫過斐波那契（Fibonacci）散列嗎？你實作過梅森旋轉演算法嗎？怎么沒聽過這些寫不了代碼嗎！不會的，即使沒聽過你一樣可以寫的了代碼，比如你實作的資料庫路由資料總是落在1庫1表它不散列分布、你實作的抽獎系統總是把運營配置的最大紅包發出去提高了運營成本、你開發的秒殺系統總是在開始后的1秒就掛了貨品根本給不出去，

除了一部分僅把編碼當成搬磚應付作業外的程式員，還有一部分總是在追求極致的碼農，寫代碼還能賺錢，真開心！ 這樣的碼農總是會考慮🤔還有沒有更好的實作邏輯能讓代碼不僅是能用，還要好用呢？其實這一點的追求到完成，需要大量擴展性學習和深度挖掘，這樣你設計出來的系統才更你考慮的更加全面，也能應對各種復雜的場景，

二、目標

在目前 IOC、AOP 兩大核心功能模塊的支撐下，完全可以管理 Bean 物件的注冊和獲取，不過這樣的使用方式總感覺像是刀耕火種有點難用，因此在上一章節我們解決需要手動配置 Bean 物件到 spring.xml 檔案中，改為可以自動掃描帶有注解 @Component 的物件完成自動裝配和注冊到 Spring 容器的操作，

那么在自動掃描包注冊 Bean 物件之后，就需要把原來在組態檔中通過 property name="token" 配置屬性和Bean的操作，也改為可以自動注入，這就像我們使用 Spring 框架中 @Autowired、@Value 注解一樣，完成我們對屬性和物件的注入操作，

三、方案

其實從我們在完成 Bean 物件的基礎功能后，后續陸續添加的功能都是圍繞著 Bean 的生命周期進行的，比如修改 Bean 的定義 BeanFactoryPostProcessor，處理 Bean 的屬性要用到 BeanPostProcessor，完成個性的屬性操作則專門繼承 BeanPostProcessor 提供新的介面，因為這樣才能通過 instanceof 判斷出具有標記性的介面，所以關于 Bean 等等的操作，以及監聽 Aware、獲取 BeanFactory，都需要在 Bean 的生命周期中完成，那么我們在設計屬性和 Bean 物件的注入時候，也會用到 BeanPostProcessor 來完成在設定 Bean 屬性之前，允許 BeanPostProcessor 修改屬性值，整體設計結構如下圖：

要處理自動掃描注入，包括屬性注入、物件注入，則需要在物件屬性 applyPropertyValues 填充之前，把屬性資訊寫入到 PropertyValues 的集合中去，這一步的操作相當于是解決了以前在 spring.xml 配置屬性的程序，
而在屬性的讀取中，需要依賴于對 Bean 物件的類中屬性的配置了注解的掃描，field.getAnnotation(Value.class); 依次拿出符合的屬性并填充上相應的配置資訊，這里有一點，屬性的配置資訊需要依賴于 BeanFactoryPostProcessor 的實作類 PropertyPlaceholderConfigurer，把值寫入到 AbstractBeanFactory的embeddedValueResolvers集合中，這樣才能在屬性填充中利用 beanFactory 獲取相應的屬性值
還有一個是關于 @Autowired 對于物件的注入，其實這一個和屬性注入的唯一區別是對于物件的獲取 beanFactory.getBean(fieldType)，其他就沒有什么差一點了，
當所有的屬性被設定到 PropertyValues 完成以后，接下來就到了創建物件的下一步，屬性填充，而此時就會把我們一一獲取到的配置和物件填充到屬性上，也就實作了自動注入的功能，

四、實作

1. 工程結構

small-spring-step-14
└── src
    ├── main
    │   └── java
    │       └── cn.bugstack.springframework
    │           ├── aop
    │           │   ├── aspectj
    │           │   │   └── AspectJExpressionPointcut.java
    │           │   │   └── AspectJExpressionPointcutAdvisor.java
    │           │   ├── framework 
    │           │   │   ├── adapter
    │           │   │   │   └── MethodBeforeAdviceInterceptor.java
    │           │   │   ├── autoproxy
    │           │   │   │   └── MethodBeforeAdviceInterceptor.java
    │           │   │   ├── AopProxy.java
    │           │   │   ├── Cglib2AopProxy.java
    │           │   │   ├── JdkDynamicAopProxy.java
    │           │   │   ├── ProxyFactory.java
    │           │   │   └── ReflectiveMethodInvocation.java
    │           │   ├── AdvisedSupport.java
    │           │   ├── Advisor.java
    │           │   ├── BeforeAdvice.java
    │           │   ├── ClassFilter.java
    │           │   ├── MethodBeforeAdvice.java
    │           │   ├── MethodMatcher.java
    │           │   ├── Pointcut.java
    │           │   ├── PointcutAdvisor.java
    │           │   └── TargetSource.java
    │           ├── beans
    │           │   ├── factory  
    │           │   │   ├── annotation
    │           │   │   │   ├── Autowired.java
    │           │   │   │   ├── AutowiredAnnotationBeanPostProcessor.java
    │           │   │   │   ├── Qualifier.java
    │           │   │   │   └── Value.java
    │           │   │   ├── config
    │           │   │   │   ├── AutowireCapableBeanFactory.java
    │           │   │   │   ├── BeanDefinition.java
    │           │   │   │   ├── BeanFactoryPostProcessor.java
    │           │   │   │   ├── BeanPostProcessor.java
    │           │   │   │   ├── BeanReference.java
    │           │   │   │   ├── ConfigurableBeanFactory.java
    │           │   │   │   ├── InstantiationAwareBeanPostProcessor.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
    │           │   │   └── PropertyPlaceholderConfigurer.java
    │           │   ├── BeansException.java
    │           │   ├── PropertyValue.java
    │           │   └── PropertyValues.java 
    │           ├── context
    │           │   ├── annotation
    │           │   │   ├── ClassPathBeanDefinitionScanner.java 
    │           │   │   ├── ClassPathScanningCandidateComponentProvider.java 
    │           │   │   └── Scope.java 
    │           │   ├── event
    │           │   │   ├── AbstractApplicationEventMulticaster.java 
    │           │   │   ├── ApplicationContextEvent.java 
    │           │   │   ├── ApplicationEventMulticaster.java 
    │           │   │   ├── ContextClosedEvent.java 
    │           │   │   ├── ContextRefreshedEvent.java 
    │           │   │   └── SimpleApplicationEventMulticaster.java 
    │           │   ├── support
    │           │   │   ├── AbstractApplicationContext.java 
    │           │   │   ├── AbstractRefreshableApplicationContext.java 
    │           │   │   ├── AbstractXmlApplicationContext.java 
    │           │   │   ├── ApplicationContextAwareProcessor.java 
    │           │   │   └── ClassPathXmlApplicationContext.java 
    │           │   ├── ApplicationContext.java 
    │           │   ├── ApplicationContextAware.java 
    │           │   ├── ApplicationEvent.java 
    │           │   ├── ApplicationEventPublisher.java 
    │           │   ├── ApplicationListener.java 
    │           │   └── ConfigurableApplicationContext.java
    │           ├── core.io
    │           │   ├── ClassPathResource.java 
    │           │   ├── DefaultResourceLoader.java 
    │           │   ├── FileSystemResource.java 
    │           │   ├── Resource.java 
    │           │   ├── ResourceLoader.java
    │           │   └── UrlResource.java
    │           ├── stereotype
    │           │   └── Component.java
    │           └── utils
    │               ├── ClassUtils.java
    │               └── StringValueResolver.java
    └── test
        └── java
            └── cn.bugstack.springframework.test
                ├── bean
                │   ├── IUserService.java
                │   └── UserService.java
                └── ApiTest.java

工程原始碼：公眾號「bugstack蟲洞堆疊」，回復：Spring 專欄，獲取完整原始碼

自動掃描注入占位符配置和物件的類關系，如圖 15-2

圖 15-2

在整個類圖中以圍繞實作介面 InstantiationAwareBeanPostProcessor 的類 AutowiredAnnotationBeanPostProcessor 作為入口點，被 AbstractAutowireCapableBeanFactory創建 Bean 物件程序中呼叫掃描整個類的屬性配置中含有自定義注解 Value、Autowired、Qualifier，的屬性值，
這里稍有變動的是關于屬性值資訊的獲取，在注解配置的屬性欄位掃描到資訊注入時，包括了占位符從組態檔獲取資訊也包括 Bean 物件，Bean 物件可以直接獲取，但配置資訊需要在 AbstractBeanFactory 中添加新的屬性集合 embeddedValueResolvers，由 PropertyPlaceholderConfigurer#postProcessBeanFactory 進行操作填充到屬性集合中，

2. 把讀取到屬性填充到容器

定義決議字串介面

cn.bugstack.springframework.util.StringValueResolver

public interface StringValueResolver {

    String resolveStringValue(String strVal);

}

介面 StringValueResolver 是一個決議字串操作的介面

填充字串

public class PropertyPlaceholderConfigurer implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            // 加載屬性檔案
            DefaultResourceLoader resourceLoader = new DefaultResourceLoader();
            Resource resource = resourceLoader.getResource(location);
            
            // ... 占位符替換屬性值、設定屬性值

            // 向容器中添加字串決議器，供決議@Value注解使用
            StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(properties);
            beanFactory.addEmbeddedValueResolver(valueResolver);
            
        } catch (IOException e) {
            throw new BeansException("Could not load properties", e);
        }
    }

    private class PlaceholderResolvingStringValueResolver implements StringValueResolver {

        private final Properties properties;

        public PlaceholderResolvingStringValueResolver(Properties properties) {
            this.properties = properties;
        }

        @Override
        public String resolveStringValue(String strVal) {
            return PropertyPlaceholderConfigurer.this.resolvePlaceholder(strVal, properties);
        }

    }

}

在決議屬性配置的類 PropertyPlaceholderConfigurer 中，最主要的其實就是這行代碼的操作 beanFactory.addEmbeddedValueResolver(valueResolver) 這是把屬性值寫入到了 AbstractBeanFactory 的 embeddedValueResolvers 中，
這里說明下，embeddedValueResolvers 是 AbstractBeanFactory 類新增加的集合 List<StringValueResolver> embeddedValueResolvers String resolvers to apply e.g. to annotation attribute values

3. 自定義屬性注入注解

自定義注解，Autowired、Qualifier、Value

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD})
public @interface Autowired {
}

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {

    String value() default "";

}  

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {

    /**
     * The actual value expression: e.g. "#{systemProperties.myProp}".
     */
    String value();

}

3個注解在我們日常使用 Spring 也是非常常見的，注入物件、注入屬性，而 Qualifier 一般與 Autowired 配合使用，

4. 掃描自定義注解

cn.bugstack.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor

public class AutowiredAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware {

    private ConfigurableListableBeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 1. 處理注解 @Value
        Class<?> clazz = bean.getClass();
        clazz = ClassUtils.isCglibProxyClass(clazz) ? clazz.getSuperclass() : clazz;

        Field[] declaredFields = clazz.getDeclaredFields();

        for (Field field : declaredFields) {
            Value valueAnnotation = field.getAnnotation(Value.class);
            if (null != valueAnnotation) {
                String value = valueAnnotation.value();
                value = beanFactory.resolveEmbeddedValue(value);
                BeanUtil.setFieldValue(bean, field.getName(), value);
            }
        }

        // 2. 處理注解 @Autowired
        for (Field field : declaredFields) {
            Autowired autowiredAnnotation = field.getAnnotation(Autowired.class);
            if (null != autowiredAnnotation) {
                Class<?> fieldType = field.getType();
                String dependentBeanName = null;
                Qualifier qualifierAnnotation = field.getAnnotation(Qualifier.class);
                Object dependentBean = null;
                if (null != qualifierAnnotation) {
                    dependentBeanName = qualifierAnnotation.value();
                    dependentBean = beanFactory.getBean(dependentBeanName, fieldType);
                } else {
                    dependentBean = beanFactory.getBean(fieldType);
                }
                BeanUtil.setFieldValue(bean, field.getName(), dependentBean);
            }
        }

        return pvs;
    }

}

AutowiredAnnotationBeanPostProcessor 是實作介面 InstantiationAwareBeanPostProcessor 的一個用于在 Bean 物件實體化完成后，設定屬性操作前的處理屬性資訊的類和操作方法，只有實作了 BeanPostProcessor 介面才有機會在 Bean 的生命周期中處理初始化資訊
核心方法 postProcessPropertyValues，主要用于處理類含有 @Value、@Autowired 注解的屬性，進行屬性資訊的提取和設定，
這里需要注意一點因為我們在 AbstractAutowireCapableBeanFactory 類中使用的是 CglibSubclassingInstantiationStrategy 進行類的創建，所以在 AutowiredAnnotationBeanPostProcessor#postProcessPropertyValues 中需要判斷是否為 CGlib 創建物件，否則是不能正確拿到類資訊的，ClassUtils.isCglibProxyClass(clazz) ? clazz.getSuperclass() : clazz;

5. 在Bean的生命周期中呼叫屬性注入

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 物件
            bean = resolveBeforeInstantiation(beanName, beanDefinition);
            if (null != bean) {
                return bean;
            }
            // 實體化 Bean
            bean = createBeanInstance(beanDefinition, beanName, args);
            // 在設定 Bean 屬性之前，允許 BeanPostProcessor 修改屬性值
            applyBeanPostProcessorsBeforeApplyingPropertyValues(beanName, bean, beanDefinition);
            // 給 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()) {
            registerSingleton(beanName, bean);
        }
        return bean;
    }

    /**
     * 在設定 Bean 屬性之前，允許 BeanPostProcessor 修改屬性值
     *
     * @param beanName
     * @param bean
     * @param beanDefinition
     */
    protected void applyBeanPostProcessorsBeforeApplyingPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
        for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
            if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor){
                PropertyValues pvs = ((InstantiationAwareBeanPostProcessor) beanPostProcessor).postProcessPropertyValues(beanDefinition.getPropertyValues(), bean, beanName);
                if (null != pvs) {
                    for (PropertyValue propertyValue : pvs.getPropertyValues()) {
                        beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
                    }
                }
            }
        }
    }  

    // ...
}

AbstractAutowireCapableBeanFactory#createBean 方法中有這一條新增加的方法呼叫，就是在設定 Bean 屬性之前，允許 BeanPostProcessor 修改屬性值 的操作 applyBeanPostProcessorsBeforeApplyingPropertyValues
那么這個 applyBeanPostProcessorsBeforeApplyingPropertyValues 方法中，首先就是獲取已經注入的 BeanPostProcessor 集合并從中篩選出繼承介面 InstantiationAwareBeanPostProcessor 的實作類，
最后就是呼叫相應的 postProcessPropertyValues 方法以及回圈設定屬性值資訊，beanDefinition.getPropertyValues().addPropertyValue(propertyValue);

五、測驗

1. 事先準備

配置 Dao

@Component
public class UserDao {

    private static Map<String, String> hashMap = new HashMap<>();

    static {
        hashMap.put("10001", "小傅哥，北京，亦莊");
        hashMap.put("10002", "八杯水，上海，尖沙咀");
        hashMap.put("10003", "阿毛，香港，銅鑼灣");
    }

    public String queryUserName(String uId) {
        return hashMap.get(uId);
    }

}

給類配置上一個自動掃描注冊 Bean 物件的注解 @Component，接下來會把這個類注入到 UserService 中，

注解注入到 UserService

@Component("userService")
public class UserService implements IUserService {

    @Value("${token}")
    private String token;

    @Autowired
    private UserDao userDao;

    public String queryUserInfo() {
        try {
            Thread.sleep(new Random(1).nextInt(100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userDao.queryUserName("10001") + "，" + token;
    }    

    // ...
}

這里包括了兩種型別的注入，一個是占位符注入屬性資訊 @Value("${token}")，另外一個是注入物件資訊 @Autowired

2. 屬性組態檔

token.properties

token=RejDlI78hu223Opo983Ds

spring.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	         http://www.springframework.org/schema/beans/spring-beans.xsd
		 http://www.springframework.org/schema/context">

    <bean class="cn.bugstack.springframework.beans.factory.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:token.properties"/>
    </bean>

    <context:component-scan base-package="cn.bugstack.springframework.test.bean"/>

</beans>

在 spring.xml 中配置了掃描屬性資訊和自動掃描包路徑范圍，

3. 單元測驗

@Test
public void test_scan() {
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
    IUserService userService = applicationContext.getBean("userService", IUserService.class);
    System.out.println("測驗結果：" + userService.queryUserInfo());
}

單元測驗時候就可以完整的測驗一個類注入到 Spring 容器，同時這個屬性資訊也可以被自動掃描填充上，

測驗結果

測驗結果：小傅哥，北京，亦莊，RejDlI78hu223Opo983Ds

Process finished with exit code 0

從測驗結果可以看到現在我們的使用方式已經通過了，有自動掃描類，有注解注入屬性，這與使用 Spring 框架越來越像了，

六、總結

從整個注解資訊掃描注入的實作內容來看，我們一直是圍繞著在 Bean 的生命周期中進行處理，就像 BeanPostProcessor 用于修改新實體化 Bean 物件的擴展點，提供的介面方法可以用于處理 Bean 物件實體化前后進行處理操作，而有時候需要做一些差異化的控制，所以還需要繼承 BeanPostProcessor 介面，定義新的介面 InstantiationAwareBeanPostProcessor 這樣就可以區分出不同擴展點的操作了，
像是介面用 instanceof 判斷，注解用 Field.getAnnotation(Value.class); 獲取，都是相當于在類上做的一些標識性資訊，便于可以用一些方法找到這些功能點，以便進行處理，所以在我們日常開發設計的組件中，也可以運用上這些特點，
當你思考把你的實作融入到一個已經細分好的 Bean 生命周期中，你會發現它的設計是如此的好，可以讓你在任何初始化的時間點上，任何面上，都能做你需要的擴展或者改變，這也是我們做程式設計時追求的靈活性，

七、系列推薦

調研位元組碼插樁技術，用于系統監控設計和實作
作業兩三年了，整不明白架構圖都畫啥？
Thread.start() ，它是怎么讓執行緒啟動的呢？
基于jdbc實作一個Demo版的Mybatis
一個Bug，讓我發現了 Java 界的.AJ(錐)！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/292025.html

標籤：java

上一篇：新手小白學JAVA 基礎內容拓展鏈接匯總

下一篇：2107 JAVASE每日復習總結鏈接匯總