Servlet教程课程笔记

一. Servlet规范介绍
1.servlet规范来自于JavaEE规范中的一种。
2.作用：
       1）在Servlet规范中，指定【动态资源文件】开发步骤；
       1）在Servlet规范中，指定Http服务器调用动态资源文件规则；
       1）在Servlet规范中，指定Http服务器管理动态资源文件实例对象规则。

二. Servlet接口实现类
1.Servlet接口是来自于Servlet规范下的一个接口，这个接口存在于Http服务器提供的jar包中。

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

3.Servlet规范中认为，Http服务器能调用的【动态资源文件】必须是一个Servlet接口实现类。
例如：

class Student{
	//不是动态资源文件，Tomcat无权调用
}

class Teacher implements Servlet{
	//合法动态资源文件，Tomcat有权调用
}

三. Servlet接口实现类开发步骤
       第一步：创建一个Java类继承于HttpServlet父类，使之成为一个Servlet接口实现类。

package com.lilanlan.controller;

import javax.servlet.http.HttpServlet;

/*
servlet接口包括五个方法：
	init()
	getServletConfig()
	service()
	getServletInfo()
	destroy()
其中，只要service()方法是我们需要的。
OneServlet--->HttpServlet--->GenericServlet--->Servlet
GenericServlet类中实现了除service()之外的四种方法；
HttpServlet中实现了service()方法，且在service方法的实现中，根据请求方式调用了doGet和doPost方法；
OneServlet重写HttpServlet中的doGet和doPost方法。
*/
public class OneServlet extends HttpServlet {
    
}

       第二步：重写HttpServlet中的两个方法，doGet或者doPost。

通过父类决定在何种情况下调用子类中的方法——>模板设计模式
HttpServlet：	service(){
					if(请求方式==GET){
						this.doGet
					}else if(请求方式==POST){
						this.doPost
					}
				}
OneServlet：	doGet()
				doPost()

Servlet oneServlet = new OneServlet();
oneServlet.service(); 

       第三步：将Servlet接口实现类信息【注册】到Tomcat服务器。（web.xml文件）

<!--将Servlet接口实现类类路径地址交给Tomcat-->
<servlet>
	<servlet-name>myservlet</servlet-name>  <!--声明一个变量存储servlet接口实现类类路径-->
	<servlet-class>com.lilanlan.controller.OneServlet</servlet-class>  <!--声明servlet接口实现类类路径-->
</servlet>

<!--以上配置完后，用户可通过http://localhost:8080/servlettest01/com/lilanlan/controller/OneServlet.class地址访问到动态资源文件-->
<!--为了降低用户访问Servlet接口实现类的难度，需要设置简短请求别名-->
<servlet-mapping>
	<servlet-name>myservlet</servlet-name>
	<url-pattern>/oneservlet</url-pattern>  <!--设置简短请求别名，别名在书写时必须以'/'为开头-->
</servlet-mapping>

四. Servlet对象生命周期
1.网站中所有的Servlet接口实现类的实例对象只能由Http服务器负责创建，开发人员不能手动创建Servlet接口实现类的实例对象。

2.在默认的情况下，Http服务器接收到关于当前Servlet接口实现类第一次的请求时，自动创建这个Servlet接口实现类的实例对象。

在手动配置的情况下，要求Http服务器在启动时自动创建某个Servlet接口实现类的实例对象。

<servlet>
        <servlet-name>myservlet</servlet-name>
        <servlet-class>com.lilanlan.controller.OneServlet</servlet-class>
        <load-on-startup>1</load-on-startup>  <!--随意填写一个大于0的整数即可-->
</servlet>

3.在Http服务器运行期间，一个Servlet接口实现类只能被创建出一个实例对象。（单例多进程）

4.在Http服务器关闭的时刻，会自动将网站中所有的Servlet对象进行销毁。

五. HttpServletResponse接口
1.介绍
       1）HttpServletResponse接口来自于Servlet规范中，存在于servlet-api.jar
       2）HttpServletResponse接口实现类由Http服务器负责提供
       3）HttpServletResponse接口负责将doGet/doPost方法执行结果写入到【响应体】中交给浏览器
       4）开发人员习惯于将HttpServletResponse接口修饰的对象称为【响应对象】

2.主要功能
       1）将执行结果以二进制形式写入到【响应体】
       2）设置响应头中【content-type】属性值，从而控制浏览器使用对应编译器将响应体二进制数据编译为【文字、图片、视频、命令】
       3）设置响应头中【location】属性，将一个请求地址赋值给location，从而控制浏览器向指定服务器发送请求

（1）响应对象将结果写入到响应体

public class OneServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String result = "Hello World";

        //----------响应对象将结果写入到响应体------------start

            //1)通过响应对象，向Tomcat索要输出流
            PrintWriter out = response.getWriter();
            //2）通过输出流，将执行结果以二进制形式写入到响应体
            out.write(result);

        //----------响应对象将结果写入到响应体------------end
    }//doGet执行完毕
    //Tomcat将响应包推送给浏览器
}

（2）使用out.writer()方法可以将【字符、字符串、ASCII码】写入到响应体中，当输出一个整数时，实际上会将该整数当作ASCII码，最后浏览器会显示该ASCII码对应的值。实际开发过程中，可以通过out.print()方法将真实数据写入到响应体中。

public class TwoServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        int money = 50;

        PrintWriter out = response.getWriter();
        //out.write(money);
        out.print(money);
    }
}

（3）HTML标签命令显示问题：

String result = "Java<br/>Mysql<br/>HTML<br/>";
PrintWriter out = response.getWriter();
out.print(result );

问题描述：直接使用out.print()方法输出响应结果，并不会将其中的HTML标签命令执行，而是当成普通的字符串。

问题原因：浏览器在接收到响应包之后，根据【响应头中的content-type】属性的值，来采用对应的【编译器】对【响应体中的二进制内容】进行编译处理。在默认情况下，content-type属性的值为“text”，此时浏览器会采用【文本编译器】对响应体二进制数据进行解析。

解决方案：一定要在得到输出流之前，通过响应对象对响应头中的content-type属性进行一次重新赋值，用于指定浏览器采用正确的编译器。

public class ThreeServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String result = "Java<br/>Mysql<br/>HTML<br/>";

        //设置响应头的content-type
        response.setContentType("text/html");

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

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

（4）设置字符编码格式

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

（5）控制浏览器向指定服务器发送请求

public class FourServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String result = "http://www.baidu.com";
        
        //通过响应对象，将地址赋值给响应头中的location属性
        response.sendRedirect(result);
    }
}

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

六. HttpServletRequest接口
1.介绍
       1）HttpServletRequest接口来自于Servlet规范中，在Tomcat中存在servlet-api.jar
       2）HttpServletRequest接口实现类由Http服务器负责提供
       3）HttpServletRequest接口负责在doGet/doPost方法运行时读取Http请求协议包中信息
       4）开发人员习惯于将HttpServletRequest接口修饰的对象称为【请求对象】

2.主要功能
       1）可以读取Http请求协议包中的【请求行】信息
       2）可以读取保存在Http请求协议包中【请求头】或者【请求体】中的请求参数信息
       3）可以代替浏览器向Http服务器申请资源文件的调用

1）读取请求行中的信息（url和method属性）

public class OneServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1）通过请求对象，读取【请求行】中的【url】信息
        String url = request.getRequestURL().toString();

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

        //3）通过请求信息，读取【请求行】中的uri信息
        /*
        *URI：资源文件精准定位地址，在请求行中并没有URI这个属性。
        *     实际上URI是从URL中截取的一个字符串，这个字符串的格式为"/网站名/资源文件名"。
        *     URI用于让Http服务器对被访问的资源文件进行定位。
         */
        String uri = request.getRequestURI();

        System.out.println("URL："+url);
        System.out.println("method："+method);
        System.out.println("uri："+uri);
    }
}

2）读取请求头（get）中的请求参数信息

public class TwoServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1）通过请求对象获得【请求头】中的【所有请求参数名】
        Enumeration paramNames = request.getParameterNames();
        while(paramNames.hasMoreElements()){
            String paramName = (String)paramNames.nextElement();
            //2）通过请求对象读取指定的请求参数的值
            String value = request.getParameter(paramName);
            System.out.println("请求参数名："+paramName+" 请求参数值："+value);
        }
    }
}

3）读取请求体（post）中的请求参数信息（和get一样）

public class ThreeServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //通过请求对象，读取【请求体】中的参数信息
        String username = req.getParameter("username");
        System.out.println("从请求体中得到参数值："+username);
    }

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

        //通过请求对象，读取【请求头】中的参数信息
        String username = request.getParameter("username");
        System.out.println("从请求头中得到参数值："+username);
    }
}

4）问题：当以get方式发送中文参数内容时，得到正常结果，但是以post方式发送中文参数内容时，得到乱码结果。

原因：浏览器以get方式发送请求，请求参数保存在【请求头】中，在Http请求协议包到达Http服务器之后，第一件事就是进行解码，请求头二进制内容由Tomcat负责解码，Tomcat9.0默认使用【utf-8】字符集。
而浏览器以post方式发送请求，请求参数保存在【请求体】中，在Http请求协议包到达Http服务器之后，第一件事就是进行解码，请求体二进制内容由当前请求对象（request）负责解码。request默认使用的是【ISO-8859-1】字符集。

解决：在post请求方式下，在读取请求体内容之前，应该通知请求对象使用utf-8字符集对请求内容进行一次重新解码。

protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //通知请求对象，使用utf-8字符集对请求体二进制内容进行一次重新编码
        req.setCharacterEncoding("utf-8");

        //通过请求对象，读取【请求体】中的参数信息
        String username = req.getParameter("username");
        System.out.println("从请求体中得到参数值："+username);
    }

七.请求对象与响应对象的生命周期
1.在Http服务器接收到浏览器发送的【Http请求协议包】之后，自动为当前的【Http请求协议包】生成一个【请求对象】和一个【响应对象】。

2.在Http服务器调用doGet/doPost方法时，负责将【请求对象】和【响应对象】作为实参传递到方法，确保doGet/doPost方法正确执行。

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

** 【请求对象】和【响应对象】生命周期贯穿一次请求的处理过程中。
** 【请求对象】和【响应对象】相当于用户在服务端的代言人。

八. 实例：在线考试管理系统开发环境搭建
1.准备工作

2.用户信息注册流程图

九. 欢迎资源文件
1.前提：用户可以记住网站名，但是不会记住网站资源文件名。

2.默认欢迎资源文件：用户发送了一个针对某个网站的【默认请求】时，此时由Http服务器自动从当前网站中返回的资源文件。
       正常请求：http://localhost:8080/myweb/index.html
       默认请求：http://localhost:8080/myweb/

3.Tomcat对于默认欢迎资源文件定位规则
1）规则位置：Tomcat安装位置/conf/web.xml
2）规则命令：

    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

4.设置当前网站的默认欢迎资源文件规则
1）规则位置：网站/web/WEB-INF/web.xml
2）规则命令：

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

3）网站设置自定义默认文件定位规则，此时Tomcat自带定位规则将失效

十. Http状态码
1.介绍
       1）由三位数字组成的一个符号。
       2）Http服务器在推送响应包之前，根据本次请求处理情况，将Http状态码写入到响应包中的【状态行】上。
       3）如果Http服务器针对本次请求，返回了对应的资源文件，通过Http状态码通知浏览器应该如何处理这个结果。
       如果Http服务器针对本次请求，无法返回对应的资源文件，通过Http状态码向浏览器解释不能提供服务的原因。

2.分类
       组成：100-599；分为5个大类
1）1XX：
       最有特征的是100：通知浏览器本次返回的资源文件并不是一个独立的资源文件，需要浏览器在接收响应包之后，继续向Http服务器索要依赖的其他文件。
2）2XX：
       最有特征的是200：通知浏览器本次返回的资源文件是一个完整的独立资源文件，浏览器在接收到之后不需要索要其他关联文件。
3）3XX：
       最有特征的是302：通知浏览器本次返回的不是一个资源文件内容，而是一个资源文件地址，需要浏览器根据这个地址自动发起请求索要这个资源文件。
4）4XX：
       404：通知浏览器，由于在服务端没有定位到被访问的资源文件，因此无法提供帮助。
       405：通知浏览器，在服务端已经定位到被访问的资源文件（servlet），但是这个servlet对于浏览器采用的请求方式不能处理。
5）5XX：
       最有特征的是500：通知浏览器，在服务端已经定位到被访问的资源文件（servlet），这个servlet可以接收浏览器采用的请求方式，但是servlet在处理请求的期间，由于Java异常导致处理失败。

十一. 多个servlet之间的调用规则
1.前提条件：
       无论本次请求涉及到多少个servlet，用户只需要手动通知浏览器发起一次请求即可，而不是浏览器一次只能访问一个servlet。

2.多个servlet之间调用规则：
1）重定向解决方案
2）请求转发解决方案

十二. 重定向解决方案
1.工作原理：用户第一次通过【手动方式】通知浏览器访问OneServlet，OneServlet工作完毕之后，将TwoServlet地址写入到【响应头的location属性】中，Tomcat就将【302状态码】写入到【状态行】中。
       在浏览器接收到响应包之后，会读取到【302状态码】。此时浏览器自动根据【响应头中的location属性】的地址发起第二次请求，访问TwoServlet去完成请求中的剩余任务。

2.实现命令：

response.sendRedirect("请求地址");

将地址写入到响应包中响应头中的location属性。

3.特征
1）请求地址：既可以把当前网站内部的资源文件地址发送给浏览器（/网站名/资源文件名），也可以把其他网站资源文件地址发送给浏览器（http://ip地址:端口号/网站名/资源文件名）。
2）请求次数：浏览器至少发送两次请求，但是只有第一次请求是用户手动发送的，后续请求都是浏览器自动发送的。
3）请求方式：重定向解决方案中，通过地址栏通知浏览器发起下一次请求，因此通过重定向解决方案调用的资源文件接受的请求一定是【GET】。

4.缺点：重定向解决方案需要在浏览器与服务器之间多次往返，大量时间消耗在往返次数上，增加用户等待服务时间。

十三. 请求转发解决方案
1.工作原理：用户第一次通过手动方式要求浏览器访问OneServlet，OneServlet工作完毕后，通过当前的请求对象代替浏览器向Tomcat发送请求，申请调用TwoServlet。Tomcat在接收到这个请求之后，自动调用TwoServlet来完成剩余任务。

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

//1)通过当前请求对象生成资源文件申请报告对象
RequestDispatcher report = request.getRequestDispatcher("/资源文件名"); //这里的资源文件名一定要以“/”开头
//2)将报告对象发送给Tomcat
report.forward(当前请求对象,当前响应对象);

3.特征
1）请求次数：在请求转发过程中，浏览器只发送一次请求。
2）请求地址：只能向Tomcat服务器申请调用当前网站下的资源文件地址。
3）请求方式：在请求转发过程中，浏览器只发送了一个Http请求协议包，参与本次请求的所有Servlet共享同一个请求协议包，因此，这些servlet接收的请求方式与浏览器发送的请求方式保持一致。

4.优点
1）无论本次请求涉及到多少个Servlet，用户只需要手动通过浏览器发送一次请求。
2）Servlet之间调用发生在服务端计算机上，节省服务端与浏览器之间的往返次数，增加处理服务速度。

十四. 多个Servlet之间数据共享实现方案
1.数据共享：OneServlet工作完毕后，将产生的数据交给TwoServlet来使用。

2.Servlet规范中提供四种数据共享方案：
1）ServletContext接口
2）Cookie类
3）HttpSession接口
4）HttpServletRequest接口

十五. ServletContext接口
1.介绍
1）来自于Servlet规范中的一个接口，在Tomcat中存在servlet-api.jar中，在Tomcat中负责提供这个接口的实现类。
2）如果两个servlet来自于同一个网站，彼此之间可以通过网站的ServletContext实例对象实现数据共享。
3）开发人员习惯于将ServletContext对象称为【全局作用域对象】。

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

3.全局作用域对象生命周期
1）在Http服务器启动过程中，自动为当前网站在内存中创建一个全局作用域对象。
2）在Http服务器运行期间，一个网站只有一个全局作用域对象。
3）在Http服务器运行期间，全局作用域对象一直处于存活状态。
4）在Http服务器准备关闭时，负责将当前网站中的全局作用域对象进行销毁处理。
*****全局作用域对象生命周期贯穿网站整个运行期间*****

4.命令实现：【同一个网站】OneServlet将数据共享给TwoServlet

OneServlet{
	public void doGet(HttpServletRequest request,HttpServletResponse response)
	//1)通过【请求对象】向Tomcat索要当前网站中的【全局作用域对象】
	ServletContext application = request.getServletContext();
	//2)将数据添加到全局作用域对象作为【共享数据】
	application.setAttribute("key1",数据);
}

TwoServlet{
	public void doGet(HttpServletRequest request,HttpServletResponse response)
	//1)通过【请求对象】向Tomcat索要当前网站中的【全局作用域对象】
	ServletContext application = request.getServletContext();
	//2)从全局作用域对象得到指定关键字对应的数据
	Object 数据 = application.getAttribute("key1");
}

十五. Cookie类
1.介绍：
1）Cookie来自于Servlet规范中的一个工具类，存在于Tomcat提供的servlet-api.jar中。
2）如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，此时可以借助于Cookie对象进行数据共享。
3）Cookie存放当前用户的私人数据，在共享数据过程中提高服务质量。

2.原理：用户通过浏览器第一次向网站发送请求申请OneServlet，OneServlet在运行期间【创建一个Cookie】存储与当前用户相关的数据。OneServlet工作完毕后，将Cookie写入到【响应头】交还给当前浏览器。浏览器收到响应包之后，将Cookie存储到【浏览器的缓存】中。之后，用户通过【同一浏览器】再次向【同一网站】发送请求申请TwoServlet时，浏览器需要无条件地将网站之前推送过来的Cookie写入到【请求头】中发送过去，此时TwoServlet在运行时，就可以通过读取请求头中的Cookie信息，得到OneServlet提供的共享数据。

3.实现：同一个网站OneServlet与TwoServlet借助于Cookie实现数据共享

OneServlet{
	public void doGet(HttpServletRequest request,HttpServletResponse response){
		//1）创建一个cookie对象，保存共享数据（当前用户数据）
		Cookie c1 = new Cookie("key1","value1");
		Cookie c2 = new Cookie("key2","value2");

		//2）将cookie写入到响应头，交给浏览器
		response.addCookie(c1);
		response.addCookie(c2);
	}
}

TwoServlet{
	public void doGet(HttpServletRequest request,HttpServletResponse response){
		//1）调用请求对象从请求头中得到浏览器返回的Cookie
		Cookie cookieArray = request.getCookies();
		//2）循环遍历数组得到每一个cookie的key和value
		for(Cookie c:cookieArray){
			String key = c.getName(); //读取key
			String value = c.getValue(); //读取value
			//提供服务……
		}
	}
}

【注意】
       1）cookie相当于一个map
       2）一个cookie中只能存放一个键值对
       3）这个键值对的key和value只能是String类型的
       4）键值对中的key不能是中文

4.Cookie销毁时机：
1）在默认情况下，Cookie对象存放在浏览器的缓存中，因此只要浏览器关闭，Cookie对象就被销毁。
2）在手动设置的情况下，可以要求浏览器将接收的Cookie存放在客户端的计算机硬盘上，同时需要指定Cookie在硬盘上存活的时间。在存活时间范围内，关闭浏览器、关闭客户端计算机、关闭服务器都不会导致Cookie被销毁。在存活时间到达时，Cookie自动从硬盘上被删除。

cookie.setMaxAge(60); //表示cookie在硬盘上存活1分钟

十六. HttpSession接口
1.介绍
1）HttpSession接口是来自于Servlet规范下的一个接口，存在于Tomcat中servlet-api.jar下。其实现类由Http服务器提供。
2）如果两个Servlet来自于同一个网站，并且为同一个浏览器/用户提供服务，此时借助于HttpSession对象进行数据共享。
3）开发人员习惯于将HttpSession接口修饰对象称为【会话作用域对象】。

2.HttpSession与Cookie的区别：
1）存储位置：Cookie存放在客户端计算机中（浏览器内存/硬盘）；HttpSession存放在服务端计算机内存中。
2）数据类型：Cookie对象存储共享数据类型只能是String类型；HttpSession对象可以存储任意类型的共享数据。
3）数据数量：一个Cookie对象只能存储一个共享数据；HttpSession使用map集合存储共享数据，所以可以存储任意数量个共享数据。

3.命令实现：同一个网站下OneServlet将数据传递给TwoServlet

OneServlet{
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1)调用请求对象向Tomcat索要当前用户在服务端的seesion
		HttpSession session = request.getSession();
		//2)将数据添加到session
		session.setAttribute("key1",共享数据);
	}
}

TwoServlet{
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1)调用请求对象向Tomcat索要当前用户在服务端的seesion
		HttpSession session = request.getSession();
		//2)从会话作用于对象中得到OneServlet提供的共享数据
		Object 共享数据 = session.getAttribute("key1");
	}
}

4.Http服务器通过cookie将用户与HttpServlet关联起来

5.getSession()与getSession(false)
1）getSession()：如果当前用户在服务端已经拥有了自己的session，则要求tomcat将这个session进行返回；如果当前用户在服务端尚未拥有自己的session，则要求tomcat为当前用户创建一个全新的session。
2）getSession(false)：如果当前用户在服务端已经拥有了自己的session，则要求tomcat将这个session进行返回；如果当前用户在服务端尚未拥有自己的session，此时tomcat将返回null。

6.HttpSession销毁时机
1）用户与HttpSession关联时使用的Cookie只能存放在浏览器缓存中
2）在浏览器关闭时，意味着用户与其HttpSession关系被切断
3）由于Tomcat无法监测浏览器何时关闭，因此在浏览器关闭时并不会导致Tomcat将浏览器关联的HttpSession进行销毁
4）为了解决这个问题，Tomcat为每一个HttpSession对象设置【空闲时间】，这个空闲时间默认为30分钟，如果当前HttpSession对象空闲时间达到30分钟，此时Tomcat认为用户已经放弃了自己的HttpSession，此时Tomcat就会销毁掉这个HttpSession

7.HttpSession空闲时间的设置
在当前网站/web/WEB-INF/web.xml中

<session-config>
	<session-timeout>5</session-timeout>  <!--当前网站中每一个session的最大空闲时间为5分钟>
</session-config>

十七. HttpServletRequest接口
1.介绍
1）在同一个网站中，如果两个Servlet之间通过【请求转发】方式进行调用，彼此之间共享【同一个请求协议包】。而一个请求协议包只对应一个请求对象，因此Servlet之间共享【同一个请求对象】，此时可以利用这个请求对象在两个Servlet之间实现数据共享。
2）在通过请求对象实现Servlet之间数据共享功能时，开发人员将请求对象称为【请求作用域对象】。

2.命令实现：OneServlet通过请求转发申请调用TwoServlet时，需要给TwoServlet提供共享数据

OneServlet{
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//1)将数据添加到【请求作用域对象】中的attribute属性中
		request.setAttribute("key1",数据); //数据类型可以是任意类型Object
	
		//2)向Tomcat申请调用TwoServlet
		request.getRequestDispatcher("/two").forward(request,response);
	}
}

TwoServlet{
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//从当前请求对象中得到OneServlet写入的共享数据
		Object 数据 = request.getAttribute("key1");
	}
}

十八. 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服务器中

<listener>
	<listener-class>com.lilanlan.listener.OneListener</listener-class>
</listener>

4.ServletContextListener接口
1）作用：通过这个接口合法地监测全局作用域对象被初始化时刻以及被销毁时刻
2）监听事件处理方法：
       public void contextInitialized()：在全局作用域对象被Http服务器初始化时被调用
       public void contextDestroyed()：在全局作用域对象被Http服务器销毁时触发调用

5.ServletContexAttributetListener接口
1）作用：通过这个接口合法的监测全局作用域对象共享数据变化的时刻。
2）监听事件处理方法：
       public void contextAdd()：在全局作用域对象添加共享数据时触发
       public void contextReplaced()：在全局作用域对象更新共享数据时触发
       public void contextRemove()：在全局作用域对象删除共享数据时触发

十九. Servlet规范扩展——Filter接口（过滤器接口）
1.介绍
1）来自于Servlet规范下接口，在Tomcat中存在于servlet-api.jar包
2）Filter接口实现类由开发人员负责提供，Http服务器不负责提供
3）Filter接口在Http服务器调用资源文件之前，对Http服务器进行拦截

2.具体作用
1）拦截Http服务器，帮助Http服务器检测当前请求的合法性
2）拦截Http服务器，对当前请求进行增强操作

3.Filter接口实现类开发步骤
1）创建一个Java类实现Filter接口
2）重写Filter接口中的doFilter方法
3）web.xml将过滤器接口实现类注册到Http服务器中

public class OneFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //1）通过拦截请求对象得到请求包参数信息
        String level = servletRequest.getParameter("level");
        //2）根据信息，帮助Http服务器判断本次请求合法性
        if(Integer.valueOf(level)>=5){
            //将拦截请求对象和响应对象交还给Tomcat，由Tomcat继续调用资源文件
            filterChain.doFilter(servletRequest,servletResponse);
        }else{
            //过滤器代替Http服务器拒绝本次请求
            servletResponse.setContentType("text/html;charset=utf-8");
            PrintWriter out = servletResponse.getWriter();
            out.print("<center><font style='color:red;font-size:40px'>无权查看！</font></center>");
        }
    }
}

	<!--将过滤器类文件路径交给Tomcat -->
    <filter>
        <filter-name>onefilter</filter-name>
        <filter-class>com.lilanlan.filter.OneFilter</filter-class>
    </filter>

    <!--通知Tomcat在调用何种资源文件时需要被当前过滤器拦截 -->
    <filter-mapping>
        <filter-name>onefilter</filter-name>
        <url-pattern>/campus.jpg</url-pattern>
    </filter-mapping>

4.Filter拦截地址格式
1）要求Tomcat在调用某一具体文件之前，调用OneFilter拦截

<url-pattern>/img/campus.jpg</url-pattern>

2）要求Tomcat在调用某一文件夹下所有的资源文件之前，调用OneFilter拦截

<url-pattern>/img/*</url-pattern>

3）要求Tomcat在调用任意文件夹下某种类型的文件之前，调用OneFilter拦截

<url-pattern>*.jpg</url-pattern>

4）要求Tomcat在调用网站中任意文件时，调用OneFilter拦截

<url-pattern>/*</url-pattern>

—————————————————————————————————————————————————
【扩展】所有的高级引用类型都可以赋值给null。如int num=null;的写法是错误的。Integer num=null;的写法是正确的。