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
# 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 contextParameters = new HashMap();

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

   }

}