Servlet-学习条记-上

1. Servlet简介

1.1 动态资源和静态资源

静态资源

•         无需再步伐运行时通过代码天生的资源，再步伐运行之前就写好的资源，比方html css js img ，音频文件和视频文件
  

动态资源

•         必要在步伐运行时通过代码运行天生的资源，在步伐运行之前无法确定的数据，运行时动态天生，比方Servlet，Thymeleaf......
  
•         动态资源指的不是视图上的动画结果大概是简朴的人机交互结果
  

生存举例

•         去蛋糕店买蛋糕
  
  
  
  •                 直接买柜台上已经做好的：静态资源
    
  •                 和柜员说要求后现场制作：动态资源
    
  
  

1.2 Servlet简介

Servlet(server applet) 是运行在服务端(tomcat)的java小步伐，是sun公司提供的一套界说动态资源规范；从代码上来讲Servlet就是一个接口

•         用来吸取从、处理惩罚客户端哀求、相应给欣赏器的动态资源。 在整个Web应用中，Servlet紧张负责吸取处理惩罚哀求、协同调治功能以及相应数据。我们可以把Servlet称为Web应用中的控制器
  
•         不是全部的JAVA项目都能用于处理惩罚客户端哀求，能处理惩罚客户端哀求并做出相应的一套技能标准就是Servlet
  
•         Servlet是运行在服务端的，以是Servlet必须在WEB应用中开辟且在Tomcat如许的服务器容器中举行
  

哀求相应与HttpServletRequest和HttpServletResponce之间的对应关系

2. package com.mdklea.servlet;
3. ​
4. import jakarta.servlet.*;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
8. ​
9. import java.io.IOException;
10. import java.io.PrintWriter;
11. ​
12. /**
13. * 1 创建javaWEB 项目，同时将tomcat添加为当前项目的依赖
14. * 2 重写service方法 service(HeepServletRequest req, HttpServletResponce resp)
15. * 3 在service方法中，定义业务处理代码
16. * 4 在web.xml中，配置Servlet 对应的请求映射路径
17. *
18. * 1 servlet-api.jar 导入问题
19. *      servlet-api 编码的时候需要，运行的时候，在服务器的环境中，由服务软件(Tomcat)提供
20. *      因此，我们的JAVAWEB项目中，在打包/构建的时候，是无需携带servlet-api的jar包的
21. * 2 Content-Type 响应头的问题
22. *      MIME类型响应头，媒体类型，文件类型，相应的数据类型
23. *      MIME类型用于告诉客户端相应的数据是什么类型的数据，客户端以此类型决定用什么方式解析响应体
24. */
25. public class UserServlet extends HttpServlet {
26.    @Override
27.    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
28.        //1. 从request 对象中获取请求中的任何信息(username参数)
29.        String username = request.getParameter("username");//根据参数名获取参数值，无论url是在url?后还是在请求体中
30.        String inFo = "yes";
31.        //2. 处理业务的代码
32.        if ("md2".equals(username)) {
33.            inFo = "no";
34.        }
35.        //3. 将要相应的数据放入responce
36.        //应该设置Content-Type响应头
37.        //response.setHeader("Content-Type","text/html");
38.        response.setContentType("text/html");
39.        PrintWriter writer = response.getWriter(); //该方法是返回一个向响应体中返回字符串的打印流
40.        writer.write(inFo);
41.    }
42. }

复制代码

2. <?xml version="1.0" encoding="UTF-8"?>
3. <web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
6.         version="6.0">
7. ​
8. <!--   模糊匹配-->
9. <!--    /   匹配全部，不包含jsp文件-->
10. <!--    /*  匹配全部，包含jsp文件-->
11. <!--    /a/*    匹配前缀，后缀模糊-->
12. <!--    *.action    匹配后缀，前缀模糊-->
13.    <servlet>
14.        <servlet-name>userServlet</servlet-name>
15.        <servlet-class>com.mdklea.servlet.UserServlet</servlet-class>
16.    </servlet>
17. ​
18.    <servlet>
19.        <servlet-name>servlet1</servlet-name>
20.        <servlet-class>com.mdklea.servlet.Servlet1</servlet-class>
21.    </servlet>
22. ​
23.    <servlet-mapping>
24.        <servlet-name>userServlet</servlet-name>
25.        <url-pattern>/userServlet</url-pattern>
26.    </servlet-mapping>
27. ​
28.    <servlet-mapping>
29.        <servlet-name>servlet1</servlet-name>
30.        <url-pattern>/s1</url-pattern>
31.    </servlet-mapping>
32. </web-app>

复制代码

2. Servlet注解方式设置

@webServlet注解源码

value 与 urlPatterns互为别名

2. //
3. // Source code recreated from a .class file by IntelliJ IDEA
4. // (powered by FernFlower decompiler)
5. //
6. ​
7. package jakarta.servlet.annotation;
8. ​
9. import java.lang.annotation.Documented;
10. import java.lang.annotation.ElementType;
11. import java.lang.annotation.Retention;
12. import java.lang.annotation.RetentionPolicy;
13. import java.lang.annotation.Target;
14. ​
15. @Target({ElementType.TYPE})
16. @Retention(RetentionPolicy.RUNTIME)
17. @Documented
18. public @interface WebServlet {
19.    String name() default "";
20. ​
21.    String[] value() default {};
22. ​
23.    String[] urlPatterns() default {};
24. ​
25.    int loadOnStartup() default -1;
26. ​
27.    WebInitParam[] initParams() default {};
28. ​
29.    boolean asyncSupported() default false;
30. ​
31.    String smallIcon() default "";
32. ​
33.    String largeIcon() default "";
34. ​
35.    String description() default "";
36. ​
37.    String displayName() default "";
38. }

复制代码

3. Servlet生命周期

3.1 声明周期简介

什么是Servlet的生命周期

•         应用步伐中的对象不但在空间上有条理布局的关系，在时间上也会由于处于步伐运行过程中的差别阶段而表现出差别状态和不偕活动-----这就是对象的生命周期。
  
•         简朴的叙述生命周期，就是对象在容器中从开始创建到烧毁的过程。
  

servlet容器

•         Servlet对象是Servlet容器创建的，生命周期方法都是由容器(现在我们利用的是Tomcat)调用的。这一点和我们之前所编写的代码有很大差别。在以后的学习中我们会看到，越来越多的对象交给容器或框架来创建，越来越多的方法由容器或框架来调用，开辟职员要尽大概多的将精力放在业务逻辑的实现上。
  

servlet紧张声明周期实行特点

3.2 线性安全标题

3.3 defaultServlet

2. package com.mdklea.servlet;
3. ​
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.annotation.WebServlet;
6. import jakarta.servlet.http.HttpServlet;
7. import jakarta.servlet.http.HttpServletRequest;
8. import jakarta.servlet.http.HttpServletResponse;
9. import jakarta.servlet.http.PushBuilder;
10. ​
11. import java.io.IOException;
12. ​
13. /**
14. * 1 实例化        构造器     第一次请求
15. * 2 初始化        init       构造完毕
16. * 3 接收请求 服务  service    每次请求
17. * 4 销毁          destory    关闭服务
18. *
19. * Servlet在Tomcat中是单例的
20. * Servlet的成员变量在多个线程之中是共享的
21. * 不建议在Service方法中修改成员变量，在并发请求时，会引发线程安全问题
22. */
23. public class ServletLifeCicle extends HttpServlet {
24.    public ServletLifeCicle() {
25.    }
26. ​
27.    @Override
28.    public void init() throws ServletException {
29.        super.init();
30.    }
31. ​
32.    @Override
33.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
34. ​
35.    }
36. ​
37.    @Override
38.    public void destroy() {
39.        super.destroy();
40.    }
41. }

复制代码

2. <servlet>
3.    <servlet-name>ServletLifeCycle</servlet-name>
4.    <servlet-class>com.mdklea.servlet.ServletLifeCicle</servlet-class>
5.    <!--
6.        默认值是-1，含义是 tomcat 启动时不会实例化该servlet
7.        其他正整数 15 含义是 tomcat 在启动时，实例化该servlet的顺序，如果序号冲突了，tomcat会自动协调启动顺序
8.    -->
9.    <load-on-startup>-1</load-on-startup>
10. </servlet>
11. <servlet-mapping>
12.    <servlet-name>ServletLifeCycle</servlet-name>
13.    <url-pattern>/ServletLifeCycle</url-pattern>
14. </servlet-mapping>

复制代码

4. Servlet继续布局

4.1 Servlet接口

2. /*
3.    1. 顶级的Servlet接口
4.    public interface Servlet {
5.    // 初始化方法，构造完毕后，由tomcat自动调用完成初始化功能的方法
6.    void init(ServletConfig var1) throws ServletException;
7. ​
8.    // 获取ServletConfig 对象的方法
9.    ServletConfig getServletConfig();
10. ​
11.    // 接收用户请求，向用户响应信息的方法
12.    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
13. ​
14.    // 返回Servlet字符串形式描述信息的方法
15.    String getServletInfo();
16. ​
17.    // Servlet在回收前，由tomcat调用的销毁方法，往往用于做资源的释放工作
18.    void destroy();
19. }
20. */

复制代码

4.2 GenericServlet抽象类

2. /*
3.    2. 抽象的类     GenericServlet  侧重于除了service方法以外的其他方法的基础处理
4.    public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
5.        private transient ServletConfig config;
6. ​
7.        public void destroy() {
8.            // 将抽象方法重写为普通方法，在方法内部没有任何的代码实现
9.            // 平庸实现
10.        }
11.        //tomcat在调用init 方法时，会读取配置信息进入一个ServletConfig 对象并将该对象传入init方法
12.        public void init(ServletConfig config) throws ServletException {
13.            // 将config 对象存储为当前的属性
14.            this.config = config;
15.            // 调用了重载的无参init
16.            this.init();
17.        }
18.        public void init() throws ServletException {
19.            // 重载的初始化方法，我们重写初始化方法时对应的方法
20.        }
21.        // 返回ServletConfig的方法
22.        public ServletConfig getServletConfig() {
23.            return this.config;
24.        }
25.        // 再次抽象声明service方法
26.        public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
27. ​
28.    }
29. */

复制代码

4.3 HttpServlet 抽象类

2. /*
3.    // 抽象的类     HttpServlet
4.    public abstract class HttpServlet extends GenericServlet {
5.            //
6.            public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
7. ​
8.            // 参数的父转子
9.            HttpServletRequest request;
10.            HttpServletResponse response;
11.            try {
12.                request = (HttpServletRequest)req;
13.                response = (HttpServletResponse)res;
14.            } catch (ClassCastException var6) {
15.                throw new ServletException(lStrings.getString("http.non_http"));
16.            }
17.            // 调用重载的service 方法
18.            this.service(request, response);
19.        }
20. ​
21.    //
22.        protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
23.            // 获取请求的方式  GET POST PUT DELETE OPTIONS
24.            String method = req.getMethod();
25.            long lastModified;
26. ​
27.            // 根据请求方式调用对应的do。。。方法   故意响应405
28.            if (method.equals("GET")) {
29.                lastModified = this.getLastModified(req);
30.                if (lastModified == -1L) {
31.                    this.doGet(req, resp);
32.                } else {
33.                    long ifModifiedSince;
34.                    try {
35.                        ifModifiedSince = req.getDateHeader("If-Modified-Since");
36.                    } catch (IllegalArgumentException var9) {
37.                        ifModifiedSince = -1L;
38.                    }
39. ​
40.                    if (ifModifiedSince < lastModified / 1000L * 1000L) {
41.                        this.maybeSetLastModified(resp, lastModified);
42.                        this.doGet(req, resp);
43.                    } else {
44.                        resp.setStatus(304);
45.                    }
46.                }
47.            } else if (method.equals("HEAD")) {
48.                lastModified = this.getLastModified(req);
49.                this.maybeSetLastModified(resp, lastModified);
50.                this.doHead(req, resp);
51.            } else if (method.equals("POST")) {
52.                this.doPost(req, resp);
53.            } else if (method.equals("PUT")) {
54.                this.doPut(req, resp);
55.            } else if (method.equals("DELETE")) {
56.                this.doDelete(req, resp);
57.            } else if (method.equals("OPTIONS")) {
58.                this.doOptions(req, resp);
59.            } else if (method.equals("TRACE")) {
60.                this.doTrace(req, resp);
61.            } else {
62.                String errMsg = lStrings.getString("http.method_not_implemented");
63.                Object[] errArgs = new Object[]{method};
64.                errMsg = MessageFormat.format(errMsg, errArgs);
65.                resp.sendError(501, errMsg);
66.            }
67. ​
68.        }
69. ​
70.        //doGet方法
71.        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
72.            String msg = lStrings.getString("http.method_get_not_supported");
73.            this.sendMethodNotAllowed(req, resp, msg);
74.        }
75.        //sendMethodNotAllowed
76.        private void sendMethodNotAllowed(HttpServletRequest req, HttpServletResponse resp, String msg) throws IOException {
77.            String protocol = req.getProtocol();
78.            // 故意响应405
79.            if (protocol.length() != 0 && !protocol.endsWith("0.9") && !protocol.endsWith("1.0")) {
80.                resp.sendError(405, msg);
81.            } else {
82.                resp.sendError(400, msg);
83.            }
84.        }
85. ​
86.        // 自定义Servlet
87.        Class Servlet1 extends HttpServlet {
88.            protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
89.                // 接收用户请求信息
90. ​
91.                // 做出响应
92.            }
93.        }
94.    }
95.    1 部分程序员推荐在servlet中重写do*** 方法处理请求，理由：service方法中可能做了一些处理，如果我们直接重写service的话，父类中service
96.      方法中的一些处理可能会失效
97.    2 目前直接重写service 也没有什么问题
98.    3 后续使用SpringMVC框架后，我们则无需继承HttpServlet，处理请求的方法也无需是 do*** service
99.    4 如果doGet 和doPost 方法中，我们定义的代码都一样，可以让一个方法直接调用另一个方法
100. ​
101.    掌握的技能 继承HttpServlet后，要么重写service 方法，要么重写 doGet/doPost
102. */

复制代码

5. ServletConfig 的利用

ServletConfig 是什么

•         为Servlet提供初始设置参数的一种对象，每个Servlet都有自己独立唯一的ServletConfig对象
  
•         容器会为每个Servlet实例化一个ServletConfig对象，并通过Servlet生命周期的init方法传入给Servlet作为属性
  

6. ServletContext 的利用

ServletContext 是什么

•         ServletContext 对象有称呼为上下文对象，大概叫应用域对象(背面同意解说域对象)
  
•         容器会为每个app创建一个独立的唯一的ServletContext对象
  
•         ServletContext对象为全部的Servlet所共享
  
•         ServletContext可以为全部的Servlet提供初始设置参数
  

ServletContext怎么用

2. package com.mdklea.servlet;
3. ​
4. ​
5. import jakarta.servlet.ServletContext;
6. import jakarta.servlet.ServletException;
7. import jakarta.servlet.http.HttpServlet;
8. import jakarta.servlet.http.HttpServletRequest;
9. import jakarta.servlet.http.HttpServletResponse;
10. import java.io.IOException;
11. import java.util.Enumeration;
12. ​
13. ​
14. public class Servlet01 extends HttpServlet {
15.    @Override
16.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
17. //        ServletConfig servletConfig = getServletConfig();
18. //        String key1 = servletConfig.getInitParameter("key1");
19. //        System.out.println("key1: " + key1);
20. //        Enumeration<String> initParameterNames = servletConfig.getInitParameterNames();
21. //        while (initParameterNames.hasMoreElements()) {
22. //            String s = initParameterNames.nextElement();
23. //            System.out.println("pname: " + s);
24. //        }
25.        System.out.println("--------------------------------------");
26.        ServletContext servletContext = this.getServletContext();
27.        Enumeration<String> initParameterNames = servletContext.getInitParameterNames();
28.        while (initParameterNames.hasMoreElements()) {
29.            String pname = initParameterNames.nextElement();
30.            System.out.println("pname:  " + pname +"\n" + "context" + servletContext.getInitParameter(pname));
31.        }
32.    }
33. }

复制代码

ServletContext APIs
获取资源的真实路径

2. String realPath = servletContext.getReadPath("资源在web目录中的路径");

复制代码

•         比方我们的目标是必要获取项目中某个静态资源的路径，不是工程目次中的路径，而是摆设目次中的路径，我们假如直接拷贝其在我们电脑中的完备路径的话着实是有标题的，由于假如该项目以后摆设到公司服务器上的话，路径肯定是会发生变革的，以是我们必要利用代码动态获取资源的真实路径，只要利用了servletContext 动态获取资源的真实路径，那么无论项目标摆设路径发生什么变革，都会动态获取项目运行时间的实际路径，以是就不会发生由于写死真实路径而导致项目摆设位置改变引发的路径错误标题。
  

获取项目标上下文路径

2. String contextPath = servletContext.getContextPath();

复制代码

•         项目摆设名称，也叫项目标上下文路径，在摆设进入tomcat时利用的路径，该路径是大概发生变革的，通过API动态获取项目真实的上下文路径，可以资助我们办理一些后端页面渲染技能大概哀求转发和相应重定向中的路径标题。
  

域对象干系的API

•         域对象：一些用于存储数据和通报数据的对象，通报数据差别的范围，我们称之为差别的域差别的域对象代表差别的域，共享数据的范围也差别
  
•         ServletContext代表应用，以是ServletContext域也叫应用域，是webapp中最大的域，可以在本应用内实现数据的共享和通报
  
•         webapp中三大域对象，分别是应用域，会话域，哀求域
  
•         背面我们会为三大域通一举行解说和演示
  

2. package com.mdklea.servlet;
3. ​
4. ​
5. import jakarta.servlet.ServletContext;
6. import jakarta.servlet.ServletException;
7. import jakarta.servlet.http.HttpServlet;
8. import jakarta.servlet.http.HttpServletRequest;
9. import jakarta.servlet.http.HttpServletResponse;
10. import java.io.IOException;
11. import java.util.Enumeration;
12. ​
13. ​
14. public class Servlet01 extends HttpServlet {
15.    @Override
16.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
17. //        ServletConfig servletConfig = getServletConfig();
18. //        String key1 = servletConfig.getInitParameter("key1");
19. //        System.out.println("key1: " + key1);
20. //        Enumeration<String> initParameterNames = servletConfig.getInitParameterNames();
21. //        while (initParameterNames.hasMoreElements()) {
22. //            String s = initParameterNames.nextElement();
23. //            System.out.println("pname: " + s);
24. //        }
25.        System.out.println("--------------------------------------");
26.        ServletContext application = this.getServletContext();
27.        Enumeration<String> initParameterNames = application.getInitParameterNames();
28.        while (initParameterNames.hasMoreElements()) {
29.            String pname = initParameterNames.nextElement();
30.            System.out.println("pname:  " + pname +"\n" + "context" + servletContext.getInitParameter(pname));
31.        }
32.        //作为域对象一定会有的API
33.        // void setAttribute(String key,Object value)   向狱中存储/修改数据
34.        application.setAttribute("keya","valueA");
35.        application.setAttribute("keyb","valueb");
36.        // Object getAttribute(String key)  获取域中的数据
37.        String keya = (String) application.getAttribute("keya");
38.        System.out.println(keya);
39.        // void removeAttribute(String key);    删除域中的数据
40.        application.removeAttribute("keyb");
41. ​
42.    }
43. }
44. ​

复制代码

7. HttpServletRequest

•         获取哀求行信息干系(方式，哀求的url，协议及版本)
  

2. package com.mdklea.servlet;
3. ​
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.annotation.WebServlet;
6. import jakarta.servlet.http.HttpServlet;
7. import jakarta.servlet.http.HttpServletRequest;
8. import jakarta.servlet.http.HttpServletResponse;
9. import java.io.IOException;
10. import java.util.Enumeration;
11. ​
12. @WebServlet("/Servlet4")
13. public class Servlet04 extends HttpServlet {
14.    @Override
15.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
16.        // 行相关 GET POST     uri        Http/1.1
17.        System.out.println(req.getMethod());    //获取请求方式
18.        System.out.println(req.getScheme());    // 获取请求协议
19.        System.out.println(req.getProtocol());  // 获取请求协议及版本
20.        System.out.println(req.getRequestURI());    // 获取请求的uri     项目内的资源路径
21.        System.out.println(req.getRequestURL());    // 获取请求的url     项目内资源的完成的路径
22.        /*
23.        URI ：统一资源标识符    /demo/a.html                interface URI()                 资源定位要求和规范       动物类
24.        URL ：统一资源定位符    http://ip:port/demo/a.html  class URL implements UTI{}      一个具体的资源路径       哺乳动物类
25.         */
26.        System.out.println(req.getLocalPort());     // 本应用容器的端口号    8080
27.        System.out.println(req.getServerPort());    // 客户端发请求时使用的端口号
28.        System.out.println(req.getRemotePort());    // 客户端软件的端口号
29.        // 头相关 key-value,key-value
30.        // 根据名字单独获取某个请求头
31.        String accept = req.getHeader("Accept");
32.        System.out.println("Accept" + accept);
33. ​
34.        // 获取本次请求中所有的请求头的名字
35.        Enumeration<String> headerNames = req.getHeaderNames();
36.        while (headerNames.hasMoreElements()) {
37.            String hname = headerNames.nextElement();
38.            System.out.println(hname + req.getHeader(hname));
39.        }
40.    }
41. }

复制代码

3. package com.mdklea.servlet;
4. ​
5. import jakarta.servlet.ServletException;
6. import jakarta.servlet.annotation.WebServlet;
7. import jakarta.servlet.http.HttpServlet;
8. import jakarta.servlet.http.HttpServletRequest;
9. import jakarta.servlet.http.HttpServletResponse;
10. import java.io.IOException;
11. import java.util.*;
12. ​
13. @WebServlet("/servlet5")
14. public class Servlet05 extends HttpServlet {
15.    @Override
16.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
17.        System.out.println(req.getParameter("username"));
18.        System.out.println(req.getParameter("userPwd"));
19. //        System.out.println(req.getParameter("hobby"));
20.        //  根据参数名获取多个参数值
21.        String[] hobbies = req.getParameterValues("hobby");
22.        for (String hobby : hobbies) {
23.            System.out.println(hobby);
24.        }
25.        // 获取所有的参数名
26.        Enumeration<String> parameterNames = req.getParameterNames();
27.        while (parameterNames.hasMoreElements()) {
28.            String pname = parameterNames.nextElement();
29.            String[] parameterValues = req.getParameterValues(pname);
30.            if (parameterValues.length > 1) {
31.                System.out.println(pname + " = " + Arrays.toString(parameterValues));
32.            }else {
33.                System.out.println(pname + "=" + parameterValues[0]);
34.            }
35.        }
36.        // 获取map形式的参数名
37.        Map<String, String[]> parameterMap = req.getParameterMap();
38.        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
39.        for (Map.Entry<String, String[]> entry : entries) {
40.            String key = entry.getKey();
41.            String[] value = entry.getValue();
42.            if (value.length > 1) {
43.                System.out.println(key + " = " + Arrays.toString(value));
44.            }else {
45.                System.out.println(key + " = " + value[0]);
46.            }
47.        }
48.        /*
49.           以上API专门用于获取key=value形式的参数，无论这些参数是在url后还是在请求体中
50.           请求
51.                请求行     方式      uri     http/1.1
52.                请求头
53.                请求体
54. ​
55.                form  表单标签提交GET请求时，参数以键值对形式放在url后，不放在请求体里，GET方式的请求也是可以有请求体的
56. ​
57.                post
58. ​
59.                获得请求体中的非键值对数据？
60.                //  获得一个从请求体中读取字符的字符输入流
61.                BufferedReader reader = req.getReader();    JSON串
62.                //  获得一个从请求中读取二进制数据字节的输入流
63.                ServletInputStream inputStream = req.getInputStream();  文件
64.         */
65.        String servletPath = req.getServletPath();
66.    }
67. }

复制代码

8. HttpServletResponce

HttpServletResponce是什么

•         HttpServletResponce 是一个接口，其父接口是ServletResponse
  
•         HttpServletResponce 是Tomcat预先创建的，在Tomcat调用service方法时传入
  
•         HttpServletResponce代表对客户端的相应，该对象会被转换成相应的报文发送给客户端，通过该对象我们可以设置相应信息
  

HttpServletResponce常用API

2. package com.mdklea.servlet;
3. ​
4. import jakarta.servlet.ServletException;
5. import jakarta.servlet.annotation.WebServlet;
6. import jakarta.servlet.http.HttpServlet;
7. import jakarta.servlet.http.HttpServletRequest;
8. import jakarta.servlet.http.HttpServletResponse;
9. ​
10. import java.io.IOException;
11. import java.io.PrintWriter;
12. ​
13. @WebServlet("/servlet6")
14. public class Servlet06 extends HttpServlet {
15.    @Override
16.    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
17.        // 设置相应行相关的API  HTTP/1.1    200/404/405/500/...
18.        resp.setStatus(200);
19.        String info = "<h1>Hello</h1>";
20.        // 设置响应头相关的API
21.        resp.setHeader("aaa","valuea");
22.        resp.setHeader("Content-Type","text/html");
23.        resp.setHeader("Content-Length","1234");
24.        resp.setContentType("text/html");
25.        resp.setContentLength(info.getBytes().length);
26. ​
27.        // 设置响应体内容API
28.        // 获得一个向响应体中输入文本字符输出流
29.        PrintWriter writer = resp.getWriter();
30.        writer.write(info);
31.        // 获得一个向响应体中输入二进制信息的字节输入流
32.        // ServletOutputStream outputStream = resp.getOutputStream();
33.    }
34. }

复制代码