概述

本文以SpringBoot應用為基礎，嘗試分析基於註解@Configuration的配置類是如何向Spring容器註冊BeanDefinition的過程

其中主要分析了 ConfigurationClassPostProcessor 這個BeanDefinitionRegistryPostProcessor 即Bean定義註冊後置處理器，在Spring啟動過程中對@Configuration配置類的處理，主要體現在 解析並發現所有配置類，處理配置類的相關邏輯（如配置類上的@ComponentScan、@Import、@Bean註解等），註冊其中的BeanDefinition

SpringBoot版本：2.0.9.RELEASE

Spring版本：5.0.13.RELEASE

ConfigurationClassPostProcessor如何被引入

首先看一下ConfigurationClassPostProcessor的類繼承關係

從紅框中可以看出ConfigurationClassPostProcessor是BeanDefinitionRegistryPostProcessor接口的實現類，即是一個Bean定義註冊的後置處理器，會在Spring容器啟動時被調用，具體時機為

// 調用鏈
AbstractApplicationContext.refresh()
    => invokeBeanFactoryPostProcessors()
    => PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()

invokeBeanFactoryPostProcessors()會先調用所有的BeanDefinitionRegistryPostProcessor之後，再調用所有的BeanFactoryPostProcessor

ConfigurationClassPostProcessor又是如何被引入Spring的呢？？

SpringBoot應用會在ApplicationContext應用上下文被創建的構造函數中new AnnotatedBeanDefinitionReader這個用於註冊基於註解的BeanDefinition的Reader，在其構造中又會調用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)使用工具類向Spring容器中註冊一些所謂的註解配置處理器，其中就包含ConfigurationClassPostProcessor

// ConfigurationClassPostProcessor被註冊
AnnotationConfigServletWebServerApplicationContext構造
    => new AnnotatedBeanDefinitionReader(registry)
        => AnnotationConfigUtils.registerAnnotationConfigProcessors(registry)
            => 註冊ConfigurationClassPostProcessor到Spring容器

ConfigurationClassPostProcessor處理過程簡述

首先，ConfigurationClassPostProcessor後置處理器的處理入口為postProcessBeanDefinitionRegistry()方法。其主要使用了ConfigurationClassParser配置類解析器解析@Configuration配置類上的諸如@ComponentScan、@Import、@Bean等註解，並嘗試發現所有的配置類；還使用了ConfigurationClassBeanDefinitionReader註冊所發現的所有配置類中的所有Bean定義；結束執行的條件是所有配置類都被發現和處理，相應的bean定義註冊到容器

大致流程如下：

1、通過BeanDefinitionRegistry查找當前Spring容器中所有BeanDefinition

2、通過ConfigurationClassUtils.checkConfigurationClassCandidate() 檢查BeanDefinition是否為 “完全配置類” 或 “簡化配置類”，並對配置類做標記，放入集合待後續處理

Spring配置類的分類可以

3、通過 ConfigurationClassParser解析器 parse解析配置類集合，嘗試通過它們找到其它配置類

4、使用 ConfigurationClassBeanDefinitionReader 註冊通過所發現的配置類中找到的所有beanDefinition

5、處理完一輪配置類后，查看BeanDefinitionRegistry中是否存在新加載的且還未被處理過的 “完全配置類” 或 “簡化配置類”，有的話繼續上面步驟

其中第3、4步後面重點分析

ConfigurationClassParser#parse()：解析構建配置類

對於SpringBoot應用來說，參与解析的種子配置文件即為SpringBoot的Application啟動類

解析構建配置類流程

通過ConfigurationClassParser解析器parse解析配置類集合，嘗試通過它們找到其它配置類

• 循環解析所有配置類 ConfigurationClassParser#processConfigurationClass()

  • 根據@Conditional的ConfigurationPhase.PARSE_CONFIGURATION階段條件判斷是否跳過配置類

    注意：有些@Conditional是在當前這個PARSE_CONFIGURATION解析配置階段使用的，有些是在REGISTER_BEAN註冊beanDefinition階段使用的

  • 【重點】調用ConfigurationClassParser#doProcessConfigurationClass()循環解析配置類，直到不存在未處理過的父類

    • 1、處理配置類的成員內部類： 檢查其是否為“完全/簡化配置類”，是則對其繼續分析處理並將其放入分析器的屬性configurationClasses
    • 2、處理@PropertySource： 將找到的PropertySource添加到environment的PropertySource集合
    • 3、處理@ComponentScan： 掃描到的@Component類BeanDefinition就直接註冊到Spring容器；如果組件為配置類，繼續分析處理並將其放入分析器的屬性configurationClasses
    • 4、處理@Import：
      • （1）處理ImportSelector： 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()；其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
      • （2）處理ImportBeanDefinitionRegistrar： 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
      • （3）其它Import：調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
    • 5、處理@ImportResource： 添加到配置類的importedResources集合，後續ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()時再使用這些導入的BeanDefinitionReader讀取Resource中的bean定義並註冊
    • 6、處理@Bean： 獲取所有@Bean方法，並添加到配置類的beanMethods集合
    • 7、處理配置類接口上的default methods
    • 8、檢查是否有未處理的父類： 如果配置類有父類，且其不在解析器維護的knownSuperclasses中，對其調用doProcessConfigurationClass()重複如上檢查，直到不再有父類或父類在knownSuperclasses中已存在

• processDeferredImportSelectors()：處理推遲的ImportSelector集合，其實就是延遲調用了processImports()

  SpringBoot的自動配置類就是被DeferredImportSelector推遲導入的

解析構建配置類源碼分析

ConfigurationClassParser#processConfigurationClass()

包含了處理單個配置類的大體流程，先根據ConfigurationPhase.PARSE_CONFIGURATION解析配置階段的@Conditional條件判斷當前配置類是否應該解析，之後調用ConfigurationClassParser#doProcessConfigurationClass()循環解析配置類，直到不存在未處理過的父類

/**
 * 解析單個配置類
 * 解析的最後會將當前配置類放到configurationClasses
 */
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    /**
     * 根據@Conditional條件判斷是否跳過配置類
     * 注意：當前這個PARSE_CONFIGURATION解析配置階段只會使用這個階段的@Conditional條件，有些REGISTER_BEAN註冊beanDefinition階段的條件不會在此時使用
     */
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        return;
    }

    ConfigurationClass existingClass = this.configurationClasses.get(configClass);
    // 如果configClass在已經分析處理的配置類記錄中已存在
    if (existingClass != null) {
        //如果配置類是被@Import註冊的，return
        if (configClass.isImported()) {
            if (existingClass.isImported()) {
                existingClass.mergeImportedBy(configClass);
            }
            // Otherwise ignore new imported config class; existing non-imported class overrides it.
            return;
        }
        // 否則，清除老的記錄，在來一遍
        else {
            // Explicit bean definition found, probably replacing an import.
            // Let's remove the old one and go with the new one.
            this.configurationClasses.remove(configClass);
            this.knownSuperclasses.values().removeIf(configClass::equals);
        }
    }

    // Recursively process the configuration class and its superclass hierarchy.
    /**
     * 遞歸處理配置類及其超類層次結構
     * 從當前配置類configClass開始向上沿着類繼承結構逐層執行doProcessConfigurationClass，直到遇到的父類是由Java提供的類結束循環
     */
    SourceClass sourceClass = asSourceClass(configClass);
    /**
     * 循環處理配置類configClass直到sourceClass變為null，即父類為null
     * doProcessConfigurationClass的返回值是其參數configClass的父類
     * 如果該父類是由Java提供的類或者已經處理過，返回null
     */
    do {
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    }
    while (sourceClass != null);

    this.configurationClasses.put(configClass, configClass);
}

ConfigurationClassParser#doProcessConfigurationClass()：真正解析配置類

通過解析配置類上的註解、內部成員類和方法構建一個完整的ConfigurationClass配置類，過程中如果發現了新的配置類可以重複調用此方法

真正解析過程中會處理成員內部類、@PropertySource、@ComponentScan、@Import、@ImportSource、@Bean方法等，流程如下：

• 1、處理配置類的成員內部類： 檢查其是否為“完全/簡化配置類”，是則對其繼續分析處理並將其放入分析器的屬性configurationClasses
• 2、處理@PropertySource： 將找到的PropertySource添加到environment的PropertySource集合
• 3、處理@ComponentScan： 掃描到的@Component類BeanDefinition就直接註冊到Spring容器；如果組件為配置類，繼續分析處理並將其放入分析器的屬性configurationClasses
• 4、處理@Import：
  • （1）處理ImportSelector： 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()；其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
  • （2）處理ImportBeanDefinitionRegistrar： 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
  • （3）其它Import： 調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
• 5、處理@ImportResource： 添加到配置類的importedResources集合，後續ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()時再使用這些導入的BeanDefinitionReader讀取Resource中的bean定義並註冊
• 6、處理@Bean： 獲取所有@Bean方法，並添加到配置類的beanMethods集合
• 7、處理配置類接口上的default methods
• 8、檢查是否有未處理的父類： 如果配置類有父類，且其不在解析器維護的knownSuperclasses中，對其調用doProcessConfigurationClass()重複如上檢查，直到不再有父類或父類在knownSuperclasses中已存在

/**
 * Apply processing and build a complete {@link ConfigurationClass} by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or {@code null} if none found or previously processed
 */
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
        throws IOException {

    // Recursively process any member (nested) classes first
    /**
     * 1、處理配置類的成員類(配置類內嵌套定義的類)
     * 內部嵌套類也可能是配置類，遍歷這些成員類，檢查是否為"完全/簡化配置類"
     * 有的話，調用processConfigurationClass()處理它們，最終將配置類放入configurationClasses集合
     */
    processMemberClasses(configClass, sourceClass);

    // Process any @PropertySource annotations
    /**
     * 2、處理 @PropertySource
     * 將找到的PropertySource添加到environment的PropertySource集合
     */
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // Process any @ComponentScan annotations
    /**
     * 3、處理 @ComponentScan
     * 處理用戶手工添加的@ComponentScan，SpringBoot創建ApplicationContext時的ClassPathBeanDefinitionScanner是為了掃描啟動類下的包
     * 為的是找到滿足條件的@ComponentScan，即@Component相關的組件，先掃描一下，掃描到的就註冊為BeanDefinition
     * 看其中是否還有配置類，有的話parse()繼續分析處理，配置類添加到configurationClasses集合
     */
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    // 如果當前配置類上有@ComponentScan，且使用REGISTER_BEAN註冊beanDefinition的條件判斷也不跳過的話
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            // 立即掃描，掃描到的就註冊為BeanDefinition，並獲得掃描到的所有beanDefinition
            // 在處理SpringBoot啟動類上的@ComponentScan時，雖然指指定了excludeFilters，但會根據啟動類所在包推測basePackage，就會掃描到SpringBoot啟動類包以下的Bean並註冊
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

            // Check the set of scanned definitions for any further config classes and parse recursively if needed
            // 檢查掃描到的beanDefinition中是否有配置類，有的話parse()繼續分析處理，，配置類添加到configurationClasses集合
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // Process any @Import annotations
    /**
     * 4、處理 @Import
     * (1)處理ImportSelector
     * 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()
     * 其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
     * (2)處理ImportBeanDefinitionRegistrar
     * 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
     * (3)其它
     * 調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
     */
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // Process any @ImportResource annotations
    /**
     * 5、處理 @ImportResource
     * 添加到配置類的importedResources集合，後續loadBeanDefinitions()加載bean定義時再讓這些導入BeanDefinitionReader自行讀取bean定義
     */
    AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // Process individual @Bean methods
    /**
     * 6、處理個別@Bean方法
     * 獲取所有@Bean方法，並添加到配置類的beanMethods集合
     */
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // Process default methods on interfaces
    /**
     * 7、處理配置類接口上的default methods
     */
    processInterfaces(configClass, sourceClass);

    // Process superclass, if any
    /**
     * 8、檢查父類是否需要處理，如果父類需要處理返回父類，否則返回null
     * 如果存在父類，且不在knownSuperclasses已經分析過的父類列表裡，返回並繼續分析
     */
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // Superclass found, return its annotation metadata and recurse
            return sourceClass.getSuperClass();
        }
    }

    // No superclass -> processing is complete
    return null;
}

ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()：讀取配置類，基於配置信息註冊BeanDefinition

讀取配置類，基於配置信息註冊BeanDefinition流程

在上面解析配置類的過程中，除了構建了一個完整的ConfigurationClass配置類，其實已經向BeanDefinitionRegistry中添加了一些beanDefinition了，比如在處理@ComponentScan時，掃描到的@Component相關組件就已經註冊了

而ConfigurationClassBeanDefinitionReader會繼續讀取已經構建好的ConfigurationClass配置類中的成員變量，從而註冊beanDefinition

構建好的ConfigurationClass配置類中在本階段可用的成員變量包括：

1. Set<BeanMethod> beanMethods： @Bean的方法
2. Map<String, Class<? extends BeanDefinitionReader>> importedResources：配置類上@ImportResource註解的類存入此集合，會使用BeanDefinitionReader讀取Resource中的BeanDefinition並註冊
3. Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars：ImportBeanDefinitionRegistrar集合

通過構建好的配置類的配置信息，使用ConfigurationClassBeanDefinitionReader註冊所有能夠讀取到的beanDefinition：

• 根據ConfigurationPhase.REGISTER_BEAN階段條件判斷配置類是否需要跳過

  循環判斷配置類以及導入配置類的類，使用ConfigurationPhase.REGISTER_BEAN階段條件判斷是否需要跳過只要配置類或導入配置類的類需要跳過即返回跳過​

• 如果configClass.isImported()，將配置類自身註冊為beanDefinition

• 註冊配置類所有@Bean方法為beanDefinition

• 註冊由@ImportedResources來的beanDefinition，即通過其它類型Resource的BeanDefinitionReader讀取BeanDefinition並註冊，如xml格式的配置源 XmlBeanDefinitionReader

• 註冊由ImportBeanDefinitionRegistrars來的beanDefinition

讀取配置類，基於配置信息註冊BeanDefinition源碼分析

/**
 * Read a particular {@link ConfigurationClass}, registering bean definitions
 * for the class itself and all of its {@link Bean} methods.
 * 讀取特定配置類，根據配置信息註冊bean definitions
 */
private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    /**
     * 根據ConfigurationPhase.REGISTER_BEAN階段條件判斷配置類是否需要跳過
     * 循環判斷配置類以及導入配置類的類，使用ConfigurationPhase.REGISTER_BEAN階段條件判斷是否需要跳過
     * 只要配置類或導入配置類的類需要跳過即返回跳過
     */
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }

    // 1、如果當前配置類是通過內部類導入 或 @Import導入，將配置類自身註冊為beanDefinition
    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }

    // 2、註冊配置類所有@Bean方法為beanDefinition
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    // 3、註冊由@ImportedResources來的beanDefinition
    // 即通過其它類型Resource的BeanDefinitionReader讀取BeanDefinition並註冊
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

    // 4、註冊由ImportBeanDefinitionRegistrars來的beanDefinition
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

思維導圖

請放大觀看

參考

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

原始衝動

最近一直在學習 Electron 開發桌面應用程序，目的是想做一個桌面編輯器，雖然一直在使用Typora這款神器，但無奈Typora太過國際化，在國內水土不服，無法滿足我的一些需求。

比如實現本地圖片上傳到雲端（mac版可以藉助iPic），無法幫我把本地圖片和文章一起發布到博客園、CSDN、SegmentFault、掘金等國內知名博客平台，要麼使用一些免費或付費的圖床，藉助類似iPic的工具，把圖片一鍵上傳到雲端。

我個人也嘗試過七牛雲的免費10G存儲空間，但是說實話，這些免費的空間到最後一定是為了讓你成為付費用戶，各種限制各種吐槽在網上很容易可以搜索到。

免費的圖床如新浪微博等，還算是比較好的圖床工具，相比一些網絡上的壓根不知道啥公司甚至是歸屬個人的免費圖床，新浪應該是比較靠譜的，相對來說可以保證圖片的存活時間，我個人用過一些免費的圖床網站，記得印象深刻的就是服務器出問題，網站掛個公告，曾經的圖片再去訪問就是默認的404。

雖然新浪家大業大不是說倒閉就倒閉的，圖片相對穩定可靠，不過新浪的圖片服務器會檢測訪問來源Referer來防止外部網站引用，造成訪問403。

總結起來就是一句話，圖片還是隨着文章一鍵發布到博客平台比較好。要丟一起丟～

心理掙扎

緣起這個動機，但是下定決心依舊是困難重重。

我個人是一個Java工程師，雖說搞過Andorid、HTML前端，但對前端深感不適的我果斷放棄了。對於桌面程序開發，我連Swing都不會，造一個Markdown編輯器有點難，何況還要加上這些定製功能。

猶猶豫豫，還是決定去嘗試一下。於是調研寫跨平台的一些途徑。

先嘗試Swing，不過Swing不好實現我期望的一些功能，改成JavaFX倒是可以，不過說實話，寫起來很累，太過繁瑣，就放棄了。最後把目光瞄向electron，就它了，HTML+Js+Css，聽起來就很簡單，事實證明，無論是測試還是打包都很方便。

決定之後，便開始進行 Electron 的系統學習。

邁出第一步

第一步就是安裝 Electron 的本地開發環境，這也是大多數應用開發的第一步。

你需要安裝 Node.js 在你的本地電腦，Electron 也是依賴於 Node.js 的環境，嚴格來說， Electron 通過將 Chromium 和 Node.js 合併到同一個運行時環境中，並將其打包為Mac，Windows和Linux系統下的應用來實現這一目的。

關於 Electron 的具體開發流程，這裏不再贅述，你完全可以在開發中使用Web前端開發的思維，除了在處理多個窗口之間交互的時候，就不得不了解Eelctron的進程機制。

主進程和渲染進程

Electron 運行 package.json 的 main 腳本的進程被稱為主進程。 在主進程中運行的腳本通過創建web頁面來展示用戶界面。 一個 Electron 應用總是有且只有一個主進程。

由於 Electron 使用了 Chromium 來展示 web 頁面，所以 Chromium 的多進程架構也被使用到。 每個 Electron 中的 web 頁面運行在它自己的渲染進程中。

在普通的瀏覽器中，web頁面通常在沙盒環境中運行，並且無法訪問操作系統的原生資源。 然而 Electron 的用戶在 Node.js 的 API 支持下可以在頁面中和操作系統進行一些底層交互。

主進程與渲染進程的區別

主進程使用 BrowserWindow 實例創建頁面。 每個 BrowserWindow 實例都在自己的渲染進程里運行頁面。 當一個 BrowserWindow 實例被銷毀后，相應的渲染進程也會被終止。

主進程管理所有的web頁面和它們對應的渲染進程。 每個渲染進程都是獨立的，它只關心它所運行的 web 頁面。

在頁面中調用與 GUI 相關的原生 API 是不被允許的，因為在 web 頁面里操作原生的 GUI 資源是非常危險的，而且容易造成資源泄露。 如果你想在 web 頁面里使用 GUI 操作，其對應的渲染進程必須與主進程進行通訊，請求主進程進行相關的 GUI 操作。

主進程與渲染進程通信

那麼進程間如何通訊？

Electron為主進程（ main process）和渲染器進程（renderer processes）通信提供了多種實現方式，如可以使用ipcRenderer 和 ipcMain模塊發送消息，使用 remote模塊進行RPC方式通信。

你還可以用 Electron 內的 IPC 機制實現。將數據存在主進程的某個全局變量中，然後在多個渲染進程中使用 remote 模塊來訪問它。

示例代碼：

// 在主進程中
global.sharedObject = {
  someProperty: 'default value'
}

// 在第一個頁面中
require('electron').remote.getGlobal('sharedObject').someProperty = 'new value'

// 在第二個頁面中
console.log(require('electron').remote.getGlobal('sharedObject').someProperty)

使用Electron的API

Electron在主進程和渲染進程中提供了大量API去幫助開發桌面應用程序， 在主進程和渲染進程中，你可以通過require的方式將其包含在模塊中以此，獲取Electron的API

const electron = require('electron')

所有Electron的API都被指派給一種進程類型。 許多API只能被用於主進程或渲染進程中，但其中一些API可以同時在上述兩種進程中使用。 每一個API的文檔都將聲明你可以在哪種進程中使用該API。

Electron中的窗口是使用BrowserWindow類型創建的一個實例， 它只能在主進程中使用。

// 這樣寫在主進程會有用，但是在渲染進程中會提示'未定義'
const { BrowserWindow } = require('electron')

const win = new BrowserWindow()

因為進程之間的通信是被允許的, 所以渲染進程可以調用主進程來執行任務。 Electron通過remote模塊暴露一些通常只能在主進程中獲取到的API。 為了在渲染進程中創建一個BrowserWindow的實例，通常使用remote模塊為中間件：

// 這樣寫在渲染進程中時行得通的，但是在主進程中是'未定義'
const { remote } = require('electron')
const { BrowserWindow } = remote

const win = new BrowserWindow()

使用Node.js的API

Electron同時在主進程和渲染進程中對Node.js 暴露了所有的接口。 這裡有兩個重要的定義：

1)所有在Node.js可以使用的API，在Electron中同樣可以使用。 在Electron中調用如下代碼是有用的：

const fs = require('fs')

const root = fs.readdirSync('/')

// 這會打印出磁盤根級別的所有文件
// 同時包含'/'和'C:\'。
console.log(root)

2)你可以在你的應用程序中使用Node.js的模塊。 選擇您最喜歡的 npm 模塊。 npm 提供了目前世界上最大的開源代碼庫，那裡包含良好的維護、經過測試的代碼，提供給服務器應用程序的特色功能也提供給Electron。

例如，在你的應用程序中要使用官方的AWS SDK，你需要首先安裝它的依賴：

npm install --save aws-sdk

然後在你的Electron應用中，通過require引入並使用該模塊，就像構建Node.js應用程序那樣：

// 準備好被使用的S3 client模塊
const S3 = require('aws-sdk/clients/s3')

有一個非常重要的提示: 原生Node.js模塊 (即指，需要編譯源碼過後才能被使用的模塊) 需要在編譯后才能和Electron一起使用。

最終產品殺青落地

終於搞明白了 Electron 的應用架構，那麼接着就要進入產品的開發階段。比較慶幸的是，ELectron 的UI完全由CSS+HTML組成，這部分可用的框架太多了，我選擇了又老又知名的 BootStarp 框架搭建界面UI，還引用了JS框架JQuery。選擇了 electron-store 作為本地存儲文件，至於最關鍵的Markdown語法解析，對比了一番主流解析框架，最終選擇了 markdown-it。貼一下效果圖：

這款軟件我給他起名為 JustWrite，意思就是現在就寫，也是在督促自己吧，畢竟猶豫徘徊，等於白來。

現在軟件的功能除了包含一鍵發布本地文章加本地圖片到博客園、CSDN、SegmentFault、掘金、開源中國等平台，我還打算將他打造為一個體驗不錯的Markdown寫作軟件。現在你閱讀的這篇文章，就是我使用 JustWrite 書寫的，使用的字體是我個人喜歡的幼圓體，除此之外，還有六款風格迥異的字體可以切換使用。字號也是可以動態放大或者縮小，還可以關閉右側預覽，專註於寫作，如下圖所示：

這些截圖是我截屏后使用快捷鍵Ctrl+V一鍵粘貼的，圖片會自動放到當前md文件所在目錄下的picture文件夾內。

關於 JustWrite 從構思到實踐的心路歷程大致就以上這些了，這次開發 JustWrite 也讓我過了一把產品經理的癮，基本已經滿足了我的日常需求。如果你有更好的想法和創意也可以告訴我，說不定第二天就會實現了。

Github：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※公開收購3c價格,不怕被賤賣!

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

一、前言

1.核心技術

• Web Real-Time Communication：網頁即時通信，可以在瀏覽器進行實時語音或者視頻對話的API
• Canvas：HTML5中的新元素,可以用來來繪製圖形、圖標、以及其它任何視覺性圖像

2.音頻採集的基本概念

• 攝像頭：用於採集圖像和視頻
• 麥克風：採集音頻數據
• 幀率：一秒鐘採集圖像的次數。幀率越高，越平滑流暢
• 軌：借鑒了多媒體的概念，每條軌數據都是獨立的，如MP4中的音頻軌、視頻軌，是分別被存儲的
• 流：可以理解為容器。在WebRTC中，流可以分為媒體流（MediaStream）和數據流（DataStream）。
• 分辨率：2K、1080P、720P等，越清晰，佔用帶寬越多

3.音視頻設備的基本原理

• 音頻設備
  音頻輸入設備主要是採集音數據，而採集音頻數據的本質是模擬信號轉成数字信號，
  採集到的數據經過量化、編碼，最終開成数字信號，這就是音頻設備要完成的工作。
  人的聽覺範圍的頻率是20Hz~20kHz之間，日常語音交流8kHz就哆了。
  為了追求高品質、高保真，需要將音頻輸入設備採樣率設置在40kHz上才能完整保留原始信號

• 視頻設備
  當實物光通過鏡頭進行攝像機后，它會通過視頻設備的模數轉換（A/D）模塊，即光學傳感器，將光轉換成数字信號，即RGB數據，獲得RGB數據后，再通過DSP進行優化處理，如自動增強、白平衡、色彩飽和等，等到24位的真彩色圖片

模數轉換使用的採集定理稱為奈奎斯特定理：

在進行模擬 / 数字信號的轉換過程中，當採樣率大於信號中最高頻率的 2 倍時，採樣之後的数字信號就完整地保留原始信號中的信息。

talk is cheap, 上代碼，以下示例運行的時候會請求攝像頭權限，同意即可，接下來就是見證奇迹的時刻！

二、示例

1.示例1-打開攝像頭

這就是照像的核心功能，以後可以用來化妝，擠痘痘，整理髮型

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>打開攝像頭</title>
</head>
<body>
<h1>打開攝像頭</h1>
<video autoplay playsinline></video>
</body>
</html>

<script>
    const mediaStreamContrains = {
        video: {
            frameRate: {min: 20},
            width: {min: 640, ideal: 1280},
            height: {min: 360, ideal: 720},
            aspectRatio: 16 / 9
        },
        audio: {
            echoCancellation: true,
            noiseSuppression: true,
            autoGainControl: true
        }
    };

    const localVideo = document.querySelector('video');

    function gotLocalMediaStream(mediaStream) {
        localVideo.srcObject = mediaStream;
    }

    function handleLocalMediaStreamError(error) {
        console.log('navigator.getUserMedia error: ', error);
    }

    navigator.mediaDevices.getUserMedia(mediaStreamContrains).then(
        gotLocalMediaStream
    ).catch(
        handleLocalMediaStreamError
    );
</script>

運行結果如下

示例2-拍照保存

這裏展示了兩個按鈕，拍照和保存，yes，就是自拍的核心功能！

<html>
<head>
    <meta charset="UTF-8">
    <title>拍照一分鐘，P圖兩小時</title>
</head>

<body>
<section>
    <div>
        <video autoplay playsinline id="player"></video>
    </div>

</section>
<section>
    <div>
        <button id="snapshot">拍照</button>
        <button id="download">下載</button>
    </div>
    <div>
        <canvas id="picture"></canvas>
    </div>
</section>
</body>
</html>


<script>
    'use strict';

    var videoplay = document.querySelector('video#player');

    function gotMediaStream(stream) {
        window.stream = stream;
        videoplay.srcObject = stream;
    }

    function handleError(err) {
        console.log('getUserMedia error:', err);
    }

    function start() {
        var constraints = {
            video: {
                width: 1280,
                height: 720,
                frameRate: 15,
                facingMode: 'enviroment'
            },
            audio: false
        }

        navigator.mediaDevices.getUserMedia(constraints)
            .then(gotMediaStream)
            .catch(handleError);
    }


    //拍照
    var snapshot = document.querySelector('button#snapshot');
    snapshot.onclick = function () {
        var picture = document.querySelector('canvas#picture');
        picture.width = 1280;
        picture.height = 720;
        picture.getContext('2d').drawImage(videoplay, 0, 0, picture.width, picture.height);
    };


    //下載
    function downLoad(url) {
        var oA = document.createElement("a");
        oA.download = 'photo';// 設置下載的文件名，默認是'下載'
        oA.href = url;
        document.body.appendChild(oA);
        oA.click();
        oA.remove(); // 下載之後把創建的元素刪除
    }

    document.querySelector("button#download").onclick = function () {
        downLoad(picture.toDataURL("image/jpeg"));
    };

    start();

</script>

運行結果如下

就是這麼簡單！

重點方法和參數解釋

• 1.方法：avigator.mediaDevices.getUserMedia(constraints);
  返回一個promise對象，調用成功，可以通過promise對象獲取MediaStream對象，

• 2.參數：mediaStreamContrains
  傳入的constraints參數類型為 MediaStreamConstraints，可以指定 MediaStream 中包含哪些類型的媒體軌（音頻軌、視頻軌），並且可為這些媒體軌設置一些限制。

    視頻的幀率最小 20 幀每秒；
    寬度最小是 640，理想的寬度是 1280；
    高度最小是 360，最理想高度是 720；
    寬高比是 16:9；
    對於音頻則是開啟迴音消除、降噪以及自動增益功能。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

EC-05 由台灣山葉（YAMAHA）和 Gogoro 聯手打造，動力系統採用與 Gogoro S2 相同的 G2 鋁合金水冷永磁同步馬達（S-Version），許多人不禁疑問 EC-05 和 Gogoro S2 到底有什麼差別？難道只是換了一個車殼？更別說 EC-05 的價格還比 Gogoro S2 貴了 2,820 元。為了比較其中的差別，《科技新報》試駕了 EC-05 和 2020 年式的 Gogoro S2，帶來兩台車的第一手觀察。

EC-05 配備嵌合式環型頭燈，能在夜間騎乘時避免光線發散，確保前方視野的明亮程度。Gogoro S2 同樣配備環型頭燈，不過形狀略有不同，和一般機車一樣完全外露。EC-05 的後照鏡為菱形設計，視野較為寬廣，Gogoro S2 的後照鏡是圓形，視野較狹窄，而且騎乘者容易被自己的身體擋住部分視線。

Gogoro S2 前方配備了多功能置物箱，可以擺放手機和手套等小型物品，也能做為飲料置杯架使用，EC-05 就沒有這項裝置。Gogoro S2 的前方置物箱內附 USB 充電插槽，EC-05 的 USB 插孔則位於後座的置物箱。EC-05 使用無線智慧鑰匙，靠近車輛後按壓鑰匙的灰色部分進行解鎖。Gogoro S2 則使用 iQ system 智慧鑰匙卡，只要輕觸 S 標誌就能解鎖。

EC-05（左）配備嵌合式環型頭燈，Gogoro S2 的頭燈則外露。

EC-05 後照鏡呈菱形，視野較寬廣。

Gogoro S2 的後照鏡為圓形。

Gogoro S2 配備多功能置物箱，並附有 USB 充電插槽。

EC-05 的 USB 充電插槽位於後置物箱內側。

EC-05 以無線智慧鑰匙解鎖。

試乘時騎行陽明山的山路，EC-05 的穩定度和避震能力優於 Gogoro S2，在路面凹凸不平時較不容易顛簸，雙載騎乘時的差距更加明顯。EC-05 的座墊將後座的後方略為墊高，讓座墊呈現「山」字型的結構，側邊則採切削設計，讓騎乘者的腿部更為舒適。Gogoro S2 的後座較為平滑，中間使用皮質材質並標有「S」字樣。雖然乍看之下差異不大，但實際騎乘時後座乘客的感受明顯不同。

EC-05 的乘客在機車減速和加速時都更容易維持穩定，比較不會有往後飛出去或往前貼到前方騎乘者身上的狀況，即使長時間乘坐也不會滑動。Gogoro S2 的後座把手較為平直，EC-05 的把手彎曲向上，對於手不夠長的乘客更容易抓握。相較於 Gogoro S2，EC-05 能給予後座乘客更安穩的乘坐體驗。

EC-05 的座墊呈現「山」字型的凸起，讓後座乘客乘坐時更穩定。

Gogoro S2 的座墊較為平滑。

EC-05 與 Gogoro S2 座墊比較。

EC-05 的後座把手彎曲向上，較容易抓握。

Gogoro S2 的後座把手平直，手沒那麼長的後座乘客較難抓握。

EC-05（右）與 Gogoro S2 的後座把手差異從車尾可以明顯看出。

由於 EC-05 與 Gogoro S2 採用相同的動力系統，因此性能上的數據相差無幾。EC-05 最大馬力為 10hp，安全極速達到時速 90 公里，靜止加速到時速 50 公里需要 3.9 秒。Gogoro S2 最大馬力為 10.18hp，安全極速達到時速 92 公里，靜止加速到時速 50 公里僅需 3.8 秒，各方面都是 Gogoro S2 稍勝。

相較於 Gogoro S2，EC-05 的儀表板略為調整傾斜角度並向前方移動，用以減少騎乘者所需的視線移動。EC-05 的腳踏板具有菱形的凸起幫助止滑，讓騎乘時腳的位置可以更穩定。Gogoro S2 的腳踏板則是完全平滑，並有著「gogoro」的字樣。

EC-05 在車及座墊高度上也有更動，車高為 1,180 mm 略高於 Gogoro S2 的 1,080 mm，座高則以 768 mm 略低於 Gogoro S2 的 780 mm。調整過後 EC-05 在龍頭和座墊間的空間增加，騎乘時較為舒適也不容易意外按壓到喇叭等按鍵。不過 EC-05 的龍頭相較 Gogoro S2 略為沉重，力氣較小的使用者操控時可能會稍微費力。

EC-05 的腳踏板具有止滑的菱形格紋。

Gogoro S2 的腳踏板較為平滑。

身高 176 公分的騎乘者與 EC-05 的比例。

身高 156 公分的騎乘者與 EC-05 的比例。

YAMAHA 的設計理念標榜「人機官能」，也就是在設計時結合機械結構和人體工學。這樣的概念讓 EC-05 看似與 Gogoro S2 僅有微幅的差異，但這些細節卻在騎乘時能發揮不成比例的效果。至於這樣的差別值不值得多花 2,820 元購買，那就要看個人是否在意這些細節帶來的感受。

EC-05 提供藍灰色、深黑色、深藍灰色和白銀色 4 種顏色讓消費者選擇，定價為台幣 99,800 元。Gogoro S2 僅有灰黑色一個款式，定價為台幣 96,980 元。

（合作媒體：。圖片來源：）

延伸閱讀：

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※高價收購3C產品,價格不怕你比較

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!