servlet（自用）

最新推荐文章于 2024-06-30 16:04:24 发布

?sterben

最新推荐文章于 2024-06-30 16:04:24 发布

阅读量112

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/qq_45906102/article/details/114793244

版权

笔记专栏收录该内容

64 篇文章 0 订阅

订阅专栏

快速入门

实现servlet接口的类

public class Hello implements Servlet {

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

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

    //用来处理客户的请求，并且对请求作出响应的方法，req请求，resp响应
    @Override
    public void service(ServletRequest req, ServletResponse resp) throws ServletException, IOException {
        //向页面输出一个helloServlet
        resp.getWriter().println("hello Servlet");
    }

在web.xml中配置servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/j2ee"
         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>
        <!--配置servlet名称，可以随便取-->
        <servlet-name>HelloServlet</servlet-name>
        <!--配置servlet类的全路径-->
        <servlet-class>servlet.demo1.Hello</servlet-class>
    </servlet>
    <!--配置servlet的映射-->、
    <servlet-mapping>
        <!--名字和上面的名字一样-->
        <servlet-name>HelloServlet</servlet-name>
        <!--配置访问路径,在主路径后加/hello会去到类路径-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

访问
在这里插入图片描述

Servlet实现类

GenericServlet（通用）
HttpServlet（http用）

通常编写一个Servlet一般都会让这个Servlet继承HttpServlet重写service方法。在service方法内部根据请求方式不同执行不同的doXXX的方法（get请求执行doGet方法，如果是post请求就会执行doPost方法）。
所以往往继承了HttpServlet之后不需要重写service方法，只需要重写doGet和doPost方法即可。往往请求要处理的内容的代码都是一致的，所以需要让doGet和doPost相互调用可以简化编程。

实现类

public class testHttpservlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("get hello");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("post hello servlet");
    }
}

配置

    <servlet>
        <servlet-name>HelloHttpServlet</servlet-name>
        <servlet-class>servlet.demo1.testHttpservlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloHttpServlet</servlet-name>
        <url-pattern>/Http</url-pattern>
    </servlet-mapping>

生命周期

Servlet中有init,service,destroy方法，这几个方法称为是Servlet生命周期相关的方法。

演示代码

public class Servletdemo2 implements Servlet {
    @Override
    //对象实例化会执行，只执行一次。（servlet是单例的）
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("被初始化");
    }

    @Override
    //任何一次请求都会执行，可以执行多次
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("执行了");
    }

    @Override
    //servlet从服务器移除或者服务器关闭时，销毁servlet。执行一次
    public void destroy() {
        System.out.println("被销毁了");
    }

在这里插入图片描述

启动加载

servlet是默认在第一次访问的时候创建的对象，现在通过一个配置将servlet实例化的过程放在服务器启动的时候（让服务器启动的时候创建对象）

    <servlet>
        <servlet-name>servletdemo2</servlet-name>
        <servlet-class>servlet.demo1.Servletdemo2</servlet-class>
        <!--配置启动加载，数字越小，越先被加载-->
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>servletdemo2</servlet-name>
        <url-pattern>/demo2</url-pattern>
    </servlet-mapping>

servlet中的urlpattern配置

<url-pattern>的配置方式

完全匹配
以/开始
目录匹配
以/开始/*结束
扩展名匹配
不能以/开始，以*开始，如：*.jsp

    <servlet-mapping>
        <servlet-name>servletdemo2</servlet-name>
        <!--完全匹配-->
        <url-pattern>/demo2</url-pattern>
        <!--目录匹配-->
        <url-pattern>/*</url-pattern>
        <!--扩展名匹配-->
        <url-pattern>*action</url-pattern>
    </servlet-mapping>

匹配优先级
完全匹配 > 目录匹配 > 扩展名匹配

servletConfig对象

获得配置信息

    <servlet>
        <servlet-name>Servletdemo3</servlet-name>
        <servlet-class>servlet.demo1.Servletdemo3</servlet-class>
        <!--配置初始化参数-->
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>root</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>Servletdemo3</servlet-name>
        <url-pattern>/demo3</url-pattern>
    </servlet-mapping>

public class Servletdemo3 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获得servletConfig对象
        ServletConfig config = this.getServletConfig();
        String name = config.getInitParameter("username");
        String pass = config.getInitParameter("password");
        System.out.println(name+pass);
        //获得所有初始化参数名称
        Enumeration<String> names = config.getInitParameterNames();
        while (names.hasMoreElements()){
            String name1 = names.nextElement();
            String value = config.getInitParameter(name1);
            System.out.println(value);
            
        //获得servlet的名称
        String servletname = config.getServletName();
        System.out.println(servletname);
        }
    }

ServletContext

ServletContext：Servlet的上下文对象。ServletContext对象对Servlet之前和之后的内容都知道。这个对象一个web项目只有一个。在服务器启动的时候为每个web项目创建一个单独的ServletContext对象。

作用一：用来获取web项目信息

    <context-param>
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>root</param-value>
        </init-param>
    </context-param>
    <servlet>
        <servlet-name>Servletdemo4</servlet-name>
        <servlet-class>servlet.demo1.Servletdemo3</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Servletdemo4</servlet-name>
        <url-pattern>/demo4</url-pattern>
    </servlet-mapping>

public class Servletdemo4 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获得web项目的信息
        ServletContext servletContext = this.getServletContext();
        //获取文件的MIME类型
        String mimetype = servletContext.getMimeType("aaa.txt");
        System.out.println(mimetype);
        //获得请求路径的工程名
        String path =servletContext.getContextPath();
        System.out.println(path);
        //获得全局的初始化参数
        String name = servletContext.getInitParameter("username");
        String pass = servletContext.getInitParameter("password");
        System.out.println(name);
        System.out.println(pass);

        }
    }

作用二：读取web项目下的文件
之前使用IO流就可以读取文件（java项目中）。现在是一个web项目，web项目需要发布到tomcat下才能访问的。获取web项目下的文件如果使用传统的IO就会出现问题（原因：路径中使用的是相对路径，相对的是JRE环境）。

在这里插入图片描述

ServletContext作为域对象

域对象：指的是将数据存入到域对象中，这个数据就会有一定的作用范围。域指的是一定的作用范围。
ServletContext是在服务器启动的时候为每个web项目单独创建一个ServletContext对象。当web项目从服务器中移除，或者是关闭服务器的时候ServletContext对象会被销毁。向ServletContext中保存的数据一直存在（当服务器关闭的时候ServletContext对象被销毁，然后里面数据才会失效）。范围：整个web应用。

public class Servletdemo5 extends HttpServlet {
    @Override
    public void init() throws ServletException {
        //当demo5被创建初始化
        this.getServletContext().setAttribute("name","张三");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获得值
        String name = (String) this.getServletContext().getAttribute("name");
        System.out.println( "姓名"+name);
    }
}

public class Servletdemo5_2 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获得值
        String name = (String) this.getServletContext().getAttribute("name");
        System.out.println( "姓名"+name);
    }
}

Response响应对象

关于响应行
setStatus 设置状态码
200：成功
302：重定向
304：查找本地缓存
404：不存在
500：服务器内部错误
关于响应头

        response.setHeader()
        response.setDateHeader()
        response.setIntHeader()

set开头的方法：针对一个key对应一个value
举例：比如有一个头 content-Type:text/html setHeader(“content-Type”,”text/plain”);
最终得到头的结果：content-Type:text/plain

        response.addHeader()
        response.addDateHeader()
        response.addIntHeader()

add开头的方法：针对一个key对应多个value的情况。
举例：比如有一个content-Type:text/html addHeader(“content-Type”,”text/plain”);
最终得到头的结果：content-Type:text/html,text/plain

关于响应体

getOutputStream
getWriter

public class Servletsponce2 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        ServletOutputStream outputStream = response.getOutputStream();
        //设置浏览器默认打开时采用的字符集
        response.setHeader("content-Type","text/heml;charset=UTF-8");
//        //设置中文的字符编码
//        outputStream.write("中文".getBytes("UTF-8"));
        //设置responce获得字符流缓冲区的编码
        response.setCharacterEncoding("UTF-8");
        
        //简化代码
//        response.setContentType("text/heml;charset=UTF-8");
        response.getWriter().println("中文");
    }
}

关于重定向

sendRedirect

public class Servletresponce1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //完成重定向
        response.setStatus(302);
        //设置响应头
        response.setHeader("location","/ServletPro/hello");

    }
}

注意重定向路径：
在这里插入图片描述

    <servlet-mapping>
        <!--名字和上面的名字一样-->
        <servlet-name>HelloServlet</servlet-name>
        <!--配置访问路径,在主路径后加/hello会去到类路径-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

        //5秒刷新
        response.setContentType("test/html;charset=UTF-8");
        response.getWriter().println("5秒后跳转页面");
        response.setHeader("Refresh","5;url=/ServletPro/hello");

设置字符集

response.setContentType

设置响应字符流的缓冲区字符流

response.setCharacterEncoding

服务器向浏览器回写cookie的方法

response.addCookie

Request请求对象

获得客户机信息

获得请求的方式

getMethed

获得请求路径后的提交参数的字符串

getQueryString

获得请求路径的URL和URI

getRequestURI
getRequestURL

获得客户机的IP地址

getRemoteAddr

获得请求头的方法

获得一个key对应一个value的请求头

getHeaders

获得一个key对应多个value的请求头

getHeaders

获得请求参数的方法

获得提交的参数（一个name对应一个value）

getParameter

获得提交的参数（一个name对应多个value）

getParameterValues

获得提交的参数，将提交的参数的名称和对应的值存入到一个Map集合中

getParameterMap

Request作为域对象存取数据的方法

向request域中存数据

setAttribute

从request域中获取数据

getAttribute

从request域中移除数据

removeAttribute

public class Servletrequest1 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("请求方式：" + request.getMethod());
        System.out.println("ip地址：" + request.getRemoteAddr());
        System.out.println("请求参数：" + request.getQueryString());
        System.out.println("资源定位符url:" + request.getRequestURL());
        System.out.println("资源标识符uri:" + request.getRequestURI());
        System.out.println("浏览器类型：" + request.getHeader("User-Agent"));
        
    }

接收表单

<html>
<head>
  <meta charset="UTF-8">
  <title>Insert title here</title>
</head>
<body>
<h1>request接收表单参数</h1>
<form action="/ServletPro/request2" method="post">
  用户名:<input type="text" name="username"/><br/>
  密码:<input type="password" name="password"><br/>
  性别:<input type="radio" name="sex" value="man"/>男<input type="radio" name="sex" value="woman"/>女<br/>
  籍贯:<select name="city">
  <option value="beijing">北京市</option>
  <option value="shanghai">上海市</option>
  <option value="shenzhen">深圳市</option>
</select><br/>
  爱好:<input type="checkbox" name="hobby" value="basketball"/>篮球
  <input type="checkbox" name="hobby" value="football"/>足球
  <input type="checkbox" name="hobby" value="volleyball"/>排球<br/>
  自我介绍:<textarea name="info" rows="3" cols="8"></textarea><br/>
  <input type="submit" value="提交">
</form>
</body>
</html>

public class Servletrequest2 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("userneme");
        String password = request.getParameter("password");
        //接受爱好
        String [] hobby = request.getParameterValues("hobby");
        //接受自我介绍
        String info = request.getParameter("info");
        System.out.println("username" + username + "password" + password);
        System.out.println("爱好：" + Arrays.toString(hobby));
        System.out.println("自我介绍：" + info);

        //使用
        Map<String,String[]> map = request.getParameterMap();
        for (String key:map.keySet()){
            String[] value = map.get(key);
            System.out.println(key + "" + Arrays.toString(value));
        }
    }
}

乱码
我的get获取没有乱码

<form action="/ServletPro/request3" method="get">
  用户名:<input type="text" name="username"/><br/>
  <input type="submit" value="提交">
</form>
<form action="/ServletPro/request3" method="post">
  用户名:<input type="text" name="username"/><br/>
  <input type="submit" value="提交">
</form>

public class Servletrequest3 extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //用post处理中文乱码
        //设置缓冲区的编码
        request.setCharacterEncoding("UTF-8");
        String name = request.getParameter("username");
        System.out.println(name);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String name = request.getParameter("username");
        System.out.println(name);
    }
}

会话技术

Cookie技术

Cookie是客户端技术，程序把每个用户的数据以cookie的形式保存到各自浏览器中。当用户使用浏览器再次访问服务器中的web资源的时候，就会带着各自的数据过去。这样，web资源处理的就是用户各自的数据了。

获取浏览器带过来的cookie

request.getCookies

像浏览器回写cookie

response.addCookie(Cookie c)

cookie构造

cookie(String name,String value)

获得cookie名称

getName

获得cookie值

getValue

设置cookie有效域名
c.setDomain
设置cookie有效路径
c.setPath
设置cookie有效时长
c.setMaxAge
查找工具类

public class Cookieutils {
    public static Cookie findCookie(Cookie[] cookies,String name){

        if (cookies == null){
            //没有携带任何cookie
            return null;
        }else {
            for (Cookie cookie : cookies){
                if (name.equals(cookie.getName())){
                    return cookie;
                }
            }
        }
        //没有指定名称
        return null;
    }
}

业务类

public class Servletcookie extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Cookie[] cookies = request.getCookies();

        Cookie cookie = Cookieutils.findCookie(cookies,"lastvisit");
        //判断第一次访问
        if (cookie == null){
            response.setContentType("text/html;charset=UTF-8");
            response.getWriter().println("欢迎来到本网站");
        }else {
            //获得上一次访问时间
            String value = cookie.getValue();
            response.setContentType("text/html;charset=UTF-8");
            response.getWriter().println("上次访问时间为："+value+"");
        }
        //获得当前时间
        Date d = new Date();
        //存入Cookie
        Cookie c = new Cookie("lastvisit","kang");
        response.addCookie(c);

    }
}

默认级别的Cookie

指的是没有设置有效时间的Cookie，默认的情况下只要关闭了浏览器，Cookie也会被销毁。（Cookie存在于浏览器的内存中，当关闭了浏览器Cookie就销毁了）。

持久级别的Cookie

指的是有有效时间的Cookie，这种Cookie的内容不是保存在浏览器的内存中，将Cookie的内容保存（持久化）到硬盘上。这个时候，关闭浏览器，再次打开浏览器会加载硬盘上的文件，从而Cookie中的数据就不会丢失。

Session技术

Session是服务器端技术，利用这个技术，服务器在运行时为每一个用户的浏览器创建一个独享的session对象。由于session为用户浏览器独享，所有用户在访问服务器的时候，可以把各自的数据放在各自的session中，当用户再次访问服务器中的web资源的时候，其他web资源再从用户各自的session中取出数据为用户服务。

向Session中存入数据

setAttribute(Sting name,Object value)

向Session中获取数据

getAttribute(String name)

向Session中移除数据

removeAttribute(String name)

Servlet的域对象的总结

请求范围（ServletRequest）

何时创建和销毁的

创建：当用户向服务器发送一次请求，服务器创建一个request对象。
销毁：当服务器对这次请求作出了响应，服务器就会销毁这个request对象。

如何存取数据

存数据：
void setAttribute(String name,Object value);
取数据
Object getAttribute(String name);

作用范围

作用范围：一次请求。（转发就是一次请求）。

会话范围（HttpSession）

何时创建和销毁的

创建：服务器端第一次调用getSession()方法的时候。
销毁：三种情况。
Session过期，默认的过期时间30分钟(web.xml中配置)。
非正常关闭服务器。（正常关闭服务器—session会被序列化）。
手动调用session.invalidate();

如何存取数据

存数据：
void setAttribute(String name,Object value);
取数据
Object getAttribute(String name);

作用范围

作用范围：一次会话（多次请求）

应用范围（ServletContext）

何时创建和销毁的

创建：服务器启动的时候创建，为每个web项目创建一个单独ServletContext对象。
销毁：服务器关闭的时候，或者项目从服务器中移除的时候。

如何存取数据

存数据：
void setAttribute(String name,Object value);
取数据
Object getAttribute(String name);

作用范围

作用范围：整个应用

监听器的概述

什么是监听器
监听器就是一个实现了特定接口的Java类，这个Java类用于监听另一个Java类的方法调用或者属性的改变。当被监听对象发生上述事件后，监听器某个方法将会立即被执行。
监听器的用途
用来监听其他对象的变化的。主要应用在图形化界面开发上。
Java中GUI，Android
监听器的术语
事件源：指的是被监听对象（汽车）
监听器：指的是监听的对象（报警器）
事件源和监听器绑定：在汽车上安装报警器
事件：指的是事件源对象的改变（踹了汽车一脚）----主要功能获得事件源对象。

监听器的入门

public class MyservletContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("servletcontext创建了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("servletcontext销毁了");
    }
}

    <listener>
        <listener-class>servlet.demo1.MyservletContextListener </listener-class>
    </listener>

Servlet中的监听器

Servlet中的监听器简介
在Servlet中定义了多种类型的监听器，它们用于监听的事件源分别是ServletContext、HttpSession和ServletRequest这三个域对象。

Servlet中的监听器的分类

一类：监听三个域对象的创建和销毁的监听器（三个）
二类：监听三个域对象的属性变更（属性添加、移除、替换）的监听器（三个）
三类：监听HttpSession中JavaBean的状态改变（钝化、活化、绑定、解除绑定）的监听（两个）

ServletContextListener监听器的作用

用来监听ServletContext域对象的创建和销毁的监听器。

ServletContext创建和销毁

ServletContext
创建：在服务器启动的时候，为每个web应用创建单独的ServletContext对象。
销毁：在服务器关闭的时候，或者项目从web服务器中移除的时候。

public class MyservletContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("servletcontext创建了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("servletcontext销毁了");
    }
}

HttpSessionListener监听器作用

用来监听HttpSession对象的创建和销毁。
HttpSession创建和销毁
创建：
服务器端第一次调用getSession()方法时候。
销毁：
非正常关闭服务器（正常关闭服务器session会被序列化）。
Session过期（默认过期时间30分钟）。
手动调用session.invalidate()方法。

public class MyHttpSeessionListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        System.out.println("HttpSession创建");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("HttpSession销毁");

    }
}

问题

访问HTML是否创建Session		：不会
访问JSP是否创建Session		：会
访问Servlet是否创建Session	：不会（默认没有调用getSession方法）

ServletRequestListener监听器作用

用户监听ServletRequest对象的创建和销毁
ServletRequest对象的创建和销毁
创建
从客户端向服务器发送一次请求，服务器就会创建request对象。
销毁
服务器对这次请求作出了响应之后，request对象就销毁了。

public class MyServletRequestListener implements ServletRequestListener {
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {

    }

    @Override
    public void requestInitialized(ServletRequestEvent sre) {

    }
}

问题：
访问HTML页面是否创建请求对象	：会
访问JSP页面是否创建请求对象		：会
访问Servlet是否创建请求对象		：会
第三类监听器概述

监听三个域对象的属性变更的监听器

public class MyServletContextAttributeListeber implements ServletContextAttributeListener {
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {
        
    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {

    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {

    }
}

public class MySessionAttributeListeber implements HttpSessionAttributeListener {
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {

    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {

    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {

    }
}

public class MyServletRequestAttributeListeber implements ServletContextAttributeListener {
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {

    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {

    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {

    }
}

第三类

保存在Session域中的Java类可以有多种状态：绑定到session中；从session中解除绑定；随session对象持久化到一个存储设备中（钝化）；随session对象从一个存储设备中恢复（活化）。
Servlet对方中定义了两个特殊的监听的接口来帮助Java类了解自己在Session域中的状态：
HttpSessionBindingListener接口
HttpSessionActivationListener接口，
实现这两个接口的类不需要在web.xml中进行配置。

HttpSessionBindingListener监听器:

监听Java类在HttpSession中的绑定和解除绑定的状态的监听器：

public class Bean1 implements HttpSessionBindingListener {
    private String name;

    @Override
    public void valueBound(HttpSessionBindingEvent event) {

    }

    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

HttpSessionActivationListener监听器

监听HttpSession中Java类的钝化和活化监听器。

public class Bean2 implements HttpSessionActivationListener , Serializable {
    @Override
    public void sessionWillPassivate(HttpSessionEvent se) {
        System.out.println("钝化，存入磁盘");
    }

    @Override
    public void sessionDidActivate(HttpSessionEvent se) {
        System.out.println("活化");
    }
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Bean2

<%
    Bean2 bean2 = new Bean2();
    bean2.setName("bean2");
    session.setAttribute("bean2",bean2);
%>

META-INF下context.xml文件

<Context>
    <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
        <Store className="org.apache.catalina.session.FileStore" directory="itheima"/>
    </Manager>
</Context>

Bean2_2

${bean2.name}

配置完成session的序列化和反序列化
Context标签可以配置在：
tomcat/conf/context.xml :所有tomcat下虚拟主机和虚拟目录下的工程都会序列化session
tomcat/conf/Catalina/localhost/context.xml :localhost虚拟主机下的所有项目会序列化session
工程/META-INF/context.xml :当前工程才会序列化session。