JavaWeb

基本概念

前言

web 开发

• web 网页
• 静态 web
  • html, css
  • 提供给所有人看到的数据始终不会发生变化
• 动态 web
  • 提供给所有人看到的数据始终会发生变化，每个人在不同时间、不同地点看到的信息各不相同
  • 技术栈：Servlet / JSP，ASP，PHP

在 Java 中，动态资源 web 开发的技术统称为 JavaWeb

web 应用程序

web 应用程序：可以提供浏览器访问的程序

• a.html、b.html… 多个 web 资源，这些 web 资源可以被外界访问，对外界提供服务
• 能访问到的任何一个页面或资源都存在于某个计算机上
• URL
• 这些统一的 web 资源会被放在同一个文件夹下，web应用程序 —> Tomcat：服务器
• 一个 web 应用由多部份组成（静态 web，动态 web）
  • html，css
  • jsp，servlet
  • java 程序
  • jar 包
  • 配置文件（properties）

web 应用程序编写完毕后，若想提供给外界访问，需要一个服务器来统一管理

静态 web

• *.htm，*.html 这些都是网页后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取（通过网络）
  

• 静态 web 存在的缺点

  • web 页面无法动态更新，所有用户看到的都是同一个页面
  • 无法和数据库交互（数据无法持久化，用户无法交互）

动态 web

页面会动态展示：web 的页面展示因人而异

动态 web 存在的缺点

• 加入服务器的动态 web 资源出现错误，需要重新编写后台程序，重新发布

动态 web 存在的优点

• web 页面可以动态更新
• 可以与数据库交互（数据持久化）

web 服务器

服务器是一种被动的操作，用来处理用户的一些请求，和给用户一些响应信息

IIS（微软的）
Tomcat

Tomcat

安装 Tomcat

Tomcat 官网：https://tomcat.apache.org/

配置

可以配置启动的端口号

1. Tomcat 默认端口号：8080
2. MySQL：3306
3. http：80
4. https：443

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

可以配置主机的名称

1. 默认的主机名为：localhost（127.0.0.1）
2. 默认的网站应用存放位置为：webapps

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

高难度面试题：请你谈一谈网站是如何进行访问的？

1. 输入一个域名；回车
2. 检查本机的 C:\Windows\System32\drivers\etc\hosts 配置文件下有没有这个域名映射
   1. 有：直接返回对应的 IP 地址，这个地址中，有我们需要访问的 web 程序，可以直接访问

   	127.0.0.1       localhost
   

   2. 没有：去 DNS 服务器（全世界的域名都在这管理）上找，找到的话就返回，找不到就返回找不到

发布一个 web 网站

• 将自己写的网站放到服务器（Tomcat）中指定的 web 应用文件夹（webapps）下，就可以访问了

网站应有的结构：

-- webapps：Tomcat 服务器的 web 目录
	- ROOT
	- JarvisStudy：网站的目录名
		- WEB-INF
			- classes：java 程序
			- lib：web 应用所依赖的 jar 包
			- web.xml：网站配置文件
		- index.html 默认的首页
		- static
			- css
				- style.css
			- js
			- img
		- ...

Http

什么是 Http

超文本传输协议（Hypertext Transfer Protocol，HTTP）是一个简单的请求-响应协议，它通常运行在TCP之上。

• 文本：html、字符串……
• 超文本：图片、音乐、视频、定位、地图……
• 默认端口：80

Https：安全的（s）

• 默认端口：443

两个时代

• http1.0
  • HTTP/1.0：客户端与 web 服务器连接后，只能获得一个 web 资源，断开连接
• http2.0
  • HTTP/1.1：客户端与 web 服务器连接后，可以获得多个 web 资源

请求

• 客户端—发请求—服务器

百度

Request URL: https://www.baidu.com/					请求地址
Request Method: GET									get 方法 / post 方法
Status Code: 200 OK									状态码
Remote Address: 180.101.49.11:443					远程地址

Accept:text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,zh-TW;q=0.6	语言
Cache-Control: max-age=0
Connection: keep-alive

• 请求行
  • 请求行中的请求方式：GET
  • 请求方式：Get / Post
    • get：请求能够携带的参数比较少，大小有限制，会在浏览器的 URL 地址栏显示数据内容，不安全但高效
    • post：请求携带的参数没有限制，大小没有限制，不会在浏览器的 URL 地址栏显示数据内容，安全但不高效
• 消息头

Accept				告诉浏览器，它所支持的数据类型
Accept-Encoding		支持哪种编码格式：GBK、UTF-8、GB2312
Accept-Language		告诉浏览器，它的语言环境
Cache-Control		缓存控制
Connection			告诉浏览器，请求完成是断开还是保持连接

响应

• 服务器—响应—客户端

百度

Cache-Control: private					缓存控制
Connection: keep-alive					连接
Content-Encoding: gzip					编码
Content-Type: text/html;charset=utf-8	类型

• 响应体

Accept				告诉浏览器，它所支持的数据类型
Accept-Encoding		支持哪种编码格式：GBK、UTF-8、GB2312
Accept-Language		告诉浏览器，它的语言环境
Cache-Control		缓存控制
Connection			告诉浏览器，请求完成是断开还是保持连接
Refresh				告诉客户端多久刷新一次
Location			让网页重新定位

• 响应状态码
  • 200 请求响应成功
  • 3xx 请求重定向（重定向：你重新到我给你的新位置去）
  • 4xx 找不到资源（资源不存在）（404）
  • 5xx 服务器代码错误（502网关错误）

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来经历了什么？

Maven

Maven 核心思想：约定大于配置
Maven 会规定好应该如何去编写 Java 代码，必须要按照这个规范

Servlet

Servlet 简介

• Servlet 就是 sun 公司开发动态 web 的一门技术
• sun 公司在这些 API 中提供了一个接口叫做 Servlet，如果想开发一个 Servlet 程序，只需两个步骤：
  • 编写一个类，实现 Servlet 接口
  • 把开发好的 Java 类部署到 web 服务器中
• 把实现了 Servlet 接口的 Java 程序叫做 Servlet

HelloServlet

1. 构件一个普通的 Maven 项目，删除 src 目录，以后就在里面建立 Module，这个空的工程就是 Maven 父工程
2. Maven 环境优化
3. 编写一个 Servlet 程序
   1. 编写一个普通类
   2. 实现 Servlet 接口（HttpServlet）

package com.jarvis.servlet;

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

public class HelloServlet extends HttpServlet {

    // 由于 get 或者 post 只是请求实现的不同方式，可以互相调用，业务逻辑都一样

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ServletOutputStream outputStream = resp.getOutputStream();
        PrintWriter writer = resp.getWriter();// 响应流
        writer.print("Hello, Servlet");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

4. 编写 Servlet 的映射

为什么需要映射？ 我们写的是 java 程序，但是要通过浏览器访问，而浏览器需要连接 web 服务器，所以我们需要在 web 服务中注册写的 Servlet，还需要给它一个浏览器能够访问的路径

	<!--注册 Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.jarvis.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet 的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

5. 配置 Tomcat
6. 启动测试

Servlet 原理

Servlet 是由 web 服务器调用，web 服务器在收到浏览器请求之后

Mapping

1. 一个 Servlet 可以指定一个映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

2. 一个 Servlet 可以指定多个映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello1</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello3</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello4</url-pattern>
    </servlet-mapping>

3. 一个 Servlet 可以指定通用映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello/*</url-pattern>
    </servlet-mapping>

4. 默认请求路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

5. 指定后缀或者前缀

	<!--* 前面不能加项目映射的路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>*.jarvis</url-pattern>
    </servlet-mapping>

6. 优先级问题

指定了固有的映射路径优先级最高，如果找不到就找默认的处理请求

    <!--404-->
    <servlet>
        <servlet-name>error</servlet-name>
        <servlet-class>com.jarvis.servlet.ErrorServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>error</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

ServletContext

web 容器在启动的时候，它会为每个 web 程序都创建一个 ServletContext 对象，它代表当前的 web 应用

1. 共享数据（我在这个 Servlet 中保存的数据，可以在另一个 Servlet 中拿到）

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

//        this.getInitParameter()   初始化参数
//        this.getServletConfig()   Servlet 配置
//        this.getServletContext()  Servlet 上下文

        ServletContext servletContext = this.getServletContext();
        String username = "Jarvis";
        servletContext.setAttribute("username", username);// 将一个数据保存在 ServletContext 中

        
    }
}

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String username = (String) servletContext.getAttribute("username");

        resp.setContentType("text/html;charset=utf-8");

        resp.getWriter().write("名字:" + username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.jarvis.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    
    <servlet>
        <servlet-name>getContext</servlet-name>
        <servlet-class>com.jarvis.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getContext</servlet-name>
        <url-pattern>/getContext</url-pattern>
    </servlet-mapping>

2. 获取初始化参数

    <!--配置一些 web 应用初始化参数-->
    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

public class ServletDemo03 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();

        String url = servletContext.getInitParameter("url");
        resp.getWriter().print(url);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

3. 请求转发

转发路径不变，重定向路径改变

public class ServletDemo04 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        System.out.println("进入 ServletDemo04");
        // RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher("/getParameter");// 转发的请求路径
        // requestDispatcher.forward(req, resp);// 调用 forward 实现请求转发
        servletContext.getRequestDispatcher("/getParameter").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

4. 读取资源文件

Properties：

• 在 Java 目录下新建 properties
• 在 resources 目录下新建 properties

都被打包到了同一个路径下：classes，我们称这个路径为类路径 classpath

思路：需要一个文件流

username=root
password=123456

public class ServletDemo05 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream resourceAsStream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties prop = new Properties();
        prop.load(resourceAsStream);
        String username = prop.getProperty("username");
        String password = prop.getProperty("password");

        resp.getWriter().print(username + ":" + password);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

HttpServletResponse

web 服务器接收到客户端 http 请求，针对这个请求，分别创建一个代表请求的 HttpServletRequest 对象，代表响应的 HttpServletResponse 对象

• 如果要获取客户端请求过来的参数，找 HttpServletRequest
• 如果要给客户端响应一些信息，找 HttpServletResponse

1. 简单分类

负责向浏览器发送数据的方法：

public ServletOutputStream getOutputStream() throws IOException;
public PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

public void setCharacterEncoding(String charset);
public void setContentLength(int len);
public void setContentLengthLong(long len);
public void setContentType(String type);
......

2. 常见应用

1. 向浏览器输出消息
2. 下载文件
   1. 要获取下载文件的路径
   2. 下载文件名是啥？
   3. 设置想办法让浏览器支持我们需要的东西
   4. 获取下载文件的输入流
   5. 创建缓冲区
   6. 获取 OutputStream 对象
   7. 将 FileOutputStream 写到 buffer 缓冲区
   8. 将缓冲区中的数据输出到客户端

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String realPath = "E:\\IntelliJ IDEA\\javaweb-02-servlet\\response\\src\\main\\resources\\汉堡王.jpg";
        System.out.println("下载文件的路径：" + realPath);
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        // 中文
        resp.setHeader("Content-disposition", "attachment;filename" + URLEncoder.encode(fileName, "UTF-8"));
        FileInputStream fileInputStream = new FileInputStream(realPath);
        byte[] buffer = new byte[1024];
        int len = 0;
        ServletOutputStream outputStream = resp.getOutputStream();
        while((len = fileInputStream.read()) > 0){
            outputStream.write(buffer, 0, len);
        }
        fileInputStream.close();
        outputStream.close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

3. 验证码功能

验证码怎么来的？

• 前端实现
• 后端实现，需要用到 Java 图片类，生产一个图片

超纲了（全麻）

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 如何让浏览器 5 秒自动刷新一次
        resp.setHeader("refresh", "3");
        // 在内存中创建图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        // 得到图片
        Graphics2D g = (Graphics2D)image.getGraphics();
        // 设置图片背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        // 给图片写数据
        g.setColor(Color.blue);
        g.setFont(new Font(null, Font.BOLD, 20));
        g.drawString(makeNum(), 0, 20);
        // 告诉浏览器这个请求用图片的方式打开
        resp.setContentType("image/jpg");
        // 网站存在缓存
        resp.setDateHeader("expires", -1);
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Program", "no-cache");
        // 把图片写给浏览器
        ImageIO.write(image,"jpg", resp.getOutputStream());
    }

    private String makeNum(){
        Random random = new Random();
        String num = random.nextInt(9999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 7 - num.length(); i++) {
            sb.append(0);
        }
        String s = sb.toString() + num;
        return num;
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

4. 实现重定向

一个 web 资源收到客户端请求后，他会通知客户端去访问另外一个 web 资源，这个过程叫重定向
常见场景：

• 用户登陆

public void sendRedirect(String location) throws IOException;

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
//        resp.setHeader("Location", "/response/image");
//        resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);

        resp.sendRedirect("/response/image");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

重定向和转发的区别：

• 请求转发的时候 URL 不会变化
• 重定向的时候 URL 会变化

HttpServletRequest

HttpServletRequest 代表客户端的请求，用户通过 Http 协议访问服务器，HTTP 请求中的所有信息会被封装到 HttpServletRequest，通过这个 HttpServletRequest，可以获得客户端的所有信息

1. 获取前端传递的参数 和 请求转发
   

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");
        System.out.println(username);
        System.out.println(password);
        // 后台接收中文乱码问题
        System.out.println(Arrays.toString(hobbies));

        // 通过请求转发
        req.getRequestDispatcher("success.jsp").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

Cookie 和 Session

会话

会话：用户打开浏览器，点击了很多链接，访问多个 web 资源，关闭浏览器，这个过程可以称之为 会话
有状态会话：

1. 服务端给客户端一个 标记，客户端下次访问服务端时带上 标记 即可：cookie
2. 服务器登记你来过了，下次你来的时候服务器来匹配你：session

保存会话的两种技术

cookie：

• 客户端技术（响应，请求）

session：

• 服务器技术，利用这个技术可以保存用户的会话信息，可以把信息或者数据放在 session 中

常见场景：第一次网站登陆之后，第二次访问时直接登上了

Cookie

1. 请求中拿到 cookie 信息
2. 服务器响应给客户端 cookie

// 保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");

        PrintWriter out = resp.getWriter();

        // Cookie，服务器端从客户端获取
        Cookie[] cookies = req.getCookies();// Cookie 可能存在多个
        // 判断 Cookie 是否为空
        if(cookies != null){
            // 如果存在怎么办
            out.write("您上一次访问的时间是：");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                // 获取 cookie 的名字
                // 避免空指针异常
                if("lastLoginTime".equals(cookie.getName())){
                    // 获取 cookie 的值
                    long l = Long.parseLong(cookie.getValue());
                    Date date = new Date(l);
                    out.write(date.toLocaleString());
                }
            }
        }else{
            out.write("这是您第一次访问本站");
        }
        // 服务器给客户端响应一个 Cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");

        // cookie 有效期为一天
        cookie.setMaxAge(24 * 60 * 60);

        resp.addCookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

// 删除一个 cookie，响应一个立即过期的 cookie，即设置有效时间为 0
public class CookieDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");

        cookie.setMaxAge(0);

        resp.addCookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

cookie 一般会保存在本地的用户目录下 appdata

一个 cookie 只能保存一个信息
一个 web 站点可以给浏览器发送多个 cookie，每个站点最多存放 20 个
cookie 大小有限制
浏览器上限 300 个

Session（重点）

Session:

• 服务器会给每一个用户（浏览器）创建一个 Session 对象
• 一个 Session 独占一个浏览器，只要浏览器没有关闭，这个 Session 就存在
• 用户登陆之后，整个网站都可以访问（保存用户的信息）

Session 和 Cookie 的区别：

• Cookie 是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
• Session 是把用户的数据写到用户独占的 Session 中，服务器端保存（保存重要的信息，减少服务器资源浪费）
• Session 由服务器创建

使用场景：

• 保存一个用户的登陆信息、购物车信息
• 在整个网站中经常会使用的数据，我们将它保存在 Session 中

使用 Session

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码问题
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        // 获取 Session
        HttpSession session = req.getSession();

        // 给 Session 中存入东西
        session.setAttribute("person", new Person("胡图图", 1));

        // 获取 Session 的 ID
        String id = session.getId();
        if(session.isNew()){
            resp.getWriter().write("Session 创建成功，SessionID为：" + id);
        }else{
            resp.getWriter().write("Session 已经在服务器中存在了，SessionID为：" + id);
        }

        // Session 创建的时候做了什么事情
//        Cookie cookie = new Cookie("JESSIONID", id);
//        resp.addCookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码问题
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        // 获取 Session
        HttpSession session = req.getSession();

        Person person = (Person) session.getAttribute("person");

        System.out.println(person);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        // 移除 Session 存的对象
        session.removeAttribute("person");
        // 手动注销 Session
        session.invalidate();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

	<!--响应的 servlet 和 servlet-mapping 在此省略-->
	
    <!--设置 Session 默认的失效时间（会话自动过期）-->
    <session-config>
        <!--1 分钟后 Session 自动失效-->
        <session-timeout>1</session-timeout>
    </session-config>