一、Servlet概述

一个类型的Servlet只有一个实例对象，就会现时出一个Servlet同时处理多个请求。多个线程公用一个Servlet对象，所以Servlet是线程不安全的。但Servlet的工作效率很高
所以不应该在Servlet中创建成员变量，因为可能会存在一个线程对这个成员变量进行写操作，另一个线程对这个成员变量进行读操作。
特性：
单例（第一次访问时，被服务器创建），一个类只有一个对象；当然可能存在多个Servlet类，线程不安全的，效率是高的！
Servlet实现类由用户实现，但对象由服务器来创建，并且由服务器来调用相应的方法。

Servlet介绍

Servlet是JavaWeb的三大组件之一，它属于动态资源。Servlet的作用是处理请求，服务器会把接收到的请求交给Servlet来处理，在Servlet中通常需要：
接收请求数据；处理请求；完成响应。
例如客户端发出登录请求，这些请求都由Servlet来完成处理。Servlet需要用户自己来编写，每个Servlet必须实现javax.servlet.Servlet接口。

Servlet实现方式

实现Servlet有三种方式：

  1. 实现javax.servlet.Servlet接口；
  2. 继承javax.servlet.GenericServlet类；
  3. 继承javax.servlet.http.HttpServlet类；

通常我们继承HttpServlet类来实现Servlet

  1. package javax.servlet;
  3. import java.io.IOException;
  5. public interface Servlet {
  7.     public void init(ServletConfig config) throws ServletException;
  9.     public ServletConfig getServletConfig();
  11.     public void service(ServletRequest req, ServletResponse res)
  12.     throws ServletException, IOException;
  14.     public String getServletInfo();
  16.     public void destroy();
  17. }

1.实现Servlet接口

  1. public class DemoServlet implements Servlet {
  2.     public void init(ServletConfig config) throws ServletException {}
  3.     public ServletConfig getServletConfig() {return null;}
  4.     public void destroy() {}
  5.     public String getServletInfo() {return null;}
  7.     //用来处理请求的方法
  8.     public void service(ServletRequest req, ServletResponse res)
  9.             throws ServletException, IOException {
  10.         System.out.println("hello servlet!");
  11.     }
  12. }

配置web.xml
将访问路径与Servlet绑定到一起。即将访问路径：/demoworld与com.masterlu.servlet.DemoServlet绑定

  1.     <servlet>
  2.         <servlet-name>helloServlet</servlet-name>
  3.         <servlet-class>com.masterlu.servlet.DemoServlet</servlet-class>
  4.     </servlet>
  5.     <servlet-mapping>
  6.         <servlet-name>demo</servlet-name>
  7.     <!-- 指定Servlet的访问路径（必须以/开头），
  8.     可以配置多个，多个路径指向同一个Servlet。
  9.     也可以使用通配符配置路径（通配符不能出现在中间，只能作为前缀或后缀）。
  10.     -->
  11.         <url-pattern>/demoworld</url-pattern>
  12.     <url-pattern>/demoworld2</url-pattern>
  13.     <url-pattern>/servlet/*<url-patter>
  14.     <url-pattern>*.do</url-pattern>
  15.     </servlet-mapping>

2.继承GenericServlet

GenericServlet是Servlet接口的实现类，也可以通过继承GenericServlet来编写自己的Servlet。

  1. package javax.servlet;
  3. import java.io.IOException;
  4. import java.util.Enumeration;
  5. import java.util.ResourceBundle;
  7. public abstract class GenericServlet 
  8.     implements Servlet, ServletConfig, java.io.Serializable
  9. {
  10.     private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
  11.     private static ResourceBundle lStrings =
  12.         ResourceBundle.getBundle(LSTRING_FILE);
  14.     private transient ServletConfig config;
  16.     public GenericServlet() { }
  18.     @Override
  19.     public void destroy() {
  20.     }
  22.     @Override
  23.     public String getInitParameter(String name) {
  24.         ServletConfig sc = getServletConfig();
  25.         if (sc == null) {
  26.             throw new IllegalStateException(
  27.                 lStrings.getString("err.servlet_config_not_initialized"));
  28.         }
  30.         return sc.getInitParameter(name);
  31.     }
  33.     @Override
  34.     public Enumeration<String> getInitParameterNames() {
  35.         ServletConfig sc = getServletConfig();
  36.         if (sc == null) {
  37.             throw new IllegalStateException(
  38.                 lStrings.getString("err.servlet_config_not_initialized"));
  39.         }
  41.         return sc.getInitParameterNames();
  42.     }   
  44.     @Override
  45.     public ServletConfig getServletConfig() {
  46.     return config;
  47.     }
  49.     @Override
  50.     public ServletContext getServletContext() {
  51.         ServletConfig sc = getServletConfig();
  52.         if (sc == null) {
  53.             throw new IllegalStateException(
  54.                 lStrings.getString("err.servlet_config_not_initialized"));
  55.         }
  57.         return sc.getServletContext();
  58.     }
  60.     @Override
  61.     public String getServletInfo() {
  62.     return "";
  63.     }
  65.     @Override
  66.     public void init(ServletConfig config) throws ServletException {
  67.     this.config = config;
  68.     this.init();
  69.     }
  71.     public void init() throws ServletException {
  73.     }
  76.     public void log(String msg) {
  77.     getServletContext().log(getServletName() + ": "+ msg);
  78.     }
  81.     public void log(String message, Throwable t) {
  82.     getServletContext().log(getServletName() + ": " + message, t);
  83.     }
  85.     @Override
  86.     public abstract void service(ServletRequest req, ServletResponse res)
  87.     throws ServletException, IOException;
  89.     @Override
  90.     public String getServletName() {
  91.         ServletConfig sc = getServletConfig();
  92.         if (sc == null) {
  93.             throw new IllegalStateException(
  94.                 lStrings.getString("err.servlet_config_not_initialized"));
  95.         }
  97.         return sc.getServletName();
  98.     }
  99. }

GenericServlet的init()方法

在GenericServlet中，定义ServletConfig config实例变量，并在init(ServletConfig)方法中把参数ServletConfig赋给了实例变量。然后该类的很多方法使用实例变量config。则子类需要完成一些初始化操作，只能覆盖GenericServlet提供的init()方法。它是没有参数的init()方法，它会在init(ServletConfig)方法中被调用。
如果子类覆盖GenericServlet的init(StringConfig)方法，那么this.config=config这一条语句就会被覆盖了，则config的值为null，那么所有依赖config的方法都不能使用。

实现了ServletConfig接口

GenericServlet还实现了ServletConfig接口，所以可以直接调用getInitParameter()、getServletContext()等ServletConfig的方法。

3.继承HttpServlet（常用方式）

HttpServlet类是GenericServlet的子类，提供了对HTTP请求的特殊支持，通常都会通过继承HttpServlet来完成自定义的Servlet。（SpringMVC的Servlet也是继承HttpServlet）

  1. package javax.servlet.http;
  3. import javax.servlet.*;
  5. public abstract class HttpServlet extends GenericServlet
  6. {
  7.     private static final String METHOD_DELETE = "DELETE";
  8.     private static final String METHOD_HEAD = "HEAD";
  9.     private static final String METHOD_GET = "GET";
  10.     private static final String METHOD_OPTIONS = "OPTIONS";
  11.     private static final String METHOD_POST = "POST";
  12.     private static final String METHOD_PUT = "PUT";
  13.     private static final String METHOD_TRACE = "TRACE";
  15.     private static final String HEADER_IFMODSINCE = "If-Modified-Since";
  16.     private static final String HEADER_LASTMOD = "Last-Modified";
  18.     private static final String LSTRING_FILE =
  19.         "javax.servlet.http.LocalStrings";
  20.     private static ResourceBundle lStrings =
  21.         ResourceBundle.getBundle(LSTRING_FILE);
  23.     public HttpServlet() { }
  25.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  26.         throws ServletException, IOException
  27.     {
  28.         String protocol = req.getProtocol();
  29.         String msg = lStrings.getString("http.method_get_not_supported");
  30.         if (protocol.endsWith("1.1")) {
  31.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
  32.         } else {
  33.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
  34.         }
  35.     }
  37.     protected long getLastModified(HttpServletRequest req) {
  38.         return -1;
  39.     }
  41.     protected void doHead(HttpServletRequest req, HttpServletResponse resp)
  42.         throws ServletException, IOException
  43.     {
  44.         NoBodyResponse response = new NoBodyResponse(resp);
  46.         doGet(req, response);
  47.         response.setContentLength();
  48.     }
  50.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
  51.         throws ServletException, IOException
  52.     {
  53.         String protocol = req.getProtocol();
  54.         String msg = lStrings.getString("http.method_post_not_supported");
  55.         if (protocol.endsWith("1.1")) {
  56.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
  57.         } else {
  58.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
  59.         }
  60.     }
  62.     protected void doPut(HttpServletRequest req, HttpServletResponse resp)
  63.         throws ServletException, IOException
  64.     {
  65.         String protocol = req.getProtocol();
  66.         String msg = lStrings.getString("http.method_put_not_supported");
  67.         if (protocol.endsWith("1.1")) {
  68.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
  69.         } else {
  70.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
  71.         }
  72.     }
  74.     protected void doDelete(HttpServletRequest req,
  75.                             HttpServletResponse resp)
  76.         throws ServletException, IOException
  77.     {
  78.         String protocol = req.getProtocol();
  79.         String msg = lStrings.getString("http.method_delete_not_supported");
  80.         if (protocol.endsWith("1.1")) {
  81.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
  82.         } else {
  83.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
  84.         }
  85.     }
  88.     private Method[] getAllDeclaredMethods(Class<? extends HttpServlet> c) {
  90.         Class<?> clazz = c;
  91.         Method[] allMethods = null;
  93.         while (!clazz.equals(HttpServlet.class)) {
  94.             Method[] thisMethods = clazz.getDeclaredMethods();
  95.             if (allMethods != null && allMethods.length > 0) {
  96.                 Method[] subClassMethods = allMethods;
  97.                 allMethods =
  98.                     new Method[thisMethods.length + subClassMethods.length];
  99.                 System.arraycopy(thisMethods, 0, allMethods, 0,
  100.                                  thisMethods.length);
  101.                 System.arraycopy(subClassMethods, 0, allMethods, thisMethods.length,
  102.                                  subClassMethods.length);
  103.             } else {
  104.                 allMethods = thisMethods;
  105.             }
  107.             clazz = clazz.getSuperclass();
  108.         }
  110.         return ((allMethods != null) ? allMethods : new Method[0]);
  111.     }
  113.     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
  114.         throws ServletException, IOException
  115.     {
  116.         Method[] methods = getAllDeclaredMethods(this.getClass());
  118.         boolean ALLOW_GET = false;
  119.         boolean ALLOW_HEAD = false;
  120.         boolean ALLOW_POST = false;
  121.         boolean ALLOW_PUT = false;
  122.         boolean ALLOW_DELETE = false;
  123.         boolean ALLOW_TRACE = true;
  124.         boolean ALLOW_OPTIONS = true;
  126.         for (int i=0; i<methods.length; i++) {
  127.             String methodName = methods[i].getName();
  129.             if (methodName.equals("doGet")) {
  130.                 ALLOW_GET = true;
  131.                 ALLOW_HEAD = true;
  132.             } else if (methodName.equals("doPost")) {
  133.                 ALLOW_POST = true;
  134.             } else if (methodName.equals("doPut")) {
  135.                 ALLOW_PUT = true;
  136.             } else if (methodName.equals("doDelete")) {
  137.                 ALLOW_DELETE = true;
  138.             }
  140.         }
  142.         // we know "allow" is not null as ALLOW_OPTIONS = true
  143.         // when this method is invoked
  144.         StringBuilder allow = new StringBuilder();
  145.         if (ALLOW_GET) {
  146.             allow.append(METHOD_GET);
  147.         }
  148.         if (ALLOW_HEAD) {
  149.             if (allow.length() > 0) {
  150.                 allow.append(", ");
  151.             }
  152.             allow.append(METHOD_HEAD);
  153.         }
  154.         if (ALLOW_POST) {
  155.             if (allow.length() > 0) {
  156.                 allow.append(", ");
  157.             }
  158.             allow.append(METHOD_POST);
  159.         }
  160.         if (ALLOW_PUT) {
  161.             if (allow.length() > 0) {
  162.                 allow.append(", ");
  163.             }
  164.             allow.append(METHOD_PUT);
  165.         }
  166.         if (ALLOW_DELETE) {
  167.             if (allow.length() > 0) {
  168.                 allow.append(", ");
  169.             }
  170.             allow.append(METHOD_DELETE);
  171.         }
  172.         if (ALLOW_TRACE) {
  173.             if (allow.length() > 0) {
  174.                 allow.append(", ");
  175.             }
  176.             allow.append(METHOD_TRACE);
  177.         }
  178.         if (ALLOW_OPTIONS) {
  179.             if (allow.length() > 0) {
  180.                 allow.append(", ");
  181.             }
  182.             allow.append(METHOD_OPTIONS);
  183.         }
  185.         resp.setHeader("Allow", allow.toString());
  186.     }
  188.     protected void doTrace(HttpServletRequest req, HttpServletResponse resp) 
  189.         throws ServletException, IOException
  190.     {
  192.         int responseLength;
  194.         String CRLF = "\r\n";
  195.         StringBuilder buffer = new StringBuilder("TRACE ").append(req.getRequestURI())
  196.             .append(" ").append(req.getProtocol());
  198.         Enumeration<String> reqHeaderEnum = req.getHeaderNames();
  200.         while( reqHeaderEnum.hasMoreElements() ) {
  201.             String headerName = reqHeaderEnum.nextElement();
  202.             buffer.append(CRLF).append(headerName).append(": ")
  203.                 .append(req.getHeader(headerName));
  204.         }
  206.         buffer.append(CRLF);
  208.         responseLength = buffer.length();
  210.         resp.setContentType("message/http");
  211.         resp.setContentLength(responseLength);
  212.         ServletOutputStream out = resp.getOutputStream();
  213.         out.print(buffer.toString());
  214.     }
  217.     protected void service(HttpServletRequest req, HttpServletResponse resp)
  218.         throws ServletException, IOException
  219.     {
  220.         String method = req.getMethod();
  222.         if (method.equals(METHOD_GET)) {
  223.             long lastModified = getLastModified(req);
  224.             if (lastModified == -1) {
  225.                 // servlet doesn't support if-modified-since, no reason
  226.                 // to go through further expensive logic
  227.                 doGet(req, resp);
  228.             } else {
  229.                 long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
  230.                 if (ifModifiedSince < lastModified) {
  231.                     // If the servlet mod time is later, call doGet()
  232.                     // Round down to the nearest second for a proper compare
  233.                     // A ifModifiedSince of -1 will always be less
  234.                     maybeSetLastModified(resp, lastModified);
  235.                     doGet(req, resp);
  236.                 } else {
  237.                     resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  238.                 }
  239.             }
  241.         } else if (method.equals(METHOD_HEAD)) {
  242.             long lastModified = getLastModified(req);
  243.             maybeSetLastModified(resp, lastModified);
  244.             doHead(req, resp);
  246.         } else if (method.equals(METHOD_POST)) {
  247.             doPost(req, resp);
  249.         } else if (method.equals(METHOD_PUT)) {
  250.             doPut(req, resp);
  252.         } else if (method.equals(METHOD_DELETE)) {
  253.             doDelete(req, resp);
  255.         } else if (method.equals(METHOD_OPTIONS)) {
  256.             doOptions(req,resp);
  258.         } else if (method.equals(METHOD_TRACE)) {
  259.             doTrace(req,resp);
  261.         } else {
  262.             //
  263.             // Note that this means NO servlet supports whatever
  264.             // method was requested, anywhere on this server.
  265.             //
  267.             String errMsg = lStrings.getString("http.method_not_implemented");
  268.             Object[] errArgs = new Object[1];
  269.             errArgs[0] = method;
  270.             errMsg = MessageFormat.format(errMsg, errArgs);
  272.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  273.         }
  274.     }
  277.     /**
  278.      * Dispatches client requests to the protected
  279.      * <code>service</code> method. There's no need to
  280.      * override this method.
  281.      * 
  282.      * @param req   the {@link HttpServletRequest} object that
  283.      *                  contains the request the client made of
  284.      *                  the servlet
  285.      *
  286.      * @param res   the {@link HttpServletResponse} object that
  287.      *                  contains the response the servlet returns
  288.      *                  to the client                                
  289.      *
  290.      * @throws IOException   if an input or output error occurs
  291.      *                              while the servlet is handling the
  292.      *                              HTTP request
  293.      *
  294.      * @throws ServletException  if the HTTP request cannot
  295.      *                                  be handled or if either parameter is not
  296.      *                           an instance of its respective {@link HttpServletRequest}
  297.      *                           or {@link HttpServletResponse} counterparts.
  298.      * 
  299.      * @see javax.servlet.Servlet#service
  300.      */
  301.     @Override
  302.     public void service(ServletRequest req, ServletResponse res)
  303.         throws ServletException, IOException
  304.     {
  305.         HttpServletRequest  request;
  306.         HttpServletResponse response;
  308.         if (!(req instanceof HttpServletRequest &&
  309.                 res instanceof HttpServletResponse)) {
  310.             throw new ServletException("non-HTTP request or response");
  311.         }
  313.         request = (HttpServletRequest) req;
  314.         response = (HttpServletResponse) res;
  316.         service(request, response);
  317.     }
  318. }

HttpServlet#service(HttpServletRequest,HttpServletResponse)方法，判断当前请求是GET还是POST，如果是GET请求，那么会去调用本类的doGet()方法，如果是POST请求会去调用doPost()方法。用户在子类中去覆盖doGet()或doPost()方法即可
image.png

二、Servlet生命周期

生命周期相关方法
void init(ServletConfig)；
void service(ServletRequest,ServletResponse)；
void destroy()；

1.Servlet初始化方法

默认情况下，Servlet实例，在Servlet第一次被访问时，由服务器创建（或者在web.xml文件中配置，使得在服务器启动时创建Servlet实例）。
一个Servlet类型，服务器只创建一个实例对象，例如在首次访问http://localhost:8080/appName/demoworld时，服务器通过“/helloworld”找到绑定的Servlet名称为com.masterlu.servlet.DemoServlet，然后服务器查看这个类型的Servlet是否已经创建过，如果没有创建过，那么服务器会通过反射来创建DemoServlet的实例。再次访问http://localhost:8080/helloservlet/helloworld时，服务器就不会再次创建DemoServlet实例了，而是直接使用上次创建的实例。
在Servlet被创建后，服务器会立刻调用Servlet的void init(ServletConfig)方法。init方法只会被调用一次。
利用这个特性，可以把Servlet的初始化工作放到init方法中。

  1. <servlet>
  2.   <servlet-name>helloServlet</servlet-name>
  3.   <servlet-class>com.masterlu.servlet.DemoServlet</servlet-class>
  4.   <!-- 服务器在启动时就创建该Servlet，其中<load-on-startup>元素的值必须是大于等于0的整数，
  5.   数字越小优先级越高-->
  6.   <load-on-startup>0</load-on-startup>
  7. </servlet>

2.Servlet服务方法

用户每次请求服务器时，服务器都会调用Servlet#service()方法来处理请求。因为service()方法可以被多次调用，所以我们才需要把处理请求的代码写到service()方法中。

3.Servlet销毁方法

在服务器被关闭时，服务器会去销毁Servlet，在销毁Servlet之前服务器会先去调用Servlet的destroy()方法，我们可以把Servlet的销毁逻辑放到destroy()方法中，例如对某些资源的释放等代码放到destroy()方法中。

三、Servlet接口用到的对象

ServletConfig
init()方法的参数，表示Servlet配置对象，它对应Servlet的配置信息，即：对应web.xml的元素。
ServletRequest
由服务器创建的请求对象，它封装了所有与请求相关的数据；
ServletResponse
由服务器创建的响应对象，在service()方法中完成对客户端的响应，需要使用这个对象；
ServletRequest和ServletResponse的实例由服务器创建，然后传递给Servlet#service() 。一个是请求对象，一个是响应对象，可以从ServletRequest对象中获取请求数据，可以使用ServletResponse对象完成响应。
如果在service() 方法中使用HTTP相关的功能，可以把ServletRequest和ServletResponse强转成HttpServletRequest和HttpServletResponse。

HttpServletRequest方法

String getParameter(String paramName)
获取指定请求参数的值；
String getMethod()
获取请求方法，例如GET或POST；
String getHeader(String name)
获取指定请求头的值；
void setCharacterEncoding(String encoding)
设置请求体的编码！因为GET请求没有请求体，所以这个方法仅对POST请求有效。当调用request.setCharacterEncoding(“utf-8”)之后，再调用getParameter()方法获取参数值时，则参数值都已经转换成UTF-8编码。所以这个方法必须在调用getParameter()方法之前调用！

HttpServletResponse方法

PrintWriter getWriter()
获取字符响应流，使用该流向客户端输出响应信息。例如response.getWriter().print(“

Hello JavaWeb!

”)；
ServletOutputStream getOutputStream()
获取字节响应流，使用该流向客户端响应字节数据，例如要向客户端响应图片；
void setCharacterEncoding(String encoding)
用来设置字符响应流的编码，例如在调用setCharacterEncoding(“utf-8”);之后，再response.getWriter()获取字符响应流对象，响应流的编码为utf-8，使用response.getWriter()输出的中文都会转换成utf-8编码后发送给客户端；
void setHeader(String name, String value)
向客户端添加响应头信息，例如setHeader(“Refresh”, “3;url=http://www.baidu.com”)，表示3秒后自动刷新到http://www.baidu.com；
void setContentType(String contentType)
是setHeader(“content-type”, “xxx”)的简便方法，即用来添加名为content-type响应头的方法。content-type响应头用来设置响应数据的MIME类型，
例如要向客户端响应jpg的图片，那么可以setContentType(“image/jepg”)，
如果响应数据为文本类型，且同时设置编码，例如setContentType(“text/html;chartset=utf-8”)表示响应数据类型为文本类型中的html类型，并且该方法会调用setCharacterEncoding(“utf-8”)方法；
void sendError(int code, String errorMsg)
向客户端发送状态码，以及错误消息。例如给客户端发送404：response(404, “您要查找的资源不存在！”)。

ServletConfig

对应web.xml文件中的元素。ServletConfig对象是由服务器创建的，然后传递给Servlet的init()方法，你可以在init()方法中使用它！
String getServletName()
获取Servlet在web.xml文件中的配置名称，即指定的名称；servletConfig.getInitParameter(“paramName1”);//获取到paramValue1
ServletContext getServletContext()
用来获取ServletContext对象。
String getInitParameter(String name)
用来获取在web.xml中配置的初始化参数，通过参数名来获取参数值；
Enumeration getInitParameterNames()
用来获取在web.xml中配置的所有初始化参数名称；

  1.     <servlet>
  2.         <servlet-name>helloServlet</servlet-name>
  3.         <servlet-class>com.masterlu.servlet.DemoServlet</servlet-class>
  4.     </servlet>
  5.     <init-param>
  6.           <param-name>paramName1</param-name>
  7.             <param-value>paramValue1</param-value>
  8.     </init-param>
  9.     <init-param>
  10.             <param-name>paramName2</param-name>
  11.             <param-value>paramValue2</param-value>
  12.     </init-param>
  13.   </servlet>

四、web.xml文件继承

每一个javaWeb应用中都需要有web.xml文件，应用中的web.xml都有一个共同的父文件（tomca的conf/web.xml）。
tomca中conf/web.xml相当于写到项目中web.xml中

  1. <?xml version="1.0" encoding="ISO-8859-1"?>
  3. <web-app xmlns="http://java.sun.com/xml/ns/javaee"
  4.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  6.                       http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  7.   version="3.0">
  8.          <!-- 它的优先级最低的Servlet
  9.           1.当访问路径不存在时，会执行该Servlet，
  10.           2.在访问index.html时也是在执行这个Servlet。
  11.           -->
  12.      <servlet>
  13.         <servlet-name>default</servlet-name>
  14.         <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
  15.         <init-param>
  16.             <param-name>debug</param-name>
  17.             <param-value>0</param-value>
  18.         </init-param>
  19.         <init-param>
  20.             <param-name>listings</param-name>
  21.             <param-value>false</param-value>
  22.         </init-param>
  23.         <load-on-startup>1</load-on-startup>
  24.     </servlet>
  26.     <servlet>
  27.         <servlet-name>jsp</servlet-name>
  28.         <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
  29.         <init-param>
  30.             <param-name>fork</param-name>
  31.             <param-value>false</param-value>
  32.         </init-param>
  33.         <init-param>
  34.             <param-name>xpoweredBy</param-name>
  35.             <param-value>false</param-value>
  36.         </init-param>
  37.         <load-on-startup>3</load-on-startup>
  38.     </servlet>
  39. <!-- 匹配所有URL，即用户访问的URL路径没有匹配的页面时，那么执行的就是名为default的Servlet，
  40.   即org.apache.catalina.servlets.DefaultServlet -->
  41.     <servlet-mapping>
  42.         <servlet-name>default</servlet-name>
  43.         <url-pattern>/</url-pattern>
  44.     </servlet-mapping>
  46.   <!-- 任何URL后缀为jsp的访问，都会执行名为jsp的Servlet，
  47.        即org.apache.jasper.servlet.JspServlet 
  48.   -->
  49.     <servlet-mapping>
  50.         <servlet-name>jsp</servlet-name>
  51.         <url-pattern>*.jsp</url-pattern>
  52.         <url-pattern>*.jspx</url-pattern>
  53.     </servlet-mapping>
  54. <!-- session的默认超时时间为30分钟 -->
  55.     <session-config>
  56.         <session-timeout>30</session-timeout>
  57.     </session-config>
  59.     <!-- 省略了大多数tomcat配置的MIME类型的定义,这里只给出两种MIME类型的定义 -->
  60.     <mime-mapping>
  61.         <extension>bmp</extension>
  62.         <mime-type>image/bmp</mime-type>
  63.     </mime-mapping>
  64.     <mime-mapping>
  65.         <extension>htm</extension>
  66.         <mime-type>text/html</mime-type>
  67.     </mime-mapping>
  69.   <!-- 设置默认主页为index.html、index.html、index.jsp -->
  70.     <welcome-file-list>
  71.         <welcome-file>index.html</welcome-file>
  72.         <welcome-file>index.htm</welcome-file>
  73.         <welcome-file>index.jsp</welcome-file>
  74.     </welcome-file-list>
  75. </web-app>

五、ServletContext

一个项目只有一个ServletContext对象，在整个Web应用的动态资源之间实现共享数据。可以在所有Servlet中来获取这个唯一的对象，使用它可以给多个Servlet传递数据！对象在Tomcat启动时就创建，在Tomcat关闭时销毁！

获取ServletContext

ServletConfig#getServletContext()；
GenericServlet#getServletContext();
HttpSession#getServletContext()
ServletContextEvent#getServletContext()

域对象的功能

JavaWeb四大域对象
PageContext、ServletRequest、HttpSession、ServletContext；
所有域对象都有存取数据的功能，因为域对象内部有一个Map，用来存储数据。
ServletContext对象用来操作数据的方法：
void setAttribute(String name, Object value)
存储一个域属性。如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值；
Object getAttribute(String name)
获取ServletContext中的数据
void removeAttribute(String name)
用来移除ServletContext中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；
Enumeration getAttributeNames()
获取所有域属性的名称；

获取应用初始化参数

配置公共的初始化参数，为所有Servlet而用！需要使用ServletContext才能使用

<web-app ...>
  <context-param>
    <param-name>paramName1</param-name>
    <param-value>paramValue1</param-value>      
  </context-param>
  <context-param>
    <param-name>paramName2</param-name>
    <param-value>paramValue2</param-value>      
  </context-param>
</web-app>

        ServletContext context = this.getServletContext();
        String value1 = context.getInitParameter("paramName1");
        String value2 = context.getInitParameter("paramName2");
        System.out.println(value1 + ", " + value2);

        Enumeration names = context.getInitParameterNames();
        while(names.hasMoreElements()) {
            System.out.println(names.nextElement());
        }