• Servlet规范:来自于JavaEE规范中的一种
    • 作用:
      • 在Servlet规范中,指定动态资源文件开发步骤;
      • 在Servlet规范中,指定Http服务器调用动态资源文件规则;
      • 在Servlet规范中,指定Http服务器管理动态资源文件实例对象规则;
    • Servlet接口实现类:
      • Servlet规范中认为:Http服务器能调用的动态资源文件必须是一个Servlet接口实现类;
    • Servlet接口实现类开发步骤:
      • 1.创建一个类继承HttpServlet父类(抽象),使之成为一个Servlet接口实现类;
      • 2.重写HttpServlet父类两个方法:doGet()/doPost(); ```java package com.jiangzhiyan.contrller;

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

    /**

    • 实现类OneServlet-继承->抽象类HttpServlet-继承->抽象类GenericServlet-实现->接口Servlet
    • 抽象类的作用:使用抽象类先继承接口,实现类再继承抽象类,降低接口实现难度
    • TomCat根据Servlet规范调用Servlet接口实现类规则:
    • 1.TomCat有权创建Servlet接口的实现类的对象:
    • Servlet oneServlet = new OneServlet();
    • 2.TomCat创建的Servlet实例对象调用service方法处理当前请求,确定是GET还是POST:
    • oneServlet.service();//service方法在抽象类HttpServlet中就已经实现了,且为protected修饰的
    • 3.执行service方法,service方法中调用getMethod方法获取浏览器的请求方式(GET/POST)
    • String method = req.getMethod();
    • 返回结果匹配到GET:当前Servlet对象调用doGet()方法;

    • 返回结果匹配到POST:当前Servlet对象调用doPost()方法; */ public class OneServlet extends HttpServlet { @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请求”); } }

      2. - 3.将Servlet实现类信息注册到TomCat服务器;
      3. ```xml
      4. <?xml version="1.0" encoding="UTF-8"?>
      5. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      6.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      7.  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
      8.  version="4.0">
      9. <!--将Servlet接口实现类的类路径交给TomCat-->
      10. <servlet>
      11.     <servlet-name>oneServlet</servlet-name>
      12.     <servlet-class>com.jiangzhiyan.contrller.OneServlet</servlet-class>
      13. </servlet>
      14. <!--为Servlet接口实现类起一个简短的别名便于用户访问-->
      15. <servlet-mapping>
      16.     <servlet-name>oneServlet</servlet-name>
      17.     <url-pattern>/one</url-pattern>
      18. </servlet-mapping>
      19. </web-app>
      • 当浏览器输入http://localhost:8080/myWeb001/one请求访问时,会访问OneServlet这个动态资源文件,以GET方式请求,则执行doGet()方法,以POST方式请求,则执行doPost()方法.
      • Servlet对象生命周期:
      • 网站中所有Servlet接口实现类对象的创建都是由Http服务器创建的,开发人员不能手动创建;
      • 默认情况下,当Http服务器接收到某个Servlet接口实现类的第一次请求时,自动创建这个实现类的实例对象;

      • 手动配置的情况下,如果要求Http服务器在启动时就自动创建某个Servlet接口实现类的实例对象,在xml文件中配置;

        1. <!--将Servlet接口实现类的类路径交给TomCat-->
        2. <servlet>
        3. <servlet-name>oneServlet</servlet-name>
        4. <servlet-class>com.jiangzhiyan.contrller.OneServlet</servlet-class>
        5. <!--TomCat启动时创建该类的实例对象,数字填大于0的整数就行-->
        6. <load-on-startup>15</load-on-startup>
        7. </servlet>

      • 在Http服务器运行期间,一个Servlet接口实现类只能被创建出一个实例对象,即使有多个用户同时访问该类;

      • 在Http服务器关闭的时候,自动将网站中所有的Servlet接口实现类对象销毁;
      • HttpServletResponse接口:
      • HttpServletResponse接口实现类由Http服务器负责提供;
      • HttpServletResponse接口负责将doGet()/doPost()方法的执行结果写入到响应体中交给浏览器;
      • 开发人员通常将HttpServletResponse接口修饰的对象称为”响应对象”;
      • 主要功能:
      • 将执行结果以二进制写入到响应体中;
      • 设置响应头中[content-type]属性值,从而控制浏览器使用对应的编译器将响应体二进制数据编译为[文字,图片,视频….];
      • 设置响应头中[location]属性,将一个请求地址赋值给location,从而控制浏览器向指定服务器发送请求; ```java package com.jiangzhiyan.controller;

    import javax.servlet.; import javax.servlet.http.; import java.io.IOException; import java.io.PrintWriter;

    public class OneServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //假定的响应结果 String result = “jiangzhiyan”; //响应对象response将结果写入到响应体: //1.通过响应对象,向TomCat索要输出流 PrintWriter out = response.getWriter(); //2.通过输出流,将响应结果以二进制写入到响应体 out.write(result);//浏览器访问OneServlet,接收到数据:”jiangzhiyan” } //doGet()方法执行结束,TomCat将响应包推送给浏览器 }

    1. ```java
    2. package com.jiangzhiyan.controller;
    4. import javax.servlet.*;
    5. import javax.servlet.http.*;
    6. import java.io.IOException;
    8. public class TwoServlet extends HttpServlet {
    9.     @Override
    10.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    11.         int money = 50;
    12.         /*response.getWriter().write(money);//浏览器访问TwoServlet,接收到数据:2
    13.             write()方法可以将"字符串",'字符',[ASCII值]写入到响应体中
    14.             [ASCII码]:
    15.             字符a-----97(ASCII值)
    16.             字符2-----50(ASCII值) ,此处write()方法写入响应体中的50为ASCII值*/
    17.         //通常实际开发中,使用print()方法将真实数据写入响应体中
    18.         response.getWriter().print(money);
    19.     }
    20. }
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    6. import java.io.PrintWriter;
    8. public class ThreeServlet extends HttpServlet {
    9.     @Override
    10.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    11.         String result = "Java<br>MySQL<br>JDBC<br>Html<br>CSS<br>JavaScript<br>";
    12.         String result2 = "我是<br>蒋稚彦<br><a href='https://www.baidu.com'>你呢?</a>";
    13.         //默认情况下content-type="text",浏览器会使用文本编译器解析响应体中的二进制数据
    14.         //在得到输出流之前,要对响应头的content-type重新赋值,用于指定浏览器使用正确的编译器进行解析
    15.         //设置charset指定浏览器使用何种字符集进行解析
    16.         response.setContentType("text/html;charset=utf-8");
    17.         PrintWriter out = response.getWriter();
    18.         //out.print(result);//因此页面显示内容不会换行
    19.         out.print(result);
    20.         out.print(result2);
    21.     }
    22. }
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    7. public class FourServlet extends HttpServlet {
    8.     @Override
    9.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    10.         String result = "https://www.baidu.com";
    11.         //通过响应对象,将地址赋值给响应头的location属性
    12.         response.sendRedirect(result);//[响应头 location="https://www.baidu.com"]
    13.     }
    14.     /*浏览器在接收到响应包后,如果发现响应头中存在location属性,
    15.       自动通过地址栏向location地址发送请求*/
    16. }
    • HttpServletRequest接口:
      • HttpServletRequest接口实现类由Http服务器负责提供;
      • HttpServletRequest接口负责在doGet()/doPost()方法运行时,读取Http请求协议包中的信息;
      • 开发人员通常将HttpServletRequest接口修饰的对象称为”请求对象”;
      • 主要功能:
        • 读取Http协议包中请求行的信息;
        • 可以读取保存在Http请求协议包中请求头或请求体中的请求参数信息;
        • 可以代替浏览器向Http服务器申请资源文件调用; ```java package com.jiangzhiyan.controller;

    import javax.servlet.; import javax.servlet.http.; import java.io.IOException;

    public class OneServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //1.通过请求request对象,读取请求行中的url信息 String url = request.getRequestURL().toString(); //2.通过请求request对象,读取请求行中method信息 String method = request.getMethod(); //3.通过请求request对象,读取uri信息:请求行中并没有uri属性 //uri:资源文件精准定位地址,实际上是url中截取一个字符串,格式为”/网站名/资源文件名” String uri = request.getRequestURI(); //设置浏览器编译方式和编译字符集 response.setContentType(“text/html;charset=utf-8”); //将信息写入到响应体中 response.getWriter().print(“url:”+url+”

    method:”+method+”

    uri:”+uri); } }

    1. ```java
    2. package com.jiangzhiyan.controller;
    4. import javax.servlet.*;
    5. import javax.servlet.http.*;
    6. import java.io.IOException;
    7. import java.io.PrintWriter;
    8. import java.util.Enumeration;
    10. public class TwoServlet extends HttpServlet {
    11.     @Override
    12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    13.         //1.通过请求request对象获得请求头中所有请求参数名
    14.         //将所有请求参数名称保存在一个枚举对象中
    15.         Enumeration<String> paramNames = request.getParameterNames();
    16.         //指定浏览器编译方式和编译字符集
    17.         response.setContentType("text;charset=utf-8");
    18.         //获取TomCat输出流对象
    19.         PrintWriter out = response.getWriter();
    20.         while (paramNames.hasMoreElements()){
    21.             String paramName = paramNames.nextElement();
    22.             //2.通过请求参数名获取对应的请求参数值
    23.             String value = request.getParameter(paramName);
    24.             out.println(paramName+"="+value);
    25.         }
    26.     }
    27. }
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    6. import java.io.PrintWriter;
    7. import java.util.Enumeration;
    9. public class ThreeServlet extends HttpServlet {
    10.     @Override
    11.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    12.         //get方式是从请求头中读取参数信息,请求头中的二进制内容由TomCat负责解码
    13.         //TomCat默认字符集为utf-8,因此中文内容不会乱码
    14.         //获取参数名称的枚举对象
    15.         Enumeration<String > paramNames = request.getParameterNames();
    16.         //设置浏览器编译方式和编译字符集
    17.         response.setContentType("text;charset=utf-8");
    18.         //获取TomCat输出流对象
    19.         PrintWriter out = response.getWriter();
    20.         while (paramNames.hasMoreElements()){
    21.             //遍历枚举获取每个参数名
    22.             String paramName = paramNames.nextElement();
    23.             //请求对象request通过参数名获取对应参数值
    24.             String value = request.getParameter(paramName);
    25.             out.println(paramName+"="+value);
    26.         }
    27.     }
    28.     @Override
    29.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    30.         //post方式是从请求体中读取参数信息,请求体中的二进制是由当前请求对象request负责解码
    31.         //请求对象request默认字符集为ISO-8859-1,中文内容会乱码,需要设置请求对象字符集为utf-8
    32.         //设置请求对象request使用utf-8字符集对请求体中内容进行解码
    33.         request.setCharacterEncoding("utf-8");
    34.         Enumeration<String > paramNames = request.getParameterNames();
    35.         response.setContentType("text;charset=utf-8");
    36.         PrintWriter out = response.getWriter();
    37.         while (paramNames.hasMoreElements()){
    38.             String paramName = paramNames.nextElement();
    39.             String value = request.getParameter(paramName);
    40.             out.println(paramName+"="+value);
    41.         }
    42.     }
    43. }
    • 请求对象和响应对象的生命周期:
      • 当Http服务器接收到浏览器发送的Http请求协议包后,自动为当前Http请求协议包生成一个请求对象和一个响应对象;
      • 在Http服务器调用doGet()/doPost()方法时,负责将请求对象和响应对象作为实参,确保doGet()/doPost()方法的执行;
      • 在Http服务器准备推送响应协议包之前,会自动将本次请求关联的请求对象和响应对象销毁.

    • 多个Servlet之间的调用规则:

      • 通常一个来自浏览器的请求,需要服务端多个Servlet来协同处理,但是浏览器一次只能访问一个Servlet,为满足用户使用浏览器发起一次请求,自动完成所有相关Servlet的调度,有以下两种解决方案:

        • 1.重定向解决方案:
          • 原理:首次请求由用户使用浏览器发起,服务器根据业务逻辑顺序,将后一个Servlet的地址写到前一个Servlet的响应头的location中,并在前一个Servlet响应包的状态行中写入状态码:302,浏览器接收到前一个Servlet发出的响应包后,读取到302状态码,此时浏览器自动向响应头中的location地址发起第二次请求,即向后一个Servlet发起请求,后一个Servlet完成剩余业务;
          • 缺点:浏览器与服务器多次往返通信,大量时间花费在通信往返次数上,增加了用户等待时间;

        • 2.请求转发解决方案:

          • 原理:首次请求由用户使用浏览器发起,服务器根据业务逻辑顺序,在前一个Servlet工作完毕后,通过当前Servlet的请求对象代替浏览器向TomCat发起请求,申请调用后一个Servlet,TomCat在接收到这个请求后,自动调用后一个Servlet完成剩余任务;
          • 特征:
            • 浏览器发送请求的请求协议包请求行中mehtod是Get,则服务器Servlet之间请求方式都是Get,请求协议包请求行中method是Post,则服务器Servlet之间请求方式都是Post,多个Servlet共享同一个请求协议包;
            • 只能调用当前网站下的资源文件,不能调用当前网站外的资源文件;

          • 实现命令:请求对象代替浏览器向TomCat发起请求:

            1. //1.通过当前请求对象生成资源文件申请报告对象
            2. //资源文件名前必须加"/"
            3. RequestDispatcher report = request.getRequestDispatcher("/资源文件名");
            4. //2.将报告对象发送给TomCat服务器
            5. report.forward(当前请求对象request,当前响应对象response);

          • 优点:

            • 无论本次请求涉及到多少个Servlet,用户只需要使用浏览器发送一次请求,接收一次响应;
            • Servlet之间的调用只发生在服务端计算机上,节省浏览器端与服务端通信次数,加快处理速度.
          • 缺点:
            • 由于Servlet间的调度都是在服务器进行,会增加服务器压力.
    • 多个Servlet之间的数据共享方案:
      • 数据共享:在前一个Servlet执行完毕后,产生的数据交给下一个Servlet来使用;
      • Servlet规范中提供了4种数据共享方案:
        • 1.ServletContext接口:
          • 如果2个Servlet来自于同一个网站,彼此之间通过ServletContext实例对象实现数据共享,ServletContext对象被称为全局作用域对象,一般用application作为全局作用域对象实例变量名;
          • 每个网站中都存在一个全局作用域对象,相当于一个Map集合,在这个网站中的每一个Servlet都可以将数据存入全局作用域对象,其他Servlet可以取出数据使用;
          • 全局作用域对象生命周期:(全局作用域对象生命周期贯穿所属网站的整个运行期间)
            • 在Http服务器启动过程中,自动为当前网站在内存中创建1个全局作用域对象;
            • 在Http服务器运行期间,一个网站只有一个全局作用域对象,并且该对象一直存活;
            • 在Http服务器准备关闭时,负责将当前网站中的全局作用域对象销毁. ```java package com.jiangzhiyan.controller;

    import javax.servlet.; import javax.servlet.http.; import java.io.IOException;

    public class OneServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //向全局作用域对象中存数据 //1.请求对象向TomCat服务器索要全局作用域对象,一般使用application作为变量名 ServletContext application = request.getServletContext(); //2.将数据添加到全局作用域对象,作为共享数据 application.setAttribute(“key1”,100); } }

    1. ```java
    2. package com.jiangzhiyan.controller;
    4. import javax.servlet.*;
    5. import javax.servlet.http.*;
    6. import java.io.IOException;
    8. public class TwoServlet extends HttpServlet {
    9.     @Override
    10.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    11.         //从全局作用域对象中取数据
    12.         //1.请求对象向TomCat服务器索要全局作用域对象
    13.         ServletContext application = request.getServletContext();
    14.         //使用Integer防止空指针异常,application可能为null
    15.         Integer value1 = (Integer) application.getAttribute("key1");
    16.         response.getWriter().print(value1);
    17.     }
    18. }
    1.   - 2.Cookie类:Servlet规范中的一个工具类;
    2.      - 如果2个Servlet来自同一个网站,并且为同一个浏览器/用户服务,此时借助于Cookie对象进行数据共享;
    3.      - Cookie对象存放当前用户的私人数据,在共享数据过程中提高服务质量;
    4.      - 原理:用户通过浏览器第一次向A网站发送请求,网站中处理该请求的Servlet在运行期间会创建一个Cookie存储当前用户相关数据,Servlet工作完毕后,将Cookie写入到响应包的响应头中交还给浏览器;浏览器接收到响应包后,将Cookie存储在浏览器缓存中,一段时间之后,用户通过同一个浏览器再次向A网站发起请求时,浏览器会将之前A网站推送过来的Cookie写入请求头中,此时相关的Servlet运行时就可以读取请求头中的Cookie信息,得到之前的Servlet提供的共享数据;
    5.      - 实现命令:
    6.         - 同一个网站不同的Servlet借助Cookie实现同一个用户的数据共享;
    7.         - 1.创建Cookie对象:
    8.            - _`Cookie cookie = new Cookie("key","value");`_
    9.            - Cookie相当于一个Map集合,但是只能储存一个键值对,并且键值对的key和value都必须为String类型,key值不能为中文;
    10.         - 2.将Cookie对象写入到响应头,交给浏览器:
    11.            - `_response.addCookie(cookie);_`
    12.         - 3.同一用户/浏览器再次向该网站发起请求时,若其他Servlet需要从请求头中读取Cookie数据;
    1. //读取所有Cookie,返回Cookie数组
    2. Cookie[] cookies = request.getCookies();
    3. //遍历Cookie[]数组,获取每一个Cookie对象的key和value并处理数据
    4. for(Cookie cookie : cookies){
    5.     String key = cookie.getName();//获取key值
    6.     String value = cookie.getValue();//获取value值
    7.     //处理数据,为用户提供更好的服务
    8. }
    1.      - Cookie销毁时机:
    2.         - 在默认情况下,Cookie对象存放在浏览器的缓存中,因此只要浏览器关闭,Cookie对象就被销毁掉;
    3.         - 在手动设置的情况下,可以要求浏览器将接收的Cookie存放在客户端计算机的硬盘上,同时需要指定Cookie在硬盘上的存活时间,在存活实际内,关闭浏览器、关闭客户端计算机、关闭服务器都不会导致Cookie被销毁,当存活时间到达时,Cookie自动从硬盘上被删除;
    4.         - 设置Cookie的存活时间:
    5.            - `_.setMaxAge(int second)_`:设置当前Cookie在硬盘上存活的秒数;
    6.   - 3.HttpSession接口:
    7.      - 如果两个Servlet来自于同一个网站,并且为同一个用户/浏览器提供服务,此时借助于HttpSession对象进行数据共享;
    8.      - 开发人员将HttpSession接口修饰的对象称为会话作用域对象;
    9.      - HttpSession与Cookie的区别:
    10.         - 1)存储位置:
    11.            - Cookie:存储在客户端计算机中(浏览器内存/硬盘);
    12.            - HttpSession:存储在服务端计算机内存中;
    13.         - 2)数据类型:
    14.            - Cookie对象存储的共享数据类型只能是String;
    15.            - HttpSession对象可以存储任意类型的共享数据Object;
    16.         - 3)存储数据数量:
    17.            - 一个Cookie对象只能存储一个共享数据;
    18.            - HttpSession使用Map集合存储共享数据,可以存储任意数量的共享数据;
    19.      - 命令实现:同一个网站下前一个Servlet将数据传递给后一个Servlet;
    20.         - 1)请求对象向TomCat索要当前用户在服务端的HttpSession对象,通常使用`_session_`作为会话作用域对象的变量名:
    21.            - `_HttpSession session = request.getSession();_`
    22.         - 2)将数据添加到HttpSession对象中:
    23.            - `_session.setAttribute("key1",共享数据);_`
    24.         - 3)后一个Servlet从会话作用域对象获取前一个Servlet提供的数据:
    25.            - _`HttpSession session = request.getSession();`_
    26.            - `_Object obj = session.getAttribute("key1");_`
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.ServletException;
    4. import javax.servlet.http.HttpServlet;
    5. import javax.servlet.http.HttpServletRequest;
    6. import javax.servlet.http.HttpServletResponse;
    7. import javax.servlet.http.HttpSession;
    8. import java.io.IOException;
    10. public class OneServlet extends HttpServlet {
    11.     @Override
    12.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    13.         //获取请求参数信息
    14.         String goodsName = request.getParameter("goodsName");
    15.         //double price = Double.parseDouble(request.getParameter("price"));
    16.         int count = Integer.parseInt(request.getParameter("count"));
    17.         //获取对话作用域对象
    18.         HttpSession session = request.getSession();
    19.         //如果对话作用域对象中没有对应数据,进行新增操作
    20.        if (session.getAttribute(goodsName)==null){
    21.            session.setAttribute(goodsName,count);
    22.            response.getWriter().println("new");
    23.        }else{
    24.            //如果对话作用域对象中由对应数据,进行数量增加操作
    25.            session.setAttribute(goodsName,(Integer)session.getAttribute(goodsName)+count);
    26.            response.getWriter().println("add");
    27.        }
    28.     }
    29. }
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    6. import java.util.Enumeration;
    8. public class TwoServlet extends HttpServlet {
    9.     @Override
    10.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    11.         //获取对话作用域对象
    12.         HttpSession session = request.getSession();
    13.         //获取所有数据的key值返回枚举
    14.         Enumeration<String> goodsNames = session.getAttributeNames();
    15.         response.setContentType("text;charset=utf-8");
    16.         //遍历对话作用域对象value值
    17.         while(goodsNames.hasMoreElements()){
    18.             String name = goodsNames.nextElement();
    19.             int count = (int)session.getAttribute(name);
    20.             response.getWriter().println(name+" : "+count);
    21.         }
    22.     }
    23. }
    1.      - Http服务器如何将用户与HttpSession关联起来?
    2.         - 通过Cookie,在用户首次发起请求时,服务器会给对话作用域对象一个JSessionId,存储到Cookie中,并返还给浏览器,浏览器下一次发起请求时,会携带Cookie中的JSessionId,服务器从Cookie中找到了JSessionId,即会自动去寻找对应的HttpSession对象;
    3.      - getSession()与getSession(false)的区别:
    4.         - getSession():如果当前用户在服务端已经拥有了一个对应的HttpSession对象,则将这个HttpSession返回,如果尚未拥有,则会为当前用户创建一个全新的HttpSession对象;
    5.         - getSession(false):如果当前用户在服务端已经拥有了一个对应的HttpSession对象,则将这个HttpSession返回,如果尚未拥有,直接返回null,不会为用户创建新的HttpSession对象;
    6.      - HttpSession对象的销毁时机:
    7.         - 用户与HttpSession关联时使用的Cookie只能存放在浏览器缓存中;
    8.         - 在浏览器关闭时,意味着用户与他的HttpSession对象失去联系;
    9.         - 但是由于TomCat无法检测用户的浏览器何时关闭,因此,浏览器关闭并不会导致TomCat将关联的HttpSession对象销毁;
    10.         - 为了解决这个问题,TomCat为每一个HttpSession对象设置了空闲时间(默认30分钟),当HttpSession对象空闲时间达到30分钟,此时TomCat就会认为用户已经放弃了自己的HttpSession,TomCat执行销毁HttpSession对象.
    11.      - HttpSession空闲时间手动设置:
    12.         - 在当前网站/web/WEB-INF/web.xml中:
    1. <!--设置HttpSession空闲时间(分钟)-->
    2. <session-config>
    3.   <session-timeout>5</session-timeout>
    4. </session-config>
    1.   - 4.HttpServletRequest接口:
    2.      - 同一个网站中,如果2个Servlet之间通过请求转发方式进行调用,彼此之间将会共享1个请求协议包,而1个请求协议包只对应一个请求对象,因此2个Servlet之间共享一个请求对象,此时可以利用这个请求对象在两个Servlet之间实现数据共享;
    3.      - 在使用请求对象实现Servlet之间的数据共享时,开发人员将请求对象称为请求作用域对象;
    4.      - 命令实现:
    5.         - 前一个Servlet给后一个Servlet提供共享数据:
    6.            - 1)将数据添加到请求作用域对象中:
    7.               - `_request.setAttribute("key1",Object o);_`
    8.            - 2)将请求转发给下一个Servlet:
    9.               - `_request.getRequestDispatcher("/nextServlet");_`
    10.               - `_report.forward(request,response);_`
    11.            - 3)从当前请求对象获取上一个Servlet写入的共享数据:
    12.               - `_Object value = request.getAttribute("key1");_`
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    7. public class OneServlet extends HttpServlet {
    8.     @Override
    9.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    10.         //向请求作用域对象中添加数据
    11.         request.setAttribute("key1",100);
    12.         request.setAttribute("key2","Hello World");
    13.         //请求转发给下一个Servlet
    14.         request.getRequestDispatcher("/two").forward(request,response);
    15.     }
    16. }
    1. package com.jiangzhiyan.controller;
    3. import javax.servlet.*;
    4. import javax.servlet.http.*;
    5. import java.io.IOException;
    7. public class TwoServlet extends HttpServlet {
    8.     @Override
    9.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    10.         //从同一个请求作用域对象中取出数据
    11.         Integer value1 = (Integer) request.getAttribute("key1");
    12.         String value2 = (String) request.getAttribute("key2");
    13.         //输出
    14.         response.getWriter().println("key1:"+value1);
    15.         response.getWriter().println("key2:"+value2);
    16.     }
    17. }