DRP(二)——Servlet解析

servlet家族：

ServletRequest和ServletResponse

      Servelt由Servlet容器来管理，当客户请求到来时，容器创建一个ServletRequest对象，封装请求数据，同时创建一个ServletResponse对象，封装相应数据。这两个对象将被容器作为service()方法的参数传递给Servlet,Servlet利用ServletRequest对象获取客户端发来的请求数据，利用ServletResponse对象发送相应数据。

HttpServletRequest和HttpServletResponse

常用方法：

httpServletRequest:

方    法	说    明
getAttributeNames()	返回当前请求的所有属性的名字集合
getAttribute(String name)	返回name指定的属性值
getCookies()	返回客户端发送的Cookie
getsession()	返回和客户端相关的session，如果没有给客户端分配session，则返回null
getsession(boolean create)	返回和客户端相关的session，如果没有给客户端分配session，则创建一个session并返回
getParameter(String name)	获取请求中的参数，该参数是由name指定的
getParameterValues(String name)	返回请求中的参数值，该参数值是由name指定的
getCharacterEncoding()	返回请求的字符编码方式
getContentLength()	返回请求体的有效长度
getInputStream()	获取请求的输入流中的数据
getMethod()	获取发送请求的方式，如get、post
getParameterNames()	获取请求中所有参数的名字
getProtocol()	获取请求所使用的协议名称
getReader()	获取请求体的数据流
getRemoteAddr()	获取客户端的IP地址
getRemoteHost()	获取客户端的名字
getServerName()	返回接受请求的服务器的名字
getServerPath()	获取请求的文件的路径

HttpServletResponse:

方    法	说    明
addCookie(Cookie cookie)	将指定的Cookie加入到当前的响应中
addHeader(String name,String value)	将指定的名字和值加入到响应的头信息中
containsHeader(String name)	返回一个布尔值，判断响应的头部是否被设置
encodeURL(String url)	编码指定的URL
sendError(int sc)	使用指定状态码发送一个错误到客户端
sendRedirect(String location)	发送一个临时的响应到客户端
setDateHeader(String name,long date)	将给出的名字和日期设置响应的头部
setHeader(String name,String value)	将给出的名字和值设置响应的头部
setStatus(int sc)	给当前响应设置状态码
setContentType(String ContentType)	设置响应的MIME类型

GenericServlet

      为了简化Servlet的编写，在javax.servlet包中提供了一个抽象的类GenericServlet，它给出了除service方法外的其他4个方法的简单实现。GenericServlet类定义了一个通用的、不依赖于具体协议的Servlet，它实现了Servlet接口和ServletConfig接口。

HttpServlet

       为了快速开发应用于HTTP协议的Servlet类，Sun公司在javax.servlet.http包中给我们提供了一个抽象的类HttpServlet，它继承自GenericService类，用于创建适合web站点的HTTPServlet。

        针对HTTP1.1中定义的7中请求方法GET、POST、HEAD、PUT、DELETE、TRACE和OPTIONS,HttpServlet分别提供了7个处理方法：

     这7个方法的参数类型及异常抛出类型与HttpServlet类中国的第二个重载service（）方法是一致的。当容器接收到一个针对HttpServlet对象的请求时，调用该对象的方法顺序如下：

      （1）调用公共的service（）方法

      （2）在service（）方法中，首先将参数类型转换为HttpServletRequest和HttpServletResponse，然后调用保护的service（）方法，将转换后的HttpServletRequest对象和HttpServletResponse对象作为参数传递进去

      （3）在保护的service（）方法中，首先调用HttpServletRequest对象的getMethod（）方法，获取HTTP请求的方法的名字，然后根据请求方法的类型，调用相应的doXxx()方法。

       

       因此，我们在编写HttpServlet的派生类时，通常不需要去覆盖service（）方法，而只需要重写相应的doXXX（）的方法。

servlet生命周期

说明：

（1）加载和实例化

（2）初始化

（3）请求处理

（4）服务终止

总结

      看了很久关于Servlet的书，感觉效率低，该加快速度了。

附录

HttpServlet类源代码：

package javax.servlet.http;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;

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
    implements java.io.Serializable {

    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 ResourceBundle lStrings =
        ResourceBundle.getBundle(LSTRING_FILE);
   
    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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        NoBodyResponse response = new NoBodyResponse(resp);

        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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, 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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, 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(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
    

    private static Method[] getAllDeclaredMethods(Class c) {

        if (c.equals(javax.servlet.http.HttpServlet.class)) {
            return null;
        }

        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;
        
        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)
            if (allow==null) allow=METHOD_GET;
        if (ALLOW_HEAD)
            if (allow==null) allow=METHOD_HEAD;
            else allow += ", " + METHOD_HEAD;
        if (ALLOW_POST)
            if (allow==null) allow=METHOD_POST;
            else allow += ", " + METHOD_POST;
        if (ALLOW_PUT)
            if (allow==null) allow=METHOD_PUT;
            else allow += ", " + METHOD_PUT;
        if (ALLOW_DELETE)
            if (allow==null) allow=METHOD_DELETE;
            else allow += ", " + METHOD_DELETE;
        if (ALLOW_TRACE)
            if (allow==null) allow=METHOD_TRACE;
            else allow += ", " + METHOD_TRACE;
        if (ALLOW_OPTIONS)
            if (allow==null) allow=METHOD_OPTIONS;
            else allow += ", " + METHOD_OPTIONS;
        
        resp.setHeader("Allow", allow);
    }
    
    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException
    {
        
        int responseLength;
        
        String CRLF = "\r\n";
        String responseString = "TRACE "+ req.getRequestURI()+
            " " + req.getProtocol();
        
        Enumeration reqHeaderEnum = req.getHeaderNames();
        
        while( reqHeaderEnum.hasMoreElements() ) {
            String headerName = (String)reqHeaderEnum.nextElement();
            responseString += CRLF + headerName + ": " +
                req.getHeader(headerName); 
        }
        
        responseString += CRLF;
        
        responseLength = responseString.length();
        
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(responseString);        
        out.close();
        return;
    }                

    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);        
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
            
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

    private void maybeSetLastModified(HttpServletResponse resp,
                                      long lastModified) {
        if (resp.containsHeader(HEADER_LASTMOD))
            return;
        if (lastModified >= 0)
            resp.setDateHeader(HEADER_LASTMOD, lastModified);
    }
   
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;
        
        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException("non-HTTP request or response");
        }
        service(request, response);
    }
}


class NoBodyResponse extends HttpServletResponseWrapper {
    private NoBodyOutputStream                noBody;
    private PrintWriter                        writer;
    private boolean                        didSetContentLength;

    // file private
    NoBodyResponse(HttpServletResponse r) {
        super(r);
        noBody = new NoBodyOutputStream();
    }

    // file private
    void setContentLength() {
        if (!didSetContentLength)
          super.setContentLength(noBody.getContentLength());
    }


    // SERVLET RESPONSE interface methods

    public void setContentLength(int len) {
        super.setContentLength(len);
        didSetContentLength = true;
    }

    public ServletOutputStream getOutputStream() throws IOException {
        return noBody;
    }

    public PrintWriter getWriter() throws UnsupportedEncodingException {

        if (writer == null) {
            OutputStreamWriter w;

            w = new OutputStreamWriter(noBody, getCharacterEncoding());
            writer = new PrintWriter(w);
        }
        return writer;
    }
}


class NoBodyOutputStream extends ServletOutputStream {

    private static final String LSTRING_FILE =
        "javax.servlet.http.LocalStrings";
    private static ResourceBundle lStrings =
        ResourceBundle.getBundle(LSTRING_FILE);

    private int                contentLength = 0;

    // file private
    NoBodyOutputStream() {}

    // file private
    int getContentLength() {
        return contentLength;
    }

    public void write(int b) {
        contentLength++;
    }

    public void write(byte buf[], int offset, int len)
        throws IOException
    {
        if (len >= 0) {
            contentLength += len;
        } else {
            // XXX
            // isn't this really an IllegalArgumentException?
            
            String msg = lStrings.getString("err.io.negativelength");
            throw new IOException(msg);
        }
    }
}