Servle规范

最新推荐文章于 2022-07-08 11:11:30 发布

王千里

最新推荐文章于 2022-07-08 11:11:30 发布

阅读量327

点赞数

CC 4.0 BY-SA版权

文章标签： tomcat http servlet

本文链接：https://blog.csdn.net/weixin_44240362/article/details/120269894

本文详细介绍了Servlet规范，包括其在动态资源开发中的作用、Servlet接口实现类的创建和注册、Servlet对象生命周期、HttpServletResponse和HttpServletRequest接口的功能，以及多个Servlet间的调用规则。文章还探讨了数据共享方案，如ServletContext、Cookie、HttpSession和HttpServletRequest接口，以及Servlet监听器和Filter过滤器的作用和实现。通过对Servlet规范的深入理解，有助于提升Web应用的开发和管理效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Servlet规范

作用：

1、在servlet规范中，指定【动态资源文件】开发步骤

2、在Servlet规范中，指定http服务器调用动态资源文件规则

3、在Servlet规范中，指定http服务器管理动态资源文件实例对象规则

一、Servlet接口实现类

1、Servlet接口来自于Servlet规范下的一个接口，这个接口存在http服务器，提供jar包。

2、Tomcat服务器下lib文件中有一个Servlet-api.jar存放servlet接口（javax.servlet.Servlet接口）。

3、Servlet规范中，http服务器能调用的动态资源文件必须是Servlet接口的实现类。

二、Servlet接口实现类开发步骤：

1、创建一个java类，继承HttpServlet父类，使之成为一个Servlet接口实现类。

/** Servlet接口中有5个抽象方法：init、getServletConfig、getServletInfo、destroy （这四个方法对于实现类没用）
														 service()  这个方法有用


/** HelloServlet ————> HttpServlet(abstract) ————> GenericServlet(abstract) ————> Servlet(interface) */

/** 这里继承HttpServlet抽象类，是为了降低直接实现Servlet接口的难度 */

2、重写HttpServlet父类的两个方法。doGet，doPost（浏览器两种不同的请求方式对应不同的方法）

    /** 怎样判断调用doGet还是doPost？
     *  只需调用service()方法，父类HttpServlet中的service()方法会判断浏览器的请求方法
     *  HttpServlet ： service() {
     *                      if (请求方法 == GET){
     *                          this.doGet;
     *                      }else if (请求方法 == Post) {
     *                          this.doPost;
     *                      }
     *                          };
     * */

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    System.out.println("实现类根据浏览器发送Get请求方法处理");
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    System.out.println("实现类根据浏览器发送Post请求方法处理");
}

3、将Servlet接口实现类信息注册到Tomcat服务器

<?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接口实现类路径交给Tomcat -->
        <servlet>
            <servlet-name> helloServlet </servlet-name>
            <servlet-class>com.example.wzweb.HelloServlet</servlet-class>
        </servlet>

        <!-- 为servlet接口实现类提供简短别名 -->
        <servlet-mapping>
            <servlet-name>helloServlet</servlet-name>
            <url-pattern>/hs</url-pattern>
        </servlet-mapping>


</web-app>

三、Servlet对象生命周期

1、所有Servlet接口实现类的对象，只能由Http服务器(tomcat)负责创建。

2、Servlet对象创建时机:

1）大多数正常情况下，只有当第一个用户向Tomcat讨要某个Servlet时候，此时Tomcat才会负责创建这个Servlet的对象

2）在人工干预情况下，要求Tomcat在启动时，自动创建某个Servlet类的对象

<servlet>

      <servlet-name></servlet-name>

   		<servlet-class></servlet-class>
	  	<load-on-startup>8888</load-on-startup> //只要写入一个大于0的整数
	  	
</servlet>

3、一个Servlet接口实现类，在Tomcat运行期间，只能被创建一个实例对象

4、在Tomcat关闭时，由Tomcat负责销毁所有的Servlet对象

四、HttpServletResponse接口（将数据写入服务器响应包）

1、介绍：

1）HttpServletResponse接口来自Servlet规范中，在Tomcat中存在servlet-api.jar

2）HttpServletResponse接口实现类由Http服务器负责提供

3）HttpServletResponse接口负责将doGet/doPost方法执行结果【写入到响应包交给浏览器】

4）开发人员习惯于将HttpServletResponse接口修饰的对象称为【响应对象】

2、主要功能：

1）将执行结果以二进制的形式写入响应体

public class HelloServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
				
       /** 当执行结果为数字时，浏览器接受到的数据会被转换为ASCII码 */
        /** 解决：实际开发中，都是通过out.print()将真实数据写入响应体 */
      
        String str = "Servlet is running ....";
        System.out.println(str);

        /** 通过响应对象，向Tomcat索要输出流 */
        PrintWriter out = resp.getWriter();

        /** 通过输出流，将执行结果以二进制的形式写入响应体中 */
        out.print(str);
    }
    
}

2）设置响应头中【content-type】属性值

从而控制浏览器使用对应编译器将响应体二进制数据编译为【文字、图片、视频、命令】

public class HelloServlet02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 将执行结果中的html标签当做命令展示出来
         *  浏览器在就收到响应包之后，会根据【响应头中的content-type】属性的值
         *  来采用对应的编译器对响应体中的二进制数据进行编译
         *  默认情况下content-type的值为text【文本】
         *  要想执行html标签，需要在的到输出流之间更改响应头中的content-type的值
         * */
        String str = "Java<br>Html<br>mysql<br>Spring<br>";

        String str1 = "杜兰特<br>哈登<br>欧文<hr>";

        /** 设置响应头中的content-type值
         *  "text/html" 表示：告知浏览器使用文本编译器和html命令编译器编译响应体内容
         *  响应体包含中文，需要加上charset=utf-8
         **/
        response.setContentType("text/html;charset=utf-8");

        /** 通过响应对象，向Tomcat索要输出流 */
        PrintWriter out = response.getWriter();

        out.print(str);
        out.print(str1);


    }

}

3）设置响应头中的【location】属性，将一个请求的地址赋值给location，从而控制浏览器向指定服务器发送请求

public class HelloServlet03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String str = "http://www.baidu.com";

        /** 通过响应对象，通过调用sendRedirect()方法，将地址赋值给响应头中的location属性 */
        response.sendRedirect(str);  //响应头  location = http://www.baidu.com

        /** 浏览器在收到响应之后，如果发现响应头中存在location属性
         *  自动通过地址栏向location指定的网站发送请求
         *  sendRedirect 方法控制浏览器请求行为 【请求地址、请求方式、请求参数】
         * */
    }
    
}

五、HttpServletRequest接口

1、介绍

1）HttpServletRequest接口来自与Servlet规范中，在Tomcat中存在servlet-api.jar

2）HttpServletResponse接口实现类由Http服务器负责提供

3）HttpServletResponse接口负责在doGet.doPost方法运行时，【读取http请求协议包中的信息】

4）开发人员习惯于将HttpServletResponse接口修饰的对象称为【请求对象】

2、作用

1）读取http请求协议包中【请求行】（包含URL请求地址和 Method请求方式）信息

public class HelloServlet01 extends HttpServlet {

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

        /** 1. 通过请求对象读取【请求行】中的【url】信息 */
        /** getRequestURL()返回的类型是Stringbuffer */
        String url = req.getRequestURL().toString();

        /** 2. 通过请求对象读取【请求行】中的【method】信息 */
        String method = req.getMethod();

        /** 3. 通过请求对象读取【请求行】中的【uri】信息 */
        /** uri : 资源文件精准定位地址
         *  请求行中并没有uri属性，是从URL中截取的字符串
         *  格式： /网站名/资源文件名
         *  用于让http服务器对被访问的资源文件进行定位
         */
        String uri = req.getRequestURI();

        /** 将结果输出到控制台 */
        System.out.println("URL = " + url);
        System.out.println("Method = " + method);
        System.out.println("URI = " + uri);

    }
}

2）读取保存在http请求协议包中【请求头】或者【请求体】中参数信息

public class HelloServlet02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 通过请求对象获得【请求头】中的【所有参数名】 */
        Enumeration<String> names = request.getParameterNames();

        while (names.hasMoreElements()){
            String s = names.nextElement();
            /** 通过请求对象读取指定的请求参数的值 */
            String value = request.getParameter(s);
            System.out.println("请求参数名(Get)：" + s + "，值：" + value );
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      
      	/** 请求头二进制内容由当前对象(Request)负责解码，使用ISO-8859-1字符集
         * 如果请求体中参数内容有中文时，无法解码，显示乱码
         * 使用setCharacterEncoding("utf-8") 设置解码方式 */
        req.setCharacterEncoding("utf-8");
      
        /** 2. 通过请求对象获得【请求体】中的【所有参数名】 */
        Enumeration<String> names = req.getParameterNames();

        while (names.hasMoreElements()){
            String s = names.nextElement();
            /** 通过请求对象读取指定的请求参数的值 */
            String value = req.getParameter(s);
            System.out.println("请求参数名(Post)：" + s + "，值：" + value);
        }
        
    }
}

3）代替浏览器向http服务器申请资源文件的调用

六、请求对象和响应对象的生命周期

1、在http服务器接收到浏览器发送的【请求协议包】之后，会自动创建一个【请求对象】和一个【响应对象】

2、在http服务器调用doGet/doPost方法时，将【请求对象】和【响应对象】作为实参传递到方法

确保的doGet/doPost执行

3、在http服务器准备推送响应包之前，负责将本次请求关联的【请求对象】和【响应对象】销毁

*** 【请求对象】和【响应对象】的生命周期贯穿一次请求的处理过程

*** 【请求对象】和【响应对象】相当于用户在服务端的代言人

【请求对象】负责将浏览器发送的参数交给http服务器，调用响应的方法。

【响应对象】负责将http服务器处理的结果放入【响应包】中发给浏览器

七、多个Servlet之间的调用规则

1、前提条件：

某些浏览器发送的请求，需要多个Servlet协同处理，但是浏览器一次只能访问一个Servlet，导致需要用户手动发起多次请求。

2、解决方案：

1）重定向解决方案

2）请求转发解决方案

八、重定向解决方案

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VXWscNlQ-1631521736898)(/Users/wz/Pictures/笔记截图/Servlet重定向原理.png)]

使用 sendRedirect() 实现

1、请求地址：

既可以把网站内部的资源文件发送给浏览器，也可以是其他网站资源文件。

2、请求次数：

浏览器至少发送两次请求，只有一次是用户手动发送的，后续为浏览器自动发送。

3、请求方式：

GET

4、缺点：

需要在浏览器与服务器之间进行多次往返，耗费时间，增加用户等待服务的时间。

public class HelloServlet03 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        /** 重定向解决方案 */
        resp.sendRedirect("/webtest/test04");

    }
}

public class HelloServlet04 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String str = "Servlet重定向解决方案....";

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

        PrintWriter out = resp.getWriter();

        out.print(str);

    }
}

九、请求转发解决方案

1、原理：用户第一次通过手动方式要求浏览器访问Servlet，第一个Servlet工作完毕后，通过当前请求对象代替浏览器向 Tomcat发送请求，申请调用第二个Servlet。Tomcat收到请求后自动调用第二个Servlet来完成剩余任务。

2、实现命令：请求对象代替浏览器向Tomcat发送请求

1）通过当前请求对象生成资源文件申请报告对象

RequestDispatcher report = request.getRequestDispatcher("/资源文件名");

2）将报告对象发送给Tomcat

report.forward(当前请求对象,当前响应对象);

3、优点

1）无论本次请求涉及到多少个Servlet，用户只需要手动通过浏览器发送一次请求。

2）Servlet之间调用发送在服务器上，节省服务器与浏览器之间的通信时间，增加处理服务的速度。

4、特征

1）请求的次数：浏览器只发送了一次请求

2）请求地址：只能向Tomcat申请调用当前网站下资源文件地址

3）请求方式：在请求转发过程中，浏览器只发送了一个Http协议包，参与本次请求的所有Servlet共享同一个协议包，因此这些Servlet接受的请求方式与浏览器发送的请求方式保持一致。

十、多个Servlet之间数据共享实现方案

1、ServletContext接口

2、Cookie类

3、HttpSession接口

4、HttpServletRequest接口

十一、ServletContext接口（1）

1、介绍：

1）来自于Servlet规范中的一个接口，在Tomcat中存在于Servlet-api.jar

2）如果两个Servlet来自于同一个网站，彼此之间可以通过网站的ServletContext实例对象实现数据共享。

3）开发人员习惯于将ServletContext称为【全局作用域对象】

2、工作原理：

每一个网站都存在一个【全局作用域对象】，相当于一个Map。在这个网站中OneServlet可以将一个数据存入到全局作用域对象，当前网站中其他Servlet此时都可以从全局作用域对象得到数据进行使用。

3、全局作用域对象生命周期

1）在Http服务器启动过程中，自动为当前网站在内存中创建一个全局作用域对象。

2）在Http服务器运行期间，一个网站只有一个全局作用域对象。

3）在Http服务器运行期间，全局作用域对象一直处于活跃状态。

4）在Http服务器准备关闭时，将全局作用域对象销毁。

4、命令实现：

public class ScServlet01 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        /** 1. 通过【请求对象】获取当前网站中的【全局作用域对象】 */
        ServletContext application = req.getServletContext();

        /** 2. 将数据添加到全局作用域作为【共享数据】
         *      application.setAttribute("key",数据);
         * */
        application.setAttribute("key01",500);

    }
}

public class ScServlet02 extends HttpServlet {

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

        /** 1. 通过【请求对象】获取当前网站中的【全局作用域对象】 */
        ServletContext application = request.getServletContext();

        /** 2. 从全局作用域对象得到指定关键字的对应的值 */
        Integer value01 = (Integer) application.getAttribute("key01");

    }
}

十二、Cookie（2）

1、介绍：

1）Cookie来自Servlet规范中的一个工具类

2）如果两个Servlet来自同一个网站，并且为同一个浏览器/用户提供服务，此时借助于Cookie对象进行数据共享。

3）Cookie存放用户个人的私人数据，在共享数据过程中提高服务质量

4）在现实生活中，Cookie相当于用户在服务端的【会员卡】

2、原理：

用户通过浏览器第一次向网站发送请求，申请OneServlet，OneServlet在运行期间创建一个Cookie存储当前用户相关数据，OneServlet工作完毕后，将Cookie写入【响应头】交还给当前浏览器。

浏览器收到【响应包】后，将Cookie存储在浏览器的缓存，一段时间后，用户通过【同一个浏览器】在此向相同网站发送请求申请TwoServlet时，【浏览器需要无条件的将该网站之前推送的Cookie，写入请求头发送给服务器】。

此时TwoServlet在运行时，就可以通过读取【请求头】中的Cookie中信息，得到OneServlet共享的数据。

3、实现命令：同一个网站，两个Servlet实现数据共享

/**
 *  Servlet 实现数据共享：
 *          二、Cookie
 */

public class CookieServlet01 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 创建一个Cookie对象，保存共享数据（当前用户数据）
         *      Cookie相当于一个Map，一个Cookie只能存放一个键值对
         *      这个键值对的key和value只能使String
         *      键值对中的key不能是中文
         * */
        Cookie cookie01 = new Cookie("key1","wz");
        Cookie cookie02 = new Cookie("key2","123");

        /** 2. 将Cookie写入【响应头】，发送给浏览器 */
        response.addCookie(cookie01);
        response.addCookie(cookie02);
        
    }
}

/**
 *  Servlet 实现数据共享：
 *          二、Cookie
 */

public class CookieServlet02 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 调用请求对象从【请求头】中获取浏览器返回的Cookie */
        Cookie[] cookies = request.getCookies();

        /** 2. 遍历数组，获取每一个Cookie的key和value */
        PrintWriter out = response.getWriter();

        for (Cookie cookie : cookies){
            String key = cookie.getName();  //读取key
            String value = cookie.getValue();   //读取value
            out.print("key = " + key + "value = " + value);
        }

    }
}

4、生命周期

1）在默认情况下，，Cookie对象存放在浏览器缓存中，因此只要关闭浏览器，Cookie对象就被销毁。

2）在手动设置的情况下，可以要求浏览器将接受的Cookie存放在客户端计算机硬盘上，同时需要指定存活的时间，到时间自动销毁。

cookie.setMaxAge(60);  //表示cookie在硬盘中存活60s

十三、HttpSession接口（3）

1、介绍：

1）HttpSession接口来自Servlet规范中，在Tomcat中存在servlet-api.jar

2）如果两个Servlet来自同一个网站，并且为同一个浏览器/用户提供服务，此时借助于HttpSession对象进行数据共享。

3）开发人员将HttpSession接口对象称为【会话作用域对象】

2、HttpSession 与 Cookie 的区别【面试题】

1）存放位置：

Cookie存放在客户端计算机中

HttpSession存放在服务端计算机内存

2）数据类型：

Cookie：String

HttpSession：任意类型Object

3）数据数量：

一个Cookie对象只能存放一个共享数据。

HttpSession使用Map集合存储共享数据，可以存放任意数量数据。

4）参照物：

Cookie相当于客户端在服务端的【会员卡】

HttpSession相当于客户端在服务端的【私人保险柜】

3、命令实现

/**
 *  HttpSession 接口 ：会话作用域对象
 * 
 * */
public class HsServlet01 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 调用请求对象获取当前请求的会话作用域对象
         *      request.getSession()  会先判断Session对象是否存在，如果存在就获取，不存在就创建
         * */
        HttpSession session = request.getSession();

        /** 2. 将数据添加到会话作用域对象 */
        session.setAttribute("key01","wz");

    }
}

/**
 *  HttpSession 接口 ：会话作用域对象
 *
 * */
public class HsServlet02 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 通过请求对象获取会话作用域对象 */
        HttpSession session = request.getSession();

        /** 2. 取出数据 */
        Object key01 = session.getAttribute("key01");

        System.out.println("key01 = " + key01);

    }
}

十四、HttpServletRequest接口实现数据共享（4）

1、介绍：

1）在同一个网站中，如果两个Servlet之间通过【请求转发】方式进行调用，彼此之间共享同一个请求协议包。而一个请求协议包对应一个请求对象，因此Servlet之间共享一个请求对象，此时可以利用这个请求对象在两个Servlet之间时间数据共享。

2）在请求对象实现Servlet之间数据共享时，开发人员将请求对象称为【请求作用域对象】

2、命令实现：

@WebServlet("/hr01")
public class HrServlet01 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 将数据添加到【请求作用域对象】中的Attribute属性 */
        request.setAttribute("key01","Hello World ! ");  //存放的数据类型可以是任意的Object

        /** 2. 通过当前请求对象生成资源文件申请报告对象，向Tomcat申请调用 HrServlet02 */
        request.getRequestDispatcher("/hr02").forward(request,response);
        
    }
    
}

@WebServlet("/hr02")
public class HrServlet02 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        /** 1. 从当前请求对象中获取共享数据 */
        String value = (String) request.getAttribute("key01");

        /** 获取输出流，写入响应体，交给浏览器 */
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().print("hr02获得共享数据：" + value);

    }
}

十五、Servlet监听器接口

1、介绍

1）一组来自Servlet规范下的接口，共有8组，在Tomcat存在servlet-api.jar包

2）监听器接口需要由开发人员亲自实现，Http服务器提供jar包并没有对应的实现类

3）监听器接口用于监控【作用域对象生命周期变化时刻】以及【作用域对象共享数据变化时刻】

2、作用域对象

1）在servlet规范中，认为在服务端内存中可以在某些条件下为多个servlet之间提供数据共享方案的对象

被称为【作用域对象】。

2）Servlet规范下的作用域对象

ServletContext：全局作用域对象

HttpSession：会话作用域对象

HttpServletRequest：请求作用域对象

3、监听器接口实现类开发规范：三步

1）根据监听的实际情况，选择对应监听器接口进行实现。

2）重写监听器接口中的【监听事件处理方法】

3）在web.xml中将监听器接口实现类注册到Http服务器

4、ServletContextListener接口

1）作用：检测全局作用域对象的生命周期

2）监听事件处理方法：

public void contextInitlized();     //在全局作用域对象被Http服务器初始化时被调用

public void contextDestory();       //在全局作用域对象被Http服务器销毁时被调用

/**
 * 全局作用域对象监听器实现类
 */

public class OneListener implements ServletContextListener {

    /**在全局作用域对象被Http服务器初始化时被调用*/
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("全局作用域对象已被创建.....");
    }

    /** 在全局作用域对象被Http服务器销毁时被调用 */
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("全局作用域对象已被销毁......");
    }
}

//在web.xml中注册监听器
 <!-- 将监听器接口注册到Tomcat -->
    <listener>
        <listener-class>com.example.listener.OneListener</listener-class>
    </listener>

5、ServletContextAttributeListener接口

1）作用：检测全局作用域对象共享数据的变化时刻

2）监听时间处理方法：

public void contextAdd();        //在全局作用域对象添加数据时调用

public void contextReplaced();   //在更新数据时调用

public void contextRemove();     //在数据删除时调用

/**
 * 全局作用域对象监听器实现类：
 *           ServletContextAttributeListener接口实现类
 */
public class TwoListener implements ServletContextAttributeListener {

    @Override
    public void attributeAdded(ServletContextAttributeEvent event) {
        System.out.println("全局作用域对象新增了共享数据......");
    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent event) {
        System.out.println("删除了共享数据....");
    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent event) {
        System.out.println("更新了共享数据.....");
    }

}

//监听测试类
@WebServlet("/listener")
public class TwoServlet extends HttpServlet {

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

        /** 获取全局作用域对象 */
        ServletContext context = request.getServletContext();

        /** 添加数据 */
        context.setAttribute("key","007");

        /** 更新数据 */
        context.setAttribute("key","110");

        /** 删除数据 */
        context.removeAttribute("key");


    }
}

十六、Filter过滤器接口

1、作用：

1）拦截Http服务器，帮助Http服务器检测当前请求的合法性。

2）拦截Http服务器，对当前请求进行增强操作。

2、步骤：

1）创建Filter接口实现类

2）重写接口中的方法

3）web.xml 注册过滤器

/**
 * 过滤器接口实现类
 */
public class OneFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        /** 1. 通过拦截请求对象得到请求包参数信息
         *         http://localhost:8080/webtest/cat.gif?age=18
         **/
        String age = request.getParameter("age");

        /** 2. 判断参数是否符合要求 */
        if (Integer.valueOf(age) >= 18){
            //合法请求，将拦截的请求对象 和 响应对象 交还给Tomcat，完成请求
            chain.doFilter(request,response);
        }else {
            //不合法过滤器代替服务器拒绝浏览器的请求
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
            out.print("<center><font style='color:red;font-size:40px'>年龄不符合要求！</font></center>");
        }
        
    }
}

  <!-- 将过滤器接口注册到Tomcat -->
    <filter>
        <filter-name>filter</filter-name>
        <filter-class>com.example.filter.OneFilter</filter-class>
    </filter>
    <!-- 通知Tomcat在调用什么资源文件时需要被当前过滤器拦截 -->
    <filter-mapping>
        <filter-name>filter</filter-name>
        <url-pattern>/cat.GIF</url-pattern>
    </filter-mapping>

3、防止用户恶意登录

 /** 4. 调用响应对象，根据验证结果将不同的资源文件地址写入响应头，交给浏览器 */
        if (result == 1){
            //用户存在
            //用户存在后，通过请求对象向Tomcat为当前对象申请一个HttpSession
            req.getSession();
            resp.sendRedirect("/ExamSystem/index.html");
        } else {
            resp.sendRedirect("/ExamSystem/Login_Error.html");
        }

/** 索要当前用户在服务端的HttpSession，判断当前用户是否是恶意登录 */
        //表示当前用户所用存在HttpSession，就返回其HttpSession，如果没有就返回null
        HttpSession session = req.getSession(false);
        if (session == null){
            //当前用户没有HttpSession
            resp.sendRedirect("/ExamSystem/Login_Error.html");
            return;
        }