SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程圖解
配置嵌入式Servlet容器
SpringBoot默認(rèn)使用Tomcat作為嵌入式的Servlet容器；
問題？
1）、如何定制和修改Servlet容器的相關(guān)配置；
1、修改和server有關(guān)的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；
server.port=8081 server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器設(shè)置 server.xxx //Tomcat的設(shè)置 server.tomcat.xxx
2、編寫一個EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定制器；來修改Servlet容器的配置(1.x)
在Spring Boot2.0以上配置嵌入式Servlet容器時EmbeddedServletContainerCustomizer類不存在，被WebServerFactoryCustomizer替代。
1.x
@Bean //一定要將這個定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
return new WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
//定制嵌入式的Servlet容器相關(guān)的規(guī)則
@Override
public void customize(ConfigurableWebServerFactory factory) {
container.setPort(8083);
}
};
}
2.x
@Bean //一定要將這個定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
return new EmbeddedServletContainerCustomizer() {
//定制嵌入式的Servlet容器相關(guān)的規(guī)則
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(8083);
}
};
}
2）、注冊Servlet三大組件【Servlet、Filter、Listener】
由于SpringBoot默認(rèn)是以jar包的方式啟動嵌入式的Servlet容器來啟動SpringBoot的web應(yīng)用，沒有web.xml文件。
注冊三大組件用以下方式
ServletRegistrationBean
//注冊三大組件
@Bean
public ServletRegistrationBean myServlet(){
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
return registrationBean;
}
FilterRegistrationBean
@Bean
public FilterRegistrationBean myFilter(){
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setFilter(new MyFilter());
registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
return registrationBean;
}
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());
//默認(rèn)攔截： / 所有請求；包靜態(tài)資源，但是不攔截jsp請求； /*會攔截jsp
//可以通過server.servletPath來修改SpringMVC前端控制器默認(rèn)攔截的請求路徑
registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
registration.setLoadOnStartup(
this.webMvcProperties.getServlet().getLoadOnStartup());
if (this.multipartConfig != null) {
registration.setMultipartConfig(this.multipartConfig);
}
return registration;
}
2）、SpringBoot能不能支持其他的Servlet容器；
3）、替換為其他嵌入式Servlet容器
默認(rèn)支持：
Tomcat（默認(rèn)使用）
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> 引入web模塊默認(rèn)就是使用嵌入式的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>
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容器自動配置原理；
SpringBoot2.X原理略有不同
由EmbeddedWebServerFactoryCustomizerAutoConfiguration（嵌入式web服務(wù)工廠定制器自動配置類）而不是EmbeddedServletContainerAutoConfiguration（嵌入式的Servlet容器自動配置），根據(jù)導(dǎo)入的依賴信息，該配置類會自動創(chuàng)建相應(yīng)類型的容器工廠定制器（目前Spring Boot 2.x 版本支持tomcat、jetty、undertow、netty），以tomcat為例，這里會創(chuàng)建TomcatWebServerFactoryCustomizer組件：
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication
//指定類ServerProperties（Servlet容器相關(guān)的配置類）中的ConfigurationProperties功能，將配置文件中對應(yīng)的屬性值與配置類中的屬性值進行映射，并將該配置類添加到IOC容器中
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {
/**
* Nested configuration if Tomcat is being used.
*/
@Configuration(proxyBeanMethods = false)
//導(dǎo)入的Servlet依賴為Tomcat，則創(chuàng)建Tomcat web服務(wù)工廠定制器
@ConditionalOnClass({ Tomcat.class, UpgradeProtocol.class })
public static class TomcatWebServerFactoryCustomizerConfiguration {
@Bean
public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment,ServerProperties serverProperties) {
return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
}
}
...
}
1.X中通過EmbeddedServletContainerAutoConfiguration：嵌入式的Servlet容器自動配置類創(chuàng)建組件
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//導(dǎo)入BeanPostProcessorsRegistrar：Spring注解版；給容器中導(dǎo)入一些組件
//導(dǎo)入了EmbeddedServletContainerCustomizerBeanPostProcessor：
//后置處理器：bean初始化前后（創(chuàng)建完對象，還沒賦值賦值）執(zhí)行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
@Configuration
@ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當(dāng)前是否引入了Tomcat依賴；
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判斷當(dāng)前容器沒有用戶自己定義EmbeddedServletContainerFactory：嵌入式的Servlet容器工廠；作用：創(chuàng)建嵌入式的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) {
//創(chuàng)建一個Tomcat
Tomcat tomcat = new Tomcat();
//配置Tomcat的基本環(huán)節(jié)
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服務(wù)器
return getTomcatEmbeddedServletContainer(tomcat);
}
4）、我們對嵌入式容器的配置修改是怎么生效？
ServerProperties、EmbeddedServletContainerCustomizer
EmbeddedServletContainerCustomizer：定制器幫我們修改了Servlet容器的配置？
怎么修改的原理？
5）、容器中導(dǎo)入了EmbeddedServletContainerCustomizerBeanPostProcessor
//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
//如果當(dāng)前初始化的是一個ConfigurableEmbeddedServletContainer類型的組件
if (bean instanceof ConfigurableEmbeddedServletContainer) {
//
postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
}
return bean;
}
private void postProcessBeforeInitialization(
ConfigurableEmbeddedServletContainer bean) {
//獲取所有的定制器，調(diào)用每一個定制器的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根據(jù)導(dǎo)入的依賴情況，給容器中添加相應(yīng)的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
2）、容器中某個組件要創(chuàng)建對象就會驚動后置處理器；EmbeddedServletContainerCustomizerBeanPostProcessor；
只要是嵌入式的Servlet容器工廠，后置處理器就工作；
3）、后置處理器，從容器中獲取所有的EmbeddedServletContainerCustomizer，調(diào)用定制器的定制方法
5）、嵌入式Servlet容器啟動原理；
什么時候創(chuàng)建嵌入式的Servlet容器工廠？什么時候獲取嵌入式的Servlet容器并啟動Tomcat；
獲取嵌入式的Servlet容器工廠：
1）、SpringBoot應(yīng)用啟動運行run方法
2）、refreshContext(context);SpringBoot刷新IOC容器【創(chuàng)建IOC容器對象，并初始化容器，創(chuàng)建容器中的每一個組件】；如果是web應(yīng)用創(chuàng)建AnnotationConfigEmbeddedWebApplicationContext，否則：AnnotationConfigApplicationContext
3）、refresh(context);刷新剛才創(chuàng)建好的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();
}
}
}
4）、 onRefresh(); web的ioc容器重寫了onRefresh方法
5）、webioc容器會創(chuàng)建嵌入式的Servlet容器；createEmbeddedServletContainer();
6）、獲取嵌入式的Servlet容器工廠：
EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
從ioc容器中獲取EmbeddedServletContainerFactory 組件；TomcatEmbeddedServletContainerFactory創(chuàng)建對象，后置處理器一看是這個對象，就獲取所有的定制器來先定制Servlet容器的相關(guān)配置；
7）、使用容器工廠獲取嵌入式的Servlet容器：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());
8）、嵌入式的Servlet容器創(chuàng)建對象并啟動Servlet容器；
先啟動嵌入式的Servlet容器，再將ioc容器中剩下沒有創(chuàng)建出的對象獲取出來；
IOC容器啟動創(chuàng)建嵌入式的Servlet容器
使用外置的Servlet容器
嵌入式Servlet容器：應(yīng)用打成可執(zhí)行的jar
優(yōu)點：簡單、便攜；
缺點：默認(rèn)不支持JSP、優(yōu)化定制比較復(fù)雜（使用定制器【ServerProperties、自定義EmbeddedServletContainerCustomizer】，自己編寫嵌入式Servlet容器的創(chuàng)建工廠【EmbeddedServletContainerFactory】）；
外置的Servlet容器：外面安裝Tomcat---應(yīng)用war包的方式打包；
步驟
1）、必須創(chuàng)建一個war項目；（利用idea創(chuàng)建好目錄結(jié)構(gòu)）
2）、將嵌入式的Tomcat指定為provided；
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency>
3）、必須編寫一個SpringBootServletInitializer的子類，并調(diào)用configure方法
public class ServletInitializer extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
//傳入SpringBoot應(yīng)用的主程序
return application.sources(SpringBoot04WebJspApplication.class);
}
}
4）、啟動服務(wù)器就可以使用；
原理
jar包：執(zhí)行SpringBoot主類的main方法，啟動ioc容器，創(chuàng)建嵌入式的Servlet容器；
war包：啟動服務(wù)器，服務(wù)器啟動SpringBoot應(yīng)用【SpringBootServletInitializer】，啟動ioc容器；
servlet3.0（Spring注解版）：
8.2.4 Shared libraries / runtimes pluggability：
規(guī)則：
1）、服務(wù)器啟動（web應(yīng)用啟動）會創(chuàng)建當(dāng)前web應(yīng)用里面每一個jar包里面ServletContainerInitializer實例：
2）、ServletContainerInitializer的實現(xiàn)放在jar包的META-INF/services文件夾下，有一個名為javax.servlet.ServletContainerInitializer的文件，內(nèi)容就是ServletContainerInitializer的實現(xiàn)類的全類名
3）、還可以使用@HandlesTypes，在應(yīng)用啟動的時候加載我們感興趣的類；
流程：
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)標(biāo)注的所有這個類型的類都傳入到onStartup方法的Set<Class<?>>；為這些WebApplicationInitializer類型的類創(chuàng)建實例；
4）、每一個WebApplicationInitializer都調(diào)用自己的onStartup；
5）、相當(dāng)于我們的SpringBootServletInitializer的類會被創(chuàng)建對象，并執(zhí)行onStartup方法
6）、SpringBootServletInitializer實例執(zhí)行onStartup的時候會createRootApplicationContext；創(chuàng)建容器
protected WebApplicationContext createRootApplicationContext(
ServletContext servletContext) {
//1、創(chuàng)建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);
//調(diào)用configure方法，子類重寫了這個方法，將SpringBoot的主程序類傳入了進來
builder = configure(builder);
//使用builder創(chuàng)建一個Spring應(yīng)用
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應(yīng)用
return run(application);
}
7）、Spring的應(yīng)用就啟動并且創(chuàng)建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應(yīng)用
到此這篇關(guān)于SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的文章就介紹到這了,更多相關(guān)SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
java使用內(nèi)存數(shù)據(jù)庫ssdb的步驟
這篇文章主要介紹了java使用內(nèi)存數(shù)據(jù)庫ssdb的步驟，幫助大家更好的理解和使用Java，感興趣的朋友可以了解下2020-12-12
這篇文章主要介紹了Spring Boot 自定義starter的示例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-11-11
一文搞懂如何實現(xiàn)Java,Spring動態(tài)啟停定時任務(wù)
定時任務(wù)的應(yīng)用場景十分廣泛，如定時清理文件、定時生成報表、定時數(shù)據(jù)同步備份等。本文將教你實現(xiàn)Java、Spring動態(tài)啟停定時任務(wù)，感興趣的可以學(xué)習(xí)一下2022-06-06
這篇文章主要為大家詳細介紹了Java實現(xiàn)撲克牌程序，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
Rest Assured 是一個基于 Java 的流行的用于測試 RESTful API 的庫。這篇文章主要介紹了Java如何基于Rest?Assured實現(xiàn)自動化測試接口，需要的可以參考一下2023-03-03
詳解java數(shù)組進行翻轉(zhuǎn)的方法有哪些
這篇文章主要介紹了詳解java數(shù)組進行翻轉(zhuǎn)的方法有哪些,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
這篇文章主要介紹了完美解決PermGen space異常的問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-01-01
這篇文章主要介紹了java中Map和List初始化的N種方法總結(jié)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-03-03
Java如何自定義類數(shù)組的創(chuàng)建和初始化
這篇文章主要介紹了Java如何自定義類數(shù)組的創(chuàng)建和初始化，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-10-10
Filter中獲取傳遞參數(shù)方式(解決post請求參數(shù)問題)
這篇文章主要介紹了Filter中獲取傳遞參數(shù)方式(解決post請求參數(shù)問題)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08