JavaWeb

特点：需要安装特定的客户端软件
优点
- 速度快（软件中的数据大部分都是集成到客户端软件当中的，很少量的数据从服务器端传送过来）
- 体验好
- 界面酷炫
- 服务器压力小 (软件中的数据大部分都是集成到客户端软件当中的，很少量的数据从服务器端传送过来)
- 安全（大量的数据是集成在客户端软件中的，并且客户端有多个，大量的数据在客户端上有缓存，有存储）
缺点
- 升级维护比较麻烦，成本比较高

B/S架构（Browser/Server）

特点：B/S系统结构实际上是一个C/S，只不过这个C比较特殊，这个Client是一个固定不变浏览器软件。
优点：
- 升级维护方便，成本低
- 不需要安装特定的客户端软件，用户操作方便
缺点
- 速度慢（所有的数据都是在服务器上，需要服务器响应）
- 体验差（界面不好看，加载速度慢）
- 不安全（所有数据都在服务器上，服务器发生意外，所有数据全部丢失）
  B/S结构的系统通信原理
  使用域名访问，域名解析器进行解析成ip和端口号
  WEB服务器软件
Tomcat（WEB服务器）
jetty（WEB服务器）
jBOSS（应用服务器）
WebLogic（应用服务器）
WebSphere（应用服务器）

应用服务器和WEB服务器的区别

应用服务器实现了JavaEE的所有规范。
WEB服务器只实现了JavaEE的两种规范JSP + Servlet
因此应用服务器包含了WEB服务器

Tomcat服务器是开源免费的轻量级WEB服务器，Tomcat是java语言写的，所以要先安装jre（java的运行环境）先安装jdk配置java的运行环境

请求和响应实际上是数据的流向不同
请求：从浏览器（Browser）发送数据到服务器（Server）
响应：从服务器（Server）发送数据到浏览器（Browser）

Tomcat 服务器的目录

bin：命令文件存放的目录。比如：启动Tomcat，关闭Tomcat
- bin目录下有一个文件startup.bat，通过它可以启动Tomcat服务器
- xxx.bat 文件是windows操作系统专用的。bat文件是批处理文件，可以编写大量的windows命令，执行bat文件就相当于批量的执行dos命令
- xxx.sh文件是Linux操作系统专用的。sh文件是在linux中批量执行shell命令
- 通过startup.bat 调用 catalina.bat 再调用 MAINCLASS=org.apache.catalina.startup.Bootstrap 中的main方法（在D:\Users\zhl36\Documents\apache-tomcat-9.0.27-src\java\org\apache\catalina\startup\Bootstrap文件下）
conf：配置文件存放目录。
lib：Tomcat服务器的核心程序目录。
logs：Tomcat服务器的日志记录。
temp：Tomcat的临时目录
webapps：这个目录就是用来存放大量的webapp
work：用来存放JSP文件翻译之后的java文件以及编译之后的class文件。
在命令行中，想要直接输入stratup打开tomcat，需要配置tomcat的环境，在系统变量中的PATH引入tomcat的bin目录，然后在系统变量中新建变量名=CATALINA_HOME，变量值为tomcat的根路径（bin的上一级目录）还必须要保证系统变量中有JAVA_HOME目录。
即配置 JAVA_HOME=JDK的根和 CATALINA_HOME=Tomcat的根
启动Tomcat：startup
关闭Tomcat：stop (已将shutdown.bat改为stop.bat，因为shutdown.bat和windows的关机命令一样)

<!doctype html>
<html>      
    <head>
        <title>index page</title>
    </head>
    <body>
        <!--点击以下超链接，实际上就相当于 在浏览器的地址栏输入了url-->
        <a href="http://localhost:8080/oa/login.html">user login</a>
        <br>
        <!--绝对路径可以省略http://localhost:8080,以"/" 开始，带项目名-->
        <a href="/oa/login.html">user login2</a>
    </body>
</html>

二、Javaweb-servlet

对于一个动态Web应用来说

参与的角色有
- 浏览器的开发团队（谷歌、火狐、IE）
- WEB server 的开发团队（Tomcat、Jetty、Weblogic）
- DB server 的开发团队（Oracle、Mysql）
- webapp 的开发团队（WEB应用就是我们程序员要做的）
角色与角色之间应该遵守哪些规范？哪些协议
- webapp的开发团队和WEBserver开发团队之间有一套规范：JavaEE规范之一的Servlet规范
- Servlet规范的作用是将webapp与web server解耦合
- DB server 和 webapp 之间的规范是JDBC
- WEB server 和浏览器（Browser）之间的规范是 http协议

开发一个带有Servlet的webapp
第一步：在webapps下新建一个目录，起名crm。注意此时crm 就是这个webapp的根
第二步：在webapps的根下新建一个目录：WEB-INF。

目录名字Servlet规范规定的，必须全部大写

第三步：在WEB-INF 目录下，新建一个目录：classes

目录名字必须是小写的，也是Servlet规范的（Java编译后的字节码文件）

第四步：在WEB-INF 目录下，新建一个目录：lib

注意：这个目录不是必须的，但是如果引入第三方jar 包，必须放在lib 目录下，名称必须小写，且必须是lib ,同样是Servlet规范的

第五步：在WEB-INF目录下，新建:web.xml

文件是必须的，文件的路径和名称不能改变。web.xml实际上就是配置文件，在这个配置文件中描述了请求路径和Servlet类之间的对应关系

第六步：编写一个Java程序，必须实现Servlet接口

Servlet接口不在JDK中
Servlet是JavaEE规范的一员
Tomcat实现了Servlet规范，在Tomcat服务器中有这个接口，在CATALINA_HOME/lib目录下，servlet-api.jar

第七步：编译写的Java程序（实现了Servlet接口）

重点：配置环境变量CLASS_PATH=.;D:\Users\zhl36\Documents\apache-tomcat-9.0.27\lib\servlet-api.jar;

//在命令行中输入 javac -d . HelloServlet.java
public class HelloServlet implements Servlet{
        public void init(ServletConfig config) throws ServletException{                
        }
        public ServletConfig getServletConfig(){
            return null;
        }
        public void service(ServletRequest request, ServletResponse response)
                throws ServletException, IOException{
            //将信息输出在Tomcat服务器上
            System.out.println("Hello Servlet! My First Servlet APP");
            //将信息发送到浏览器上：
            // 需要使用ServletResponse接口
            // 对浏览器进行响应
            PrintWriter out = response.getWrite();
            //这个输出流，负责输出字符串到浏览器
            out.print("Hello Servlet,you are my first Servlet!");
            //不需要进行流资源的关闭，因为Tomcat已经帮助我们做过了
        }        
        public String getServletInfo(){
            return "";
        }
        public void destroy(){
        }
}

第八步：将编译后的.class文件复制到WEB-INF/classes目录下

第九步：在web.xml中编写servlet的配置信息，

    <!--servlet配置信息-->
    <!--servlet描述信息-->
    <servlet>
        <servlet-name>dasdasdasds</servlet-name>
        <!--带有包名的全限定类名 包名+类名-->
        <servlet-class>com.mysite.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--servlet映射信息-->
    <servlet-mapping>
        <servlet-name>dasdasdasds</servlet-name>
        <!--url路径以 / 开始-->
        <url-pattern>/helloServlet</url-pattern>
    </servlet-mapping>

第十步：启动Tomcat服务器

第十一步：打开浏览器，在浏览器地址栏上输入一个 url，这个URL 必须是" /项目名/web.xml中的url-pattern"
浏览器上编写的路径太复杂，可以使用超链接的形式。（在WEB-INF目录外，编写.html页面）

关于JavaEE的版本
JavaEE目前最高版本是 JavaEE8
JavaEE被Oracle捐献了，Oracle将JavaEE规范捐献给Apache了。
Apache把JavaEE换名了，以后不叫JavaEE了，以后叫做 jakarta EE。
JavaEE8版本升级之后的"JavaEE 9"，不再是"JavaEE9"这个名字了，叫做JakartaEE9

JavaEE8 的时候对应的Servlet类名是：javax.servlet.Servlet
JakarataEE9 的时候对应的Servlet类名是：jakarata.servlet.Servlet（换了包名）
意味着如果之前的项目使用的是 javax.servlet.Servlet，则项目就无法部署在Tomcat10+版本上，只能部署在Tomcat9-版本上。
Java代码可以在任何地方写，只是编译后的字节码文件必须放在webapps/crm/WEB-INF/classes目录下

向浏览器响应一段HTML代码

public void service(ServletRequest request,ServletResponse response){
//设置响应类型时，设置在响应之前才有效
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.print("<h1>hello Servlet, 你好 servlet</h1>");
}

在Servlet中连接数据库
- 在Servlet中直接编写JDBC代码

三、Javaweb-在Servlet中实现JDBC

在Servlet中编写JDBC程序连接数据库

public class StudentServlet implements Servlet{
    public void init(ServletConfig config) throws ServletException{
    }
    public ServletConfig getServletConfig(){
            return null;
    }

    public void service(ServletRequest request, ServletResponse response)
            throws ServletException, IOException{

        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet res = null;
        String sql = "select * from t_student";
        //输出在Tomcat服务器上
        System.out.println("It's My JDBC APP");
        try{
            Class.forName("com.mysql.cj.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/javaweb";
            String user = "root";
            String password = "15737979065";
            conn = DriverManager.getConnection(url,user,password);
            psmt = conn.prepareStatement(sql);
            res = psmt.executeQuery();
            while(res.next()){
                Integer no = res.getInt("no");
                String name = res.getString("name");
                System.out.println(no + "\t" + name);

                response.setContentType("text/html;charset=UTF-8"); //在浏览器上 以 html的形式输出，
                //Tomcat 响应 客户端发送的数据
                PrintWriter out = response.getWriter();
                out.println(no + "," + name + "<br>");
            }
        }catch( ClassNotFoundException | SQLException e){
            throw new RuntimeException(e);
        }finally{
            try{
                if(res != null){
                    res.close();
                }
                if (psmt != null){
                    psmt.close();
                }
                if (conn != null){
                    conn.close();
                }
            }catch(SQLException e){
                throw new RuntimeException(e);
            }
        }                
    }

    public String getServletInfo(){
        return "";
    }

    public void destroy(){
    }
}

在crm/WEB-INF/web.xml中

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                  http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0"
metadata-complete="true">
<servlet>
    <servlet-name>servletQuick</servlet-name>
    <servlet-class>com.mysite.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>servletQuick</servlet-name>
    <url-pattern>/helloservlet</url-pattern>
</servlet-mapping>

<servlet>
    <servlet-name>servletJDBC</servlet-name>
    <servlet-class>com.mysite.servlet.StudentServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>servletJDBC</servlet-name>
    <url-pattern>/student/List</url-pattern>
</servlet-mapping>
</web-app>

在crm/index.html中 //静态资源文件放在 WEB-INF 目录下

<!doctype html>
<html>
<head>
    <title>my Servlet</title>
</head>
<body>
    <!--可以以超链接的形式 访问 url路径-->
    <a href="/crm/helloservlet">hello servlet</a>
    <br>
    <a href="/crm/student/List">servlet JDBC</a>
</body>
</html>

四、Javaweb-servlet生命周期

Servlet 对象是由谁来维护的？
- Servlet对象的创建，对象上方法的调用，对象的销毁Javaweb程序员是无权干预的
- Servlet对象的生命周期是由Tomcat服务器（WEB Server）负责的
- Tomcat服务器通常我们又称为：WEB容器。
自己创建的Servlet对象是否受WEB容器的管理？
- 自己创建的Servlet对象是不受WEB容器管理的。
- WEB容器创建的Servlet对象，这些Servlet对象都会被放到一个集合当中（HashMap）,只有放到这个HashMap集合中的Servlet才能被WEB容器管理
- web容器底层应该有一个HashMap这样的集合，在这个集合当中存储了Servlet对象和请求路径之间的关系
Servlet对象生命周期
- 默认情况下服务器启动的时候AServlet对象并没有实例化
- 在用户发送第一次请求时，控制台输出了以下内容
```
Aservlet的 无参构造方法执行了
Aservlet's init method execute
Aservlet's service method execute
```
- 用户在发送第一次请求的时候Servlet对象被实例化（AServlet的构造方法被执行了。并且执行的是无参数构造方法）
- AServlet对象被创建出来以后，Tomcat就执行了 init 和 service 方法
- 用户继续发送请求，输出的内容是一直是 service 方法
  1. 说明Servlet对象是单实例的（但是Servlet类并不符合单例模式。因为servlet对象的创建是属于Tomcat管理的，我们称之为假单例模式，真单例模式的构造方法是私有化的）
  2. 无参数构造方法，init 方法只在用户发送请求时执行，也就是说无参数构造方法执行一次。
  3. 用户发送每一次请求，服务器就调用一次service方法
- 关闭服务器的时候，控制台输出了以下内容
```
Aservlet's destroy method execute
```
- Servlet的destroy方法只被Tomcat调用一次，且在服务器关闭的时候。因为服务器关闭前要销毁Aservlet对象的内存，在销毁之前，Tomcat服务器会自动调用Aservlet对象的destroy方法。

在实现了Servlet类中，不能添加有参构造方法。否则在服务器获取请求时，无法实例化servlet对象。报500 错误。

由于无参构造方法和 init 方法同时执行且执行一次，但是一般不将init中的代码写在构造方法中，不建议编写无参数构造方法，容易被覆盖，导致Servlet对象无法实例化。所以init方法是有存在的必要的。

五、JavaWeb-GenericServlet-ServletConfig

我们直接编写一个Servlet类实现Servlet接口的缺点是很多方法大部分情况是不需要使用的。

通过适配器设计模式，抽象的GenericServlet类，GenericServlet类实现了Servlet接口，并且将经常调用的service方法，设为抽象方法。方便让子类直接实现服务，且不容易使代码冗余。同时在GenericServlet类中定义了 init 方法进行重载，方便在子类中重写init方法，且不影响ServletConfig。

ServletConfig

ServletConfig接口在 javax.servlet.ServletConfig下也是Servlet规范下的成员，实现了这个接口的全类名是 org.apache.catalina.core.StandardWrapperFacade@5c282d31
说明是Tomcat服务器实现了ServletConfig接口

ServletConfig对象是谁创建的？在什么时候创建的？
- 是由web服务器创建的，web服务器在 WEB-INF/web.xml 中servlet-class 通过反射创建Servlet对象，同时创建ServletConfig对象，以形参传入init方法
  ServletConfig接口中有四个方法
public String getServletName()
public Enumeration<String> getServletParameterNames()：获取所有的初始化参数name。
public String getServletParameter(String name)：通过初始化参数name 获取对应的value 。
public ServletContext getServletContext()

ServletConfig对象封装了标签内的信息(web.xml 文件下的 servlet配置信息) GenericServlet抽象类实现了ServletConfig接口，可以直接调用方法

六、ServletContext-应用域

ServletContext是接口，也是Servlet规范中的一员是由Tomcat服务器创建的。

ServletContext 被称为servlet对象的上下文对象，也就是说 ServletContext对象对应的其实就是整个web.xml文件。

Tomcat是一个容器，一个容器中可以存放多个webapp(项目)，一个webapp对应一个ServletContext对象。
ServletContext接口中常用的方法：

public String getInitParameter(String name);
通过初始化参数值name 获取 value 值
public Enumeration<String> getInitParameterNames();
获取所有的初始化参数 name

<!--以上两个方法是ServletContext对象的方法。获取到的 参数值是 <context-param></context-param>标签内的配置信息-->
<context-param>
    <param-name>pageSize</param-name>
    <param-value>10</param-value>
</context-param>
<context-param>
    <param-name>startIndex</param-name>
    <param-value>0</param-value>
</context-param>
<!--注意：以上配置信息属于应用级（全局）的配置信息，一般一个项目中共享的配置信息会放到以上的标签中-->
<!--例如一个 webapp中，对所有的servlet 进行分页管理-->

这两个方法与 ServletConfig 对象的方法的区别：

方法体一样
获取参数的范围不一样
ServletConfig 获取的是 \\ 标签里的配置信息，一个Servlet的配置
ServletContext 获取的是 \\ 标签里的配置信息，全局的配置

public String getContextPath();
获取应用的根路径，webapp的项目名。因为在java源代码中有一些地方可能会需要应用的根路径，这个方法可以动态获取应用的根路径。
public String getRealPath();
获取文件的绝对路径（真实路径）
public void setAttribute(String name,Object name);
存（怎么向ServletContext应用域中存数据）
public Object getAttribute(String name);
取（怎么向ServletContext应用域中取出数据）
public void removeAttribute(String name);
删（怎么删除ServletContext应用域中的数据）

七、HTTP 协议

注意：我们编写Servlet类的时候，实际上是不会去直接继承GenericServlet类的，因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的，在Servlet规范当中，提供了一个类叫做HttpServlet，它是专门为HTTP协议准备的一个Servlet类。我们编写Servlet类要继承HttlServlet。（HttpServlet是HTTP协议专用的。）使用HttpSevlet处理HTTP协议更便捷。

HTTP 协议

HTTP协议是W3C规定的一种超文本传输协议。

这种协议游走在B和S之间。B向S 发送数据要遵循HTTP协议。S向B发数据同样需要遵循HTTP协议。这样B和S才能解耦合。

Http请求报文

包括四部分: 请求行、请求头、空白行、请求体。

Http请求协议的报文：GET请求

请求行 GET /servlet05/getServlet?username=zhou&userpwd=aaa HTTP/1.1                        
请求头 Accept:                                                                             
    text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
    Accept-Encoding: gzip, deflate, br
    Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
    Connection: keep-alive
    Cookie: _ga=GA1.1.1091204702.1668316984; Idea-b072d93f=67a4ee35-90f4-4412-b35a-352c8eab454a; Idea-b072d57d=177f58c8-4517-4b53-8f89-29cf02b35de8
    Host: localhost:8080
    Referer: http://localhost:8080/servlet05/index.html
    Sec-Fetch-Dest: document
    Sec-Fetch-Mode: navigate
    Sec-Fetch-Site: same-origin
    Sec-Fetch-User: ?1
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36
    sec-ch-ua: "Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"
    sec-ch-ua-mobile: ?0
    sec-ch-ua-platform: "Windows"
空白行                                            
请求体

get请求无请求体

Http请求协议的报文：POST请求

请求行 POST /servlet05/postServlet HTTP/1.1                                                                        
请求头 Accept:                                                                        
    text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
    Accept-Encoding: gzip, deflate, br
    Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
    Cache-Control: max-age=0
    Connection: keep-alive
    Content-Length: 25
    Content-Type: application/x-www-form-urlencoded
    Cookie: _ga=GA1.1.1091204702.1668316984; Idea-b072d93f=67a4ee35-90f4-4412-b35a-352c8eab454a; Idea-b072d57d=177f58c8-4517-4b53-8f89-29cf02b35de8
    Host: localhost:8080
    Origin: http://localhost:8080
    Referer: http://localhost:8080/servlet05/index.html
    Sec-Fetch-Dest: document
    Sec-Fetch-Mode: navigate
    Sec-Fetch-Site: same-origin
    Sec-Fetch-User: ?1
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36
    sec-ch-ua: "Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"
    sec-ch-ua-mobile: ?0
    sec-ch-ua-platform: "Windows"
空白行                             
请求体 username=zhou&userpwd=aaa

请求行 有三部分

第一部分：请求方式(7种)
get(常用的) post(常用的) delete put head trace options
第二部分：URI (统一资源标识符)
代表网路中某个资源的名字。但是通过URI是无法定位资源的 (URL 统一资源定位符，代表网络中某个资源，通过URL是可以定位到该资源的)

URL包括URI, 比如 URL:http:localhost:8080/servlet05/index.html
URI: /servlet05/index.html
第三部分：HTTP协议的版本号

请求头

请求的主机、主机的端口、浏览器信息、平台信息、cookie信息

空白行

用来区分"请求头"和"请求体"的

请求体

向服务器发送的具体数据（post请求）

HTTP响应报文

Http响应协议包括四部分：状态行、响应头、空白行、响应体

Http响应协议的报文

状态行 HTTP/1.1 200 OK
响应头 Content-Type: text/html;charset=UTF-8
    Content-Length: 178
    Date: Wed, 11 Oct 2023 02:37:02 GMT
空白行                     
响应体 <!doctype html>                                            
     <html>
        <head>
            <title>from get Servlet</title>
        </head>
        <body>
            <h1>from get Servlet</h1>
        </body>
     </html>

状态行 有三部分

第一部分：协议版本号（HTTP/1.1）
第二部分：状态码
第三部分：状态的描述信息
ok 表示正常成功结束
not found表示资源找不到

响应头

响应内容的类型、长度、时间

空白行

用来分隔"响应头"和"响应体"的

响应体

响应体是响应的正文

状态码信息

200表示请求响应成功，正常结束；404表示访问的资源不存在，可能是路径写错了，可能是对应的服务器中的资源没有启动成功。405表示前端发送的请求方式与后端请求的处理方式不一致时发生；比如前端是POST请求，后端的处理方式按照get方式处理，发生405，500表示服务端的程序出现了异常。一般会认为是服务器端的错误造成的
以4开始的，一般是浏览器端的错误导致的
以5开始的，一般是服务器端的错误导致的

八、GET-POST

GET请求与POST请求的区别
发送报文的格式

get请求发送数据的时候，数据后放在URI的后面，并且在URI后面添加一个?，?后面是数据，这样会导致发送的数据回显到浏览器的地址栏上

http:localhost:8080/servlet05/getServlet?username=zhou&userpwd=sss
post请求发送数据的时候，在请求体当中发送。不会回显到浏览器的地址栏

发送数据的规范

get请求只能发送普通的字符串，并且发送的字符串长度有限制，不同的浏览器限制不同，这个没有明确的规范
post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息。

数据量限制

get请求无法发送大数据量
post请求可以发送大数据量，理论上没有长度限制

数据传输的方式

get请求一般从服务器端获取数据。
post请求一般向服务器端发送数据。

是否是安全的

get请求是安全的，get请求只是为了从服务器上获取数据。不会对服务器造成威胁
post请求是危险的，因为post请求是向服务器提交数据，如果这些数据通过后门的方式进入到服务器当中，服务器是很危险的。另外post请求是为了提交数据，所以一般情况下拦截请求的时候，大部分会拦截（监听）post请求

是否支持缓存：

get请求支持缓存
- 任何一个get请求最终的"响应结果"都会被浏览器缓存起来。在浏览器缓存当中：
  一个get请求的路径对应一个资源
  实际上，你只要发送get请求，浏览器都会先从本地浏览器的缓存中找，找不到的时候才会去服务器上获取。这种缓存机制是为了提高用户的体验
- 有这样的需求，我们不希望get请求走缓存，怎么办？怎么避免走缓存？我希望每一次get请求都去服务器上找资源，不想从本地的浏览器缓存中获取
  - 只要每一次get请求的请求路径不同即可
  - 可以在get路径后面添加一个每时每刻都在变化的”时间戳“，这样，每一次的请求路径都不一样，浏览器就不走缓存了。
post请求不支持缓存

GET请求和POST请求如何选择？什么时候使用GET请求？什么时候使用POST请求？

如何选择取决于这个请求是想从服务器端获取数据，还是想向服务器端发送数据。如果是想从服务器上获取数据，建议使用GET请求，如果想向服务器提交发送数据，建议使用POST请求。
如果表单中有敏感信息，建议使用POST请求，因为get请求会回显敏感信息到浏览器地址栏上。(例如：密码信息)
不管是POST请求还是GET请求，发送的请求数据的格式是完全相同的，只不过位置不同，格式都是统一的：

九、HttpServlet

HttpServlet 底层使用了模板方法设计模式，

HttpServlet类是专门为HTTP协议准备的。比GenericServlet更加适合HTTP协议下的开发

HttpServlet的全类名 javax.servlet.http.HttpServlet

http包下主要的类和接口，即 javax.servlet.http.*

javax.servlet.http.HttpServlet（Http协议专用的Servlet类，抽象类）
javax.servlet.http.HttpServletRequest（Http协议专用的请求对象）
javax.servlet.http.HttpServletResponse（Http协议专用的响应对象）

HttpServletRequest对象种封装了什么信息？
- HttpServletRequest，简称request对象
- HttpServletRequest中封装了HTTP协议的全部内容
- Tomcat服务器(WEB服务器)将"请求协议"中的数据全部解析出来，然后将这些数据全部封装到request对象当中了
- 也就是说，我们可以通过HttpServletRequest，就可以获取协议中的全部数据
HttpServletResponse对象是专门用来响应HTTP协议到浏览器

HttpServlet源码分析

public class HelloServlet extends HttpServlet{
    //通过无参数构造方法创建对象
    public HelloServlet(){
    }
}

public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {
     //用户第一次发送请求，HelloServlet对象第一次创建之后，这个init方法会执行
     public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
    //用户第一次请求的时候，带有参数的init方法会调用无参的init方法
    public void init() throws ServletException {
    }    
} 

public class HttpServlet extends GenericServlet{
    //用户发送第一次请求的时候这个service会执行
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {
        HttpServletRequest  request;
        HttpServletResponse response;

        try {
        //将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        service(request, response);
    }

    //该方法service就是模板方法
    //在该方法中定义核心算法骨架，由子类具体实现
    protected void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        //获取请求方式 request.getMethod();
        //doGet,doPost...等方法需要后端程序员重写，与前端的请求方式一致
        //如果前端发送请求的方式是 get ，后端程序员重写 doPost方法，报405 错误
        //也就是说，如果在HttpServlet类中执行了doGet或doPost方法（未重写），必然报405     
        doGet(request,response);
        doPost(request,response);
        doPut(request,response);
        ...
    }
}

十、HttpServletRequest-请求域

HttpServletRequest 是一个接口，全限定名：javax.servlet.http.HttpServletRequest
HttpServletRequest接口是Servlet规范中的一员, HttpServletRequest的父接口是 ServletRequest，

HttpServletRequest对象是Tomcat服务器负责创建的。封装了HTTP请求协议，Tomcat服务器将HTTP协议中的信息以及数据全部解析出来，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中，传给了javaweb程序员

request和response对象的生命周期？
- request 和 response 这两个对象只在当前请求或响应中有效

HttpServletRequest接口中常用的方法

public Map<String, String[]> getParameterMap();
将前端获取的数据存放在Map集合中，因为key对应的value可能有多个，所以用String[]表示
public Enumeration<String> getParameterNames();
获取所有的key
public String[] getParameterValues(String name);
根据key获取所有的values
public String getParameter(String name);
根据key获取数组的第一个元素，这个方法最常用

request对象实际上又称为"请求域"对象（ServletContext是"应用域"）
ServletContext当中有三个操纵域的方法：

public void setAttribute(String name,Object obj);    //向域中绑定数据 设置key 和 value
public Object getAttribute(String name);             //向域中根据name 获取数据value
public void removeAttribute(String name);            //将域中绑定的数据移除 根据key移除
//以上操作类似于map集合
Map<String,Object> map;    
map.put("name",obj);         //向map集合中存放key 和 value
Object obj = map.get("name");//根据key 获取 map集合中的value
map.remove("name");          //通过Map集合中的key删除key 和 value这个键值对

"请求域"对象要比"应用域"对象范围小很多，生命周期短很多。请求域只在一次请求内有效。一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就结束了。

尽量使用小的域对象，因为小的域对象占用的资源较少

两个RequestServlet怎么共享数据？

可以将数据发送到ServletContext应用域当中，但是应用域范围太大，占用资源太多。不建议使用。
可以将数据发送到ServletRequest请求域当中，然后AServlet转发到BServlet，保证AServlet和BServlet在同一个请求中，这样就可以做到两个Servlet,或者多个Servlet共享同一份数据。