• Servlet

    Servlet

    • Servlet是Java提供的一门动态web资源开发技术，其实就是一个接口（规范），将来我们需要自定义Servlet类实现Servlet接口即可，并由web服务器运行Servlet。

    快速入门

    • 创建Web项目，导入Servlet依赖坐标 
        1.         
        2.         <dependency>
        3.             <groupId>javax.servletgroupId>
        4.             <artifactId>javax.servlet-apiartifactId>
        5.             <version>3.1.0version>
        6.             <scope>providedscope>
        7.         dependency>
    • 定义一个类，实现Servlet接口，并重写其中的方法，并在service方法中输出一句话
    • 使用注解方式配置@WebServlet，配置该Servlet的访问路径（就是这个Servlet处理哪些请求）
    • 访问，启动tomcat，输入url地址，访问对应的Servlet类
      • 通过maven插件的方式来启动tomcat服务器，然后在浏览器中输入对应的url地址

    Servlet执行流程

    • Servlet由web服务器创建，其中的方法也由web服务器来调用

    Servlet生命周期

    • Servlet运行在web服务器中（Servlet容器）、其生命周期由容器管理，分为四个阶段
      • 加载实例化：默认情况下，在Servlet第一次被访问时，有容器创建Servlet对象
        • loadStartup
          • 负整数：Servlet对象第一次被访问是创建
          • 正整数或0：服务器启动时，创建Servlet对象，数字越小优先级越高
      • 初始化：在Servlet实例化之后，容器调用其中的init（）方法初始化Servlet对象，完成加载配置文件、创建连接等功能，该方法只调用一次。
      • 处理请求：每当请求Servelt时，Servlet容器都会调用Servlet的service（）方法对请求进行处理
      • 服务终止：当释放内存或容器关闭的时候，容器都会调用Servlet中的destroy（）方法，完成资源的释放，在destroy（）方法调用之后，容器会释放这个Servlet实例对象，该实例对象随后会被Java的垃圾回收器所回收。

    Servlet体系结构

    • 方法
      • 除了上述三个必须执行的方法之外，还有两个方法 
          1.     // 获取ServletConfig对象
          2.     public ServletConfig getServletConfig() {
          3.         return null;
          4.     }
          5.  
          6.     // 获取Servlet信息
          7.     public String getServletInfo() {
          8.         return null;
          9.     }
    • 体系结构 
      • GenericServlet类实现类Servlet接口，HttpServlet类（对HTTP协议封装的Servlet类）继承GenericServlet类
      • 我们将来开发B/S框架的web项目，都是针对HTTP协议，所以我们自定义Servlet，继承HttpServlet即可，在自定义的Servlet类中编写处理get/post请求的方法即可。
    • HttpServlet中为什么要根据请求方式的不同，调用不同的方法，以及如何调用
      • 在接口Servlet的Service方法中，会对请求的参数信息进行处理，但是不同请求的参数位置不同，get请求的请求参数就在请求行中，post请求的请求参数在请求体中，所以要使用不同的请求逻辑。而这些逻辑被封装到HttpServlet类中，我们创建的Servlet类直接继承HttpServlet类即HttpServlet类的源码如下（） 
          1. //
          2. // Source code recreated from a .class file by IntelliJ IDEA
          3. // (powered by FernFlower decompiler)
          4. //
          5.  
          6. package javax.servlet.http;
          7.  
          8. import java.io.IOException;
          9. import java.lang.reflect.Method;
          10. import java.text.MessageFormat;
          11. import java.util.Enumeration;
          12. import java.util.ResourceBundle;
          13. import javax.servlet.GenericServlet;
          14. import javax.servlet.ServletException;
          15. import javax.servlet.ServletOutputStream;
          16. import javax.servlet.ServletRequest;
          17. import javax.servlet.ServletResponse;
          18.  
          19. public abstract class HttpServlet extends GenericServlet {
          20.     private static final String METHOD_DELETE = "DELETE";
          21.     private static final String METHOD_HEAD = "HEAD";
          22.     private static final String METHOD_GET = "GET";
          23.     private static final String METHOD_OPTIONS = "OPTIONS";
          24.     private static final String METHOD_POST = "POST";
          25.     private static final String METHOD_PUT = "PUT";
          26.     private static final String METHOD_TRACE = "TRACE";
          27.     private static final String HEADER_IFMODSINCE = "If-Modified-Since";
          28.     private static final String HEADER_LASTMOD = "Last-Modified";
          29.     private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
          30.     private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
          31.  
          32.     public HttpServlet() {
          33.     }
          34.  
          35.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          36.         String protocol = req.getProtocol();
          37.         String msg = lStrings.getString("http.method_get_not_supported");
          38.         if (protocol.endsWith("1.1")) {
          39.             resp.sendError(405, msg);
          40.         } else {
          41.             resp.sendError(400, msg);
          42.         }
          43.  
          44.     }
          45.  
          46.     protected long getLastModified(HttpServletRequest req) {
          47.         return -1L;
          48.     }
          49.  
          50.     protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          51.         NoBodyResponse response = new NoBodyResponse(resp);
          52.         this.doGet(req, response);
          53.         response.setContentLength();
          54.     }
          55.  
          56.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          57.         String protocol = req.getProtocol();
          58.         String msg = lStrings.getString("http.method_post_not_supported");
          59.         if (protocol.endsWith("1.1")) {
          60.             resp.sendError(405, msg);
          61.         } else {
          62.             resp.sendError(400, msg);
          63.         }
          64.  
          65.     }
          66.  
          67.     protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          68.         String protocol = req.getProtocol();
          69.         String msg = lStrings.getString("http.method_put_not_supported");
          70.         if (protocol.endsWith("1.1")) {
          71.             resp.sendError(405, msg);
          72.         } else {
          73.             resp.sendError(400, msg);
          74.         }
          75.  
          76.     }
          77.  
          78.     protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          79.         String protocol = req.getProtocol();
          80.         String msg = lStrings.getString("http.method_delete_not_supported");
          81.         if (protocol.endsWith("1.1")) {
          82.             resp.sendError(405, msg);
          83.         } else {
          84.             resp.sendError(400, msg);
          85.         }
          86.  
          87.     }
          88.  
          89.     private Method[] getAllDeclaredMethods(Classextends HttpServlet> c) {
          90.         Class clazz = c;
          91.  
          92.         Method[] allMethods;
          93.         for(allMethods = null; !clazz.equals(HttpServlet.class); clazz = clazz.getSuperclass()) {
          94.             Method[] thisMethods = clazz.getDeclaredMethods();
          95.             if (allMethods != null && allMethods.length > 0) {
          96.                 Method[] subClassMethods = allMethods;
          97.                 allMethods = new Method[thisMethods.length + allMethods.length];
          98.                 System.arraycopy(thisMethods, 0, allMethods, 0, thisMethods.length);
          99.                 System.arraycopy(subClassMethods, 0, allMethods, thisMethods.length, subClassMethods.length);
          100.             } else {
          101.                 allMethods = thisMethods;
          102.             }
          103.         }
          104.  
          105.         return allMethods != null ? allMethods : new Method[0];
          106.     }
          107.  
          108.     protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          109.         Method[] methods = this.getAllDeclaredMethods(this.getClass());
          110.         boolean ALLOW_GET = false;
          111.         boolean ALLOW_HEAD = false;
          112.         boolean ALLOW_POST = false;
          113.         boolean ALLOW_PUT = false;
          114.         boolean ALLOW_DELETE = false;
          115.         boolean ALLOW_TRACE = true;
          116.         boolean ALLOW_OPTIONS = true;
          117.  
          118.         for(int i = 0; i < methods.length; ++i) {
          119.             String methodName = methods[i].getName();
          120.             if (methodName.equals("doGet")) {
          121.                 ALLOW_GET = true;
          122.                 ALLOW_HEAD = true;
          123.             } else if (methodName.equals("doPost")) {
          124.                 ALLOW_POST = true;
          125.             } else if (methodName.equals("doPut")) {
          126.                 ALLOW_PUT = true;
          127.             } else if (methodName.equals("doDelete")) {
          128.                 ALLOW_DELETE = true;
          129.             }
          130.         }
          131.  
          132.         StringBuilder allow = new StringBuilder();
          133.         if (ALLOW_GET) {
          134.             allow.append("GET");
          135.         }
          136.  
          137.         if (ALLOW_HEAD) {
          138.             if (allow.length() > 0) {
          139.                 allow.append(", ");
          140.             }
          141.  
          142.             allow.append("HEAD");
          143.         }
          144.  
          145.         if (ALLOW_POST) {
          146.             if (allow.length() > 0) {
          147.                 allow.append(", ");
          148.             }
          149.  
          150.             allow.append("POST");
          151.         }
          152.  
          153.         if (ALLOW_PUT) {
          154.             if (allow.length() > 0) {
          155.                 allow.append(", ");
          156.             }
          157.  
          158.             allow.append("PUT");
          159.         }
          160.  
          161.         if (ALLOW_DELETE) {
          162.             if (allow.length() > 0) {
          163.                 allow.append(", ");
          164.             }
          165.  
          166.             allow.append("DELETE");
          167.         }
          168.  
          169.         if (ALLOW_TRACE) {
          170.             if (allow.length() > 0) {
          171.                 allow.append(", ");
          172.             }
          173.  
          174.             allow.append("TRACE");
          175.         }
          176.  
          177.         if (ALLOW_OPTIONS) {
          178.             if (allow.length() > 0) {
          179.                 allow.append(", ");
          180.             }
          181.  
          182.             allow.append("OPTIONS");
          183.         }
          184.  
          185.         resp.setHeader("Allow", allow.toString());
          186.     }
          187.  
          188.     protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          189.         String CRLF = "\r\n";
          190.         StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
          191.         Enumeration reqHeaderEnum = req.getHeaderNames();
          192.  
          193.         while(reqHeaderEnum.hasMoreElements()) {
          194.             String headerName = (String)reqHeaderEnum.nextElement();
          195.             buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
          196.         }
          197.  
          198.         buffer.append(CRLF);
          199.         int responseLength = buffer.length();
          200.         resp.setContentType("message/http");
          201.         resp.setContentLength(responseLength);
          202.         ServletOutputStream out = resp.getOutputStream();
          203.         out.print(buffer.toString());
          204.     }
          205.  
          206.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          207.         String method = req.getMethod();
          208.         long lastModified;
          209.         if (method.equals("GET")) {
          210.             lastModified = this.getLastModified(req);
          211.             if (lastModified == -1L) {
          212.                 this.doGet(req, resp);
          213.             } else {
          214.                 long ifModifiedSince = req.getDateHeader("If-Modified-Since");
          215.                 if (ifModifiedSince < lastModified) {
          216.                     this.maybeSetLastModified(resp, lastModified);
          217.                     this.doGet(req, resp);
          218.                 } else {
          219.                     resp.setStatus(304);
          220.                 }
          221.             }
          222.         } else if (method.equals("HEAD")) {
          223.             lastModified = this.getLastModified(req);
          224.             this.maybeSetLastModified(resp, lastModified);
          225.             this.doHead(req, resp);
          226.         } else if (method.equals("POST")) {
          227.             this.doPost(req, resp);
          228.         } else if (method.equals("PUT")) {
          229.             this.doPut(req, resp);
          230.         } else if (method.equals("DELETE")) {
          231.             this.doDelete(req, resp);
          232.         } else if (method.equals("OPTIONS")) {
          233.             this.doOptions(req, resp);
          234.         } else if (method.equals("TRACE")) {
          235.             this.doTrace(req, resp);
          236.         } else {
          237.             String errMsg = lStrings.getString("http.method_not_implemented");
          238.             Object[] errArgs = new Object[]{method};
          239.             errMsg = MessageFormat.format(errMsg, errArgs);
          240.             resp.sendError(501, errMsg);
          241.         }
          242.  
          243.     }
          244.  
          245.     private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
          246.         if (!resp.containsHeader("Last-Modified")) {
          247.             if (lastModified >= 0L) {
          248.                 resp.setDateHeader("Last-Modified", lastModified);
          249.             }
          250.  
          251.         }
          252.     }
          253.  
          254.     public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
          255.         if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
          256.             HttpServletRequest request = (HttpServletRequest)req;
          257.             HttpServletResponse response = (HttpServletResponse)res;
          258.             this.service(request, response);
          259.         } else {
          260.             throw new ServletException("non-HTTP request or response");
          261.         }
          262.     }
          263. }

        • 我们可以看到其中对于Http中的其中不同的请求方式都进行了判断，并且进行了封装，我们自定义的Servlet类继承HttpServlet类就可以，然后重写其中的不同的方法来处理不同类型的请求即可，简单讲就是HttpServlet类帮我们完成了url请求的类型的判断，我们只需要完成对于不同请求类型的处理逻辑即可。

    Servlet urlPattern配置

    • urlParttern就是设置Servlet类访问路径，即该请求被哪一个Servlert来进行逻辑处理，在实际的开发过程中，前后端应该是通过需求文档来确定访问路径的（产品经理提供好）
    • 一个Servlet可以配置多个访问路径
    • urlParttern配置规则
      • 精确匹配
      • 目录匹配
      • 拓展名匹配
      • 任意匹配
      • /和/*的区别（这两个在以后的servlet访问路劲中尽量不要使用）
        • 当我们的项目中的Servlet配置了“/”，会覆盖掉tomcat中的DefaultServlet，当其他的url-pattern都匹配不上的时候，就会调用该默认的servlet，该默认Servlet会处理项目中静态资源的访问，如果覆盖掉就无法范文静态资源（html页面等.）。
        • 当我们项目中的配置了“/*“，意味该Servlet匹配任意访问路径
      • 优先级
        • 精确路径》目录路径》拓展名路径》/*》/
        • 精确度来划分（在一个项目应该指挥只会使用一种方式来进行配置）

    xml配置方式编写Servlet

    • 以后学习框架很多都是全注解开发，就是用注解来讲xml配置方式给替代掉，使用起来非常方柏霓，但学习xml配置方式也有助于我理解注解配置方式，要理解xml配置方式，就需要学习Spring的原理了，可以参考我在Spring专栏的相关文章。
    • 编写好Servlet类之后，我们需要在web.xml配置文件中，进行对应的映射
  • 相关阅读:
    笔试强训第18天
    【kubernetes】k8s对象☞pod
    开发笔记 03，为什么不要问别人在做什么小产品？
    JSP如何使用request获取当前访问者的真实IP呢？
    安装Docker
    【Cisco Packet Tracer】管理方式，命令，接口trunk，VLAN
    Ambari 安装多个impala deamon节点（apache impala）
    成绩 (爱思创算法四)(期中测试)(答案记录)
    如何保卫您的网站：解决DDoS攻击与CC攻击
    component 动态组件的用法
  • 原文地址：https://blog.csdn.net/weixin_64939936/article/details/133699353