Java Web 學習與總結（一）Servlet基礎

配置環境：https://www.cnblogs.com/qq965921539/p/9821374.html

簡介：

　　Servlet是Sun公司提供的一種實現動態網頁的解決方案，在制定J2EE時引入它作為實現了基于Java語言的動態技術，目前流行的Web框架基本都基于Servlet技術，只有掌握了Servlet，才能真正掌握Java Web編程的核心和精髓。

　　Servlet是運行在Servlet容器中的Java類，它能處理Web客戶的HTTP請求，并產生HTTP響應。

　　Servlet對請求的處理和響應過程可進一步細分為以下幾個步驟：

　　　　1.接收HTTP請求

　　　　2.取得請求信息，包括請求頭和請求參數數據

　　　　3.調用其它Java類方法，完成具體的業務功能

　　　　4.實現到其他Web組件的跳轉（包括重定向或請求轉發）

　　　　5.生成HTTP響應（包括HTML或非HTML響應）

?

優點：

　　Servlet有以下幾個優點：

　　　　1.高效，在Servlet中，每個請求由一個輕量級的java線程處理；

　　　　2.方便，提供了大量實用工具例程，這個在后面會慢慢敘述；

　　　　3.功能強大，繼承了Java的優點，能夠直接和Web服務器交互，還能夠在各個程序之間共享數據；

　　　　4.可移植性好，Servlet由Java語言編寫，并且其API具有完善的標準，支持Servlet規范的容器都可以運行Servlet程序，如Tomcat和Resin等。

Servlet體系結構：

　　Servlet是使用Servlet API及相關類和方法的Java程序，Servlet API包含兩個軟件包：

　　　　javax.servlet包：包含支持所有協議的通用的Web組件接口和類，如ServletRequest接口，ServletResponse接口

　　　　javax.servlet.http包：包含支持HTTP協議的接口和類，如HttpServletRequest接口，HttpServletResponse接口

　　Servet API的主要接口和類之間的關系為：

　　　　

Servlet接口：

　　所有的Servlet都必須直接或間接地實現javax.servlet.Servlet接口。Servlet接口規定了必須由Servlet類實現并且由Servlet引擎識別和管理的方法集。Servlet接口的基本目標是提供與Servlet生命周期相關的方法，如init(),service()和destory()等，下述示例為Servlet接口的源代碼：

package javax.servlet;

import java.io.IOException;

public interface Servlet {
    void init(ServletConfig var1) throws ServletException;

    ServletConfig getServletConfig();

    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    String getServletInfo();

    void destroy();
}

　　1.init()，初始化servlet對象，Servlet實例化后，容器調用該方法進行初始化工作。ServletAPI規定該方法只能被調用一次，如果此方法沒有正常結束就會拋出一個ServletException異常，一旦拋出該異常，Servlet將不再執行。

　　2.service(ServletRequest var1, ServletResponse var2)，接受客戶端請求對象，執行業務操作，利用響應對象響應客戶端請求。

　　3.destroy()，當容器監測到一個servlet從服務中被移除時，容器調用該方法，釋放資源，調用該方法前必須給service()足夠時間來結束執行。

　　4.getServletConfig()，ServletConfig是容器向servlet傳遞參數的載體，此方法可以讓Servlet在任何時候獲得ServletConfig對象。

　　5.getServletInfo()，返回一個String對象獲取servlet相關信息。

GenericServlet類：

　　GenericServlet類是一個抽象類，是Servlet接口的直接實現，除service()方法之外還提供了其他有關Servlet生命周期的方法。這意味著只需通過簡單地擴展GenericServlet和實現servlet方法就可以編寫一個基本的Servlet。

package javax.servlet;

import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final long serialVersionUID = 1L;
    private transient ServletConfig config;

    public GenericServlet() {
    }

    public void destroy() {
    }

    public String getInitParameter(String name) {
        return this.getServletConfig().getInitParameter(name);
    }

    public Enumeration<String> getInitParameterNames() {
        return this.getServletConfig().getInitParameterNames();
    }

    public ServletConfig getServletConfig() {
        return this.config;
    }

    public ServletContext getServletContext() {
        return this.getServletConfig().getServletContext();
    }

    public String getServletInfo() {
        return "";
    }

    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

    public void init() throws ServletException {
    }

    public void log(String msg) {
        this.getServletContext().log(this.getServletName() + ": " + msg);
    }

    public void log(String message, Throwable t) {
        this.getServletContext().log(this.getServletName() + ": " + message, t);
    }

    public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    public String getServletName() {
        return this.config.getServletName();
    }
}

　　init(ServletConfig config：該方法來源于Servlet接口，覆寫該方法，必須調用super.init(config)

　　init()：該方法重載Servlet.init(ServletConfig config)方法而無需調用super.init(config)。而ServletConfig對象依然可以通過調用getServletConfig()方法獲得。

　　destory()方法作用與Servlet接口中的方法相同，略。

　　getInitParameter()：返回一個包含初始化變量的值的字符串，如果變量不存在則返回null，該方法從servlet的ServletConfig變量獲得命名變量的值。

　　getInitParameterNames()：該方法返回一個包含所有初始化變量的枚舉函數。如果沒有初始化變量，則返回一個空枚舉函數。

　　getServletConfig()：返回一個servlet的ServletConfig對象getServletContext()方法與ServletConfig.getServletContext()相同，略。

　　getServletInfo()：該方法來源于Servlet接口，覆寫該方法以產生有意義的信息。（如：版本號、版權、作者等）

　　log(java.lang.String msg)：public void log(java.lang.String msg)該方法把指定的信息寫入一個日志文件，見ServletContext.log(String)。

　　log(java.lang.String message,java.lang.Throwable t)：public void log(java.lang.String message,java.lang.Throwable t)　該方法把解釋性的內容和拋出的例外信息寫入一個日志文件。

　　service()：這是一個抽象的方法，當為執行網絡請求繼承GenericServlet類時必須實現它，該方法必須由servlet容器調用以允許servlet 對請求作出響應。見Servlet.service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)。

　　getServletName()：見ServletConfig.getServletName()。

HttpServlet類：

　　這個是重點啦（拍桌子）！HttpServlet類擴展了GenericServlet類并且對Servlet接口提供了與HTTP相關的實現，是在Web開發中定義Servlet最常使用的類。HttpServlet類中的主要方法的源代碼如下所示：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.servlet.http;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.DispatcherType;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public abstract class HttpServlet extends GenericServlet {
    private static final long serialVersionUID = 1L;
    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
    private static final ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");

    public HttpServlet() {
    }

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) {
            this.doGet(req, resp);
        } else {
            NoBodyResponse response = new NoBodyResponse(resp);
            this.doGet(req, response);
            response.setContentLength();
        }

    }

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_put_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_delete_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    private static Method[] getAllDeclaredMethods(Class<?> c) {
        if (c.equals(HttpServlet.class)) {
            return null;
        } else {
            Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
            Method[] thisMethods = c.getDeclaredMethods();
            if (parentMethods != null && parentMethods.length > 0) {
                Method[] allMethods = new Method[parentMethods.length + thisMethods.length];
                System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);
                System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);
                thisMethods = allMethods;
            }

            return thisMethods;
        }
    }

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Method[] methods = getAllDeclaredMethods(this.getClass());
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
        Class clazz = null;

        try {
            clazz = Class.forName("org.apache.catalina.connector.RequestFacade");
            Method getAllowTrace = clazz.getMethod("getAllowTrace", (Class[])null);
            ALLOW_TRACE = (Boolean)getAllowTrace.invoke(req, (Object[])null);
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | ClassNotFoundException var14) {
            ;
        }

        for(int i = 0; i < methods.length; ++i) {
            Method m = methods[i];
            if (m.getName().equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            }

            if (m.getName().equals("doPost")) {
                ALLOW_POST = true;
            }

            if (m.getName().equals("doPut")) {
                ALLOW_PUT = true;
            }

            if (m.getName().equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }

        String allow = null;
        if (ALLOW_GET) {
            allow = "GET";
        }

        if (ALLOW_HEAD) {
            if (allow == null) {
                allow = "HEAD";
            } else {
                allow = allow + ", HEAD";
            }
        }

        if (ALLOW_POST) {
            if (allow == null) {
                allow = "POST";
            } else {
                allow = allow + ", POST";
            }
        }

        if (ALLOW_PUT) {
            if (allow == null) {
                allow = "PUT";
            } else {
                allow = allow + ", PUT";
            }
        }

        if (ALLOW_DELETE) {
            if (allow == null) {
                allow = "DELETE";
            } else {
                allow = allow + ", DELETE";
            }
        }

        if (ALLOW_TRACE) {
            if (allow == null) {
                allow = "TRACE";
            } else {
                allow = allow + ", TRACE";
            }
        }

        if (ALLOW_OPTIONS) {
            if (allow == null) {
                allow = "OPTIONS";
            } else {
                allow = allow + ", OPTIONS";
            }
        }

        resp.setHeader("Allow", allow);
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String CRLF = "\r\n";
        StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
        Enumeration reqHeaderEnum = req.getHeaderNames();

        while(reqHeaderEnum.hasMoreElements()) {
            String headerName = (String)reqHeaderEnum.nextElement();
            buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
        }

        buffer.append(CRLF);
        int responseLength = buffer.length();
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(buffer.toString());
        out.close();
    }

    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch (IllegalArgumentException var9) {
                    ifModifiedSince = -1L;
                }

                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }

    }

    private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
        if (!resp.containsHeader("Last-Modified")) {
            if (lastModified >= 0L) {
                resp.setDateHeader("Last-Modified", lastModified);
            }

        }
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request;
        HttpServletResponse response;
        try {
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) {
            throw new ServletException("non-HTTP request or response");
        }

        this.service(request, response);
    }
}

HttpServlet雖然看起來很長，但由于前兩個類的結構已趨于完善，主要方法也不多：

service(ServletRequest req, ServletResponse res)：HttpServlet在實現Servlet接口時，重寫了service()方法，該方法會自動判斷用戶的請求方式：若為GET請求，則調用doGet（）方法，若為POST請求，則調用doPost方法。如果Servlet收到一個HTTP請求而沒有重載相應的do方法，它就返回一個說明此方法對本資源不可用的標準HTTP錯誤

doGet(ServletRequest req, ServletResponse res):被本類的service方法調用，用來處理一個HTTP GET請求

doPost(ServletRequest req, ServletResponse res):被本類的service方法調用，用來處理一個HTTP POST請求

HttpServlet作為HTTP請求的分發器，除了提供對GET和POST請求的處理方法doGet()和doPost()之外，對于其他請求類型如HEAD,OPTIONS,DELETE,PUT,TRACE也提供了相應的處理方法，如doHead(),doOptions等等

HttpServlet指能夠處理HTTP請求的Servlet，開發人員在編寫Servlet時，通常應繼承這個類，而避免去直接實現Servlet接口

?

下面是一個正常能夠處理請求的Servlet基本結構，我們在后面也主要使用這種結構：

package com.Servlet;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "SimpleServlet")
public class SimpleServlet extends HttpServlet {
    public SimpleServlet(){
        super();
    }
    
    public void init(ServletConfig servletConfig) throws ServletException{
        //初始化方法
    }
    
    public void destroy() {
        //銷毀方法
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //處理POST請求時調用的方法
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //處理GET請求時調用的方法
    }
}

Servlet生命周期:

Servlet生命周期有七種狀態：創捷，初始化，服務可用，服務不可用，處理請求，終止服務，銷毀

根據七種狀態可以又分為四個階段：

1.加載和實例化：在服務器運行中，客戶機首次向Servlet發出請求時或者再重新裝入Servlet時（如服務器重新啟動，Servlet被修改）或配置了自動裝入選項時（load-on-startup）,服務器在啟動時會自動裝入此Servlet

2.初始化：調用上面方法中的init(ServletConfig config）來對Servlet實例進行初始化，成功時進入服務可用狀態，失敗時Servlet容器會從運行環境中清除掉該實例，運行出現異常時進入服務不可用狀態，維護人員也可以設置不可用狀態或從不可用變成可用

3.處理請求：服務器收到客戶端請求時會為該請求創建一個“請求”對象和一個相應對象并調用service()方法，service()方法可能被多次調用，多個客戶端訪問某個Servlet的service方法時，服務器會為每個請求創建一個線程來減少等待時間

4.銷毀：當Servlet容器需要終止Servlet時，它會先調用destroy()方法來釋放資源，調用該方法前必須讓所有service()的線程完成實行，該方法完成后，Servlet容器必須釋放該實例以便被垃圾回收

時序圖：

?