Servlet知识点总结（非常详细全面）

系统架构

C/S架构

C/S指的是Client/Server架构，即客户端和服务器架构，下载的QQ客户端或者爱奇艺客户端等都是采用的这种架构。
该架构的优点是：
1、安全稳定，大量的缓存数据存储在客户端上，即使服务器端遭到破坏，也不会影响到客户端的数据。
2、速度快：软件中的大部分数据是存储在客户端软件中的，很少有数据从服务器端传来。
3、服务器压力小：因为数据交互较少，大部分数据在本地
4、界面酷炫
该架构缺点是：
1、升级维护较差，有一些软件较难安装
**一般的应用场景：**大型的游戏，娱乐性的软件

B/S架构（我们学习的重点）

B/S架构指的是Browser/Server架构，即浏览器和服务器架构，只需要一个浏览器，在网页上输入某一个应用的url，就可以访问到对应的应用资源，如QQ网页版、爱奇艺网页版等。
该架构的优点是：
1、升级维护方便，成本较低
2、不需要安装特定的软件
缺点是：
1、不够安全，数据大部分存储在服务器端，意外情况下数据全部丢失
2、服务器压力大，因为服务器存储大量数据而且数据交互很频繁
3、画面不够酷炫
**一般的应用场景：**公司内部的业务软件，不需要页面很酷炫，维护成本低，只需要数据的维护即可

JavaEE、JavaSE、JavaME

JavaSE是java标准被，也是基础，一些基本语法，数据类型，IO、反射机制、面向对象都是JavaSE内容。
JavaEE是java企业版，也是一套类库，但是是用来给企业完成项目用的。
JavaME是Java微型版，也是一套类库，用于电子微型设备内部程序开发。

B/S架构通信原理

WEB系统的访问过程

1、打开浏览器
2、输入一个网址
3、域名解析器（DNS）将网址转成对应的IP地址
4、通过该 IP 地址来建立 TCP 连接
5、发送http请求
6、通过端口号和访问资源名称定位要访问的资源，服务器处理请求
7、服务器响应（生成http响应并返回）
8、浏览器接受和解析响应
9、浏览器渲染响应
10、关闭TCP连接

关于域名

网址：https://www.baidu.com/
域名：www.baidu.com
url（统一资源定位符）：通过DNS将https://www.baidu.com/ 解析为一个url即http://110.242.68.3:80/index.html
IP地址：http://110.242.68.3:80/index.html 中110.242.68.3为IP地址，一个终端设备设备对应一个IP地址，服务器业是
端口号：http://110.242.68.3:80/index.html 中80为端口号，访问服务器中具体的某一个应用，用端口号区分
协议：http为通信协议

配置Tomcat服务器

Tomat是一种用java写的轻量级的WEB服务器，下载地址为：
Tomcat官网地址
下载完之后需要配置环境（JDK根目录和Tomcat服务器的根都是必须要的）：
JAVA_HOME=C:\Program Files\Java\jdk-17.0.1
CATALINA_HOME=D:\dev\Tomcat\apache-tomcat-9.0.87
PATH=%JAVA_HOME%\bin
PATH= %CATALINA_HOME%\bin
tomcat服务器就是Java语言写的，既然是java语言写的，那么启动Tomcat服务器就是执行main方法。

B/S架构参与的角色以及协议

Servlet

为什么需要Servlet？

webapp只有遵循Servlet规范，才能在不同的服务器下运行。

Servlet的实现机制

示意图：

假设用Scanner输入要访问的Servlet的名称作为key（其实包含在http请求中），通过查询配置文件中的key-value找到对应的Servlet的地址。假设web.properties中是以下内容：
这个propertiesties就相当于web.xml，包含请求和Servlet的映射关系

/aaaa=com.bjpowernode.servlet.UserListServlet
/bbbb=com.bjpowernode.servlet.UserLoginServlet
/cccc=com.bjpowernode.servlet.BankServlet

下面是具体的几个Servlet：

import javax.servlet.Servlet;

// 充当的角色发生了改变:webapp开发者
// 只要是我们webapp开发者写的XXXServlet都要实现Servlet接口
public class BankServlet implements Servlet{
	public void service(){
		System.out.println("BankServlet's service...");
	}
}
public class UserListServlet implements Servlet{
	public void service(){
		System.out.println("UserListServlet's service...");
	}
}
public class UserLoginServlet implements Servlet{
	public void service(){
		System.out.println("UserLoginServlet's service...");
	}
}

以下为Tomcat执行的主函数：

import java.util.Scanner;
import java.util.Properties;
import java.io.FileReader;
import javax.servlet.Servlet;

// 以下为Tomcat执行的主函数
public class Tomcat{
	public static void main(String[] args) throws Exception{
		System.out.println("Tomcat服务器启动成功，开始接收用户的访问。");
		// 简单的使用Scanner来模拟一下用户的请求
		// 用户访问服务器是通过浏览器上的“请求路径”
		// 也就是说用户请求路径不同，后台执行的Servlet不同。
		/*
			/userList    UserListServlet
			/login		 UserLoginServlet
			/bank		 BankServlet
			......
		*/
		System.out.print("请输入您的访问路径：");
		Scanner s = new Scanner(System.in);

		// 用户的请求路径  /bbbb
		String key = s.nextLine(); // Tomcat服务器已经获取到了用户的请求路径了。

		// Tomcat服务器应该通过用户的请求路径找对应的XXXServlet
		// 请求路径和XXXServlet之间的关系应该由谁指定呢？
		// 对于Tomcat服务器来说需要解析配置文件
		FileReader reader = new FileReader("web.properties");
		Properties pro = new Properties();
		pro.load(reader);
		reader.close();

		// 通过key获取value
		String className = pro.getProperty(key);
		// 通过反射机制创建对象
		Class clazz = Class.forName(className);
		Object obj = clazz.newInstance(); // obj的类型对于Tomcat服务器开发人员来说不知道。
		
		// Tomcat服务器的开发者知道，你写的XXXXServlet一定实现了Servlet接口
		Servlet servlet = (Servlet)obj;
		//访问Servlet一定会调用service()，是因为Tomcat主函数里写死了
		servlet.service();
	}
}

开发一个带有Servlet的小程序

创建项目

File–New Project–Empty Project–命名

项目配置

File – Project Structrue – Dependencies–Modules – + 加号 – Add JARS.
将apache-tomcat-9.0.87\lib\servlet-api.jar和jsp-api.jar添加到classpath当中

创建模块

File–Module–Empty Project–命名

配置模块

让Module变成JavaEE的模块。（让Module变成webapp的模块。符合webapp规范。符合Servlet规范的Module）
在Module上点击右键：Add Framework Support…（添加框架支持）
在弹出的窗口中，选择Web Application（选择的是webapp的支持）
选择了这个webapp的支持之后，IDEA会自动给你生成一个符合Servlet规范的webpp目录结构。
重点，需要注意的：在IDEA工具中根据Web Application模板生成的目录中有一个web目录，这个目录就代表webapp的根

配置tomcat环境

点击IDEA右上角add configuration

选择Tomcat Server下的local

将JDBC的jar包放入到lib文件夹下

学过JDBC的都知道，我们连接数据库的第一步需要先建立驱动：
Class.forName(“com.mysql.cj.jdbc.Driver”);
新版本中建议使用：com.mysql.cj.jdbc.Driver驱动。
点击这里下载mysql-connector的jar包

写Servlet代码用来和数据库建立连接

都是JDBC里面老生常谈的六步，不懂的自行百度

import jakarta.servlet.Servlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.ServletConfig;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;


public class StudentServlet implements Servlet{

    public void init(ServletConfig config) throws ServletException{

    }

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

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        // 编写JDBC代码，连接数据库，查询所有学生信息。
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try{
            // 注册驱动 （com.mysql.jdbc.Driver，这个已过时。）
            // 新版本中建议使用：com.mysql.cj.jdbc.Driver驱动。
            //反射机制加载驱动，也就是加载驱动中静态代码块，以便在后续的数据库操作中可以使用该驱动程序
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 获取连接
            String url = "jdbc:mysql://localhost:3306/bjpowernode";
            String user = "root";
            String password = "root";
            //获取连接器
            conn = DriverManager.getConnection(url,user,password);
            // 获取预编译的数据库操作对象
            String sql = "select no,name from t_student";
            //获取执行平台
            ps = conn.prepareStatement(sql);
            // 执行SQL
            rs = ps.executeQuery();
            // 处理查询结果集
            while(rs.next()){
                String no = rs.getString("no");
                String name = rs.getString("name");
                //System.out.println(no + "," + name);
                out.print(no + "," + name + "<br>");
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            // 释放资源
            if(rs != null){
                try{
                    rs.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(ps != null){
                try{
                    ps.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }

    public void destroy(){

    }

    public String getServletInfo(){
        return "";
    }

    public ServletConfig getServletConfig(){
        return null;
    }
}

在web.xml文件中完成StudentServlet类的注册。

web.xml在WEB-INF文件夹下面，配置的目的是把请求路径和Servlet之间对应起来
/servlet/student就是URL请求路径中内容，比如http://localhost:8080/mywebapp/servlet/student这个请求就会映射到相应的Servlet中，这里也就是mywebapp的src下的com.bjpowernode.javaweb.servlet.StudentServlet，去执行StudentServlet中的相关代码。
当然也可以是html页面中的超链接发送请求。

<?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">

    <servlet>
        <servlet-name>studentServlet</servlet-name>
        <servlet-class>com.bjpowernode.javaweb.servlet.StudentServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>studentServlet</servlet-name>
        <url-pattern>/servlet/student</url-pattern>
    </servlet-mapping>
    
</web-app>

如果是超链接链接到这个Servelet

给一个html页面，在HTML页面中编写一个超链接，用户点击这个超链接，发送请求，Tomcat执行后台的StudentServlet。
这个文件不能放到WEB-INF目录里面，只能放到WEB-INF目录外面。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>student page</title>
  </head>
  <body>
    <!--这里的项目名是 /xmm ，无法动态获取，先写死-->
    <a href="/mywebapp/servlet/student">student list</a>
  </body>
</html>

IDEA工具去关联Tomcat服务器

关联的过程当中将webapp部署到Tomcat服务器当中。
■ IDEA工具右上角，绿色小锤子右边有一个：Add Configuration
■ 左上角加号，点击Tomcat Server --> local
■ 在弹出的界面中设置服务器Server的参数（基本上不用动）
■ 在当前窗口中有一个Deployment（点击这个用来部署webapp），继续点击加号，部署即可。
■ 修改 Application context为：/mywebapp

启动Tomcat服务器

■ 在右上角有绿色的箭头，或者绿色的小虫子，点击这个绿色的小虫子，可以采用debug的模式启动Tomcat服务器。
■ 我们开发中建议适用debug模式启动Tomcat

访问该app

打开浏览器，在浏览器地址栏上输入：http://localhost:8080/xmm/student.html

Servlet对象的生命周期

定义

Servlet对象的生命周期指的是Servlet从创建到销毁的全过程，这个过程由Tomcat全权负责，程序员无权干预。

Servlet的创建

1、Tomcat服务器通常我们又称为：WEB容器。（WEB Container）。
2、我们自己new创建的Servlet对象是不受WEB容器管理的，只有WEB容器创建的对象才收其控制，其创建的Servlet都被保存在一个HashMap集合当中。
3、Servlet中提供一个无参数的构造方法，只有在用户发送请求的时候，Servlet才会被实例化，服务器启动的时候并不会。这样做的原因是：在没有发送请求之前，没有调用Servlet对象，这个时候创建出来是在浪费资源。
4、如果一定要在启动Tomcat的时候创建Servlet对象，可以在web.xml中配置子标签， 1中数字越小，优先级越高：

<servlet>
    <servlet-name>aservlet</servlet-name>
    <servlet-class>com.bjpowernode.javaweb.servlet.AServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>aservlet</servlet-name>
    <url-pattern>/a</url-pattern>
</servlet-mapping>

Servlet对象的生命周期的几个过程

1、用户在发送第一次请求的时候Servlet被实例化。
2、Servlet对象一旦被创建出来，Tomcat服务器马上调用该对象的init()方法。
3、init()方法执行之后，Tomcat服务器马上调用service()方法。
4、用户发在发送完第一次请求后，Servlet对象并没有新建，还是使用之前创建好的Servlet对象，直接调用该Servlet对象的service方法。只要用户发送一次请求：service方法必然会被Tomcat服务器调用一次。发送100次请求，service方法会被调用100次。所以类似于单例模式，但也区别于单例模式，因为真正的单例模式构造方法是私有化的。
5、关闭服务器的时候，Servlet的destroy方法在Servlet销毁之前被调用一次。

Servelet的一生

无参构造：（调用一次，标志着Servlet出生）
init()方法：（调用一次，标志着Servlet正在接受教育）
service()：（用户发送一次请求则执行一次，发送N次请求则执行N次。标志着Servlet出生）
destroy()方法：（调用一次，标志着Servlet死亡）

注意点

1、当我们Servlet类中编写一个有参数的构造方法，如果没有手动编写无参数构造方法，会报错：500
■ 注意：500是一个HTTP协议的错误状态码。
■ 500一般情况下是因为服务器端的Java程序出现了异常。（服务器端的错误都是500错误：服务器内部错误。）
■ 如果没有无参数的构造方法，会导致出现500错误，无法实例化Servlet对象。
■ 所以，一定要注意：在Servlet开发当中，不建议程序员来定义构造方法，因为定义不当，一不小心就会导致无法实例化Servlet对象。
2、不建议程序员手动重写构造方法，因为很容易导致Servlet无法实例化
3、 使用最多就是service方法，service方法是一定要实现的，因为service方法是处理用户请求的核心方法。
4、通常在init方法当中做初始化操作，并且这个初始化操作只需要执行一次
5、 通常在destroy方法当中，进行资源的关闭。马上对象要被销毁了，还有什么没有关闭的，抓紧时间关闭资源。还有什么资源没保存的，抓紧时间保存一下。

适配器模式改造Servlet

为什么要用适配器改造Servlet

因为如果面向接口直接编程，需要重写接口中的所有方法，但大部分时候我们只需要重写service()方法。再重写init()、destory()方法，代码会显得很累赘。因此我们可以写一个GenericServlet抽象类实现Servlet的所有方法，然后面向这个GenericServlet编写我们需要的Servlet，这个时候我们自己的Servlet只重写service()方法是被允许的。

GenericServlet代码：

import jakarta.servlet.*;
import java.io.IOException;

/**
 * 编写一个标准通用的Servlet，起名：GenericServlet
 * 以后所有的Servlet类都不要直接实现Servlet接口了。
 * 以后所有的Servlet类都要继承GenericServlet类。
 * GenericServlet 就是一个适配器。
 */
public abstract class GenericServlet implements Servlet {

    // 成员变量
    private ServletConfig config;

    /**
     * init方法中的ServletConfig对象是小猫咪创建好的。
     * 这个ServletConfig对象目前在init方法的参数上，属于局部变量。
     * 那么ServletConfig对象肯定以后要在service方法中使用，
	 * 怎么才能保证ServletConfig对象在service方法中能够使用呢？
     */
    @Override
    public final void init(ServletConfig config) throws ServletException {
        //System.out.println("servletConfig对象，小猫咪创建好的：" + config);
        this.config = config;
        // 调用init()方法
        this.init();
    }

    /**
     * 这个init方法是供子类重写的。
     */
    public void init(){

    }

    @Override
    public ServletConfig getServletConfig() {
        return config;
    }

    /**
     * 抽象方法，这个方法最常用。所以要求子类必须实现service方法。
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    public abstract void service(ServletRequest servletRequest, ServletResponse servletResponse)
            throws ServletException, IOException;

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

我们发现GenericServlet还有一个私有变量 private ServletConfig config;这个变量是Tomcat在创建我们自己的Servlet实例的时候创建并且传递给init()方法的，如果想要调用，可以调用Servlet对象中的getServletConfig()方法,继承GenericServlet的子类也可以通过this.getServletConfig()直接调用到config对象：

public class Tomcat {
    public static void main(String[] args){
        // .....
        // Tomcat服务器伪代码
        // 创建LoginServlet对象（通过反射机制，调用无参数构造方法来实例化LoginServlet对象）
        Class clazz = Class.forName("com.bjpowernode.javaweb.servlet.LoginServlet");
        Object obj = clazz.newInstance();
        
        // 向下转型
        Servlet servlet = (Servlet)obj;
        
        // 创建ServletConfig对象
        // Tomcat服务器负责将ServletConfig对象实例化出来。
        // 多态（Tomcat服务器完全实现了Servlet规范）
        ServletConfig servletConfig = new org.apache.catalina.core.StandardWrapperFacade();
        
        // 调用Servlet的init方法
        servlet.init(servletConfig);
        
        // 调用Servlet的service方法
        // ....
        
    }
}

ServletConfig接口详解

1、ServletConfig是Servlet对象的配置信息对象。
以下是web.xml文件中的一部分，标签中的是初始化参数。这个初始化参数信息会自动被Tomcat封装到ServletConfig对象当中，可以通过
public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration getInitParameterNames(); // 获取所有的初始化参数的name
这俩方法获取到

 <servlet>
 *         <servlet-name>configTest</servlet-name>
 *         <servlet-class>com.bjpowernode.javaweb.servlet.ConfigTestServlet</servlet-class>
 *         <!--这里是可以配置一个Servlet对象的初始化信息的。-->
 *         <init-param>
 *             <param-name>driver</param-name>
 *             <param-value>com.mysql.cj.jdbc.Driver</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>url</param-name>
 *             <param-value>jdbc:mysql://localhost:3306/bjpowernode</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>user</param-name>
 *             <param-value>root</param-value>
 *         </init-param>
 *         <init-param>
 *             <param-name>password</param-name>
 *             <param-value>root1234</param-value>
 *         </init-param>
 *     </servlet>

2、ServletConfig中封装了web.xml中关于Servlet的配置信息。
3、一个Servlet对应一个ServletConfig对象。
4、Servlet是Tomcat创建的，ServletConfig也是Tomcat创建的，传递给init()方法。
5、ServletConfig中的常见方法有以下四个，可以直接在继承GenericServlet的类上调用，如:
ServletConfig config = this.getServletConfig();//先获取config对象
config.getInitParameter(String name)

public String getInitParameter(String name); // 通过初始化参数的name获取value
public Enumeration<String> getInitParameterNames(); // 获取所有的初始化参数的name
public ServletContext getServletContext(); // 获取ServletContext对象
public String getServletName(); // 获取Servlet的name

6、Tomcat解析web.xml文件，将web.xml文件中标签中的配置信息自动包装到ServletConfig对象中。
7、获取ServletContext对象的两种方式：
方式一：ServletContext application = config.getServletContext();//通过ServletConfig对象获取ServletContext对象。
方式二： ServletContext application2 = this.getServletContext();//通过this也可以直接获取ServletContext对象。

继承GenericServlet的ConfigTestServlet 的代码：

import jakarta.servlet.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;


public class ConfigTestServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        // 获取ServletConfig对象
        ServletConfig config = this.getServletConfig();
        // 输出该对象
        // org.apache.catalina.core.StandardWrapperFacade@aea0d43
        out.print("ServletConfig对象是：" + config.toString());
        out.print("<br>");

        // 获取<servlet-name></servlet-name>
        String servletName = config.getServletName();
        out.print("<servlet-name>"+servletName+"</servlet-name>");
        out.print("<br>");

        // 通过ServletConfig对象的两个方法，可以获取到web.xml文件中的初始化参数配置信息。
        // java.util.Enumeration<java.lang.String>	getInitParameterNames() 获取所有的初始化参数的name
        Enumeration<String> initParameterNames = config.getInitParameterNames();
        // 遍历集合
        while(initParameterNames.hasMoreElements()) { // 是否有更多元素
            String parameterName = initParameterNames.nextElement(); // 取元素
            String parameterVal = config.getInitParameter(parameterName); // 通过name获取value
            out.print(parameterName + "=" + parameterVal);
            out.print("<br>");
        }
        // java.lang.String	getInitParameter(java.lang.String name) 通过初始化参数的name获取value
        /*String driver = config.getInitParameter("driver");
        out.print(driver);*/

        // 实际上获取一个Servlet对象的初始化参数，可以不用获取ServletConfig对象。直接通过this也可以。
        Enumeration<String> names = this.getInitParameterNames();
        while(names.hasMoreElements()){
            String name = names.nextElement();
            String value = this.getInitParameter(name);
            // 打印到后台
            System.out.println(name + "=" + value);
        }

        // 怎么获取ServletContext对象呢？
        // 第一种方式：通过ServletConfig对象获取ServletContext对象。
        ServletContext application = config.getServletContext();
        // 输出
        out.print("<br>" + application); //org.apache.catalina.core.ApplicationContextFacade@19187bbb

        // 第二种方式：通过this也可以获取ServletContext对象。
        ServletContext application2 = this.getServletContext();
        out.print("<br>" + application2); //org.apache.catalina.core.ApplicationContextFacade@19187bbb
    }
}

ServletContext接口

1、ServletContext和ServletConfig是包含关系，如果说ServletConfig配置了一个Servlet的信息，一个webapp是由很多个Servlet组成的，那么ServletContext就配置了多个Servlet共有的全局信息也就是web.xml。
2、对于一个webapp而言，ServletContext只有一个。
3、Tomcat是一个容器，一个容器当中可以放多个webapp，一个webapp对应一个ServletContext对象。
4、ServletContext同样也是Tomcat在WEB服务器启动的时候创建的，在服务器关闭的时候销毁。
5、放在ServletContext对象当中的数据，所有Servlet一定是共享的。比如：一个教室中的空调是所有学生共享的，一个教室中的语文老师是所有学生共享的。
6、ServletContext中的常见方法有以下两个：

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

以上方法获取的是下面的信息，都是一对标签中有一个key和一个value：

<param-name>startIndex</param-name>
<param-value>0</param-value>：

<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>
<!--注意：以上的配置信息属于应用级的配置信息，一般一个项目中共享的配置信息会放到以上的标签当中。-->
<!--如果你的配置信息只是想给某一个servlet作为参考，那么你配置到servlet标签当中即可，使用ServletConfig对象来获取。-->

还有以下方法：

// 获取文件的绝对路径（真实路径）
public String getRealPath(String path);
// 通过ServletContext对象也是可以记录日志的
public void log(String message);
public void log(String message, Throwable t);
// 存（向ServletContext应用域中存数据）
public void setAttribute(String name, Object value); // map.put(k, v)
// 取（从ServletContext应用域中取数据）
public Object getAttribute(String name); // Object v = map.get(k)
// 删（删除ServletContext应用域中的数据）
public void removeAttribute(String name); // map.remove(k)

HttpServlet接口

继承关系

事实上，我们编写Servlet类的时候，是不会去直接继承GenericServlet类的，因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的，在Servlet规范当中，提供了一个类叫做HttpServlet，它是专门为HTTP协议准备的一个Servlet类。我们编写的Servlet类要继承HttpServlet。（HttpServlet是HTTP协议专用的。）使用HttpServlet处理HTTP协议更便捷,它的继承结构如下：
jakarta.servlet.Servlet（接口）【爷爷】
jakarta.servlet.GenericServlet implements Servlet（抽象类）【儿子】
jakarta.servlet.http.HttpServlet extends GenericServlet（抽象类）【孙子】

我们以后编写的Servlet要继承HttpServlet类。

HTTP协议详解

几种常见的缓存机制：

1、字符串型
一个字符串在java虚拟机的堆内存的常量池中只能被创建一次：如“abc”，如果二次调用，只需要在常量池中找它即可。
2、整数型常量池
-128-127的整数放在常量池中，在这个范围内，在常量池中取即可
3、连接池
JVM和Mysql属于两个进程，两个进程建立联系进行通信是一个非常费劲的事情，一般都会创建多个Connection连接对象放到一个集合中，把这个有Connection的对象称为连接池。每次用户需要和数据库建立连接的时候直接调用Connection即可。

线程池

线程池也是一种缓存机制，在线程池中提前创建好多个Thread（）对象放在集合中，当用户有请求发过来之后，需要一个相对应的线程处理，可以直接从这个集合中拿，提高了效率。所有的WEB服务器都是支持线程池的。

HTTP协议

协议：协议就是通信双方共同制定好一套相互传输信息的规则，这样双方才可以实现无障碍信息传输。
HTTP协议：是W3C（万维网联盟）制定的一种超文本（声音、图片、视频等非文字类的信息）传输协议
HTTP协议的作用：B/S双方的解耦合，双方不相互依赖，这样不同品牌的浏览器和服务器都可以实现通信，因为他们共同遵守一套规则
HTTP协议分类：
HTTP请求协议：B向S发送信息时遵循的一套协议
HTTP响应协议：S向B端发送信息时遵循的一套协议
HTTP请求协议的构成：
HTTP请求协议包括：请求行、请求头、空白行、请求体
HTTP请求协议又分为get和post类型
各部分具体构成：
请求行：请求方式、URI、HTTP协议版本号
URI：（统一资源标识符，URL是统一资源定位符，URL包含URI）
–http://localhost:8080/servlet05/index.html 这是URL。
– /servlet05/index.html 这是URI。
请求方式有7中：get、post、delete、put、head、options
请求头： ⅰ. 请求的主机
ⅱ. 主机的端口
ⅲ. 浏览器信息
ⅳ. 平台信息
ⅴ. cookie等信息
ⅵ. …
空白行：区分请求行和请求体
请求体；：向服务器发送的具体数据
HTTP请求协议包括 具体如下：

HTTP/1.1 200 ok                                     状态行
----------------------------------------------------------------------------------
Content-Type: text/html;charset=UTF-8               响应头
Content-Length: 160
Date: Mon, 08 Nov 2021 13:19:32 GMT
Keep-Alive: timeout=20
Connection: keep-alive
----------------------------------------------------------------------------------
                                                    空白行
----------------------------------------------------------------------------------
<!doctype html>                                     响应体
<html>
    <head>
        <title>from get servlet</title>
    </head>
    <body>
        <h1>from get servlet</h1>
    </body>
</html>

HTTP响应协议的构成：
HTTP响应协议包括：状态行、响应头、空白行、响应体
各部分具体构成：
状态行
● 第一部分：协议版本号（HTTP/1.1）
● 第二部分： 状态码（HTTP协议中规定的响应状态号。不同的响应结果对应不同的号码。）
○ 200 表示请求响应成功，正常结束。
○ 404表示访问的资源不存在，通常是因为要么是你路径写错了，要么是路径写对了，但是服务器中对应的资源并没有启动成功。总之404错误是前端错误。
○ 405表示前端发送的请求方式与后端请求的处理方式不一致时发生：
■ 比如：前端是POST请求，后端的处理方式按照get方式进行处理时，发生405
■ 比如：前端是GET请求，后端的处理方式按照post方式进行处理时，发生405
○ 500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的。
○ 以4开始的，一般是浏览器端的错误导致的。
○ 以5开始的，一般是服务器端的错误导致的。
● 第三部分：状态的描述信息
○ ok 表示正常成功结束。
○ not found 表示资源找不到。
响应头：
■ 响应的内容类型
■ 响应的内容长度
■ 响应的时间
■ …
空白行：
■ 用来分隔“响应头”和“响应体”的。
响应体：
响应体就是响应的正文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释并执行，最终展示出效果。
HTTP响应协议的具体报文：

HTTP/1.1 200 ok                                     状态行
----------------------------------------------------------------------------------
Content-Type: text/html;charset=UTF-8               响应头
Content-Length: 160
Date: Mon, 08 Nov 2021 13:19:32 GMT
Keep-Alive: timeout=20
Connection: keep-alive
----------------------------------------------------------------------------------
                                                    空白行
----------------------------------------------------------------------------------
<!doctype html>                                     响应体
<html>
    <head>
        <title>from get servlet</title>
    </head>
    <body>
        <h1>from get servlet</h1>
    </body>
</html>

GET和POST的区别

1. get请求发送数据的时候，数据会挂在URI的后面，并且在URI后面添加一个“?”，"?"后面是数据。这样会导致发送的数据回显在浏览器的地址栏上。（get请求在“请求行”上发送数据）
   a. http://localhost:8080/servlet05/getServlet?username=zhangsan&userpwd=1111
2. post请求发送数据的时候，在请求体当中发送。不会回显到浏览器的地址栏上。也就是说post发送的数据，在浏览器地址栏上看不到。（post在“请求体”当中发送数据）
3. get请求只能发送普通的字符串。并且发送的字符串长度有限制，不同的浏览器限制不同。这个没有明确的规范。
4. get请求无法发送大数据量。
5. post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频、声音、图片。
6. post请求可以发送大数据量，理论上没有长度限制。
7. get请求在W3C中是这样说的：get请求比较适合从服务器端获取数据。
8. post请求在W3C中是这样说的：post请求比较适合向服务器端传送数据。
9. get请求是安全的。get请求是绝对安全的。为什么？因为get请求只是为了从服务器上获取数据。不会对服务器造成威胁。（get本身是安全的，你不要用错了。用错了之后又冤枉人家get不安全，你这样不好（太坏了），那是你自己的问题，不是get请求的问题。）
10. post请求是危险的。为什么？因为post请求是向服务器提交数据，如果这些数据通过后门的方式进入到服务器当中，服务器是很危险的。另外post是为了提交数据，所以一般情况下拦截请求的时候，大部分会选择拦截（监听）post请求。
11. get请求支持缓存。
    a. https://n.sinaimg.cn/finance/590/w240h350/20211101/b40c-b425eb67cabc342ff5b9dc018b4b00cc.jpg
    b. 任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中：
    ⅰ. 一个get请求的路径a 对应 一个资源。
    ⅱ. 一个get请求的路径b 对应 一个资源。
    ⅲ. 一个get请求的路径c 对应 一个资源。
    ⅳ. …
    c. 实际上，你只要发送get请求，浏览器做的第一件事都是先从本地浏览器缓存中找，找不到的时候才会去服务器上获取。这种缓存机制目的是为了提高用户的体验。
    d. 有没有这样一个需求：我们不希望get请求走缓存，怎么办？怎么避免走缓存？我希望每一次这个get请求都去服务器上找资源，我不想从本地浏览器的缓存中取。
    ⅰ. 只要每一次get请求的请求路径不同即可。
    ⅱ. https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897898
    ⅲ. https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897899
    ⅳ. https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=系统毫秒数
    ⅴ. 怎么解决？可以在路径的后面添加一个每时每刻都在变化的“时间戳”，这样，每一次的请求路径都不一样，浏览器就不走缓存了。
12. post请求不支持缓存。（POST是用来修改服务器端的资源的。）
    a. post请求之后，服务器“响应的结果”不会被浏览器缓存起来。因为这个缓存没有意义。

GET和POST分别在什么时候使用

1、post适合向服务器发送数据，get适合向服务器索取数据
2、 如果表单中有敏感信息，还是建议适用post请求，因为get请求会回显敏感信息到浏览器地址栏上。（例如：密码信息）
3、大部分的form表单提交，都是post方式，因为form表单中要填写大量的数据，这些数据是收集用户的信息，一般是需要传给服务器，服务器将这些数据保存/修改等。
4、做文件上传，一定是post请求。要传的数据可能不是普通文本。

模板方法设计模式

模板方法定义：
定义一个抽象类，类中有final方法和抽象方法
final方法定义核心方法
抽象方法定义一些不确定的给子类做的事情

模版的定义：某个问题的固定解决方式（可以被重复利用）
○ GoF设计模式：
■ 通常我们所说的23种设计模式。（Gang of Four：4人组提出的设计模式）
■ 单例模式
■ 工厂模式
■ 代理模式
■ 门面模式
■ 责任链设计模式
■ 观察者模式
■ 模板方法设计模式
■ …
○ JavaEE设计模式：
■ DAO
■ DTO
■ VO
■ PO
■ pojo
■ …

代码示例

/**
 * Teacher和Student都是Person
 * 1. Person就是模板方法设计模式当中的模板类。
 * 2. oneDay()方法就是模板方法设计模式当中的模板方法。
 */
public abstract class Person { // 模板类通常是抽象类。

    // 模板方法
    // 添加了final之后，这个方法无法被覆盖，这样核心的算法也可以得到保护。
    // 模板方法定义核心的算法骨架，具体的实现步骤可以延迟到子类当中去实现。
    // 核心算法一方面是得到了保护，不能被改变。另外一方面就是算法得到了重复使用。
    // 另外代码也得到了服用，因为算法中某些步骤的代码是固定的。这些固定的代码不会随着子类的变化而变换，这一部分代码可以写到模板类当中。
    public final void oneDay(){
        // 第一步
        qiChuang();
        // 第二步
        xiShu();
        // 第三步
        chiZaoCan();
        // 第四步
        doSome();
        // 第五步
        chiWanFan();
        // 第六步
        shuiJiao();
    }

    // 其中的某些步骤，不会随着子类的变化而变化，这些代码可以写到父类中，得到代码复用。
    public void Getup(){
        System.out.println("起床");
    }

    public void chiZaoCan(){
        System.out.println("吃早餐");
    }

    // 这一步是要做，但是具体这一步怎么做，子类说了算。
    public abstract void doSome();

    public void Sleep(){
        System.out.println("睡觉");
    }
}

public class Student extends Person {

    public void doSome(){
        System.out.println("学生上学，学习");
    }

}

public class Teacher extends Person{

    public void doSome(){
        System.out.println("老师正在课堂上授课，教授学生知识");
    }

}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Teacher();
        p1.oneDay();
        System.out.println("-----------------");
        Person p2 = new Student();
        p2.oneDay();
    }
}

HttpServlet源码

jakarta.servlet.http.HttpServlet ，这个包下还有
○ jakarta.servlet.http.HttpServletRequest （HTTP协议专用的请求对象）
HttpServletRequest中封装了请求协议的全部内容（Tomcat服务器解析并封装）

○ jakarta.servlet.http.HttpServletResponse （HTTP协议专用的响应对象）
HttpServletResponse对象是专门用来响应HTTP协议到浏览器的

HttpServlet源码分析（重点）

1、从源码中可以看出 HttpServlet有两个service方法，如果传来的请求是HttpServletRequest类型的，则会直接执行service(HttpServletRequest req, HttpServletResponse resp)方法，如果传来的是ServletRequest的请求，则会先执行
service(ServletRequest req, ServletResponse res)，在这个service方法中将请求对象先向下转型再送给下面的那个service方法执行。
2、在service(ServletRequest req, ServletResponse res)方法中，会用req.getMethod()方法获取请求中的方法类型，然后判断是哪种类型，对应执行这个类型的doXXX()方法。比如doGet()方法，doPost()方法。
3、这些方法在HttpServletRequest类中的原方法都是用来向前端返回405的，因此如果不被重写，调用的时候就会显示405。比如用户请求为Post方式，但是Servlet类中没有重写doPost()方法，这个时候就会执行父类HttpServletRequest中的doPost()，想页面返回405。

/**
	从上往下看，依次执行
*/
public class HelloServlet extends HttpServlet {
	// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
	public HelloServlet() {
    }
    
    //override 重写 doGet方法
    //override 重写 doPost方法
}

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(ServletConfig config)执行之后，会执行这个没有参数的init()
	public void init() throws ServletException {
        // NOOP by default
    }
}

// HttpServlet模板类。
public abstract class HttpServlet extends GenericServlet {
    // 用户发送第一次请求的时候这个service会执行
    // 用户发送第N次请求的时候，这个service方法还是会执行。
    // 用户只要发送一次请求，这个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方法。
        service(request, response);
    }
    
    // 这个service方法的两个参数都是带有Http的。
    // 这个service是一个模板方法。
    // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成。
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 获取请求方式
        // 这个请求方式最终可能是：""
        // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
        // GET POST PUT DELETE HEAD OPTIONS TRACE
        String method = req.getMethod();

        // 如果请求方式是GET请求，则执行doGet方法。
        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;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // 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)) {
            // 如果请求方式是POST请求，则执行doPost方法。
            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);
        }
    }
    
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException{
        // 报405错误
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 报405错误
        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
}

/*
通过以上源代码分析：
	假设前端发送的请求是get请求，后端程序员重写的方法是doPost
	假设前端发送的请求是post请求，后端程序员重写的方法是doGet
	会发生什么呢？
		发生405这样的一个错误。
		405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。
	
	通过以上源代码可以知道：只要HttpServlet类中的doGet方法或doPost方法执行了，必然405.

怎么避免405的错误呢？
	后端重写了doGet方法，前端一定要发get请求。
	后端重写了doPost方法，前端一定要发post请求。
	这样可以避免405错误。
	
	这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。
	
有的人，你会看到为了避免405错误，在Servlet类当中，将doGet和doPost方法都进行了重写。
这样，确实可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错。
如果你要是同时重写了doGet和doPost，那还不如你直接重写service方法好了。这样代码还能
少写一点。
*/

关于一个web站点的欢迎页面

什么是一个web站点的欢迎页面？
○ 对于一个webapp来说，我们是可以设置它的欢迎页面的。
○ 设置了欢迎页面之后，当你访问这个webapp的时候，或者访问这个web站点的时候，没有指定任何“资源路径”，这个时候会默认访问你的欢迎页面。、
步骤1：
在webapp中写一个欢迎页面welcome.html
步骤2：
在web.xml中配置servlet的映射

<welcome-file-list>
        <welcome-file>login.html</welcome-file>
</welcome-file-list>

步骤3：
启动服务器，在地址栏输入： http://localhost:8080/webapp名称

当然也可以配置多个欢迎页面，当一个不存在时一次向下找欢迎页面：

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index2.html</welcome-file>
    <welcome-file>index3.html</welcome-file>
</welcome-file-list>

欢迎页也可以是一个Servlet

HttpServletRequest接口

WEB-INF目录下的资源是受保护的，不能直接访问，所以一般像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。

方法

Tomcat会解析HTTP的请求协议，然后Tomcat服务器把这些信息封装到HttpServletRequest对象当中，我们对于 HttpServletRequest只需要知道其中有哪些方法并且会用这些方法对请求进行操作就行了。
因为前端传来的数据类似于键值对：username=abc&userpwd=111&aihao=s&aihao=d&aihao=tt ，因此我们也可以用类似于map中的一些方法去存储或者调用这些数据，这些数据的减值对都是以String的形式去存储的。
以下为常用方法：

Map<String,String[]> getParameterMap() 这个是获取Map
Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key
String[] getParameterValues(String name) 根据key获取Map集合的value
String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
// 以上的4个方法，和获取用户提交的数据有关系。

请求域对象

request其实是一种请求域对象。
而ServletContext是一种应用域对象。一般参数同时满足以下几个特征可以向应用域中配置：
1、数据量较小
2、所有用户共享
3、数据很少被修改
将参数配置到应用域中相当于把参数放到了缓存中，这样用户可以直接从缓存中访问数据，大大提升系统性能。
要区分以下两种方法：
1、getInitParameter(" ")获取的是servletContext中的静态变量，比如数据库连接 URL、日志级别等，用于配置整个应用程序的属性。
2、Attribute相关方法设置的属性是动态的，可以在运行时根据需要修改或删除）：
我们可以用以下方法配置应用域中的一些动态属性

void setAttribute(String name, Object obj); // 向域当中绑定数据。
Object getAttribute(String name); // 从域当中根据name获取数据。
void removeAttribute(String name); // 将域当中绑定的数据移除

// 以上的操作类似于Map集合的操作。
Map<String, Object> map;
map.put("name", obj); // 向map集合中放key和value
Object obj = map.get("name"); // 通过map集合的key获取value
map.remove("name"); // 通过Map集合的key删除key和value这个键值对。

请求域对象和应用域对象的区别

1、 “请求域”对象要比“应用域”对象范围小很多。生命周期短很多。请求域只在一次请求内有效。
2、 一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。
3、请求域中和应用域一样有以下三种方法：

void setAttribute(String name, Object obj); // 向域当中绑定数据。
Object getAttribute(String name); // 从域当中根据name获取数据。
void removeAttribute(String name); // 将域当中绑定的数据移除

4、请求域和应用域的选用原则是尽量选择小的那个域，因为小的那个域占用资源更少

两个Servlet共享数据

可以将数据放在ServletContext中，但是范围太大，浪费资源。因此可以将数据放到请求域中，通过两个Servlet转发实现共享。
代码实现：
在以下代码中，AServlet将访问AServlet时的时间转发给BServlet，这时这个时间被配置在了同一个请求域中，跳转到BServlet之后会执行BServlet中的service方法，在service方法内部执行doGet方法打印当前时间。

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.Date;

public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取系统当前时间
        Date nowTime = new Date();

        // 将系统当前时间绑定到请求域当中
        request.setAttribute("sysTime", nowTime);
        // 一行代码搞定转发。
        //request.getRequestDispatcher("/b").forward(request, response);
        // 转发到一个Servlet，也可以转发到一个HTML，只要是WEB容器当中的合法资源即可。
        request.getRequestDispatcher("/test.html").forward(request, response);
    }
}
public class BServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

        // 从请求域当中取出绑定的数据
        Object sysTime = request.getAttribute("sysTime");

        //输出到浏览器
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.print("系统当前时间是：" + sysTime);
    }
}

要区分以下两种方法：
第一个方法：获取的是用户在浏览器上提交的数据。
第二个方法：获取的是请求域当中绑定的数据。

// uri?username=zhangsan&userpwd=123&sex=1
String username = request.getParameter("username");

// 之前一定是执行过：request.setAttribute("name", new Object())
Object obj = request.getAttribute("name");

其他常用方法

// 获取客户端的IP地址
String remoteAddr = request.getRemoteAddr();
// 设置请求体的字符集。（显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。）
// Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题。
// Tomcat9前（包括9在内），如果前端请求体提交的是中文，后端获取之后出现乱码，怎么解决这个乱码？执行以下代码。
request.setCharacterEncoding("UTF-8");

// 在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？
response.setContentType("text/html;charset=UTF-8");
// 在Tomcat10之后，包括10在内，响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。
// 注意一个细节
// 在Tomcat10包括10在内之后的版本，中文将不再出现乱码。（这也体现了中文地位的提升。）

// get请求乱码问题怎么解决？
// get请求发送的时候，数据是在请求行上提交的，不是在请求体当中提交的。
// get请求乱码怎么解决
// 方案：修改CATALINA_HOME/conf/server.xml配置文件
<Connector URIEncoding="UTF-8" />
// 注意：从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了。
// 获取应用的根路径
String contextPath = request.getContextPath();
// 获取请求方式
String method = request.getMethod();
// 获取请求的URI
String uri = request.getRequestURI();  // /aaa/testRequest
// 获取servlet所在的路径
String servletPath = request.getServletPath(); 

在一个web应用中完成资源的跳转

两种方法实现资源跳转

1、转发

request.getRequestDispatcher("/dept/list").forward(request, response);
// AServlet转发到BServlet，再转发到CServlet，再转发到DServlet，不管转发了多少次，都在同一个request当中。
// 这是因为调用forward方法的时候，会将当前的request和response对象传递给下一个Servlet，但是传递的是同一个Servlet。

// 注意：路径上要加一个项目名。
// 浏览器发送请求，请求路径上是需要添加项目名的。
// 以下这一行代码会将请求路径“/oa/dept/list”发送给浏览器
// 浏览器会自发的向服务器发送一次全新的请求：/oa/dept/list
response.sendRedirect("/oa/dept/list");

import com.bjpowernode.javaweb.bean.User;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class AServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        // 创建一个用户对象
        User user = new User();
        user.setId("111111");
        user.setName("杰克");

        // 将用户对象存储到请求域当中
        request.setAttribute("userObj", user);

        // 转发
        //request.getRequestDispatcher("/b").forward(request, response);

        // 重定向（重新定方向）
        // 重定向时的路径当中需要以项目名开始，或者说需要添加项目名。
        // response对象将这个路径："/servlet10/b"响应给浏览器了。
        // 浏览器又自发的向服务器发送了一次全新的请求：http://localhost:8080/servlet10/b
        // 所以浏览器一共发送了两次请求：
        // 第一次请求：http://localhost:8080/servlet10/a
        // 第二次请求：http://localhost:8080/servlet10/b
        // 最终浏览器地址栏上显示的地址当然是最后那一次请求的地址。所以重定向会导致浏览器地址栏上的地址发生改变。
        response.sendRedirect(request.getContextPath() + "/b");
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 从请求域当中取出存储的数据
        Object userObj = request.getAttribute("userObj");

        // 输出到浏览器
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.print("请求域当中的用户对象：" + userObj)//输出还是"杰克"
    }
}

2、重定向（本质上让浏览器再次发送一个全新的请求）

转发和重定向的区别

分别在什么时候使用这两种请求
1、如果在上一个Servlet当中向request域当中绑定了数据，希望从下一个Servlet当中把request域里面的数据取出来，使用转发机制。
比如：假设在一个 Servlet 中进行用户身份验证，验证通过后将用户信息存储在请求域中，然后需要在下一个 Servlet 中展示用户的个人信息。
2、剩下所有的请求均使用重定向。（重定向使用较多。）
3、跳转可以转发到WEB-INF目录下，重定向不可以

Servlet中的注解式开发

使用原因

1、 现在只是一个单标的CRUD，没有复杂的业务逻辑，很简单的一丢丢功能。web.xml文件中就有如此多的配置信息。如果采用这种方式，对于一个大的项目来说，这样的话web.xml文件会非常庞大，有可能最终会达到几十兆。
2、在web.xml文件中进行servlet信息的配置，显然开发效率比较低，每一个都需要配置一下。
3、而且在web.xml文件中的配置是很少被修改的，所以这种配置信息能直接写到java类当中

配置在web.xml中的内容

1、有一些需要变化的信息，还是要配置到web.xml文件中。一般都是 注解+配置文件 的开发模式。
2、一些不会经常变化修改的配置建议使用注解。一些可能会被修改的建议写到配置文件中。

配置格式

@注解名称(属性名=属性值, 属性名=属性值, 属性名=属性值…)
如果像这种：@WebServlet(“/detailServlet”)，只有一个参数"/detailServlet"，那么默认是value值，这里不需要参数名=参数值。

和web.xml中的对应关系

1、name属性：用来指定Servlet的名字。
对应：HelloServlet
2、urlPatterns属性：用来指定Servlet的映射路径。一个数组类型，如果数组只有一个。可以省略大括号。
对应：/greet
3、loadOnStartUp属性：用来指定在服务器启动阶段是否加载该Servlet。
如果配置了这个属性，那么服务器在启动的时候会自动创建servlet对象
4、value属性：当注解的属性名是value的时候，使用注解的时候，value属性名是可以省略的。
5、initParams属性：{@WebInitParam(name=“username”,value=“zonda”)}
这个属性类型是一个注解数组，只需要提供需要的属性。

使用模板方法设计模式解决类爆炸

使用原因

1、 注解式开发解决了配置文件的问题。但是现在的oa项目仍然存在一个比较臃肿的问题。
2、一个单标的CRUD，就写了6个Servlet。如果一个复杂的业务系统，这种开发方式，显然会导致类爆炸。（类的数量太大。）
3、可以使用模板方法设计模式解决这类问题。

解决方法

1、以前的设计是一个请求一个Servlet类。1000个请求对应1000个Servlet类。导致类爆炸。
2、可以这样做：一个请求对应一个方法。一个业务对应一个Servlet类。
3、处理部门相关业务的对应一个DeptServlet。处理用户相关业务的对应一个UserServlet。处理银行卡卡片业务对应一个CardServlet。
比如代码：

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class MyServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 设置响应内容类型
        response.setContentType("text/html;charset=UTF-8");

        // 根据请求参数进行不同的业务逻辑处理
        String action = request.getParameter("action");
        PrintWriter out = response.getWriter();
        if (action != null) {
            switch (action) {
                case "dept":
                    handleDeptRequest(request, out);
                    break;
                case "user":
                    handleUserRequest(request, out);
                    break;
                case "card":
                    handleCardRequest(request, out);
                    break;
                default:
                    out.println("Unknown action");
            }
        } else {
            out.println("Action parameter is missing");
        }
    }

    private void handleDeptRequest(HttpServletRequest request, PrintWriter out) {
        // 处理部门相关业务逻辑
        out.println("Handling department request...");
    }

    private void handleUserRequest(HttpServletRequest request, PrintWriter out) {
        // 处理用户相关业务逻辑
        out.println("Handling user request...");
    }

    private void handleCardRequest(HttpServletRequest request, PrintWriter out) {
        // 处理银行卡卡片业务逻辑
        out.println("Handling card request...");
    }
}