Tomcat 架构分析(四) Servlet和Jsp模块

最新推荐文章于 2019-08-20 17:53:02 发布
最新推荐文章于 2019-08-20 17:53:02 发布
阅读量565 收藏 1
点赞数 1
分类专栏： Java tomcat 不，是你的Tomcat 文章标签： java tomcat 架构 servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Noseparte/article/details/78756491
版权
Tomcat 架构分析(四) Servlet和Jsp模块


前言:

Servlet的框架是由两个Java包组成:javax.servlet和javax.servlet.http. 在javax.servlet包中定义了所有的Servlet类都必须实现或扩展的的通用接口和类.在javax.servlet.http包中定义了采用HTTP通信协议的HttpServlet类.

Servlet的框架的核心是javax.servlet.Servlet接口,所有的Servlet都必须实现这一接口.在Servlet接口中定义了5个方法,其中有3个方法代表了Servlet的声明周期:

  • init方法,负责初始化Servlet对象
  • service方法,负责相应客户的请求
  • destory方法,当Servlet对象退出声明周期时,负责释放占有的资源


当Web容器接收到某个Servlet请求时,Servlet把请求封装成一个HttpServletRequest对象,然后把对象传给Servlet的对应的服务方法.

     HTTP的请求方式包括DELETE,GET,OPTIONS,POST,PUT和TRACE,在HttpServlet类中分别提供了相应的服务方法,它们是,doDelete(),doGet(),doOptions(),doPost(), doPut()和doTrace().

HttpServlet的功能 

HttpServlet首先必须读取Http请求的内容。Servlet容器负责创建HttpServlet对象，并把Http请求直接封装到HttpServlet对象中，大大简化了HttpServlet解析请求数据的工作量。HttpServlet容器响应Web客户请求流程如下：

1）Web客户向Servlet容器发出Http请求；
2）Servlet容器解析Web客户的Http请求；
3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；
4）Servlet容器创建一个HttpResponse对象；
5）Servlet容器调用HttpServlet的service方法，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；
6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；
7）HttpServlet调用HttpResponse的有关方法，生成响应数据；
8）Servlet容器把HttpServlet的响应结果传给Web客户。

二、创建HttpServlet的步骤——“四部曲”

1）扩展HttpServlet抽象类；
2）覆盖HttpServlet的部分方法，如覆盖doGet()或doPost()方法；
3）获取HTTP请求信息。通过HttpServletRequest对象来检索HTML表单所提交的数据或URL上的查询字符串；
4）生成HTTP响应结果。通过HttpServletResponse对象生成响应结果，它有一个getWriter()方法，该方法返回一个PrintWriter对象。

下面是HttpServlet的继承关系树，关于其他类源码可以到API文档查看，地址： http://tomcat.apache.org/tomcat-8.5-doc/servletapi/



下面是对HttpServlet源码的分析 

/**
 * 
 * Copyright © 2017 http://blog.csdn.net/noseparte © Like the wind, like rain
 * @author Noseparte
 * @Comile 2017年12月8日--下午9:31:27
 * @Version 1.0
 * @Description		HttpServlet源码分析
 */
@SuppressWarnings("unused")
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");

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理GET请求。
     * 
     * 覆盖此方法以支持GET请求也会自动支持HTTP HEAD请求。HEAD请求是GET请求，在响应中不返回任何主体，只有请求头字段。
     * 
     * 在覆盖该方法时，读取请求数据，编写响应头，获取响应的写入器或输出流对象，最后，编写响应数据。最好是包含内容类型和编码。当使用PrintWriter对象返回响应时，在访问PrintWriter对象之前设置内容类型。
     * 
     * servlet容器必须在提交响应之前写头文件，因为在HTTP中，必须在响应主体之前发送头部。
     * 
     * 在可能的情况下,标题设置content - length(ServletResponse.setContentLength(int)方法),允许servlet容器使用持久连接返回响应给客户端,改善性能。如果整个响应都在响应缓冲区内，则会自动设置内容长度。
     * 
     * 当使用HTTP 1.1分块编码(这意味着响应有一个传输编码头)时，不要设置内容长度的标题。
     * 
     * GET方法应该是安全的，也就是说，没有任何对用户负责的副作用。例如，大多数表单查询都没有副作用。如果客户机请求用于更改存储的数据，则请求应该使用其他的HTTP方法。
     * 
     * GET方法也应该是幂等的，这意味着它可以安全地重复。有时，使方法安全也使其具有强大的功能。例如，重复查询既安全又有效，但在网上购买产品或修改数据既不安全，也不具有幂等功能。
     * 
     * 如果请求格式不正确，doGet将返回HTTP "Bad Request" 消息。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    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);
        }
    }

    /**
     * 返回HttpServletRequest对象最后一次修改的时间，从1970年1月1日午夜开始，时间为毫秒。如果时间未知，该方法返回一个负数(默认值)。
     * 
     * 支持HTTP GET请求的servlet可以快速确定它们的最后修改时间，应该覆盖这个方法。这使得浏览器和代理缓存更加有效，减少了服务器和网络资源的负载。
     * 
     * @param req
     * @return
     */
    protected long getLastModified(HttpServletRequest req) {
        return - 1L;
    }

    /**
     * 从受保护的服务方法接收HTTP HEAD请求并处理请求。客户端发送一个HEAD请求，当它只想看到响应的头，例如内容类型或内容长度。HTTP HEAD方法计算响应中的输出字节，以便准确地设置内容长度标题。
     * 
     * 如果您覆盖了这个方法，您可以避免计算响应主体，并直接设置响应标头以提高性能。请确保您所编写的doHead方法既安全又具有强大的功能(也就是说，保护自己不被多次调用一个HTTP头请求)。
     * 
     * 如果HTTP HEAD请求格式不正确，doHead将返回HTTP "Bad Request" 消息。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
    IOException {
        if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) {
            doGet(req, resp);
        } else {
            NoBodyResponse response = new NoBodyResponse(resp);
            doGet(req, response);
            response.setContentLength();
        }
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理POST请求。HTTP POST方法允许客户端将无限长度的数据发送到Web服务器，并且在发布诸如信用卡号之类的信息时非常有用。
     * 
     * 在覆盖该方法时，读取请求数据，编写响应头，获取响应的写入器或输出流对象，最后，编写响应数据。最好是包含内容类型和编码。当使用PrintWriter对象返回响应时，在访问PrintWriter对象之前设置内容类型。
     * 
     * servlet容器必须在提交响应之前写头文件，因为在HTTP中，必须在响应主体之前发送头部。
     * 
     * 在可能的情况下,标题设置content - length(ServletResponse.setContentLength(int)方法),允许servlet容器使用持久连接返回响应给客户端,改善性能。如果整个响应都在响应缓冲区内，则会自动设置内容长度。
     * 
     * 当使用HTTP 1.1分块编码(这意味着响应有一个传输编码头)时，不要设置内容长度的标题。
     * 
     * 这种方法不需要是安全的，也不需要强大的。通过POST请求的操作可以有副作用，例如，更新存储的数据或在线购买项目。
     * 
     * 如果HTTP POST请求格式不正确，doPost将返回HTTP "Bad Request" 消息。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    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);
        }
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理PUT请求。PUT操作允许客户端将文件放在服务器上，类似于通过FTP发送文件。
     * 
     * 在覆盖此方法时，保留与请求发送的任何内容头(包括内容长度、内容类型、内容转换编码、内容编码、内容基础、内容语言、内容位置、内容-md5和内容范围)。
     * 如果您的方法不能处理一个内容头，它必须发出一个错误消息(HTTP 501-没有实现)并丢弃该请求。有关HTTP 1.1的更多信息，请参阅RFC 2616。
     * 
     * 这种方法不需要是安全的，也不需要强大的。doPut执行的操作可能会有一些副作用，用户可以对此负责。在使用这种方法时，可以在临时存储中保存受影响的URL的副本。
     * 
     * 如果HTTP PUT请求格式不正确，则doPut将返回HTTP "Bad Request" 消息。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    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);
        }
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理一个删除请求。删除操作允许客户端从服务器中删除文档或Web页面。
     * 
     * 这种方法不需要是安全的，也不需要强大的。通过删除所请求的操作可以有副作用，用户可以对此负责。在使用这种方法时，可以在临时存储中保存受影响的URL的副本。
     * 
     * 如果HTTP DELETE请求格式不正确，doDelete将返回HTTP "Bad Request" 消息。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    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);
        }
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理一个选项请求。选项请求确定服务器支持哪些HTTP方法，并返回一个适当的标头。
     * 例如，如果一个servlet覆盖doGet，该方法将返回以下标题:允许:GET，HEAD，TRACE，选项
     * 
     * 除非servlet实现了新的HTTP方法，否则没有必要覆盖这个方法，除了HTTP 1.1实现的方法之外。
     * 
     * @param c
     * @return
     */
    private static Method[] getAllDeclaredMethods(Class < ?>c) {
        if (c.equals(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;
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理一个选项请求。选项请求确定服务器支持哪些HTTP方法，并返回一个适当的标头。
     * 例如，如果一个servlet覆盖doGet，该方法将返回以下标题:允许:GET，HEAD，TRACE，选项
     * 
     * 除非servlet实现了新的HTTP方法，否则没有必要覆盖这个方法，除了HTTP 1.1实现的方法之外。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
    IOException {
        Method[] methods = getAllDeclaredMethods(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)).booleanValue();
        } catch(ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException localClassNotFoundException) {}
        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);
    }

    /**
     * 由服务器调用(通过服务方法)来允许servlet处理跟踪请求。
     * 跟踪返回将跟踪请求发送到客户机的头，以便在调试中使用它们。没有必要覆盖这个方法。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    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 < String > 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();
    }

    /**
     * 从公共服务方法接收标准HTTP请求，并将它们分派到这个类中定义的doMethod方法。
     * 
     * 该方法是servlet.service(javax.servlet的一个特定于http的版本。
     * 
     * ServletRequest,javax.servlet.ServletResponse)方法。
     * 
     * 没有必要覆盖这个方法。
     * 
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException,
    IOException {
        String method = req.getMethod();
        if (method.equals("GET")) {
            long lastModified = getLastModified(req);
            if (lastModified == -1L) {
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch(IllegalArgumentException iae) {
                    ifModifiedSince = -1L;
                }
                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);
        } else if (method.equals("POST")) {
            doPost(req, resp);
        } else if (method.equals("PUT")) {
            doPut(req, resp);
        } else if (method.equals("DELETE")) {
            doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(501, errMsg);
        }
    }

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

    /**
     * 将客户端请求发送到受保护的服务方法。没有必要覆盖这个方法。
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException,IOException {
    	HttpServletResponse response;
    	HttpServletRequest request;
        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch(ClassCastException e) {
            throw new ServletException("non-HTTP request or response");
        }
        service(request, response);
    }
}


故而，我们在web容器里注册一个的继承HttpServlet的实现类，构建web.xml入口。

默认的servlet是既服务于静态资源又服务于目录列表(如果允许目录列表的话)的servlet。

它在$CATALINA_HOME/conf/web.xml中被全局声明。默认形式的声明是这样的： $CATALINA_HOME/conf/web.xml


JSP与Servlet的关系
JSP是Servlet的扩展，在没有JSP之前，就已经出现了Servlet技术。Servlet是利用输出流动态生成HTML页面，包括每一个HTML标签和每个在HTML页面中出现的内容。
JSP通过在标准的HTML页面中插入Java代码，其静态的部分无须Java程序控制，只有那些需要从数据库读取并根据程序动态生成信息时，才使用Java脚本控制。
事实上，JSP是Servlet的一种特殊形式，每个JSP页面就是一个Servlet实例——JSP页面由系统编译成Servlet，Servlet再负责响应用户请求。JSP其实也是Servlet的一种简化，使用JSP时，其实还是使用Servlet，因为Web应用中的每个JSP页面都会由Servlet容器生成对应的Servlet。


JSP的九大对象及其作用域：

   对象名称
     对象释义
           实现类
    作用域
request
请求对象
javax.servlet.ServletRequest
Request
response
响应对象
javax.servlet.SrvletResponse
Page
pageContext
页面上下文对象 
javax.servlet.jsp.PageContext
Page
session
会话对象
javax.servlet.http.HttpSession
session
application
应用程序对象
javax.servlet.ServletContext
Application
out
输出对象
javax.servlet.jsp.JspWriter
Page
config
配置对象
javax.servlet.ServletConfig
Page
page
页面对象
javax.lang.Object
Page
exception
异常对象
javax.lang.Throwable
Page

HttpServletRequest
常用方法
获得客户机信息
  • getRequestURL() 方法返回客户端发出请求时的完整URL。

  • getRequestURI() 方法返回请求行中的资源名部分。

  • getQueryString() 方法返回请求行中的参数部分。

  • getRemoteAddr() 方法返回发出请求的客户机的IP地址

  • getRemoteHost() 方法返回发出请求的客户机的完整主机名

  • getRemotePort() 方法返回客户机所使用的网络端口号

  • getLocalAddr() 方法返回WEB服务器的IP地址。

  • getLocalName() 方法返回WEB服务器的主机名

  • getMethod() 得到客户机请求方式

获得客户机请求头
  • getHead(name)方法

  • getHeaders(String name)方法

  • getHeaderNames() 方法

获得客户机请求参数(客户端提交的数据)
  • getParameter(name):获取指定名称的参数值。这是最为常用的方法之一。

  • getParameterValues（String name）:获取指定名称参数的所有值数组。它适用于一个参数名对应多个值的情况。如页面表单中的复选框，多选列表提交的值。

  • getParameterNames():返回一个包含请求消息中的所有参数名的Enumeration对象。通过遍历这个Enumeration对象，就可以获取请求消息中所有的参数名。

  • getParameterMap():返回一个保存了请求消息中的所有参数名和值的Map对象。Map对象的key是字符串类型的参数名，value是这个参数所对应的Object类型的值数组
     

  • 调用RequestDispatcher.forward() 方法的请求转发过程结束后，
    浏览器地址栏保持初始的URL地址不变。

  • HttpServletResponse.sendRedirect() 方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的访问请求；

  • RequestDispatcher.forward() 方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。

  • RequestDispatcher.forward() 方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；

  • 而HttpServletResponse.sendRedirect() 方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。


HttpSession获取Session,常用方法:

  • setAttribute(String name,Object value) 
    将value对象以name名称绑定到会话

  • getAttribute(String name) 
    取得name的属性值，如果属性不存在则返回null

  • removeAttribute(String name) 
    从会话中删除name属性，如果不存在不会执行，也不会抛处错误.

  • getAttributeNames() 
    返回和会话有关的枚举值

  • invalidate() 
    使会话失效，同时删除属性对象

  • isNew() 
    用于检测当前客户是否为新的会话

  • getCreationTime() 
    返回会话创建时间

  • getLastAccessedTime() 
    返回在会话时间内web容器接收到客户最后发出的请求的时间

  • getMaxInactiveInterval() 
    返回在会话期间内客户请求的最长时间.秒

  • setMasInactiveInterval(int seconds) 
    允许客户客户请求的最长时间

  • ServletContext getServletContext() 
    返回当前会话的上下文环境，ServletContext对象可以使Servlet与web容器进行通信

  • getId() 
    返回会话期间的识别号


About Me：











Noseparte
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Servlet 规范笔记—servlet概念及结构
yingxiongtnt的专栏
01-04 192
Servlet, 这个词对java程序员并不陌生，我想几乎每个java程序员在学习J2EE知识时，首先学习的就是servlet，这是一种正确的学习方式，在我看来Servlet是J2EE的基础，要熟练的掌握J2EE，必须深刻的了解Servlet的原理，因为你想想，现在只要是web相关的技术或框架，无论是开源的、非开源的，哪个和Servlet没有关系？ Spring MVC、Struts、We...
Servlet系统架构分析
SU坡馒的博客
12-11 511
1.系统架构分类： - C/S - B/S 2.C/S Client/Server 3.B/S Browser/Server 本质上还是C/S架构，客户端访问服务器，只不过客户端比较特殊，是浏览器。 4.B/S优缺点： 优点： *不需要安装特定的客户端，只要有浏览器即可云翔，客户体验不错。 *升级只需要升级服务器端，升级方便。 ......
模块化架构之tomcat的jsp加载处理
niemingming的专栏
11-09 1542
jsp模块化加载
六、Java Web模块（Servlet、Tomcat）
Karen博客
08-20 495
六、Java Web模块 1. JSP和 Servlet的区别？ 2. JSP的九大内置对象？ 3. JSP的四种作用域？ ------------------------------------------------------------------------------------------ 4. session的工作原理？ 5. session和 cookie的区别？ 6................
Tomcat,Servlet,JSP之间是什么关系?
BoomMan
01-17 8282
首先Tomcat,Servlet,JSP之间是什么关系? JAVA EE即Java Web标准 Tomcat是Servlet的容器,Servlet运行在Tomcat容器当中(如docker镜像运行在docker容器当中) Servlet容器有很多(tomcat,Jboss,weblogic)等 JSP是动态网页技术，出现在Servlet技术之后的,JSP技术是为了解决Servlet的开发效
tomcat 架构解析和优化。pdf
06-26
《Tomcat架构解析与优化》一书主要涵盖了Apache Tomcat服务器的基础架构、工作原理以及性能调优策略。Tomcat作为一款广泛使用的Java Servlet容器，它的高效运行和优化对于任何Java Web应用都至关重要。 首先，...
基于servlet+jsp个人博客系统.zip
08-22
这个个人博客系统不仅展示了Servlet和JSP的基本用法，还涵盖了Web开发中的常见功能和设计模式，对于学习和实践Java Web开发是非常有价值的资源。下载后，阅读README.md文件可以获取更多运行和部署的指导。
基于jsp+servlet+mysql+tomcat的在线考试系统.zip
最新发布
08-22
4. **Apache Tomcat服务器**: Tomcat是Apache软件基金会的一个开源项目，主要用来部署和运行Java Web应用，包括JSP和Servlet。在这个在线考试系统中，Tomcat作为应用服务器，承载着整个系统的运行环境，接收客户端的...
java EE选修课小作业 商城项目 使用javaEE+tomcat开发的商城项目作业 使用了JSP和servlet两种不同的方式实现
06-26
通过这个项目，学生可以深入理解Web应用的架构，学习如何利用Java EE的组件进行业务逻辑处理和界面展示，同时提升对Tomcat服务器的管理和部署能力。这个过程对于他们将来从事Java Web开发工作具有重要的实践意义。
tomcat 架构解析
01-23
**Tomcat架构解析** Tomcat是一款广泛使用的开源Java Servlet容器，由Apache软件基金会开发和维护...《Tomcat架构解析》这本书将引导读者逐步探索这些概念和技术，无论你是初学者还是经验丰富的开发者，都能从中受益。
servlet工作原理与tomcat的系统架构
tangyuan_sibal的博客
04-25 403
文章目录一 从Servlet容器说起1、server服务器2、tomcat容器3、客户端请求服务器（http请求的过程）二 servlet的过程1、解析过程2.web应用初始化3、创建servlet实例（1）创建 Servlet 对象（2）初始化 Servlet4、servlet如何工作5、整个流程三 模仿tomcat和servlet实现Http请求过程。（1）http基本要求（2）项目的基本结构...
Java JsonParseException异常的解决
热门推荐
Noseparte的博客
11-14 3万+
Java JsonParseException异常的解决办法
Java 地区字典之省市区三级联动 MySQL (一)
Noseparte的博客
11-07 1万+
Java 地区字典之省市区三级联动 MySQL
Java 微信支付之APP支付服务端 (一)
Noseparte的博客
11-06 1万+
Java 微信支付之APP支付服务端 (一) 如图所示，这是服务端要集成的所有微信接口。至于在开放平台申请就不做赘述了。主要流程，1.下单，2.异步通知，3.查询。 一、微信统一下单请求交易 /**        * 微信统一下单请求交易        *        * @param userId        * @par
Java 工程师岗位要求(支付)
Noseparte的博客
11-19 1万+
Java 工程师岗位要求(支付行业)
Hadoop Operations(Hadoop操作) 详解(一) 简介
Noseparte的博客
08-19 1万+
Hadoop Operations 详解 文章目录结构如下： Chapter 1. Introduction     Over the past few years, there has been a fundamental shift in data storage, management, and processing. Companies are storing mor
Java IM环信服务端集成之用户注册(三)
Noseparte的博客
10-29 1万+
开博后，由于个人原因停了接近三个月，如今重新执笔，回归CSDN，壮哉我大Java。...
Java IM环信服务端集成之用户体系集成(二)
Noseparte的博客
10-25 1万+
Java IM环信服务端集成之创建应用(一) 由于业务我们涉及到即时通讯(IM)的原因，在多个第三方的选择后，选择了环信。业务的改变导致了接口的重构。下面我就简述一下环信IM的用户体系集成的流程以及规则： 涉及到业务参数，请查看Java IM环信服务端集成之创建应用(一)  参数后边都要用到。 名词解释 当您申请了 AppKey 后，会得到一个 xxxx#xx
Java 支付宝之APP支付服务端 (二)
Noseparte的博客
11-07 1万+
在上一篇中，集成第三方支付的流程：下单，异步通知，查询，还涉及到提现，退款，关闭订单等，我们以后在介绍。目前先介绍前三个。
jsp servlet mysql tomcat架构设计
05-14
下面是一个简单的 JSP、Servlet、MySQL 和 Tomcat 架构设计： 1. 前端页面设计：使用 HTML、CSS 和 JavaScript 设计 Web 应用程序的前端页面。 2. JSP 页面：使用 JSP 技术来渲染动态页面，并且能够与后端的 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值