標籤: 台中網頁設計公司推薦

前面兩章講了netcore在linux上部署以及配置nginx，並讓nginx代理webapi。

這一章主要講如何配置負載均衡，有些步驟在前兩章講的很詳細了，所以這一章我就不會一個個截圖了。

因為本人只有一個服務器。所以我會在同一台服務器上部署兩套差不多的實例。

同樣的代碼，我們在Program.cs進行了修改，如圖所示：

這裏我把原來的端口6666改成了8888

 然後你可以改一改你的接口部分的代碼，便於讓你更好的看到效果。

這裏把value1和value2改成value3和value4，這裡是為了看到測試效果，在實際的開發中這裏不用改。

 然後發布和上傳到服務器，如何發布和上傳，我在第一章有講到：https://www.cnblogs.com/dengbo/p/11878766.html

注意的是你同樣的地方新建一個新的目錄保存你新上傳的程序，netcore是我第一章建立的，netcore1是新建的，

你把你新的發布包放在netcore即可。如圖：

上傳結束后，在這個目錄中運行你的程序，輸入下面的命令

dotnet WebApiTest.dll   --server.urls "http://*:8888"

如圖所示

 然後去看看你的接口是否正常

好了，這裏的準備工作完成了，下面我們進入到nginx的配置的目錄中

輸入下面的命令：

cd /usr/local/nginx/conf

然後對文件進行編輯

vim nginx.conf

 我們需要在這裏修改一下配置。

在如圖的server的平級添加如下的代碼

upstream NgWebApi {
                server localhost:6666;
                server localhost:8888;
    }

上面的 NgWebApi是隨意寫的名稱，不要糾結這裏。

然後在修改 proxy_pass後面的內容：

proxy_pass http://NgWebApi;

最終的結果如下：

 這樣你就修改完成，輸入:wq退出並保存即可。

最後檢查並重啟nginx

/usr/local/nginx/sbin/nginx -t

/usr/local/nginx/sbin/nginx -s reload

最後不要忘記把你的8888端口的webapi啟動一下。

這裏我務必要提醒你，請進入到你的程序的目錄中執行這段代碼，

cd /root/netcore1

dotnet WebApiTest.dll   --server.urls "http://*:8888"

啟動如下：

 好了，配置結束了，下面我們來測試下

還是昨天的那個網站進行測試   https://www.sojson.com/httpRequest/

多次發送請求會出現下面的響應

看到上面兩個請求，就說明你配置成功了，是不是很簡單。

上面這種配置，系統會採用默認的輪詢訪問不同的端口，nginx作為強大的反向代理，強大的遠遠不止這裏

下面簡單講講分發策略。

1)、輪詢 ——輪流處理請求（這是系統默認的）

      每個請求按時間順序逐一分配到不同的應用服務器，如果應用服務器down掉，自動剔除它，剩下的繼續輪詢，如果您的服務器都差不多，建議這個。 

2)、權重 ——誰的設置的大，誰就承擔大部分的請求

      通過配置權重，指定輪詢幾率，權重和訪問比率成正比，用於應用服務器性能不均的情況，有時候你買的服務器可能參差不齊，有的性能強大

    有的一般，你可以通過設置權重，把服務器性能強大權重設置大一點，這樣可以合理分配壓力。 

3)、ip_哈希算法

      每一次的請求按訪問ip的hash結果分配，這樣每個訪客固定訪問一個應用服務器，可以解決session共享的問題。

關於權重的策略，如下圖示的 你只要加一個  weight=6 即可這裏不一定是6，是整數都行。

 然後保存即可

這裏不要忘記重啟nginx，以及運行8888端口的程序了，如果你不會，可以看前面的部分

最後我們看看效果

結果和上面的測試結果差不多，唯一不同的是出現下面這個結果的次數要大於另外一個的。

到這裏就結束了，感謝觀看。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

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

※專營大陸快遞台灣服務

※台灣快遞大陸的貨運公司有哪些呢?

Spring Boot默認使用Tomcat作為嵌入式的Servlet容器，只要引入了spring-boot-start-web依賴，則默認是用Tomcat作為Servlet容器：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Servlet容器的使用

默認servlet容器

我們看看spring-boot-starter-web這個starter中有什麼

核心就是引入了tomcat和SpringMvc，我們先來看tomcat

Spring Boot默認支持Tomcat，Jetty，和Undertow作為底層容器。如圖：

而Spring Boot默認使用Tomcat，一旦引入spring-boot-starter-web模塊，就默認使用Tomcat容器。

切換servlet容器

那如果我么想切換其他Servlet容器呢，只需如下兩步：

• 將tomcat依賴移除掉
• 引入其他Servlet容器依賴

引入jetty：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <!--移除spring-boot-starter-web中的tomcat-->
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <!--引入jetty-->
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

Servlet容器自動配置原理

EmbeddedServletContainerAutoConfiguration

其中
EmbeddedServletContainerAutoConfiguration是嵌入式Servlet容器的自動配置類，該類在
spring-boot-autoconfigure.jar中的web模塊可以找到。

我們可以看到EmbeddedServletContainerAutoConfiguration被配置在spring.factories中，看過我前面文章的朋友應該知道SpringBoot自動配置的原理，這裏將EmbeddedServletContainerAutoConfiguration配置類加入到IOC容器中，接着我們來具體看看這個配置類：

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication// 在Web環境下才會起作用
@Import(BeanPostProcessorsRegistrar.class)// 會Import一個內部類BeanPostProcessorsRegistrar
public class EmbeddedServletContainerAutoConfiguration {

    @Configuration
    // Tomcat類和Servlet類必須在classloader中存在 // 文章開頭我們已經導入了web的starter，其中包含tomcat和SpringMvc // 那麼classPath下會存在Tomcat.class和Servlet.class
    @ConditionalOnClass({ Servlet.class, Tomcat.class }) // 當前Spring容器中不存在EmbeddedServletContainerFactory類型的實例
    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT) public static class EmbeddedTomcat {

        @Bean
        public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
            // 上述條件註解成立的話就會構造TomcatEmbeddedServletContainerFactory這個EmbeddedServletContainerFactory
            return new TomcatEmbeddedServletContainerFactory();
        }
    }
    
    @Configuration
    @ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
            WebAppContext.class })
    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedJetty {

        @Bean
        public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
            return new JettyEmbeddedServletContainerFactory();
        }

    }
    
    @Configuration
    @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedUndertow {

        @Bean
        public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
            return new UndertowEmbeddedServletContainerFactory();
        }

    }
    
    //other code...
}

在這個自動配置類中配置了三個容器工廠的Bean，分別是：

• TomcatEmbeddedServletContainerFactory

• JettyEmbeddedServletContainerFactory

• UndertowEmbeddedServletContainerFactory

這裏以大家熟悉的Tomcat為例，首先Spring Boot會判斷當前環境中是否引入了Servlet和Tomcat依賴，並且當前容器中沒有自定義的
EmbeddedServletContainerFactory的情況下，則創建Tomcat容器工廠。其他Servlet容器工廠也是同樣的道理。

EmbeddedServletContainerFactory

• 嵌入式Servlet容器工廠

public interface EmbeddedServletContainerFactory {

    EmbeddedServletContainer getEmbeddedServletContainer( ServletContextInitializer... initializers);
}

內部只有一個方法，用於獲取嵌入式的Servlet容器。

該工廠接口主要有三個實現類，分別對應三種嵌入式Servlet容器的工廠類，如圖所示：

TomcatEmbeddedServletContainerFactory

以Tomcat容器工廠TomcatEmbeddedServletContainerFactory類為例：

public class TomcatEmbeddedServletContainerFactory extends AbstractEmbeddedServletContainerFactory implements ResourceLoaderAware {
    
    //other code...
    
    @Override
    public EmbeddedServletContainer getEmbeddedServletContainer( ServletContextInitializer... initializers) {
        //創建一個Tomcat
        Tomcat tomcat = new Tomcat(); //配置Tomcat的基本環節
        File baseDir = (this.baseDirectory != null ? this.baseDirectory: createTempDir("tomcat"));
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
       tomcat.getService().addConnector(connector);
        customizeConnector(connector);
      tomcat.setConnector(connector); tomcat.getHost().setAutoDeploy(false);
        configureEngine(tomcat.getEngine());
        for (Connector additionalConnector : this.additionalTomcatConnectors) {
            tomcat.getService().addConnector(additionalConnector);
        }
        prepareContext(tomcat.getHost(), initializers);
        
        //包裝tomcat對象，返回一個嵌入式Tomcat容器，內部會啟動該tomcat容器
        return getTomcatEmbeddedServletContainer(tomcat);
    }
}

首先會創建一個Tomcat的對象，並設置一些屬性配置，最後調用getTomcatEmbeddedServletContainer(tomcat)方法，內部會啟動tomcat，我們來看看：

protected TomcatEmbeddedServletContainer getTomcatEmbeddedServletContainer(
    Tomcat tomcat) {
    return new TomcatEmbeddedServletContainer(tomcat, getPort() >= 0);
}

該函數很簡單，就是來創建Tomcat容器並返回。看看TomcatEmbeddedServletContainer類：

public class TomcatEmbeddedServletContainer implements EmbeddedServletContainer {

    public TomcatEmbeddedServletContainer(Tomcat tomcat, boolean autoStart) {
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        
        //初始化嵌入式Tomcat容器，並啟動Tomcat
 initialize();
    }
    
    private void initialize() throws EmbeddedServletContainerException {
        TomcatEmbeddedServletContainer.logger
                .info("Tomcat initialized with port(s): " + getPortsDescription(false));
        synchronized (this.monitor) {
            try {
                addInstanceIdToEngineName();
                try {
                    final Context context = findContext();
                    context.addLifecycleListener(new LifecycleListener() {

                        @Override
                        public void lifecycleEvent(LifecycleEvent event) {
                            if (context.equals(event.getSource())
                                    && Lifecycle.START_EVENT.equals(event.getType())) {
                                // Remove service connectors so that protocol
                                // binding doesn't happen when the service is
                                // started.
                                removeServiceConnectors();
                            }
                        }

                    });

                    // Start the server to trigger initialization listeners
                    //啟動tomcat
                    this.tomcat.start(); // We can re-throw failure exception directly in the main thread
                    rethrowDeferredStartupExceptions();

                    try {
                        ContextBindings.bindClassLoader(context, getNamingToken(context),
                                getClass().getClassLoader());
                    }
                    catch (NamingException ex) {
                        // Naming is not enabled. Continue
                    }

                    // Unlike Jetty, all Tomcat threads are daemon threads. We create a
                    // blocking non-daemon to stop immediate shutdown
                    startDaemonAwaitThread();
                }
                catch (Exception ex) {
                    containerCounter.decrementAndGet();
                    throw ex;
                }
            }
            catch (Exception ex) {
                stopSilently();
                throw new EmbeddedServletContainerException(
                        "Unable to start embedded Tomcat", ex);
            }
        }
    }
}

到這裏就啟動了嵌入式的Servlet容器，其他容器類似。

Servlet容器啟動原理

SpringBoot啟動過程

我們回顧一下前面講解的SpringBoot啟動過程，也就是run方法：

public ConfigurableApplicationContext run(String... args) {
    // 計時工具
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();

    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

    configureHeadlessProperty();

    // 第一步：獲取並啟動監聽器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        // 第二步：根據SpringApplicationRunListeners以及參數來準備環境
        ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
        configureIgnoreBeanInfo(environment);

        // 準備Banner打印器 - 就是啟動Spring Boot的時候打印在console上的ASCII藝術字體
        Banner printedBanner = printBanner(environment);

        // 第三步：創建Spring容器
        context = createApplicationContext();

        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);

        // 第四步：Spring容器前置處理
        prepareContext(context, environment, listeners, applicationArguments,printedBanner);

        // 第五步：刷新容器
 refreshContext(context);

　　　　 // 第六步：Spring容器後置處理
        afterRefresh(context, applicationArguments);

  　　　 // 第七步：發出結束執行的事件
        listeners.started(context);
        // 第八步：執行Runners
        this.callRunners(context, applicationArguments);
        stopWatch.stop();
        // 返回容器
        return context;
    }
    catch (Throwable ex) {
        handleRunFailure(context, listeners, exceptionReporters, ex);
        throw new IllegalStateException(ex);
    }
}

我們回顧一下第三步：創建Spring容器

public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
            + "annotation.AnnotationConfigApplicationContext";

public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework."
            + "boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext";

protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            //根據應用環境，創建不同的IOC容器
            contextClass = Class.forName(this.webEnvironment ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
}

創建IOC容器，如果是web應用，則創建
AnnotationConfigEmbeddedWebApplicationContext的IOC容器；如果不是，則創建AnnotationConfigApplicationContext的IOC容器；很明顯我們創建的容器是AnnotationConfigEmbeddedWebApplicationContext
，接着我們來看看
第五步，刷新容器
refreshContext(context);

private void refreshContext(ConfigurableApplicationContext context) {
    refresh(context);
}

protected void refresh(ApplicationContext applicationContext) {
    Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
    //調用容器的refresh()方法刷新容器
 ((AbstractApplicationContext) applicationContext).refresh();
}

容器刷新過程

調用抽象父類AbstractApplicationContext的refresh()方法；

AbstractApplicationContext

 1 public void refresh() throws BeansException, IllegalStateException {
 2     synchronized (this.startupShutdownMonitor) {
 3         /**
 4          * 刷新上下文環境
 5          */
 6         prepareRefresh();
 7 
 8         /**
 9          * 初始化BeanFactory，解析XML，相當於之前的XmlBeanFactory的操作，
10          */
11         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
12 
13         /**
14          * 為上下文準備BeanFactory，即對BeanFactory的各種功能進行填充，如常用的註解@Autowired @Qualifier等
15          * 添加ApplicationContextAwareProcessor處理器
16          * 在依賴注入忽略實現*Aware的接口，如EnvironmentAware、ApplicationEventPublisherAware等
17          * 註冊依賴，如一個bean的屬性中含有ApplicationEventPublisher(beanFactory)，則會將beanFactory的實例注入進去
18          */
19         prepareBeanFactory(beanFactory);
20 
21         try {
22             /**
23              * 提供子類覆蓋的額外處理，即子類處理自定義的BeanFactoryPostProcess
24              */
25             postProcessBeanFactory(beanFactory);
26 
27             /**
28              * 激活各種BeanFactory處理器,包括BeanDefinitionRegistryBeanFactoryPostProcessor和普通的BeanFactoryPostProcessor
29              * 執行對應的postProcessBeanDefinitionRegistry方法 和  postProcessBeanFactory方法
30              */
31             invokeBeanFactoryPostProcessors(beanFactory);
32 
33             /**
34              * 註冊攔截Bean創建的Bean處理器，即註冊BeanPostProcessor，不是BeanFactoryPostProcessor，注意兩者的區別
35              * 注意，這裏僅僅是註冊，並不會執行對應的方法，將在bean的實例化時執行對應的方法
36              */
37             registerBeanPostProcessors(beanFactory);
38 
39             /**
40              * 初始化上下文中的資源文件，如國際化文件的處理等
41              */
42             initMessageSource();
43 
44             /**
45              * 初始化上下文事件廣播器，並放入applicatioEventMulticaster,如ApplicationEventPublisher
46              */
47             initApplicationEventMulticaster();
48 
49             /**
50  * 給子類擴展初始化其他Bean 51              */
52  onRefresh(); 53 
54             /**
55              * 在所有bean中查找listener bean，然後註冊到廣播器中
56              */
57             registerListeners();
58 
59             /**
60              * 設置轉換器
61              * 註冊一個默認的屬性值解析器
62              * 凍結所有的bean定義，說明註冊的bean定義將不能被修改或進一步的處理
63              * 初始化剩餘的非惰性的bean，即初始化非延遲加載的bean
64              */
65             finishBeanFactoryInitialization(beanFactory);
66 
67             /**
68              * 通過spring的事件發布機制發布ContextRefreshedEvent事件，以保證對應的監聽器做進一步的處理
69              * 即對那種在spring啟動后需要處理的一些類，這些類實現了ApplicationListener<ContextRefreshedEvent>，
70              * 這裏就是要觸發這些類的執行(執行onApplicationEvent方法)
71              * spring的內置Event有ContextClosedEvent、ContextRefreshedEvent、ContextStartedEvent、ContextStoppedEvent、RequestHandleEvent
72              * 完成初始化，通知生命周期處理器lifeCycleProcessor刷新過程，同時發出ContextRefreshEvent通知其他人
73              */
74             finishRefresh();
75         }
76 
77         finally {
78     
79             resetCommonCaches();
80         }
81     }
82 }

我們看第52行的方法：

protected void onRefresh() throws BeansException {

}

很明顯抽象父類AbstractApplicationContext中的onRefresh是一個空方法，並且使用protected修飾，也就是其子類可以重寫onRefresh方法，那我們看看其子類AnnotationConfigEmbeddedWebApplicationContext中的onRefresh方法是如何重寫的，AnnotationConfigEmbeddedWebApplicationContext又繼承EmbeddedWebApplicationContext，如下：

public class AnnotationConfigEmbeddedWebApplicationContext extends EmbeddedWebApplicationContext {

那我們看看其父類EmbeddedWebApplicationContext 是如何重寫onRefresh方法的：

EmbeddedWebApplicationContext

@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        //核心方法：會獲取嵌入式的Servlet容器工廠，並通過工廠來獲取Servlet容器
 createEmbeddedServletContainer();
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start embedded container", ex);
    }
}

在createEmbeddedServletContainer方法中會獲取嵌入式的Servlet容器工廠，並通過工廠來獲取Servlet容器：

 1 private void createEmbeddedServletContainer() {
 2     EmbeddedServletContainer localContainer = this.embeddedServletContainer;
 3     ServletContext localServletContext = getServletContext();
 4     if (localContainer == null && localServletContext == null) {
 5         //先獲取嵌入式Servlet容器工廠
 6         EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();  7         //根據容器工廠來獲取對應的嵌入式Servlet容器
 8         this.embeddedServletContainer = containerFactory.getEmbeddedServletContainer(getSelfInitializer());  9     }
10     else if (localServletContext != null) {
11         try {
12             getSelfInitializer().onStartup(localServletContext);
13         }
14         catch (ServletException ex) {
15             throw new ApplicationContextException("Cannot initialize servlet context",ex);
16         }
17     }
18     initPropertySources();
19 }

關鍵代碼在第6和第8行，先獲取Servlet容器工廠，然後根據容器工廠來獲取對應的嵌入式Servlet容器

獲取Servlet容器工廠

protected EmbeddedServletContainerFactory getEmbeddedServletContainerFactory() {
    //從Spring的IOC容器中獲取EmbeddedServletContainerFactory.class類型的Bean
    String[] beanNames = getBeanFactory().getBeanNamesForType(EmbeddedServletContainerFactory.class); //調用getBean實例化EmbeddedServletContainerFactory.class
    return getBeanFactory().getBean(beanNames[0], EmbeddedServletContainerFactory.class);
}

我們看到先從Spring的IOC容器中獲取EmbeddedServletContainerFactory.class類型的Bean，然後調用getBean實例化EmbeddedServletContainerFactory.class，大家還記得我們第一節Servlet容器自動配置類EmbeddedServletContainerAutoConfiguration中注入Spring容器的對象是什麼嗎？當我們引入spring-boot-starter-web這個啟動器后，會注入TomcatEmbeddedServletContainerFactory這個對象到Spring容器中，所以這裏獲取到的Servlet容器工廠是TomcatEmbeddedServletContainerFactory，然後調用

TomcatEmbeddedServletContainerFactory的getEmbeddedServletContainer方法獲取Servlet容器，並且啟動Tomcat，大家可以看看文章開頭的getEmbeddedServletContainer方法。

大家看一下第8行代碼獲取Servlet容器方法的參數getSelfInitializer()，這是個啥？我們點進去看看

private ServletContextInitializer getSelfInitializer() {
    //創建一個ServletContextInitializer對象，並重寫onStartup方法，很明顯是一個回調方法
    return new ServletContextInitializer() { public void onStartup(ServletContext servletContext) throws ServletException { EmbeddedWebApplicationContext.this.selfInitialize(servletContext); } };
}

創建一個ServletContextInitializer對象，並重寫onStartup方法，很明顯是一個回調方法，這裏給大家留一點疑問：

• ServletContextInitializer對象創建過程是怎樣的？
• onStartup是何時調用的？
• onStartup方法的作用是什麼？

ServletContextInitializer是 Servlet 容器初始化的時候，提供的初始化接口。這裏涉及到Servlet、Filter實例的註冊，我們留在下一篇具體講

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

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

※專營大陸快遞台灣服務

※台灣快遞大陸的貨運公司有哪些呢?

怎麼捕獲錯誤並且處理，是一門語言必備的知識。在JavaScript中也是如此。

那怎麼捕獲錯誤呢？初看好像很簡單，try-catch就可以了嘛！但是有的時候我們發現情況卻繁多複雜。

• Q1: 同步可以try-catch,但一個異步回調，比如setTimeOut里的函數還可以try-catch嗎？

• Q2: Promise的錯誤捕獲怎麼做？

• Q3: async/await怎麼捕獲錯誤？

• Q4: 我能夠在全局環境下捕獲錯誤並且處理嗎？

• Q5: React16有什麼新的錯誤捕獲方式嗎？

• Q6: 捕獲之後怎麼上報和處理？

問題有點多，我們一個一個來。

Q1. 同步代碼里的錯誤捕獲方式

在同步代碼里，我們是最簡單的，只要try-catch就完了 

function test1 () {
  try {
    throw Error ('callback err');
  } catch (error) {
    console.log ('test1:catch err successfully');
  }
}
test1();

輸出結果如下，顯然是正常的

Q2. 普通的異步回調里的錯誤捕獲方式（Promise時代以前）

上面的問題來了，我們還能通過直接的try-catch在異步回調外部捕獲錯誤嗎？我們試一試 

// 嘗試在異步回調外部捕獲錯誤的結果
function test2 () {
  try {
    setTimeout (function () {
      throw Error ('callback err');
    });
  } catch (error) {
    console.log ('test2:catch err successfully');
  }
}
test2(); 

輸出

注意這裏的Uncaught Error的文本，它告訴我們錯誤沒有被成功捕捉。

為什麼呢？ 因為try-catch的是屬於同步代碼，它執行的時候，setTimeOut內部的的匿名函數還沒有執行呢。而內部的那個匿名函數執行的時候，try-catch早就執行完了。（ error的內心想法：哈哈，只要我跑的夠慢，try-catch還是追不上我！）

但是我們簡單想一想，誒我們把try-catch寫到函數裏面不就完事了嘛！

function test2_1 () {
  setTimeout (function () {
    try {
      throw Error ('callback err');
    } catch (error) {
      console.log ('test2_1:catch err successfully');
    }
  });
}
test2_1();

輸出結果如下，告訴我們這方法可行

總結下Promise時代以前，異步回調中捕獲和處理錯誤的方法

• 在異步回調內部編寫try-catch去捕獲和處理，不要在外部哦

• 很多異步操作會開放error事件，我們根據事件去操作就可以了

Q3. Promise里的錯誤捕獲方式

可通過Promise.catch方法捕獲

function test3 () {
  new Promise ((resolve, reject) => {
    throw Error ('promise error');
  }).catch (err => {
    console.log ('promise error');
  });
}

輸出結果

>> reject方法調用和throw Error都可以通過Promise.catch方法捕獲

function test4 () {
  new Promise ((resolve, reject) => {
    reject ('promise reject error');
  }).catch (err => {
    console.log (err);
  });
} 

輸出結果

>> then方法中的失敗回調和Promise.catch的關係

• 如果前面的then方法沒寫失敗回調，失敗時後面的catch是會被調用的

• 如果前面的then方法寫了失敗回調，又沒拋出，那麼後面的catch就不會被調用了

// then方法沒寫失敗回調
function test5 () {
  new Promise ((resolve, reject) => {
    throw Error ('promise error');
  })
    .then (success => {})
    .catch (err => {
      console.log ('the error has not been swallowed up');
    });
}
// then方法寫了失敗回調
function test5 () {
  new Promise ((resolve, reject) => {
    throw Error ('promise error');
  })
    .then (success => {},err => {})
    .catch (err => {
      console.log ('the error has not been swallowed up');
    });
}

輸出分別為

1.the error has not been swallowed up

2.無輸出

Q4.async/await里的錯誤捕獲方式

對於async/await這種類型的異步，我們可以通過try-catch去解決

async function test6 () {
  try {
    await getErrorP ();
  } catch (error) {
    console.log ('async/await error with throw error');
  }
}
 
function getErrorP () {
  return new Promise ((resolve, reject) => {
    throw Error ('promise error');
  });
}
test6();

輸出結果如下

>> 如果被await修飾的Promise因為reject調用而變化，它也是能被try-catch的

（我已經證明了這一點，但是這裏位置不夠，我寫不下了）

Q5.在全局環境下如何監聽錯誤

window.onerror可以監聽全局錯誤，但是很顯然錯誤還是會拋出

window.onerror = function (err) {
  console.log ('global error');
};
throw Error ('global error');

輸出如下

Q6.在React16以上如何監聽錯誤

>> componentDidCatch和getDerivedStateFromError鈎子函數

class Bar extends React.Component {
  // 監聽組件錯誤
  componentDidCatch(error, info) {
    this.setState({ error, info });
  }
  // 更新 state 使下一次渲染能夠显示降級后的 UI
  static getDerivedStateFromError(error) {
    return { hasError: true };
  }
  render() {
  }
}

有錯誤，那肯定要上報啊！不上報就發現不了Bug這個樣子。Sentry這位老哥就是個人才，日誌記錄又好看，每次見面就像回家一樣

Sentry簡單介紹

Sentry provides open-source and hosted error monitoring that helps all software
teams discover, triage, and prioritize errors in real-time.
One million developers at over fifty thousand companies already ship
better software faster with Sentry. Won’t you join them?
—— Sentry官網

Sentry是一個日誌上報系統，Sentry 是一個實時的日誌記錄和匯總處理的平台。專註於錯誤監控，發現和數據處理，可以讓我們不再依賴於用戶反饋才能發現和解決線上bug。讓我們簡單看一下Sentry支持哪些語言和平台吧

在JavaScript領域，Sentry的支持也可以說是面面俱到

參考鏈接
https://docs.sentry.io/platforms/ 

Sentry的功能簡單說就是，你在代碼中catch錯誤，然後調用Sentry的方法，然後Sentry就會自動幫你分析和整理錯誤日誌，例如下面這張圖截取自Sentry的網站中

在JavaScript中使用Sentry 

1.首先呢，你當然要註冊Sentry的賬號

這個時候Sentry會自動給你分配一個唯一標示，這個標示在Sentry里叫做 dsn

2. 安卓模塊並使用基礎功能

安裝@sentry/browser 

npm install @sentry/browser

在項目中初始化並使用

import * as Sentry from '@sentry/browser';
 
Sentry.init ({
  dsn: 'xxxx',
});
 
try {
  throw Error ('我是一個error');
} catch (err) {
    // 捕捉錯誤
  Sentry.captureException (err);
}

3.上傳sourceMap以方便在線上平台閱讀出錯的源碼

// 安裝
$ npm install --save-dev @sentry/webpack-plugin
$ yarn add --dev @sentry/webpack-plugin
 
// 配置webpack
const SentryWebpackPlugin = require('@sentry/webpack-plugin');
module.exports = {
  // other configuration
  plugins: [
    new SentryWebpackPlugin({
      include: '.',
      ignoreFile: '.sentrycliignore',
      ignore: ['node_modules', 'webpack.config.js'],
      configFile: 'sentry.properties'
    })
  ]
}; 

4. 為什麼不是raven.js?

// 已經廢棄，雖然你還是可以用
var Raven = require('raven-js');
Raven
  .config('xxxxxxxxxxx_dsn')
  .install();

Sentry的核心功能總結

捕獲錯誤

try { aFunctionThatMightFail(); } catch (err) { Sentry.captureException(err); }

設置該錯誤發生的用戶信息

下面每個選項都是可選的，但必須 存在一個選項 才能使Sentry SDK捕獲用戶： id 

Sentry.setUser({
    id:"penghuwan12314"
  email: "penghuwan@example.com",
  username:"penghuwan",
  ip_addressZ:'xxx.xxx.xxx.xxx'
  });

設置額外數據

Sentry.setExtra("character_name", "Mighty Fighter");

設置作用域 

Sentry.withScope(function(scope) {
    // 下面的set的效果只存在於函數的作用域內
  scope.setFingerprint(['Database Connection Error']);
  scope.setUser(someUser);
  Sentry.captureException(err);
});
// 在這裏，上面的setUser的設置效果會消失

設置錯誤的分組

整理日誌信息，避免過度冗餘 

Sentry.configureScope(function(scope) {
  scope.setFingerprint(['my-view-function']);
});

設置錯誤的級別

在閱讀日誌時可以確定各個bug的緊急度，確定排查的優先書序

Sentry.captureMessage('this is a debug message', 'debug');
//fatal，error，warning，info，debug五個值
// fatal最嚴重,debug最輕

自動記錄某些事件

例如下面的方法，會在每次屏幕調整時完成上報 

window.addEventListener('resize', function(event){
  Sentry.addBreadcrumb({
    category: 'ui',
    message: 'New window size:' + window.innerWidth + 'x' + window.innerHeight,
    level: 'info'
  });
})

Sentry實踐的運用

根據環境設置不同的dsn

let dsn;
  if (env === 'test') {
    dsn = '測試環境的dsn';
  } else {
    dsn =
      '正式環境的dsn';
  }
 
Sentry.init ({
  dsn
});

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

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

※專營大陸快遞台灣服務

※台灣快遞大陸的貨運公司有哪些呢?

在前面隨筆《》中介紹了在代碼生成工具中使用ODP.NET（Oracle.ManagedDataAccess.dll）訪問Oracle數據庫，如果我們在框架應用中需要使用這個如何處理了？由於我們開發框架底層主要使用微軟企業庫（目前用的版本是4.1），如果是使用它官方的Oracle擴展，那麼就是使用EntLibContrib.Data.OdpNet（這個企業庫擴展類庫使用了Oracle.DataAccess.dll），不過這種方式還是受限於32位和64位的問題；假如我們使用ODP.NET（Oracle.ManagedDataAccess.dll）方式，可以使用自己擴展企業庫支持即可，類似於我們支持國產數據庫–達夢數據庫一樣的原理，使用Oracle.ManagedDataAccess類庫可以避免32位和64位衝突問題，實現統一兼容。

1、擴展支持ODP.NET（Oracle.ManagedDataAccess.dll）訪問

為了實現自定義的擴展支持，我們需要對企業庫的擴展類庫進行處理，類似我們之前編寫達夢數據庫的自定義擴展類庫一樣，這方面可以了解下之前的隨筆《》，我們現在增加對ODP.NET（Oracle.ManagedDataAccess.dll）方式的擴展支持。

首先我們創建一個項目，並通過Nugget的方式獲得對應的Oracle.ManagedDataAccess.dll類庫，參考企業庫對於Mysql的擴展或者其他的擴展，稍作調整即可。

 OracleDatabase類似下面代碼

using System;
using System.Data;
using System.Data.Common;

using Microsoft.Practices.EnterpriseLibrary.Common;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Configuration;
using Oracle.ManagedDataAccess.Client;

namespace EntLibContrib.Data.OracleManaged
{
    /// <summary>
    /// <para>Oracle數據庫對象(使用ODP驅動)</para>
    /// </summary>
    /// <remarks>
    /// <para>
    /// Internally uses OracleProvider from Oracle to connect to the database.
    /// </para>
    /// </remarks>
    [DatabaseAssembler(typeof(OracleDatabaseAssembler))]
    public class OracleDatabase : Database
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="OracleDatabase"/> class
        /// with a connection string.
        /// </summary>
        /// <param name="connectionString">The connection string.</param>
        public OracleDatabase(string connectionString) : base(connectionString, OracleClientFactory.Instance)
        {
        }
        
        /// <summary>
        /// <para>
        /// Gets the parameter token used to delimit parameters for the
        /// Oracle database.</para>
        /// </summary>
        /// <value>
        /// <para>The '?' symbol.</para>
        /// </value>
        protected char ParameterToken
        {
            get
            {
                return ':';
            }
        }

        .........

主要就是把對應的類型修改為Oracle的即可，如Oracle的名稱，以及參數的符號為 ：等地方，其他的一一調整即可，不在贅述。

完成后，修改程序集名稱，編譯為 EntLibContrib.Data.OracleManaged.dll 即可。

2、框架應用的數據庫配置項設置

完成上面的步驟，我們就可以在配置文件中增加配置信息如下所示，它就能正常的解析並處理了。

 上面使用了兩種方式，一種是官方擴展的EntLibContrib.Data.OdpNet方式，一種是我們這裏剛剛出爐的 EntLibContrib.Data.OracleManaged方式，完整的數據庫支持文件信息如下所示。

<?xml version="1.0"?>
<configuration>
  <configSections>
    <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data"/>
    <section name="oracleConnectionSettings" type="EntLibContrib.Data.OdpNet.Configuration.OracleConnectionSettings, EntLibContrib.Data.OdpNet" />
  </configSections>
  <connectionStrings>
    <!--SQLServer數據庫的連接字符串-->
    <add name="sqlserver" providerName="System.Data.SqlClient" connectionString="Persist Security Info=False;Data Source=(local);Initial Catalog=WinFramework;Integrated Security=SSPI"/>
    
    <!--Oracle數據庫的連接字符串-->
    <add name="oracle" providerName="System.Data.OracleClient" connectionString="Data Source=orcl;User ID=whc;Password=whc"/>
    
    <!--MySQL數據庫的連接字符串-->
    <add name="mysql" providerName="MySql.Data.MySqlClient" connectionString="Server=localhost;Database=WinFramework;Uid=root;Pwd=123456;"/>
    
    <!--PostgreSQL數據庫的連接字符串-->
    <add name="npgsql" providerName="Npgsql" connectionString="Server=localhost;Port=5432;Database=postgres;User Id=postgres;Password=123456"/>
    
    <!--路徑符號|DataDirectory|代表當前運行目錄-->    
    <!--SQLite數據庫的連接字符串-->
    <add name="sqlite"  providerName="System.Data.SQLite" connectionString="Data Source=|DataDirectory|\WinFramework.db;Version=3;" />
    <!--Microsoft Access數據庫的連接字符串-->
    <add name="access" providerName="System.Data.OleDb" connectionString="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\WinFramework.mdb;User ID=Admin;Jet OLEDB:Database Password=;" />   
    
    <!--IBM DB2數據庫的連接字符串-->
    <add    name="db2" providerName="IBM.Data.DB2"    connectionString="database=whc;uid=whc;pwd=123456"/>
    
    <!--採用OdpNet方式的Oracle數據庫的連接字符串-->
    <add    name="oracle2"    providerName="Oracle.DataAccess.Client"    connectionString="Data Source=orcl;User id=win;Password=win;" />
    <add    name="oracle3"    providerName="OracleManaged"    connectionString="Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=localhost)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=orcl.mshome.net)));User ID=win;Password=win" />
  </connectionStrings>
  <dataConfiguration defaultDatabase="oracle3">
    <providerMappings>
      <add databaseType="EntLibContrib.Data.MySql.MySqlDatabase, EntLibContrib.Data.MySql" name="MySql.Data.MySqlClient" />
      <add databaseType="EntLibContrib.Data.SQLite.SQLiteDatabase, EntLibContrib.Data.SqLite" name="System.Data.SQLite" />
      <add databaseType="EntLibContrib.Data.PostgreSql.NpgsqlDatabase, EntLibContrib.Data.PostgreSql" name="Npgsql" />      
      <add databaseType="EntLibContrib.Data.DB2.DB2Database, EntLibContrib.Data.DB2" name="IBM.Data.DB2" />
      <add databaseType="EntLibContrib.Data.OdpNet.OracleDatabase, EntLibContrib.Data.OdpNet" name="Oracle.DataAccess.Client" />
      <add databaseType="EntLibContrib.Data.Dm.DmDatabase, EntLibContrib.Data.Dm" name="Dm" />
      <!--增加ODP.NET（Oracle.ManagedDataAccess.dll）方式的擴展支持-->
      <add databaseType="EntLibContrib.Data.OracleManaged.OracleDatabase, EntLibContrib.Data.OracleManaged" name="OracleManaged" />
    </providerMappings>
  </dataConfiguration>
  
  <appSettings>

  </appSettings>
  <startup useLegacyV2RuntimeActivationPolicy="true">
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
    <supportedRuntime version="v2.0.50727"/>
  </startup>
</configuration>

這樣我們底層就可以實現多種數據庫的兼容訪問了。

採用不同的數據庫，我們需要為不同數據庫的訪問層進行生成處理，如為SQLServer數據的表生成相關的數據訪問層DALSQL，裏面放置各個表對象的內容，不過由於採用了相關的繼承類處理和基於數據庫的代碼生成，需要調整的代碼很少。

我們來編寫一段簡單的程序代碼來測試支持這種ODP.net方式，測試代碼如下所示。

private void btnGetData_Click(object sender, EventArgs e)
{
    string sql = "select * from T_Customer";// + " Where Name = :name";
    Database db = DatabaseFactory.CreateDatabase();
    DbCommand command = db.GetSqlStringCommand(sql);
    //command.Parameters.Add(new OracleParameter("name", "張三"));

    using (var ds = db.ExecuteDataSet(command))
    {
        this.dataGridView1.DataSource = ds.Tables[0];   
    }
}

測試界面效果如下所示。

以上這些處理，可以適用於Web框架、Bootstrap開發框架、Winform開發框架、混合式開發框架中的應用，也就是CS、BS都可以使用。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

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

從中國發改委網站獲悉，停車場充電設施建設協調會7月18日下午召開。會議表示將針對大城市、特大城市存在的停車位資源緊張、社會停車場投資主體多、充電設施企業盈利模式相對單一等問題，進一步推進相關工作。  
  停車場充電設施建設協調會由中國國家發改委基礎產業司副司長鄭劍主持，就2016年第二批城市停車場項目配建充電基礎設施問題，與安徽、江蘇、江西、陝西、浙江、湖北、上海、大連、廈門等地方發展改革委、充電基礎設施服務企業和國家電網公司進行交流座談。   據國家能源局電力司初步統計，截至今年6月底，中國全國已建成公共充電樁8.1萬個，比去年底增長65%；隨車建成私人充電樁超過5萬個，比去年底增長約12%。1-6月全國新能源汽車充電量超過6億kWh，替代燃油約20萬噸，電動汽車的發展對能源結構調整和城市環境提升貢獻明顯。   為新能源汽車的推廣和應用創造良好的環境，國家能源局相關部門加快了推動充電樁政策規劃的落實，組織起草加快居民區充電基礎設施建設的檔。該文件有望7月份出臺，將有效推進居民區和工作場所建樁工作，合理優化公共充電樁佈局，提高公共充電樁利用率。   文章來源：中國發展網

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

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

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