ServerProperties

Spring Boot 其默认是集成web容器的，启动方式由像普通Java程序一样，main函数入口启动。其内置Tomcat容器或Jetty容器，具体由配置来决定（默认Tomcat）。当然你也可以将项目打包成war包，放到独立的web容器中（Tomcat、weblogic等等），当然在此之前你要对程序入口做简单调整。

项目构建我们使用Maven或Gradle，这将使项目依赖、jar包管理、以及打包部署变的非常方便。

一、内嵌 Server 配置

Spring Boot将容器内置后，它通过配置文件的方式类修改相关server配置。
先看一下下面的图，为关于server的配置列项：





其中常用的配置只有少数几个，已经用紫色标记起来。红框圈起来的部分，看名称分类就可以明白其作用。
对server的几个常用的配置做个简单说明：

# 项目contextPath，一般在正式发布版本中，我们不配置
server.context-path=/myspringboot
# 错误页，指定发生错误时，跳转的URL。请查看BasicErrorController源码便知
server.error.path=/error
# 服务端口
server.port=9090
# session最大超时时间(分钟)，默认为30
server.session-timeout=60
# 该服务绑定IP地址，启动服务器时如本机不是该IP地址则抛出异常启动失败，只有特殊需求的情况下才配置
# server.address=192.168.16.11

Tomcat
Tomcat为Spring Boot的默认容器，下面是几个常用配置：

# tomcat最大线程数，默认为200

server.tomcat.max-threads=800

# tomcat的URI编码

server.tomcat.uri-encoding=UTF-8

# 存放Tomcat的日志、Dump等文件的临时文件夹，默认为系统的tmp文件夹（如：C:\Users\Shanhy\AppData\Local\Temp）

server.tomcat.basedir=H:/springboot-tomcat-tmp

# 打开Tomcat的Access日志，并可以设置日志格式的方法：

#server.tomcat.access-log-enabled=true

#server.tomcat.access-log-pattern=

# accesslog目录，默认在basedir/logs

#server.tomcat.accesslog.directory=

# 日志文件目录

logging.path=H:/springboot-tomcat-tmp

# 日志文件名称，默认为spring.log

logging.file=myapp.log

http://www.cnblogs.com/duyinqiang/p/5696342.html 
org.springframework.boot:spring-boot-autoconfigure:1.3.0.M1
spring-boot-autoconfigure-1.3.0.M1.jar

org.springframework.boot.autoconfigure.web.ServerProperties

/*
* Copyright 2012-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package org.springframework.boot.autoconfigure.web;

import java.io.File;
import java.net.InetAddress;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import javax.validation.constraints.NotNull;

import org.apache.catalina.Context;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.valves.AccessLogValve;
import org.apache.catalina.valves.RemoteIpValve;
import org.apache.coyote.AbstractProtocol;
import org.apache.coyote.ProtocolHandler;
import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizer;
import org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizerBeanPostProcessor;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.InitParameterConfiguringServletContextInitializer;
import org.springframework.boot.context.embedded.JspServlet;
import org.springframework.boot.context.embedded.Ssl;
import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatContextCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.undertow.UndertowEmbeddedServletContainerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;
import org.springframework.core.Ordered;
import org.springframework.util.StringUtils;

/**
* {@link ConfigurationProperties} for a web server (e.g. port and path settings). Will be
* used to customize an {@link EmbeddedServletContainerFactory} when an
* {@link EmbeddedServletContainerCustomizerBeanPostProcessor} is active.
*
* @author Dave Syer
* @author Stephane Nicoll
* @author Andy Wilkinson
* @author Ivan Sopov
* @author Marcos Barbero
*/
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = false)
public class ServerProperties implements EmbeddedServletContainerCustomizer, Ordered {

/**
* Server HTTP port.
*/
private Integer port;

/**
* Network address to which the server should bind to.
*/
private InetAddress address;

/**
* Session timeout in seconds.
*/
private Integer sessionTimeout;

/**
* Context path of the application.
*/
private String contextPath;

/**
* Display name of the application.
*/
private String displayName = "application";

@NestedConfigurationProperty
private Ssl ssl;

/**
* Path of the main dispatcher servlet.
*/
@NotNull
private String servletPath = "/";

private final Tomcat tomcat = new Tomcat();

private final Undertow undertow = new Undertow();

@NestedConfigurationProperty
private JspServlet jspServlet;

/**
* ServletContext parameters.
*/
private final Map<String, String> contextParameters = new HashMap<String, String>();

@Override
public int getOrder() {
return 0;
}

public Tomcat getTomcat() {
return this.tomcat;
}

public Undertow getUndertow() {
return this.undertow;
}

public String getContextPath() {
return this.contextPath;
}

public void setContextPath(String contextPath) {
this.contextPath = contextPath;
}

public String getDisplayName() {
return this.displayName;
}

public void setDisplayName(String displayName) {
this.displayName = displayName;
}

public String getServletPath() {
return this.servletPath;
}

public String getServletMapping() {
if (this.servletPath.equals("") || this.servletPath.equals("/")) {
return "/";
}
if (this.servletPath.contains("*")) {
return this.servletPath;
}
if (this.servletPath.endsWith("/")) {
return this.servletPath + "*";
}
return this.servletPath + "/*";
}

public String getServletPrefix() {
String result = this.servletPath;
if (result.contains("*")) {
result = result.substring(0, result.indexOf("*"));
}
if (result.endsWith("/")) {
result = result.substring(0, result.length() - 1);
}
return result;
}

public void setServletPath(String servletPath) {
this.servletPath = servletPath;
}

public Integer getPort() {
return this.port;
}

public void setPort(Integer port) {
this.port = port;
}

public InetAddress getAddress() {
return this.address;
}

public void setAddress(InetAddress address) {
this.address = address;
}

public Integer getSessionTimeout() {
return this.sessionTimeout;
}

public void setSessionTimeout(Integer sessionTimeout) {
this.sessionTimeout = sessionTimeout;
}

public Ssl getSsl() {
return this.ssl;
}

public void setSsl(Ssl ssl) {
this.ssl = ssl;
}

public JspServlet getJspServlet() {
return this.jspServlet;
}

public void setJspServlet(JspServlet jspServlet) {
this.jspServlet = jspServlet;
}

public Map<String, String> getContextParameters() {
return this.contextParameters;
}

public void setLoader(String value) {
// no op to support Tomcat running as a traditional container (not embedded)
}

@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
if (getPort() != null) {
container.setPort(getPort());
}
if (getAddress() != null) {
container.setAddress(getAddress());
}
if (getContextPath() != null) {
container.setContextPath(getContextPath());
}
if (getDisplayName() != null) {
container.setDisplayName(getDisplayName());
}
if (getSessionTimeout() != null) {
container.setSessionTimeout(getSessionTimeout());
}
if (getSsl() != null) {
container.setSsl(getSsl());
}
if (getJspServlet() != null) {
container.setJspServlet(getJspServlet());
}
if (container instanceof TomcatEmbeddedServletContainerFactory) {
getTomcat()
.customizeTomcat((TomcatEmbeddedServletContainerFactory) container);
}
if (container instanceof UndertowEmbeddedServletContainerFactory) {
getUndertow().customizeUndertow(
(UndertowEmbeddedServletContainerFactory) container);
}
container.addInitializers(new InitParameterConfiguringServletContextInitializer(
getContextParameters()));
}

public String[] getPathsArray(Collection<String> paths) {
String[] result = new String[paths.size()];
int i = 0;
for (String path : paths) {
result[i++] = getPath(path);
}
return result;
}

public String[] getPathsArray(String[] paths) {
String[] result = new String[paths.length];
int i = 0;
for (String path : paths) {
result[i++] = getPath(path);
}
return result;
}

public String getPath(String path) {
String prefix = getServletPrefix();
if (!path.startsWith("/")) {
path = "/" + path;
}
return prefix + path;
}

public static class Tomcat {

/**
* Format pattern for access logs.
*/
private String accessLogPattern;

/**
* Enable access log.
*/
private boolean accessLogEnabled = false;

/**
* Regular expression that matches proxies that are to be trusted.
*/
private String internalProxies = "10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|" // 10/8
+ "192\\.168\\.\\d{1,3}\\.\\d{1,3}|" // 192.168/16
+ "169\\.254\\.\\d{1,3}\\.\\d{1,3}|" // 169.254/16
+ "127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|" // 127/8
+ "172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|" // 172.16/12
+ "172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|"
+ "172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3}";

/**
* Header that holds the incoming protocol, usually named "X-Forwarded-Proto".
* Configured as a RemoteIpValve only if remoteIpHeader is also set.
*/
private String protocolHeader;

/**
* Name of the HTTP header used to override the original port value.
*/
private String portHeader;

/**
* Name of the http header from which the remote ip is extracted. Configured as a
* RemoteIpValve only if remoteIpHeader is also set.
*/
private String remoteIpHeader;

/**
* Tomcat base directory. If not specified a temporary directory will be used.
*/
private File basedir;

/**
* Delay in seconds between the invocation of backgroundProcess methods.
*/
private int backgroundProcessorDelay = 30; // seconds

/**
* Maximum amount of worker threads.
*/
private int maxThreads = 0; // Number of threads in protocol handler

/**
* Maximum size in bytes of the HTTP message header.
*/
private int maxHttpHeaderSize = 0; // bytes

/**
* Character encoding to use to decode the URI.
*/
private String uriEncoding;

/**
* Controls response compression. Acceptable values are "off" to disable
* compression, "on" to enable compression of responses over 2048 bytes, "force"
* to force response compression, or an integer value to enable compression of
* responses with content length that is at least that value.
*/
private String compression = "off";

/**
* Comma-separated list of MIME types for which compression is used.
*/
private String compressableMimeTypes = "text/html,text/xml,text/plain";

public int getMaxThreads() {
return this.maxThreads;
}

public void setMaxThreads(int maxThreads) {
this.maxThreads = maxThreads;
}

public int getMaxHttpHeaderSize() {
return this.maxHttpHeaderSize;
}

public void setMaxHttpHeaderSize(int maxHttpHeaderSize) {
this.maxHttpHeaderSize = maxHttpHeaderSize;
}

public boolean getAccessLogEnabled() {
return this.accessLogEnabled;
}

public void setAccessLogEnabled(boolean accessLogEnabled) {
this.accessLogEnabled = accessLogEnabled;
}

public int getBackgroundProcessorDelay() {
return this.backgroundProcessorDelay;
}

public void setBackgroundProcessorDelay(int backgroundProcessorDelay) {
this.backgroundProcessorDelay = backgroundProcessorDelay;
}

public File getBasedir() {
return this.basedir;
}

public void setBasedir(File basedir) {
this.basedir = basedir;
}

public String getAccessLogPattern() {
return this.accessLogPattern;
}

public void setAccessLogPattern(String accessLogPattern) {
this.accessLogPattern = accessLogPattern;
}

public String getCompressableMimeTypes() {
return this.compressableMimeTypes;
}

public void setCompressableMimeTypes(String compressableMimeTypes) {
this.compressableMimeTypes = compressableMimeTypes;
}

public String getCompression() {
return this.compression;
}

public void setCompression(String compression) {
this.compression = compression;
}

public String getInternalProxies() {
return this.internalProxies;
}

public void setInternalProxies(String internalProxies) {
this.internalProxies = internalProxies;
}

public String getProtocolHeader() {
return this.protocolHeader;
}

public void setProtocolHeader(String protocolHeader) {
this.protocolHeader = protocolHeader;
}

public String getPortHeader() {
return this.portHeader;
}

public void setPortHeader(String portHeader) {
this.portHeader = portHeader;
}

public String getRemoteIpHeader() {
return this.remoteIpHeader;
}

public void setRemoteIpHeader(String remoteIpHeader) {
this.remoteIpHeader = remoteIpHeader;
}

public String getUriEncoding() {
return this.uriEncoding;
}

public void setUriEncoding(String uriEncoding) {
this.uriEncoding = uriEncoding;
}

void customizeTomcat(TomcatEmbeddedServletContainerFactory factory) {
if (getBasedir() != null) {
factory.setBaseDirectory(getBasedir());
}
customizeBackgroundProcessorDelay(factory);
customizeHeaders(factory);
if (this.maxThreads > 0) {
customizeMaxThreads(factory);
}
if (this.maxHttpHeaderSize > 0) {
customizeMaxHttpHeaderSize(factory);
}
customizeCompression(factory);
if (this.accessLogEnabled) {
customizeAccessLog(factory);
}
if (getUriEncoding() != null) {
factory.setUriEncoding(getUriEncoding());
}
}

private void customizeBackgroundProcessorDelay(
TomcatEmbeddedServletContainerFactory factory) {
factory.addContextCustomizers(new TomcatContextCustomizer() {

@Override
public void customize(Context context) {
context.setBackgroundProcessorDelay(Tomcat.this.backgroundProcessorDelay);
}

});
}

private void customizeHeaders(TomcatEmbeddedServletContainerFactory factory) {
String remoteIpHeader = getRemoteIpHeader();
String protocolHeader = getProtocolHeader();
if (StringUtils.hasText(remoteIpHeader)
|| StringUtils.hasText(protocolHeader)) {
RemoteIpValve valve = new RemoteIpValve();
valve.setRemoteIpHeader(remoteIpHeader);
valve.setProtocolHeader(protocolHeader);
valve.setInternalProxies(getInternalProxies());
valve.setPortHeader(getPortHeader());
factory.addContextValves(valve);
}
}

@SuppressWarnings("rawtypes")
private void customizeMaxThreads(TomcatEmbeddedServletContainerFactory factory) {
factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {
@Override
public void customize(Connector connector) {

ProtocolHandler handler = connector.getProtocolHandler();
if (handler instanceof AbstractProtocol) {
AbstractProtocol protocol = (AbstractProtocol) handler;
protocol.setMaxThreads(Tomcat.this.maxThreads);
}

}
});
}

@SuppressWarnings("rawtypes")
private void customizeMaxHttpHeaderSize(
TomcatEmbeddedServletContainerFactory factory) {
factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {

@Override
public void customize(Connector connector) {
ProtocolHandler handler = connector.getProtocolHandler();
if (handler instanceof AbstractHttp11Protocol) {
AbstractHttp11Protocol protocol = (AbstractHttp11Protocol) handler;
protocol.setMaxHttpHeaderSize(Tomcat.this.maxHttpHeaderSize);
}
}

});
}

private void customizeCompression(TomcatEmbeddedServletContainerFactory factory) {
factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {

@Override
public void customize(Connector connector) {
ProtocolHandler handler = connector.getProtocolHandler();
if (handler instanceof AbstractHttp11Protocol) {
@SuppressWarnings("rawtypes")
AbstractHttp11Protocol protocol = (AbstractHttp11Protocol) handler;
protocol.setCompression(coerceCompression(Tomcat.this.compression));
protocol.setCompressableMimeTypes(Tomcat.this.compressableMimeTypes);
}
}

private String coerceCompression(String compression) {
if ("true".equalsIgnoreCase(compression)) {
return "on";
}
if ("false".equalsIgnoreCase(compression)) {
return "off";
}
return compression;
}

});
}

private void customizeAccessLog(TomcatEmbeddedServletContainerFactory factory) {
AccessLogValve valve = new AccessLogValve();
String accessLogPattern = getAccessLogPattern();
valve.setPattern(accessLogPattern == null ? "common" : accessLogPattern);
valve.setSuffix(".log");
factory.addContextValves(valve);
}

}

public static class Undertow {

/**
* Size of each buffer in bytes.
*/
private Integer bufferSize;

/**
* Number of buffer per region.
*/
private Integer buffersPerRegion;

/**
* Number of I/O threads to create for the worker.
*/
private Integer ioThreads;

/**
* Number of worker threads.
*/
private Integer workerThreads;

/**
* Allocate buffers outside the Java heap.
*/
private Boolean directBuffers;

/**
* Format pattern for access logs.
*/
private String accessLogPattern = "common";

/**
* Enable access log.
*/
private boolean accessLogEnabled = false;

/**
* Undertow access log directory.
*/
private File accessLogDir = new File("logs");

public Integer getBufferSize() {
return this.bufferSize;
}

public void setBufferSize(Integer bufferSize) {
this.bufferSize = bufferSize;
}

public Integer getBuffersPerRegion() {
return this.buffersPerRegion;
}

public void setBuffersPerRegion(Integer buffersPerRegion) {
this.buffersPerRegion = buffersPerRegion;
}

public Integer getIoThreads() {
return this.ioThreads;
}

public void setIoThreads(Integer ioThreads) {
this.ioThreads = ioThreads;
}

public Integer getWorkerThreads() {
return this.workerThreads;
}

public void setWorkerThreads(Integer workerThreads) {
this.workerThreads = workerThreads;
}

public Boolean getDirectBuffers() {
return this.directBuffers;
}

public void setDirectBuffers(Boolean directBuffers) {
this.directBuffers = directBuffers;
}

public String getAccessLogPattern() {
return this.accessLogPattern;
}

public void setAccessLogPattern(String accessLogPattern) {
this.accessLogPattern = accessLogPattern;
}

public boolean isAccessLogEnabled() {
return this.accessLogEnabled;
}

public void setAccessLogEnabled(boolean accessLogEnabled) {
this.accessLogEnabled = accessLogEnabled;
}

public File getAccessLogDir() {
return this.accessLogDir;
}

public void setAccessLogDir(File accessLogDir) {
this.accessLogDir = accessLogDir;
}

void customizeUndertow(UndertowEmbeddedServletContainerFactory factory) {
factory.setBufferSize(this.bufferSize);
factory.setBuffersPerRegion(this.buffersPerRegion);
factory.setIoThreads(this.ioThreads);
factory.setWorkerThreads(this.workerThreads);
factory.setDirectBuffers(this.directBuffers);
factory.setAccessLogDirectory(this.accessLogDir);
factory.setAccessLogPattern(this.accessLogPattern);
factory.setAccessLogEnabled(this.accessLogEnabled);
}

}

}