配置Servlet 容器

来源:https://www.cnblogs.com/thelovelybugfly/archive/2019/08/26/11410095.html
-Advertisement-
Play Games

SpringBoot預設使用Tomcat作為嵌入式的Servlet容器； 1、如何定製和修改Servlet容器的相關配置； 1、修改和server有關的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）； 2、編寫一個Embedded ...


SpringBoot預設使用Tomcat作為嵌入式的Servlet容器；

1、如何定製和修改Servlet容器的相關配置；

1、修改和server有關的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）； 

server.port=8081
server.context‐path=/crud
server.tomcat.uri‐encoding=UTF‐8
//通用的Servlet容器設置
server.xxx
//Tomcat的設置
server.tomcat.xxx

2、編寫一個EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定製器；來修改Servlet容器的配置 

@Bean //一定要將這個定製器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
return new EmbeddedServletContainerCustomizer() {
//定製嵌入式的Servlet容器相關的規則
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(8083);
　　　　}
　　};
}

2、註冊Servlet三大組件【Servlet、Filter、Listener】

由於SpringBoot預設是以jar包的方式啟動嵌入式的Servlet容器來啟動SpringBoot的web應用，沒有web.xml文件。 
註冊三大組件用以下方式
1.ServletRegistrationBean 

//註冊三大組件
@Bean
public ServletRegistrationBean myServlet(){
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new
MyServlet(),"/myServlet");
return registrationBean;}

 2.FilterRegistrationBean 

@Bean
public FilterRegistrationBean myFilter(){
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setFilter(new MyFilter());
registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
return registrationBean;
    }

 3.ServletListenerRegistrationBean 

@Bean
public ServletListenerRegistrationBean myListener(){
ServletListenerRegistrationBean<MyListener> registrationBean = new
ServletListenerRegistrationBean<>(new MyListener());
return registrationBean;
    }

 SpringBoot幫我們自動配置SpringMVC的時候，自動的註冊SpringMVC的前端控制器；DIspatcherServlet；DispatcherServletAutoConfiguration中：

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet) {
ServletRegistrationBean registration = new ServletRegistrationBean(
dispatcherServlet, this.serverProperties.getServletMapping());
//預設攔截： / 所有請求；包靜態資源，但是不攔截jsp請求； /*會攔截jsp
//可以通過server.servletPath來修改SpringMVC前端控制器預設攔截的請求路徑
registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
registration.setLoadOnStartup(
this.webMvcProperties.getServlet().getLoadOnStartup());
if (this.multipartConfig != null) {
registration.setMultipartConfig(this.multipartConfig);
　　} 
　　return registration;
}

SpringBoot能不能支持其他的Servlet容器；

3、替換為其他嵌入式Servlet容器

 

預設支持：
Tomcat（預設使用） 

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
引入web模塊預設就是使用嵌入式的Tomcat作為Servlet容器；
</dependency>

Jetty （多用於長連接的形勢，比如會話伺服器）

<!‐‐ 引入web模塊 ‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
<exclusions>
<exclusion>
<artifactId>spring‐boot‐starter‐tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
<!‐‐引入其他的Servlet容器‐‐>
<dependency>
<artifactId>spring‐boot‐starter‐jetty</artifactId>
<groupId>org.springframework.boot</groupId>
</dependency>
<!‐‐ 引入web模塊 ‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
<exclusions>
<exclusion>
<artifactId>spring‐boot‐starter‐tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>

Undertow 

<!‐‐ 引入web模塊 ‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
<exclusions>
<exclusion>
<artifactId>spring‐boot‐starter‐tomcat</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>

<!‐‐引入其他的Servlet容器‐‐>
<dependency>
<artifactId>spring‐boot‐starter‐undertow</artifactId>
<groupId>org.springframework.boot</groupId>
</dependency>

4、嵌入式Servlet容器自動配置原理；

EmbeddedServletContainerAutoConfiguration：嵌入式的Servlet容器自動配置？  

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//導入BeanPostProcessorsRegistrar：Spring註解版；給容器中導入一些組件
//導入了EmbeddedServletContainerCustomizerBeanPostProcessor：
//後置處理器：bean初始化前後（創建完對象，還沒賦值賦值）執行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
@Configuration
@ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當前是否引入了Tomcat依賴；
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search =
SearchStrategy.CURRENT)//判斷當前容器沒有用戶自己定義EmbeddedServletContainerFactory：嵌入式的
Servlet容器工廠；作用：創建嵌入式的Servlet容器
public static class EmbeddedTomcat {
@Bean
public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory()
{
return new TomcatEmbeddedServletContainerFactory();
    }
} /
**
* Nested configuration if Jetty is being used.
*/
@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();
    }
}

/**
* Nested configuration if Undertow is being used.
*/
@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();
　　}
}

 1）、EmbeddedServletContainerFactory（嵌入式Servlet容器工廠）

public interface EmbeddedServletContainerFactory {
//獲取嵌入式的Servlet容器
EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer... initializers);
}

 

2）、EmbeddedServletContainer：（嵌入式的Servlet容器）

3）、以TomcatEmbeddedServletContainerFactory為例 

@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傳入進去，返回一個EmbeddedServletContainer；並且啟動Tomcat伺服器
return getTomcatEmbeddedServletContainer(tomcat);
}

 4）、我們對嵌入式容器的配置修改是怎麼生效？

 ServerProperties、EmbeddedServletContainerCustomizer 

EmbeddedServletContainerCustomizer：定製器幫我們修改了Servlet容器的配置？ 

怎麼修改的原理？
5）、容器中導入了EmbeddedServletContainerCustomizerBeanPostProcessor 

//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
//如果當前初始化的是一個ConfigurableEmbeddedServletContainer類型的組件
if (bean instanceof ConfigurableEmbeddedServletContainer) {
//
postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
}
return bean;
}

private void postProcessBeforeInitialization(
ConfigurableEmbeddedServletContainer bean) {
//獲取所有的定製器，調用每一個定製器的customize方法來給Servlet容器進行屬性賦值；
for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
customizer.customize(bean);
}
}

private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
if (this.customizers == null) {
// Look up does not include the parent context
this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
this.beanFactory
//從容器中獲取所有這葛類型的組件：EmbeddedServletContainerCustomizer
//定製Servlet容器，給容器中可以添加一個EmbeddedServletContainerCustomizer類型的組件
.getBeansOfType(EmbeddedServletContainerCustomizer.class,
false, false)
.values());
Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
this.customizers = Collections.unmodifiableList(this.customizers);
}
return this.customizers;
}

ServerProperties也是定製器

步驟：

1）、SpringBoot根據導入的依賴情況，給容器中添加相應的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2）、容器中某個組件要創建對象就會驚動後置處理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

只要是嵌入式的Servlet容器工廠，後置處理器就工作；

3）、後置處理器，從容器中獲取所有的EmbeddedServletContainerCustomizer，調用定製器的定製方法

5、嵌入式Servlet容器啟動原理；

什麼時候創建嵌入式的Servlet容器工廠？什麼時候獲取嵌入式的Servlet容器並啟動Tomcat；

獲取嵌入式的Servlet容器工廠：

1）、SpringBoot應用啟動運行run方法

2）、refreshContext(context);SpringBoot刷新IOC容器【創建IOC容器對象，並初始化容器，創建容器中的每一個組件】；如果是web應用創建AnnotationConfigEmbeddedWebApplicationContext，否則：AnnotationConfigApplicationContext

3）、refresh(context);刷新剛纔創建好的ioc容器；

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}
View Code

4）、 onRefresh(); web的ioc容器重寫了onRefresh方法

5）、webioc容器會創建嵌入式的Servlet容器；createEmbeddedServletContainer();

6）、獲取嵌入式的Servlet容器工廠：

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

​ 從ioc容器中獲取EmbeddedServletContainerFactory 組件；TomcatEmbeddedServletContainerFactory創建對象，後置處理器一看是這個對象，就獲取所有的定製器來先定製Servlet容器的相關配置；

7）、使用容器工廠獲取嵌入式的Servlet容器：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());

8）、嵌入式的Servlet容器創建對象並啟動Servlet容器；

先啟動嵌入式的Servlet容器，再將ioc容器中剩下沒有創建出的對象獲取出來；

IOC容器啟動創建嵌入式的Servlet容器

6、使用外置的Servlet容器

嵌入式Servlet容器：應用打成可執行的jar

​ 優點：簡單、便攜；

​ 缺點：預設不支持JSP、優化定製比較複雜（使用定製器【ServerProperties、自定義EmbeddedServletContainerCustomizer】，自己編寫嵌入式Servlet容器的創建工廠【EmbeddedServletContainerFactory】）；

外置的Servlet容器：外面安裝Tomcat---應用war包的方式打包；

步驟

1）、必須創建一個war項目；（利用idea創建好目錄結構）

2）、將嵌入式的Tomcat指定為provided；

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

 3）、必須編寫一個SpringBootServletInitializer的子類，並調用configure方法

public class ServletInitializer extends SpringBootServletInitializer {

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //傳入SpringBoot應用的主程式
      return application.sources(SpringBoot04WebJspApplication.class);
   }

}

4）、啟動伺服器就可以使用；

原理

jar包：執行SpringBoot主類的main方法，啟動ioc容器，創建嵌入式的Servlet容器；

war包：啟動伺服器，伺服器啟動SpringBoot應用【SpringBootServletInitializer】，啟動ioc容器；

 

servlet3.0（Spring註解版）：

8.2.4 Shared libraries / runtimes pluggability：

規則：

​ 1）、伺服器啟動（web應用啟動）會創建當前web應用裡面每一個jar包裡面ServletContainerInitializer實例：

​ 2）、ServletContainerInitializer的實現放在jar包的META-INF/services文件夾下，有一個名為javax.servlet.ServletContainerInitializer的文件，內容就是ServletContainerInitializer的實現類的全類名

​ 3）、還可以使用@HandlesTypes，在應用啟動的時候載入我們感興趣的類；

流程：

1）、啟動Tomcat

2）、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer：

Spring的web模塊裡面有這個文件：org.springframework.web.SpringServletContainerInitializer

3）、SpringServletContainerInitializer將@HandlesTypes(WebApplicationInitializer.class)標註的所有這個類型的類都傳入到onStartup方法的Set<Class<?>>；為這些WebApplicationInitializer類型的類創建實例；

4）、每一個WebApplicationInitializer都調用自己的onStartup；

 

5）、相當於我們的SpringBootServletInitializer的類會被創建對象，並執行onStartup方法

6）、SpringBootServletInitializer實例執行onStartup的時候會createRootApplicationContext；創建容器

protected WebApplicationContext createRootApplicationContext(
      ServletContext servletContext) {
    //1、創建SpringApplicationBuilder
   SpringApplicationBuilder builder = createSpringApplicationBuilder();
   StandardServletEnvironment environment = new StandardServletEnvironment();
   environment.initPropertySources(servletContext, null);
   builder.environment(environment);
   builder.main(getClass());
   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
   if (parent != null) {
      this.logger.info("Root context already created (using as parent).");
      servletContext.setAttribute(
            WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
      builder.initializers(new ParentContextApplicationContextInitializer(parent));
   }
   builder.initializers(
         new ServletContextApplicationContextInitializer(servletContext));
   builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
    
    //調用configure方法，子類重寫了這個方法，將SpringBoot的主程式類傳入了進來
   builder = configure(builder);
    
    //使用builder創建一個Spring應用
   SpringApplication application = builder.build();
   if (application.getSources().isEmpty() && AnnotationUtils
         .findAnnotation(getClass(), Configuration.class) != null) {
      application.getSources().add(getClass());
   }
   Assert.state(!application.getSources().isEmpty(),
         "No SpringApplication sources have been defined. Either override the "
               + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
   if (this.registerErrorPageFilter) {
      application.getSources().add(ErrorPageFilterConfiguration.class);
   }
    //啟動Spring應用
   return run(application);
}

7、Spring的應用就啟動並且創建IOC容器

public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      analyzers = new FailureAnalyzers(context);
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
       
       //刷新IOC容器
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

 啟動Servlet容器，再啟動SpringBoot應用


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 原生JS實現滾動條
    原生JS模擬滾動條 求滾動條的高度   可視內容區的高度 / 內容區的實際高度 = 滾動條的高度 / 滑道的高度 求內容區top的值   內容區距離頂部的距離 / (內容區的實際高度 可視內容區域的高度 ) = 滾動條距離頂部的距離 / ( 滑道的高度 滾動條的高度) 使用onm ...
  • kafka cmd首個單機例子配置
    下載地址：http://kafka.apache.org/downloads http://mirror.bit.edu.cn/apache/kafka/2.3.0/kafka_2.12-2.3.0.tgz zookeeper.properties修改dataDir server.propertie ...
  • 前後端分離，認證框架分析
    跨域安全訪問API oauth2是一種用戶授權標準，jwt是傳遞token的一種消息標準，shiro是一個授權框架 1、JWT JSON Web Token (JWT)是一個開放標準(RFC 7519)，它定義了一種緊湊的、自包含的方式，用於作為JSON對象在各方之間安全地傳輸信息。該信息可以被驗證 ...
  • 分散式系統之中心化複製集管理
    文章首發於公眾號 松花皮蛋的黑板報 作者就職於京東,在穩定性保障、敏捷開發、高級JAVA、微服務架構有深入的理解 為了避免分散式系統單點異常引發的系統可靠性和高可用問題，可行的辦法就是數據冗餘，也稱為複製集，那麼複製集是怎麼管理的呢？ 實際上管理方式可以有去中心化副本集和中心化副本集兩種。 去中心化 ...
  • python上播放mp3歌曲
    我想從python播放我的歌曲（mp3），你能給我一個最簡單的命令嗎？ 這不正確： 解決方案 試試這個。它過於簡單但可能不是最好的方法。 請註意，支持MP3是有限的。 安裝很簡單 - ...
  • C_C語言環境、編譯、預處理
    1、環境 2、編譯 預處理: gcc E main.c o main.i 編譯: gcc S main.i o main.s //同時做語法檢查 彙編: gcc c main.s o main.o 鏈接: gcc main.o o main.exe 3、4996錯誤 4、預處理 4.1 巨集 巨集定義 ...
  • python_集合
    1.add添加 2.discard刪除 3.update批量添加 4.intersection取交集 5.union取並集 6.difference取差集 7.symmetric_difference對稱差集 ...
  • PHP代碼篇（五）--如何將圖片文件上傳到另外一臺服務上
    說，我有一個需求，就是一個臨時功能。由於工作開發問題，我們有一個B項目，需要有一個商品添加的功能，涉及到添加商品內容，比如商品名字，商品描述，商品庫存，商品圖片等。後臺商品添加的介面已經寫完了，但是問題是目前沒有後臺頁面，就是產品還沒有出後臺詳細頁面。前端已經完備了，上線了。後臺還需要工作時間處理。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類