SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

配置嵌入式Servlet容器

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容器的配置(1.x)

Spring Boot2.0以上配置嵌入式Servlet容器时EmbeddedServletContainerCustomizer类不存在,被WebServerFactoryCustomizer替代。

1.x

@Bean //一定要将这个定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
 return new WebServerFactoryCustomizer<ConfigurableWebServerFactory> {

 //定制嵌入式的Servlet容器相关的规则
 @Override
 public void customize(ConfigurableWebServerFactory factory) {
  container.setPort(8083);
 }
 };
}

2.x

@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文件。

注册三大组件用以下方式

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());
 //默认拦截: / 所有请求;包静态资源,但是不拦截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;
}

2)、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>

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服务工厂定制器自动配置类)而不是EmbeddedServletContainerAutoConfiguration(嵌入式的Servlet容器自动配置),根据导入的依赖信息,该配置类会自动创建相应类型的容器工厂定制器(目前Spring Boot 2.x 版本支持tomcat、jetty、undertow、netty),以tomcat为例,这里会创建TomcatWebServerFactoryCustomizer组件:

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication
//指定类ServerProperties(Servlet容器相关的配置类)中的ConfigurationProperties功能,将配置文件中对应的属性值与配置类中的属性值进行映射,并将该配置类添加到IOC容器中
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {

	/**
	 * Nested configuration if Tomcat is being used.
	 */
 @Configuration(proxyBeanMethods = false)
 //导入的Servlet依赖为Tomcat,则创建Tomcat web服务工厂定制器
 @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容器自动配置类创建组件

@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();
 }
 }
}

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容器

使用外置的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应用

到此这篇关于SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的文章就介绍到这了,更多相关SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

时间:2020-07-09

关于SpringBoot获取IOC容器中注入的Bean(推荐)

一: 注入一个TestUtils类 package com.shop.sell.Utils; import com.shop.sell.dto.CartDTO; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class TestUtils { @Bean(name="test

SpringBoot初始教程之Servlet、Filter、Listener配置详解

1.介绍 通过之前的文章来看,SpringBoot涵盖了很多配置,但是往往一些配置是采用原生的Servlet进行的,但是在SpringBoot中不需要配置web.xml的 因为有可能打包之后是一个jar包的形式,这种情况下如何解决?SpringBoot 提供了两种方案进行解决 2.快速开始 2.1 方案一 方案一采用原生Servlet3.0的注解进行配置.@WebServlet .@WebListener.@WebFilter是Servlet3.0 api中提供的注解 通过注解可以完全代替web

springboot2.3.1替换为其他的嵌入式servlet容器的详细方法

现阶段,springboot内嵌了Tomcat服务器,如果你不想使用Tomcat,springboot也是支持其他的服务器切换的. 如果你想了解底层springboot所支持的服务器你可以使用idea的快捷键快速按两次shift查询一个ServerProperties 的类,通过这个类你可以知道你想要了解的情况: springboot里面支持的服务器有Jetty.Netty-等等,大家有兴趣的话可以百度一下. 接着通过在pom文件的视图依赖分析可以得知: springboot里面的Tomcat是

SpringBoot 项目如何在tomcat容器中运行的实现方法

一. SpringBoot内嵌容器的部署方式 SpringBoot内部默认提供内嵌的tomcat容器,所以可以直接打成jar包,丢到服务器上的任何一个目录,然后在当前目录下执行java -jar demo.jar即可运行,但是这种方式的运行退出进程就结束了.如果想在后台可以运行,则需要执行 java -jar demo.jar > log_demo.file 2>&1 & 即可在后台运行该服务了,log_demo.file是日志文件.如需停止该进程 执行ps -ef|grep

springboot注入servlet的方法

问:有了springMVC,为什么还要用servlet?有了servlet3的注解,为什么还要使用ServletRegistrationBean注入的方式? 使用场景:在有些场景下,比如我们要使用hystrix-dashboard,这时候就需要注入HystrixMetricsStreamServlet(第三方的servlet),该servlet是hystrix的组件. 一.代码 1.TestServlet(第一个servlet) package com.xxx.secondboot.servle

SpringBoot注入配置文件的3种方法详解

SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

这篇文章主要介绍了SpringBoot注入配置文件的3种方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 方案1:@ConfigurationProperties+@Component 定义spring的一个实体bean装载配置文件信息,其它要使用配置信息是注入该实体bean /** * 将配置文件中配置的每一个属性的值,映射到这个组件中 * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配

Spring根据XML配置文件注入属性的方法

方法一使用setter方法 package com.swift; public class Book { private String bookName; public void setBook(String bookName) { this.bookName = bookName; } @Override public String toString() { return "Book [book=" + bookName + "]"; } } 在Spring框架中

SpringBoot整合Thymeleaf的方法

简介: 在目前的企业级应用开发中 前后端分离是趋势,但是视图层技术还占有一席之地, Spring Boot 对视图层技术提供了很好的支持,官方推荐使用的模板引擎是 Thymeleaf 不过像 FreeMarker 也支持, JSP 技术在这里并不推荐使用. Thymeleaf 是新一代 Java 模板引擎,类似于 Velocity.FreeMarker 等传统 Java 模板引擎.与传统 Java 模板引擎不同的是 Thymeleaf 支持 HTML 原型,既可 以让前端工程师在浏览器中直接打

MySQL解决SQL注入的另类方法详解

本文实例讲述了MySQL解决SQL注入的另类方法.分享给大家供大家参考,具体如下: 问题解读 我觉得,这个问题每年带来的成本可以高达数十亿美元了.本文就来谈谈,假定我们有如下 SQL 模板语句: select * from T where f1 = ‘{value1}’ and f2 = {value2} 现在我们需要根据用户输入值填充该语句: value1=hello value2=5 我们得到了下面的 SQL 语句,我们再提交给数据库: select * from T where f1=’h

浅谈html转义及防止javascript注入攻击的方法

有的时候页面中会有一个输入框,用户输入内容后会显示在页面中,类似于网页聊天应用.如果用户输入了一段js脚本,比例:<script>alert(‘test’);</script>,页面会弹出一个对话框,或者输入的脚本中有改变页面js变量的代码则会时程序异常或者达到跳过某种验证的目的.那如何防止这种恶意的js脚本攻击呢?通过html转义能解决这个问题. 一:什么是html转义? html转义是将特殊字符或html标签转换为与之对应的字符.如:< 会转义为 <> 或转义

JSP开发之Spring方法注入之替换方法实现

JSP开发之Spring方法注入之替换方法实现 Spring提供了一种替换方法实现的机制,可以让我们改变某个bean某方法的实现.打个比方我们有一个bean,其中拥有一个add()方法可以用来计算两个整数的和,但这个时候我们想把它的实现逻辑改为如果两个整数的值相同则把它们相乘,否则还是把它们相加,在不改变或者是不能改变源码的情况下我们就可以通过Spring提供的替换方法实现机制来实现这一要求. 替换方法实现机制的核心是MethodReplacer接口,其中定义了一个reimplement ()方

MySQL 及 SQL 注入与防范方法

所谓SQL注入,就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令. 我们永远不要信任用户的输入,我们必须认定用户输入的数据都是不安全的,我们都需要对用户输入的数据进行过滤处理. 1.以下实例中,输入的用户名必须为字母.数字及下划线的组合,且用户名长度为 8 到 20 个字符之间: if (preg_match("/^/w{8,20}$/", $_GET[‘username’], $matches)) { $result =

jquery过滤特殊字符’,防sql注入的实现方法

SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

今天写的代码给项目经理看了下,因为之前没有考虑sql注入的问题,然后在他测试我的code的时候,打了一个"’",然后我的程序就挂了! 于是乎,我在网上找到了一个验证并过滤文本框的jquery! 先上图: PS:这里用@#测试,因为’太小了,都看不清楚了! 具体的jquery代码: <script type="text/javascript" language="javascript"> $(document).ready(functi

servlet配置方法及其生命周期详解

servlet配置: 在web.xml中,首先向服务器注册一个servlet.在<servlet>标签下 给定一个servlet名字,这个servlet-name是我们自己用的,方便我们用它对servlet进行配置. 1 <servlet-name>AServlet</servlet-name>然后指定一个全类名,这个是给服务器使用,服务器用来创建全类名对象的实例 1 <servlet-class>com.servlet.AServlet</servl

原文 

https://www.zhangshengrong.com/p/ERNnqdG2a5/

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址