springservletjsp配置

1. springmvc配置servlet的拦截形式/*和/的区别

/* 代表拦截所有, 一切的东西; 包括jsp ; 这种配置是错误的,因为如果这样配置了,jsp都不能被转发请求,直接报错了.

/ 代表拦截除了jsp的所有,实际开发推荐使用这种 resultfull风格的一种

2. applicationcontext.xml和spring-servlet.xml怎么配置

spring-servlet.xml是说springmvc吗?

这些都需要看你具体用到了什么来进行具体配置的.

给你一个参考吧:

spring-servlet.xml的:

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd"
	default-lazy-init="true">
	<!--enableaop-->
	<aop:aspectj-autoproxy/>

	<!--enableautowire-->
	<context:annotation-config/>
	<context:component-scanbase-package="info.kkdo"/>
	<!--启动对@AspectJ注解的支持-->
	<!--通知spring使用cglib而不是jdk的来生成代理方法AOP可以拦截到Controller-->
	<!--<aop:aspectj-autoproxyproxy-target-class="true"/>-->
	<!--注解支持-->
	<!--<context:annotation-config/>-->
	<!--避免IE执行AJAX时，返回JSON出现下载文件-->
	<beanid=""
		class="org.springframework.http.converter.json.">
		<propertyname="supportedMediaTypes">
			<list>
				<value>text/html;charset=UTF-8</value>
				<value>text/json;charset=UTF-8</value>
				<value>application/json;charset=UTF-8</value>
			</list>
		</property>
	</bean>
	<!--采用SpringMVC自带的JSON转换工具，支持@ResponseBody注解-->
	<bean
		class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<propertyname="messageConverters">
			<list>
				<refbean=""/><!--JSON转换器-->
			</list>
		</property>
	</bean>
	<!--对模型视图名称的解析，即在模型视图名称添加前后缀-->
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<propertyname="viewClass"
			value="org.springframework.web.servlet.view.JstlView"/>
		<propertyname="prefix"value="/WEB-INF/jsp/"></property>
		<propertyname="suffix"value=".jsp"></property>
	</bean>
	<mvc:annotation-driven>
		<!--处理responseBody里面日期类型-->
		<mvc:message-converters>
			<bean
				class="org.springframework.http.converter.json.">
				<propertyname="objectMapper">
					<beanclass="com.fasterxml.jackson.databind.ObjectMapper">
						<propertyname="dateFormat">
							<beanclass="java.text.SimpleDateFormat">
								<constructor-argtype="java.lang.String"value="yyyy-MM-ddHH:mm:ss"/>
							</bean>
						</property>
					</bean>
				</property>
			</bean>
		</mvc:message-converters>
	</mvc:annotation-driven>
	
	
	<!--配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包-->
	<beanid="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<!--默认编码-->
		<propertyname="defaultEncoding"value="utf-8"/>
		<!--文件大小最大值-->
		<propertyname="maxUploadSize"value="10485760000"/>
		<!--内存中的最大值-->
		<propertyname="maxInMemorySize"value="40960"/>
	</bean>
	<!--这个移动到spring-application中-->
	<!--<importresource="spring-mvc-shiro.xml"/>-->
	<!--开启了spring的监听器,这里就关闭,否则bean会创建两次-->
	<!--<importresource="spring-application.xml"/>-->
</beans>

application.xml

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"xmlns:task="http://www.springframework.org/schema/task"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd"
default-lazy-init="false">

	<!--定时器开关开始-->
	<task:annotation-driven/>
	<!--统一异常处理方式,在Controller中处理了-->
	<!--<beanid="exceptionHandler"class="info.kkdo.common.exception.MyExceptionHandler"/>-->
	<!--初始化数据-->
	
	<!--引入spring-shiro配置文件-->
	<importresource="spring-shiro.xml"/>

	<importresource="spring-mybatis.xml"/>
	
	<importresource="spring-task.xml"/>

	<!--全局application-->
	<!--<beanid="springAcaHolder"class="com.kkdo.core.tools.support.SpringAcaHolder"></bean>-->
	<!--使用Spring组件扫描的方式来实现自动注入bean-->
	<context:component-scanbase-package="info.kkdo"/>
	<!--隐式地向Spring容器注册-->
	<!--<context:annotation-config/>-->
	
	<!--用于读取配置文件的bean-->
	<!--<beanid="configurationLoader"
		class="info.kkdo.common.config.ConfigurationLoader">
		<propertyname=""value="true"/>
	</bean>-->
	
</beans>

3. springmvc配置servlet的拦截形式/*和/的区别

一、我们都知道在基于Spring的Application中，需要在web.xml中增加下面类似的配置信息：

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<!-- Spring MVC Servlet -->

<servlet>
<servlet-name>servletName</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>servletName</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
此处需要特别强调的是 <url-pattern>/</url-pattern>使用的是/，而不是/*,如果使用/*,那么请求时可以通过DispatcherServlet转发到相应的Action或者Controller中的，但是返回的内容，如返回的jsp还会再次被拦截，这样导致404错误，即访问不到jsp。所以如果以后发现总是有404错误的时候，别忘了check一下 <url-pattern>/</url-pattern>的配置是否是/*.

二、其实Spring 的Servlet拦截器匹配规则（即 <url-pattern>...</url-pattern> ）都可以自己定义，例：当映射为@RequestMapping("/user/add")时

1、拦截*.do、*.htm， 例如：/user/add.do

这是最传统的方式，最简单也最实用。不会导致静态文件（jpg,js,css）被拦截。

2、拦截/，例如：/user/add

可以实现现在很流行的REST风格。很多互联网类型的应用很喜欢这种风格的URL。

弊端：会导致静态文件（jpg,js,css）被拦截后不能正常显示。想实现REST风格，事情就是麻烦一些。后面有解决办法还算简单。

3、拦截/*，这是一个错误的方式，请求可以走到Action中，但转到jsp时再次被拦截，不能访问到jsp。

三、如何访问到静态的文件，如jpg,js,css?

如果你的DispatcherServlet拦截"*.do"这样的有后缀的URL，就不存在访问不到静态资源的问题。

如果你的DispatcherServlet拦截"/"，为了实现REST风格，拦截了所有的请求，那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。

4. 第二章：SpringBoot与JSP间不可描述的秘密

springboot 内部对jsp的支持并不是特别理想，而 springboot 推荐的视图是 Thymeleaf ，对于 java 开发人员来说还是大多数人员喜欢使用jsp，接下来我们来讲解下 springboot 是如何支持jsp的。

整合springboot web项目支持jsp作为视图输出。

恒宇少年在博客整理出来了SpringBoot、ApiBoot、SpringCloud的文章汇总【 SpringBoot基础教程专题 】，【 SpringCloud基础教程专题 】，【 ApiBoot组件使用专题 】

我们使用IntelliJ IDEA 工具来构建项目，首先我们需要创建一个springboot项目，如下图1所示.

点击Next后输入一些项目的基本参数（包名，工程名，打包形式，maven形式构建等），如下图2所示：

点击Next后选择我们预先加入到工程的springboot内置的jar包组件，我们这里选择一个web组件。如下图3所示：

点击 Next 输入项目名称后店家 Finish 既可以完成了项目的构建。新构建的项目目录结构如下图4所示：

可以看到上图中比我们 lessonOne 项目中多出来了一个类文件, ServletInitlalizer ，打开该类我们不难发现它继承了 SpringBootServletInitializer 这个父类，而 SpringBootServletInitializer 这个类是 springboot 提供的 web 程序初始化的入口，当我们使用外部容器（后期文章讲解使用外部tomcat如何运行项目）运行项目时会自动加载并且装配。
实现了 SpringBootServletInitializer 的子类需要重写一个configure方法，方法内自动根据 LessontwoApplication .class的类型创建一个 SpringApplicationBuilder 交付给 springboot 框架来完成初始化运行配置。

我们打开pom.xml（maven配置文件）可以看到我们之前构建项目时已经添加了web模块，而springboot给我们自动添加了 spring-boot-starter-tomcat 配置引入。springboot内部集成了tomcat组件，这里我们就不需要重复引入tomcat组件。

我们先来添加jsp的maven支持，如下图4所示：

我们还需要引入jsp对servlet容器的支持,如下图5所示：

除了上面的jsp,servlet支持以外，如果你还需要在jsp页面使用jstl标签来处理界面逻辑，那么需要引入jstl maven，如下图6所示：

上面配置就是我们本章需要的全部配置，那么我们先来尝试运行下项目是否已经可以正常运行。这里项目运行也可以使用IntelliJ IDEA工具提供的组件来完成，如下图7所示,：
（注意：如果你已经开启了另外一个spring boot项目请先关闭，因为springboot内置的端口号都是8080这样会引起冲突）

点击绿色三角号即可开始运行项目，我们先来尝试下点击后看看控制台输入的日志信息。可以看到项目已经正常运行了，右上角的绿色三角号也变成了重启的按钮，如下图8所示：

项目运行如图9所示：

可以看到项目已经正常运行，但是我们现在还没有配置，创建JSP文件，我们接下来开始配置，创建JSP。

如果是使用过eclipse工具的人肯定知道jsp文件之前是在/webapp/WEB-INF/jsp目录下，那么我们也沿用eclipse的风格。
1. 在main目录下创建webapp文件夹
2. 在webapp下创建jsp文件夹如下图10所示：

3. 修改application.properties文件让springmvc支持视图的跳转目录指向为/main/webapp/jsp，配置如下图11所示：

我们在webapps/jsp目录下创建一个index.jsp用于测试我们的配置是否已经支持了jsp，新建jsp文件如下图12所示：

上面工作我们已经完成了jsp的所有配置，那么接下来我们需要配置springmvc的控制器，我们新建indexController如下图13所示：

可以看到上图我们在IndexController配置文件内添加了index()方法配置了@RequestMapping注解来描述index()方法是一个可以被springmvc管理的请求视图。我们的index()方法返回值这里是"index"。
为什么我们返回"index"，还记得上述步骤中配置的application.properties文件的springmvc请求前缀以及后缀，那么当我们访问/index时springmvc就会去找/webapp/WEB-INF/jsp/index.jsp文件。

重启项目我们尝试访问 127.0.0.1:8080/index ，可以看到如下图14的效果，证明已经完成了springboot与jsp的整合：

上述便是我们本章的全部内容，本章主要是讲解了springboot集成jsp作为渲染视图，结合springmvc来转发请求。

本章内容已经上传到码云：

SpringBoot配套源码地址： https://gitee.com/hengboy/spring-boot-chapter

SpringCloud配套源码地址： https://gitee.com/hengboy/spring-cloud-chapter

SpringBoot相关系列文章请访问： 目录：SpringBoot学习目录

QueryDSL相关系列文章请访问： QueryDSL通用查询框架学习目录

SpringDataJPA相关系列文章请访问： 目录：SpringDataJPA学习目录

SpringBoot相关文章请访问： 目录：SpringBoot学习目录 ，感谢阅读！

知识星球 - 恒宇少年

5. spring 中如何实现jsp与java的交互

1：servlet，一个JSP页面经过编译后是一个servlet类，可以通过servlet进行交互。
2：添加Struts框架，通专过Struts进行交互。
3：JS，Ajax或者DWR，不过用DWR的话属似乎也用不到spring了。
4：标签。有自定义标签，spring也有自己的标签，可以进行交互。
5：与第一个办法类似，JSP本身可以嵌套java代码，当成是2个java类之间的交互就行。

6. jsp 如何通过javascript访问servlet 我用的是spring+hibernate+servlet写的项目 web.xml配置了

自己检查一下注入的错误啊。
ssh搭起来很容易出错的。

7. 如何配置springboot的jsp支持

只是要打包成war包，然后在tomcat下跑:
spring-boot默认已经不再支持jsp视图展示，要支持jsp需要做一下工作：
1、application.yml中配置(这里也可以是properties配置文件)：
mvc:
view:
prefix: /WEB-INF/views/
suffix: .jsp

2、Application的服务启动类如下：
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(CommonApplication.class, PlatformApplication.class);
}

public static void main(String[] args) throws Exception {
SpringApplication springApplication = new SpringApplication(CommonApplication.class, PlatformApplication.class);
springApplication.run(args);
}

3、引入jsp解析及jstl依赖，pom.xml：
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>

4、配置maven项目打包方式为war包，不要使用main方法启动应用，一定要放到tomcat容器跑，即像没有使用spring-boot时在ide配置tomcat来跑应用。

8. JSP手动配置Struts+Hibernate+Spring要领及步骤

为什么要手动配置呢，现在不都是快速开发吗。

ssh框架整合实例子-配置文件

主要配置文件如下：

1.web.xml:

配置actionservlet类和映射
配置Listener，加载spring配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<servlet>
<servlet-name>action</servlet-name>
<servlet-class>
org.apache.struts.action.ActionServlet
</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>
/WEB-INF/struts-config.xml
</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

</web-app>

2. struts-config.xml

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
"http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>

<form-beans>

<form-bean name="userForm"
type="com.yanek.demo.ssh.bean.UserForm">
</form-bean>

</form-beans>
<global-forwards>
<forward name="error" path="/error.jsp"></forward>
</global-forwards>
<action-mappings>

<!--
<action path="/user" name="userForm"
type="com.yanek.demo.ssh.action.UserAction"
scope="request" validate="true" input="/register.jsp">
<forward name="success" path="/reg_success.jsp" />
</action>
-->

<action path="/user" name="userForm"
type="org.springframework.web.struts.DelegatingActionProxy"
scope="request" validate="false" input="/register.jsp"

parameter="method">
<forward name="success" path="/reg_success.jsp" />
<forward name="list" path="/list.jsp" />
</action>

</action-mappings>

<message-resources parameter="ApplicationResources" />

</struts-config>

3. applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
<!-- 定义数据源 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"
destroy-method="close">
<!-- 指定连接数据库驱动 -->
<property name="driverClassName"
value="com.microsoft.jdbc.sqlserver.SQLServerDriver" />
<!-- 指定连接数据库url -->
<property name="url"
value="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=ssh"

/>
<!-- 指定连接数据库用户名，密码为空 -->
<property name="username" value="sa" />
<property name="password" value="" />
</bean>
<!-- 定义Hibernate的sessionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 指定数据源 -->
<property name="dataSource" ref="dataSource" />
<!-- 指定Hibernate映射文件 -->
<property name="mappingResources">
<list>
<value>com/yanek/demo/ssh/vo/User.hbm.xml</value>

</list>
</property>
<property name="hibernateProperties">
<props>
<!-- 指定使用方言 -->
<prop key="hibernate.dialect">
org.hibernate.dialect.SQLServerDialect
</prop>
<!-- 是否在控制台输出sql语句 -->
<prop key="show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.jdbc.batch_size">20</prop>
</props>
</property>
</bean>
<!-- 定义事务管理 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 定义事务管理拦截器 -->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义代理自动管理事务 -->
<bean id="ProxyCreator"

class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定需要Spring管理事务的Bean -->
<property name="beanNames">
<list>
<value>userService</value>

</list>
</property>
<!-- 调用事务管理拦截器 -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
<!-- 把DAO注入给Session工厂 -->

<bean id="userDAO" class="com.yanek.demo.ssh..UserDAOImpl">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<!-- 把Service注入给DAO -->

<bean id="userService"
class="com.yanek.demo.ssh.service.UserServiceImpl">
<property name="userDAO" ref="userDAO"></property>
</bean>

<!-- 把Action注入给Service -->
<bean name="/user"
class="com.yanek.demo.ssh.action.UserAction">
<property name="userService" ref="userService"></property>

</bean>

</beans>

9. springMVC 设置了<mvc:default-servlet-handler/> 为什么拦截不到jsp 我的DispatcherServlet设置的是"/"

在springMVC-servlet.xml中配置<mvc:default-servlet-handler />后，会在Spring MVC上下文中定义一个org.springframework.web.servlet.resource.，它会像一个检查员，对进入DispatcherServlet的URL进行筛查，如果发现是静态资源的请求，就将该请求转由Web应用服务器默认的Servlet处理，如果不是静态资源的请求，才由DispatcherServlet继续处理。

10. SpringBoot配置

server配置
1. server.address指定server绑定的地址
2. server.compression.enabled是否开启压缩，默认为false.
3. server.compression.excluded-user-agents指定不压缩的user-agent，多个以逗号分隔，默认值为:text/html,text/xml,text/plain,text/css
4. server.compression.mime-types指定要压缩的MIME type，多个以逗号分隔.
5. server.compression.min-response-size执行压缩的阈值，默认为2048
6. server.context-parameters.[param name]设置servlet context 参数
7. server.context-path设定应用的context-path.
8. server.display-name设定应用的展示名称，默认: application
9. server.jsp-servlet.class-name设定编译JSP用的servlet，默认: org.apache.jasper.servlet.JspServlet)
10. server.jsp-servlet.init-parameters.[param name]设置JSP servlet 初始化参数.
11. server.jsp-servlet.registered设定JSP servlet是否注册到内嵌的servlet容器，默认true
12. server.port设定http监听端口
13. server.servlet-path设定dispatcher servlet的监听路径，默认为: /
cookie、session配置
1. server.session.cookie.comment指定session cookie的comment
2. server.session.cookie.domain指定session cookie的domain
3. server.session.cookie.http-only是否开启HttpOnly.
4. server.session.cookie.max-age设定session cookie的最大age.
5. server.session.cookie.name设定Session cookie 的名称.
6. server.session.cookie.path设定session cookie的路径.
7. server.session.cookie.secure设定session cookie的“Secure” flag.
8. server.session.persistent重启时是否持久化session，默认false
9. server.session.timeoutsession的超时时间
10. server.session.tracking-modes设定Session的追踪模式(cookie, url, ssl).
ssl配置
1. server.ssl.ciphers是否支持SSL ciphers.
2. server.ssl.client-auth设定client authentication是wanted 还是 needed.
3. server.ssl.enabled是否开启ssl，默认: true
4. server.ssl.key-alias设定key store中key的别名.
5. server.ssl.key-password访问key store中key的密码.
6. server.ssl.key-store设定持有SSL certificate的key store的路径，通常是一个.jks文件.
7. server.ssl.key-store-password设定访问key store的密码.
8. server.ssl.key-store-provider设定key store的提供者.
9. server.ssl.key-store-type设定key store的类型.
10. server.ssl.protocol使用的SSL协议，默认: TLS
11. server.ssl.trust-store持有SSL certificates的Trust store.
12. server.ssl.trust-store-password访问trust store的密码.
13. server.ssl.trust-store-provider设定trust store的提供者.
14. server.ssl.trust-store-type指定trust store的类型.
tomcat
1. server.tomcat.access-log-enabled是否开启access log ，默认: false)
2. server.tomcat.access-log-pattern设定access logs的格式，默认: common
3. server.tomcat.accesslog.directory设定log的目录，默认: logs
4. server.tomcat.accesslog.enabled是否开启access log，默认: false
5. server.tomcat.accesslog.pattern设定access logs的格式，默认: common
6. server.tomcat.accesslog.prefix设定Log 文件的前缀，默认: access_log
7. server.tomcat.accesslog.suffix设定Log 文件的后缀，默认: .log
8. server.tomcat.background-processor-delay后台线程方法的Delay大小: 30
9. server.tomcat.basedir设定Tomcat的base 目录，如果没有指定则使用临时目录.
10. server.tomcat.internal-proxies设定信任的正则表达式，默认:“10.\d{1,3}.\d{1,3}.\d{1,3}| 192.168.\d{1,3}.\d{1,3}| 169.254.\d{1,3}.\d{1,3}| 127.\d{1,3}.\d{1,3}.\d{1,3}| 172.1[6-9]{1}.\d{1,3}.\d{1,3}| 172.2[0-9]{1}.\d{1,3}.\d{1,3}|172.3[0-1]{1}.\d{1,3}.\d{1,3}”
11. server.tomcat.max-http-header-size设定http header的最小值，默认: 0
12. server.tomcat.max-threads设定tomcat的最大工作线程数，默认为: 0
13. server.tomcat.port-header设定http header使用的，用来覆盖原来port的value.
14. server.tomcat.protocol-header设定Header包含的协议，通常是 X-Forwarded-Proto，如果remoteIpHeader有值，则将设置为RemoteIpValve.
15. server.tomcat.protocol-header-https-value设定使用SSL的header的值，默认https.
16. server.tomcat.remote-ip-header设定remote IP的header，如果remoteIpHeader有值，则设置为RemoteIpValve
17. server.tomcat.uri-encoding设定URI的解码字符集.
undertow
1. server.undertow.access-log-dir设定Undertow access log 的目录，默认: logs
2. server.undertow.access-log-enabled是否开启access log，默认: false
3. server.undertow.access-log-pattern设定access logs的格式，默认: common
4. server.undertow.accesslog.dir设定access log 的目录.
5. server.undertow.buffer-size设定buffer的大小.
6. server.undertow.buffers-per-region设定每个region的buffer数
7. server.undertow.direct-buffers设定堆外内存
8. server.undertow.io-threads设定I/O线程数.
9. server.undertow.worker-threads设定工作线程数