zoukankan      html  css  js  c++  java
  • Servlet 使用介绍(1)

    说明

    本篇介绍java web中比较重要的一个技术:servlet。servlet是一种对用户请求动态响应的一个技术,是java web的核心一环。对于一般服务性质的纯后台服务应用而言,或许整个应用是由若干个servlet组成
    ,而其他方面表现较弱。

    servlet

    一般的我们的应用都会发布到一个服务应用中,即一个servlet容器中,常见的servlet容器有:Tomcat,JBoss,WebLogic等。我们通过servlet容器处理用户请求,当用户向我们的某个servlet发起请求时,servlet容器会调用并转发请求结果到该servlet,同时会将servlet返回结果回馈给请求方(用户)。其实,servlet本质就是一个接口,我们可以通过注册servlet服务,实现servlet接口,用于监听各种状态先的信息交互。如下,仅仅介绍tomcat中的servlet的相关使用(主要是其他也没用过)。

    Tomcat中为servlet的使用提供了一个调用的jar包:sevlet-api.jar ,该jar包位于Tomcat根目录的lib目录下(所有和Tomcat相关的Jar包均放在这里),如下为servlet-api.jar中的包信息:

    servlet-api.jar
    --javax.servlet           //核心
    --javax.servlet.annotation
    --javax.servlet.descriptor
    --javax.servlet.http     //基于http的实现

    可以看到,这里主要石油javax.servlet和javax.servlet.http两个包组成实现。其中javax.servlet.Servlet接口为api的核心,servlet容器通过调用其定义方法,实现网络中客户端和服务端之前通信的中转传递,Servlet提供了五个方法,其中三个方法是由servlet容器调用。如下,servlet的源码:

    
    
    package javax.servlet;
    
    import java.io.IOException;
    
    public interface Servlet {
        /**
         *由sevler容器调用,servlet对象初始化后,servlet容器调用此方法
         *
         */
        public void init(ServletConfig config) throws ServletException;
    
        /**
         *提供的一个获取ServletConfig对象的方法,该方法由我们自己实现,返回的对象即是init
         *的方法传入的参数。
         *
         */
        public ServletConfig getServletConfig();
    
        /**
         *该方法需要在init方法成功调用后才可正常调用(即客户端请求的时候必须姚该servlet以及
         *初始化成功)
         *
         */
        public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException;
    
    
    
        /**
         *返回当前servlet的创建信息包括创建者等(为一个String字串)
         *
         */
        public String getServletInfo();
    
        /**
         *由servlet容器调用,当一个servlet容器被销毁时调用,可以用于清理销毁servlet中的占
         *用的一些资源。
         *
         */
        public void destroy();
    }
    

    Servlet接口为最基础的Servlet组件,可供我们最大限度的对servlet进行定制.servlet-api.jar中也为我们提供了它的两个替代实现:一个是javax.servlet.GenericServlet是其实现类,完成它的最基础的一些逻辑实现,但保留其对于网络通信的处理,交由我们自行处理;另一个是javax.servlet.http.HttpServlet,该类是GenericServlet的子类,是对GenericServlet的一种扩展,其对于Servlet的servive方法进行了处理,主要用于Http请求。如下,给出这两个类的实现源码:

    1. GenericServlet

    该抽象类并未对servive方法作处理。

    public abstract class GenericServlet implements Servlet, ServletConfig,  
                          java.io.Serializable{
    
        private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
        private static ResourceBundle lStrings =
            ResourceBundle.getBundle(LSTRING_FILE);
    
        private transient ServletConfig config;
    
    
    
        public GenericServlet() { }
    
    
        /**
         *销毁方法
         */
        public void destroy() {
        }
    
    
        /**
         *获取servlet初始化传入参数
         *
         */
        public String getInitParameter(String name) {
            ServletConfig sc = getServletConfig();
            if (sc == null) {
                throw new IllegalStateException(
                    lStrings.getString("err.servlet_config_not_initialized"));
            }
    
            return sc.getInitParameter(name);
        }
    
    
       /**
        *servlet参数参数名获取
        */
        public Enumeration<String> getInitParameterNames() {
            ServletConfig sc = getServletConfig();
            if (sc == null) {
                throw new IllegalStateException(
                    lStrings.getString("err.servlet_config_not_initialized"));
            }
    
            return sc.getInitParameterNames();
        }   
    
    
        /**
         *实现Servlet方法返回初始化获取的ServletConfig对象
         */    
        public ServletConfig getServletConfig() {
                   return config;
        }
    
    
        /**
         *获取ServletContext对象(Servlet上下文),是在ServletConfig中获取
         */
        public ServletContext getServletContext() {
            ServletConfig sc = getServletConfig();
            if (sc == null) {
                throw new IllegalStateException(
                    lStrings.getString("err.servlet_config_not_initialized"));
            }
    
            return sc.getServletContext();
        }
    
    
    
        public String getServletInfo() {
                return "";
        }
    
    
        /**
         *实现Servlet初始化方法,并回调init()无参方法,可供实现者监听状态.
         *
         *
         */
        public void init(ServletConfig config) throws ServletException {
              this.config = config;
               this.init();
        }
    
    
        /**
         * 子类可通过重写监听Servlet对象初始化状态.
         */
        public void init() throws ServletException {
    
        }
    
    
        public void log(String msg) {
               getServletContext().log(getServletName() + ": "+ msg);
        }
    
    
    
        public void log(String message, Throwable t) {
             getServletContext().log(getServletName() + ": " + message, t);
        }
    
    
        public abstract void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException;
    
        public String getServletName() {
            ServletConfig sc = getServletConfig();
            if (sc == null) {
                throw new IllegalStateException(
                    lStrings.getString("err.servlet_config_not_initialized"));
            }
    
            return sc.getServletName();
        }
    }
    
    1. HttpServlet

    是GenericServlet的子类,对service添加了Http的处理,一般适用于Http通信的Servlet,是较为常用的一种Servlet.

    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.Locale;
    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{
        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() { }
    
    
        /**
         *Http协议Get方式请求回调
         *
         */
        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 long getLastModified(HttpServletRequest req) {
            return -1;
        }
    
    
        /**
         *Http协议HHEAD(只请求页面的头部)方式请求回调
         */
        protected void doHead(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException
        {
            NoBodyResponse response = new NoBodyResponse(resp);
    
            doGet(req, response);
            response.setContentLength();
        }
    
    
        /**
         *Http协议POST方式请求回调
         */
        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);
            }
        }
    
    
        /**
         *Http协议Put方式请求回调
         */
        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);
            }
        }
    
    
        /**
         *Http协议Delete方式请求回调
         */
        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 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)
                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);
        }
    
    
        /**
         *处理TRACE请求
         */
        protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException
        {
    
            int responseLength;
    
            String CRLF = "
    ";
            StringBuilder buffer = new StringBuilder("TRACE ").append(req.getRequestURI())
                .append(" ").append(req.getProtocol());
    
            Enumeration<String> reqHeaderEnum = req.getHeaderNames();
    
            while( reqHeaderEnum.hasMoreElements() ) {
                String headerName = reqHeaderEnum.nextElement();
                buffer.append(CRLF).append(headerName).append(": ")
                    .append(req.getHeader(headerName));
            }
    
            buffer.append(CRLF);
    
            responseLength = buffer.length();
    
            resp.setContentType("message/http");
            resp.setContentLength(responseLength);
            ServletOutputStream out = resp.getOutputStream();
            out.print(buffer.toString());
        }
    
    
        /**
         *http协议处理
         */
        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) {
                        // 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);
        }
    
    
        /**
         *重写父类方法,转化为http协议处理,调用自有http处理
         */
        public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException
        {
            HttpServletRequest  request;
            HttpServletResponse response;
    
            if (!(req instanceof HttpServletRequest &&
                    res instanceof HttpServletResponse)) {
                throw new ServletException("non-HTTP request or response");
            }
    
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
    
            service(request, response);
        }
    }
    
    
    // file private
    class NoBodyResponse extends HttpServletResponseWrapper {
    
        private static final ResourceBundle lStrings
            = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
    
        private NoBodyOutputStream noBody;
        private PrintWriter writer;
        private boolean didSetContentLength;
        private boolean usingOutputStream;
    
        // file private
        NoBodyResponse(HttpServletResponse r) {
            super(r);
            noBody = new NoBodyOutputStream();
        }
    
        // file private
        void setContentLength() {
            if (!didSetContentLength) {
                if (writer != null) {
                    writer.flush();
                }
                setContentLength(noBody.getContentLength());
            }
        }
    
        public void setContentLength(int len) {
            super.setContentLength(len);
            didSetContentLength = true;
        }
    
        public ServletOutputStream getOutputStream() throws IOException {
    
            if (writer != null) {
                throw new IllegalStateException(
                    lStrings.getString("err.ise.getOutputStream"));
            }
            usingOutputStream = true;
    
            return noBody;
        }
    
        public PrintWriter getWriter() throws UnsupportedEncodingException {
    
            if (usingOutputStream) {
                throw new IllegalStateException(
                    lStrings.getString("err.ise.getWriter"));
            }
    
            if (writer == null) {
                OutputStreamWriter w = new OutputStreamWriter(
                    noBody, getCharacterEncoding());
                writer = new PrintWriter(w);
            }
    
            return writer;
        }
    }
    
    
    /*
     * Servlet output stream that gobbles up all its data.
     */
    // file private
    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 {
                // This should have thrown an IllegalArgumentException, but
                // changing this would break backwards compatibility
                throw new IOException(lStrings.getString("err.io.negativelength"));
            }
        }
    }
    
    

    如上,Servlet对于用户的请求获取和返回主要是通过方法:

    public void service(ServletRequest req, ServletResponse res)
    throws ServletException, IOException;

    实现的。这里,servlet容器在调用时传入两个参数:一个ServletRequest对象,用于接收用户请求信息;一个ServletResponse对象,用于返回请求用户信息。而HttpServlet对于对象则更改为HttpServletRequest和HttpServletResponse对象。其实这两个接口是同样在对应的ServletRequest和ServletResponse接口的基础上扩展的。

    Enjoytoday,EnjoyCoding

  • 相关阅读:
    Backtrader中文笔记之CSV Data Feed Development-General
    Backtrader中文笔记之CSV Data Feed Filters
    Backtrader中文笔记之CSV Data Feed Development
    Backtrader中文笔记之Extending a Datafeed
    Backtrader中文笔记之Data Feeds
    discuz功能列表
    phpcms功能列表
    empireCMS 帝国cms功能总结
    ecshop功能目录
    织梦所有功能导航列表介绍
  • 原文地址:https://www.cnblogs.com/amiko/p/7906213.html
Copyright © 2011-2022 走看看