一、Servlet：server applet

1. 概念：

运行在服务器端的小程序

Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。我们只要实现Servlet接口，复写其中的方法即可。

2. Servlet简单案例入门：

实现步骤：

1. 创建JavaEE项目
2. 定义一个类，实现Servlet接口
   public class ServletDemo1 implements Servlet
3. 实现接口中的抽象方法
4. 配置Servlet

代码如下：

• 项目结构如下：
  

• 修改项目的虚拟请求路径
  

• 在web.xml中配置：

  <?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-->
      <servlet>
          <!--给指定的Servlet代码起个别名-->
          <servlet-name>demo</servlet-name>
          <!--通过全类名指定要执行的Servlet代码-->
          <servlet-class>com.kejizhentan.servlet.Demo</servlet-class>
      </servlet>
      <servlet-mapping>
          <!--通过Servlet的别名指定Servlet请求的访问路径-->
          <servlet-name>demo</servlet-name>
          <url-pattern>/demo</url-pattern>
      </servlet-mapping>
  </web-app>
  

• Java代码：

  public class Demo implements Servlet {
  
  	/**
       * 初始方法
       * 在servlet被创建时执行，只会被创建一次(说明sevlet时单例的)
      */
      @Override
      public void init(ServletConfig servletConfig) throws ServletException {
          System.out.println("执行了init方法...");
      }
      /**
       * 获取ServletConfig对象的
       * ServletConfig对象是Servlet的配置对象
      */
      @Override
      public ServletConfig getServletConfig() {
          return null;
      }
  
  	 /**
       *  提供服务的方法
       *  每次servlet被访问时执行，能被执行多次
      */
      @Override
      public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
          System.out.println("hello servlet");
      }
  
  	/**
       * 获取Servlet的一些信息的，如版本、作者等等
      */
      @Override
      public String getServletInfo() {
          return null;
      }
  
      /**
       * 销毁的方法
       * 在服务器正常关闭的时候执行，只执行一次
      */
      @Override
      public void destroy() {
          System.out.println("执行了destroy方法...");
      }
  }
  

• 请求和结果如下：
  
  

执行原理：
1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
2. 查找web.xml文件，是否有对应<url-pattern>标签体内容。
3. 如果有，则在找到对应的<servlet-class>全类名
4. tomcat会将字节码文件加载进内存，并且创建其对象
5. 调用其方法

3. Servlet中的生命周期方法：

⑴ 被创建：执行init方法，只执行一次

① Servlet什么时候被创建？

默认情况下，第一次被访问时，Servlet被创建。
可以配置执行Servlet的创建时机。
在<servlet>标签下配置

• 第一次被访问时，创建
  <load-on-startup>的值为负数
• 在服务器启动时，创建
  <load-on-startup>的值为0或正整数

Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
多个用户同时访问时，可能存在线程安全问题。
解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对其修改值

② 提供服务：执行service方法，执行多次

每次访问Servlet时，Service方法都会被调用一次。

③ 被销毁：执行destroy方法，只执行一次

Servlet被销毁时执行。服务器关闭时，Servlet被销毁。只有服务器正常关闭时，才会执行destroy方法。 destroy方法在Servlet被销毁之前执行，一般用于释放资源。

4. Servlet3.0：支持注解配置。可以不需要web.xml了。

步骤：

1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
2. 定义一个类，实现Servlet接口
3. 复写方法
4. 在类上使用@WebServlet注解，进行配置
   @WebServlet("资源路径")

代码如下：

• 项目结构：
  

• 修改项目的虚拟请求路径
  

• Java代码：

  @WebServlet("/demo")
  public class ServletDemo implements Servlet {
      /**
       * 初始方法
       * 在servlet被创建时执行，只会被创建一次(说明sevlet时单例的)
       */
      @Override
      public void init(ServletConfig servletConfig) throws ServletException {
          System.out.println("执行了init方法...");
      }
      /**
       * 获取ServletConfig对象的
       * ServletConfig对象是Servlet的配置对象
       */
      @Override
      public ServletConfig getServletConfig() {
          return null;
      }
  
      /**
       *  提供服务的方法
       *  每次servlet被访问时执行，能被执行多次
       */
      @Override
      public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
          System.out.println("hello servlet");
      }
  
      /**
       * 获取Servlet的一些信息的，如版本、作者等等
       */
      @Override
      public String getServletInfo() {
          return null;
      }
  
      /**
       * 销毁的方法
       * 在服务器正常关闭的时候执行，只执行一次
       */
      @Override
      public void destroy() {
          System.out.println("执行了destroy方法...");
      }
  }
  

• 请求和结果如下：
  
  

@WebServlet注解详解：

5. IDEA与tomcat的相关配置

⑴ IDEA会为每一个tomcat部署的项目单独建立一份配置文件

通过该配置文件可以找到tomcat部署的项目

Using CATALINA_BASE: “C:\Users\Administrator.IntelliJIdea2019.3\system\tomcat\Tomcat_8_5_31_servlet-project_2”

根据控制台打印的路径，找到对应的文件夹


打开servlet.xml配置文件

⑵ 工作空间项目 和 tomcat部署的web项目

tomcat真正访问的是“tomcat部署的web项目”，“tomcat部署的web项目"对应着"工作空间项目” 的web目录下的所有资源

WEB-INF目录下的资源不能被浏览器直接访问。

6. Servlet的体系结构

GenericServlet(一般不常用)：将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象，将来定义Servlet类时，可以继承GenericServlet，实现service()方法即可。


HttpServlet(常用)：对http协议的一种封装，简化操作
定义类继承HttpServlet， 复写doGet/doPost方法

7 Servlet相关配置

⑴ urlpartten:Servlet访问路径

① 一个Servlet可以定义多个访问路径 ： @WebServlet({"/d4","/dd4","/ddd4"})

② 路径定义规则：

1. /xxx：路径匹配
2. /xxx/xxx:多层路径，目录结构
3. *.do：扩展名匹配(不能加‘/’)

二、HTTP：Hyper Text Transfer Protocol 超文本传输协议

1. 概念：

传输协议：定义了客户端和服务器端通信时发送数据的格式

2.特点：

1. 基于TCP/IP的高级协议
2. 默认端口号:80
3. 基于请求/响应模型的:一次请求对应一次响应
4. 无状态的：无状态是指协议对于事务处理没有记忆能力，简单说就是每次请求处理完断开后，没有记录信息，客户端再次请求，服务端也不能识别是否是同一个客户端。

历史版本：

• 1.0版本：每一次请求响应都会建立新的连接
• 1.1版本：复用连接

⑴ 请求消息数据格式

① 请求行

请求方式  请求url   请求协议/版本

例如：
GET  /login.html   HTTP/1.1

请求方式：
HTTP协议有7中请求方式，常用的有2种

• GET：
  1. 请求参数在请求行中，在url后。
  2. 请求的url长度有限制的
  3. 不太安全
• POST：
  1. 请求参数在请求体中
  2. 请求的url长度没有限制的
  3. 相对安全

② 请求头：客户端浏览器告诉服务器一些信息

请求头名称: 请求头值

常见的请求头：

1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
   * 可以在服务器端获取该头的信息，解决浏览器的兼容性问题

2. Referer：http://localhost/login.html
   * 告诉服务器，我(当前请求)从哪里来？
   * 作用：
      1. 防盗链：
      2. 统计工作：

③ 请求空行

空行，就是用于分割POST请求的请求头，和请求体的。

④ 请求体(正文,get方法没有请求体)：

封装POST请求消息的请求参数的

请求消息数据格式以post为例：

POST /login.html	HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://localhost/login.html
Connection: keep-alive
Upgrade-Insecure-Requests: 1

username=zhangsan	

⑵ 响应消息数据格式：

① 响应行：

1. 组成：
协议/版本  响应状态码  状态码描述
2. 响应状态码(状态码都是3位数字)：
服务器告诉客户端浏览器本次请求和响应的一个状态。

分类：

• 1xx：服务器就收客户端消息，但没有接受完成，等待一段时间后，发送1xx多状态码
• 2xx：成功。代表：200
• 3xx：重定向。代表：302(重定向)，304(访问缓存)
• 4xx：客户端错误。 * 代表： * 404（请求路径没有对应的资源） * 405：请求方式没有对应的doXxx方法
• 5xx：服务器端错误。代表：500(服务器内部出现异常)

② 响应头：

1. 格式：头名称： 值
2. 常见的响应头：

• Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式
• Content-disposition：服务器告诉客户端以什么格式打开响应体数据
   * 值：
    * in-line:默认值,在当前页面内打开
    * attachment;filename=xxx：以附件形式打开响应体。文件下载

③ 响应空行

④ 响应体:传输的数据

响应字符串格式:

HTTP/1.1 200 OK
Content-Type: text/html;charset=UTF-8
Content-Length: 101
Date: Wed, 06 Jun 2018 07:08:42 GMT

<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  hello , response
  </body>
</html>

三、request和response请求详解

1. Request对象

⑴ request对象和response对象的原理

• request和response对象是由服务器创建的。我们来使用它们
• request对象是来获取请求消息，response对象是来设置响应消息
  

⑵ request对象继承体系结构：

通过查看tomcat源码可以看到：

⑶ request功能：

① 获取请求消息数据

1. 获取请求行数据

请求行的数据格式：

GET /servlet/demo?name=zhangsan HTTP/1.1

方法：
 a. 获取请求方式 ：GET
  * String getMethod()
 b. ()获取虚拟目录：/servlet
   String getContextPath()
 c. 获取Servlet路径: /demo
  * String getServletPath()
 d. 获取get方式请求参数：name=zhangsan
  * String getQueryString()
 e. (*)获取请求URI：/servlet/demo
   * String getRequestURI(): /servlet/demo
   * StringBuffer getRequestURL() : http://localhost//servlet/demo

• URL:统一资源定位符 ： http://localhost/servlet/demo 中华人民共和国
• URI：统一资源标识符 : /servlet/demo 共和国

  f. 获取协议及版本：HTTP/1.1
   * String getProtocol()

  g. 获取客户机的IP地址：
   * String getRemoteAddr()

代码如下：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
         a. 获取请求方式 ：GET
              String getMethod()
         b.获取虚拟目录： /servlet
               String getContextPath()
         c. 获取Servlet路径: /demo
               String getServletPath()
         d. 获取get方式请求参数：name=zhangsan
                String getQueryString()
         e. 获取请求URI：/servlet/demo
                 String getRequestURI()  :	/servlet/demo
                 StringBuffer getRequestURL() :  http://localhost//servlet/demo
         f. 获取协议及版本：HTTP/1.1
                String getProtocol()
          g. 获取客户机的IP地址：
                String getRemoteAddr()
        */
        String method = request.getMethod();
        System.out.println("请求的方式为："+method);
        System.out.println("***************************************************");
        String contextPath = request.getContextPath();
        System.out.println("请求的虚拟目录为："+contextPath);
        System.out.println("***************************************************");
        String servletPath = request.getServletPath();
        System.out.println("请求路径为："+servletPath);
        System.out.println("***************************************************");
        String queryString = request.getQueryString();
        System.out.println("请求参数为："+queryString);
        System.out.println("***************************************************");
        String requestURI = request.getRequestURI();
        System.out.println("请求uri为："+requestURI);
        System.out.println("***************************************************");
        StringBuffer requestURL = request.getRequestURL();
        System.out.println("请求url为："+requestURL);
        System.out.println("***************************************************");
        String protocol = request.getProtocol();
        System.out.println("协议版本号为"+protocol);
        System.out.println("***************************************************");
        String remoteAddr = request.getRemoteAddr();
        System.out.println("客户机的ip为:"+remoteAddr);
    }
}

请求如下：

结果如下：

2. 获取请求头数据
方法：

• String getHeader(String name):通过请求头的名称获取请求头的值
• Enumeration<String> getHeaderNames():获取所有的请求头名称（返回值是个枚举，该枚举的获取和迭代器类似）

代码如下：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //获取请求头数据
        //1.获取所有的请求头名称
        Enumeration<String> headerNames = request.getHeaderNames();
        //2.遍历请求头中的名称
        while(headerNames.hasMoreElements()){
            //获取请求头中的名称
            String name = headerNames.nextElement();
            //根据请求头的名称获取请求头名称对应的值
            String value = request.getHeader(name);
            System.out.print("请求头的名称为："+name);
            System.out.print("——>对应的值为："+value);
            System.out.println();
        }

        System.out.println("*******************************演示获取请求头数据：user-agent对应的值来判断请求的浏览器版本************************************");
        String agent = request.getHeader("user-agent");
        //判断浏览器的版本
        if(agent != null && agent.contains("Chrome")){
            //谷歌浏览器
            System.out.println("通过谷歌浏览器发起的访问！！！！");
        }else if(agent != null && agent.contains("Firefox")){
            System.out.println("通过火狐览器发起的访问！！！！");
        }
    }
}

请求如下：

结果如下：

防盗链的案例：
index.html页面

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>模拟防盗链</title>
</head>
<body>
<a href="/servlet/demo">点击播放电影</a>
</body>
</html>

hello.html页面

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>模拟防盗链</title>
</head>
<body>
<a href="/servlet/demo">点击播放电影</a>
</body>
</html>

实现防盗链的Servlet

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //演示获取请求头数据:referer
        String referer = request.getHeader("referer");
        System.out.println(referer);//如果通过地址栏直接访问，referer的值是null
        //防盗链
        if(referer != null ){
            if(referer.contains("/servlet/hello.html")){
                //正常访问
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("播放电影....");
            }else{
                //盗链
                response.setContentType("text/html;charset=utf-8");
                response.getWriter().write("想看电影吗？来优酷吧...");
            }
        }else{
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("直接访问referer的值为null...");
        }
    }
}

请求的演示如下：

打印的结果如下：

3. 获取请求体数据:
请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数

步骤：
 1. 获取流对象
  * BufferedReader getReader()：获取字符输入流，只能操作字符数据
  * ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据（在文件上传知识点后讲解）
 2. 再从流对象中拿数据

获取字符流的演示：

注册页面：regist.html

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>注册界面</title>
</head>
<body>
<form action="/servlet/demo" method="post">
    姓名：<input type="text" name="name">
    密码：<input type="text" name="password">
    <input type="submit" value="注册">
</form>
</body>
</html>

ServletDemo.java代码

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求消息体--请求参数
        //1.获取字符流
        BufferedReader br = request.getReader();
        //2.读取数据
        String line = null;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

结果如下：

② 其他功能：

1.获取请求参数通用方式：
不论get还是post请求方式都可以使用下列方法来获取请求参数

• String getParameter(String name):根据参数名称获取参数值 username=zs&password=123
• String[] getParameterValues(String name):根据参数名称获取参数值的数组 如：hobby=xx&hobby=game
• Enumeration<String> getParameterNames():获取所有请求的参数名称
• Map<String,String[]> getParameterMap():获取所有参数的map集合

中文乱码问题：
* get方式：tomcat 8 已经将get方式乱码问题解决了
* post方式：会乱码
解决：在获取参数前，设置request的编码request.setCharacterEncoding("utf-8");

例如：通过获取请求参数通用方式的演示

注册页面regist.html如下：

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>注册界面</title>
</head>
<body>
<form action="/servlet/demo" method="post">
    用户名：<input type="text" placeholder="请输入用户名" name="username"><br>
    密码：<input type="text" placeholder="请输入密码" name="password"><br>
    爱好：<input type="checkbox" name="hobby" value="game">游戏
    <input type="checkbox" name="hobby" value="study">学习
    <br>
    <input type="submit" value="注册">
</form>
</body>
</html>

获取参数值的ServletDemo如下：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.设置流的编码
        request.setCharacterEncoding("utf-8");
        /*
            String getParameter(String name):根据参数名称获取参数值    username=zs&password=123
            String[] getParameterValues(String name):根据参数名称获取参数值的数组  **如：hobby=xx&hobby=game**
            Enumeration<String> getParameterNames():获取所有请求的参数名称
            Map<String,String[]> getParameterMap():获取所有参数的map集合
         */
        //根据参数名称获取参数值
        String name = request.getParameter("username");
        System.out.println("根据参数名称获取参数值为："+name);
        System.out.println("-------------------根据参数名称获取参数值的数组-------------------------");
        //根据参数名称获取参数值的数组
        String[] hobbies = request.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }
        System.out.println("------------------获取所有请求的参数名称和参数的值-------------------------------");
        //获取所有请求的参数名称
        Enumeration<String> parameterNames = request.getParameterNames();
        while(parameterNames.hasMoreElements()){
            String param = parameterNames.nextElement();
            String str = request.getParameter(param);
            System.out.println("请求参数的名称为："+param+"——>对应的值为："+str);
        }
        System.out.println("---------------------------获取所有参数的map集合并且遍历取key和value----------------------------------------");
        Map<String, String[]> parameterMap = request.getParameterMap();
        Set<String> strings = parameterMap.keySet();
        for (String key : strings) {
            String[] values = parameterMap.get(key);
            for (String value : values) {
                System.out.println("参数key为："+key+"——>对应的值为："+value);
            }
        }
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用通用方式获取请求参数时，doPost和doGet可以通过下面的方式来只写一个就可以
        this.doPost(request,response);
    }
}

结果如下：


2. 请求转发：一种在服务器内部的资源跳转方式

步骤：

1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response)

特点：

1. 浏览器地址栏路径不发生变化
2. 只能转发到当前服务器内部资源中。
3. 转发是一次请求

3.共享数据：

• 域对象：一个有作用范围的对象，可以在范围内共享数据
• request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
• 方法：
    void setAttribute(String name,Object obj):存储数据
    Object getAttitude(String name):通过键获取值
    void removeAttribute(String name):通过键移除键值对

案例：通过请求转发共享request域中的数据：
AServlet代码：

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AServlet被访问了！！！");
        //存储数据到request域中
        request.setAttribute("msg","hello");
        //转发到BServlet资源
        /*
        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/requestDemo9");
        requestDispatcher.forward(request,response);
        */
        request.getRequestDispatcher("/bServlet").forward(request,response);
    }

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

BServlet代码：

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据
        Object msg = request.getAttribute("msg");
        System.out.println("Aservlet的request域中存储的值为:"+msg);
        System.out.println("BServlet被访问了。。。");
    }

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

结果如下：


4. 获取ServletContext：
ServletContext getServletContext()
例如：

@WebServlet("/demo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext servletContext = request.getServletContext();
        System.out.println(servletContext);
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用通用方式获取请求参数时，doPost和doGet可以通过下面的方式来只写一个就可以
        this.doPost(request,response);
    }
}

⑷ BeanUtils工具类，简化数据封装

用于封装JavaBean的

① JavaBean：标准的Java类

1. 要求：
  1. 类必须被public修饰
  2. 必须提供空参的构造器
  3. 成员变量必须使用private修饰
  4. 提供公共setter和getter方法
2. 功能：封装数据

② 概念：

1.成员变量：
javaBean中一般用private的变量
2.属性：
setter和getter方法截取后的产物
例如：getUsername() --> Username–> username

③BeanUtils工具类中的方法：

1. void setProperty()
2. String getProperty()
3. void populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中

例如：
项目结构：

BeanUtils依赖包
点击下载包

代码如下：
Student类

public class Student {
    private String username;
    private String password;
    private String[] hobby;
   	...
}

测试类：

public class Test {
    public static void main(String[] args) {
        try {
            Student student = new Student();
            BeanUtils.setProperty(student,"username","张三");
            System.out.println(student);
            Map<String, String[]> maps = new HashMap<>();
            String[] str = {"张三"};
            String[] password = {"123456"};
            String[] hobby = {"学习","打游戏"};
            maps.put("username",str);
            maps.put("password",password);
            maps.put("hobby",hobby);
            BeanUtils.populate(student,maps);
            System.out.println(student);
            String username = BeanUtils.getProperty(student, "username");
            System.out.println(username);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果如下：

2. Response对象

⑴ Response对象的功能：设置响应消息

① 设置响应行

1. 格式：HTTP/1.1 200 ok
2. 设置状态码：setStatus(int sc)

② 设置响应头：

 setHeader(String name, String value)

③ 设置响应体：

使用步骤：

1. 获取输出流
   * 字符输出流：PrintWriter getWriter()
   * 字节输出流：ServletOutputStream getOutputStream()

2. 使用输出流，将数据输出到客户端浏览器

⑵ 案例：

① 完成重定向

1. 重定向：资源跳转的方式

2. 代码实现：

//1. 设置状态码为302
response.setStatus(302);
//2.设置响应头location
response.setHeader("location","/day15/responseDemo2");
//简单的重定向方法(这种方式最常用)
response.sendRedirect("/day15/responseDemo2");

例如：
AServlet代码：

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("AServlet...");
        //响应重定向的方式一
        /*response.setStatus(302);
        response.setHeader("location","/servlet/bServlet");*/
        //响应重定向方式二(最常用的方式)
         //动态获取虚拟目录
        String contextPath = request.getContextPath();
        //响应重定向方式二(最常用的方式)
        response.sendRedirect(contextPath+"/bServlet");
        //response.sendRedirect("/servlet/bServlet");
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

BServlet代码

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("BServlet...");
    }
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
}

结果如下：

forward 和 redirect 区别:

• 重定向的特点:redirect
  1. 地址栏发生变化
  2. 重定向可以访问其他站点(服务器)的资源
  3. 重定向是两次请求。不能使用request对象来共享数据
• 转发的特点：forward
  1. 转发地址栏路径不变
  2. 转发只能访问当前服务器下的资源
  3. 转发是一次请求，可以使用request对象来共享数据

路径写法：

1. 相对路径：通过相对路径不可以确定唯一资源
      * 如：./index.html
     * 不以/开头，以.开头路径
      * 规则：找到当前资源和目标资源之间的相对位置关系
        * ./：当前目录
        * ../:后退一级目录
2. 绝对路径：通过绝对路径可以确定唯一资源
      * 如：http://localhost/day15/responseDemo2(完整写法)  /day15/responseDemo2（简写）
      * 以/开头的路径
    * 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出
      * 给客户端浏览器使用：需要加虚拟目录(项目的访问路径)
        * 建议虚拟目录动态获取：request.getContextPath()
         例如： //动态获取虚拟目录
          String contextPath = request.getContextPath();
          //响应重定向方式二(最常用的方式)
          response.sendRedirect(contextPath+"/bServlet");
        * 如：<a>, <form> , 重定向等路径需要使用绝对路径
      * 给服务器使用：不需要加虚拟目录
        * 转发路径:
        如:request.getRequestDispatcher("/bServlet").forward(request,response);

② 服务器输出字符数据到浏览器

1. 步骤：
  1. 获取字符输出流
  2. 输出数据

注意： 乱码问题：
 1. PrintWriter pw = response.getWriter();获取的流的默认编码是ISO-8859-1
 2. 设置该流的默认编码
 3. 告诉浏览器响应体使用的编码
 //简单的形式，设置编码，是在获取流之前设置
  response.setContentType("text/html;charset=utf-8");

代码如下：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
         //获取流对象之前，设置流的默认编码：ISO-8859-1 设置为：GBK
         response.setCharacterEncoding("utf-8");
        //告诉浏览器，服务器发送的消息体数据的编码。建议浏览器使用该编码解码
        response.setHeader("content-type","text/html;charset=utf-8");
         */
        //简单的形式，设置编码（最常用的方式）
        response.setContentType("text/html;charset=utf-8");
        //1.获取字符输出流
        PrintWriter pw = response.getWriter();
        //2.输出数据
        pw.write("你好 response");
    }

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

结果如下：

③ 服务器输出字节数据到浏览器

步骤：

1. 获取字节输出流
2. 输出数据

代码如下：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //简单的形式，设置编码（最常用的方式）
        response.setContentType("text/html;charset=utf-8");
        //1.获取字节输出流
        ServletOutputStream os = response.getOutputStream();
        //2.输出数据
        os.write("你好".getBytes("utf-8"));
    }

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

结果如下：

④ 验证码

1. 本质：图片
2. 目的：防止恶意表单注册

验证码页面：regist.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        /*
            分析：
                点击超链接或者图片，需要换一张
                1.给超链接和图片绑定单击事件
                2.重新设置图片的src属性值
         */
        window.onload = function(){
            //1.获取图片对象
            var img = document.getElementById("checkCode");
            //2.绑定单击事件
            img.onclick = function(){
                //加时间戳
                img.src = "/servlet/servletDemo";
            }
        }
    </script>
</head>
<body>
<img id="checkCode" src="/servlet/servletDemo" />
<a id="change" href="">看不清换一张？</a>
</body>
</html>

ServletDemo.java

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //服务器通知浏览器不要缓存
        response.setHeader("pragma","no-cache");
        response.setHeader("cache-control","no-cache");
        response.setHeader("expires","0");

        //在内存中创建一个长80，宽30的图片，默认黑色背景
        //参数一：长
        //参数二：宽
        //参数三：颜色
        int width = 80;
        int height = 30;
        BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

        //获取画笔
        Graphics g = image.getGraphics();
        //设置画笔颜色为灰色
        g.setColor(Color.GRAY);
        //填充图片
        g.fillRect(0,0, width,height);

        //产生4个随机验证码，12Ey
        String checkCode = getCheckCode();
        //将验证码放入HttpSession中
        request.getSession().setAttribute("CHECKCODE_SERVER",checkCode);

        //设置画笔颜色为黄色
        g.setColor(Color.YELLOW);
        //设置字体的小大
        g.setFont(new Font("黑体",Font.BOLD,24));
        //向图片上写入验证码
        g.drawString(checkCode,15,25);

        //设置画笔颜色为pink
        g.setColor(Color.white);
        //画十条干扰线
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            //随机生成线的的横坐标（坐标点不能超过图片的长和高）
            int x1 = random.nextInt(width);
            int x2 = random.nextInt(width);
            int y1 = random.nextInt(height);
            int y2 = random.nextInt(height);
            //开始画干扰线
            g.drawLine(x1,y1,x2,y2);
        }

        //将内存中的图片输出到浏览器
        //参数一：图片对象
        //参数二：图片的格式，如PNG,JPG,GIF
        //参数三：图片输出到哪里去
        ImageIO.write(image,"PNG",response.getOutputStream());
    }
    /**
     * 产生4位随机字符串
     */
    private String getCheckCode() {
        String base = "0123456789ABCDEFGabcdefg";
        int size = base.length();
        Random r = new Random();
        StringBuffer sb = new StringBuffer();
        for(int i=1;i<=4;i++){
            //产生0到size-1的随机值
            int index = r.nextInt(size);
            //在base字符串中获取下标为index的字符
            char c = base.charAt(index);
            //将c放入到StringBuffer中去
            sb.append(c);
        }
        return sb.toString();
    }

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

效果如下：

四、ServletContext对象：

1. 概念：

代表整个web应用，可以和程序的容器(服务器)来通信

2. 获取：

1. 通过request对象获取
   request.getServletContext();
2. 通过HttpServlet获取
   this.getServletContext();

例如：

@WebServlet("/servletDemo")
public class ServletDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         /*

            ServletContext对象获取：
                1. 通过request对象获取
			        request.getServletContext();
                2. 通过HttpServlet获取
                    this.getServletContext();
         */
        //1. 通过request对象获取
        ServletContext context1 = request.getServletContext();
        //2. 通过HttpServlet获取
        ServletContext context2 = this.getServletContext();
        System.out.println(context1);
        System.out.println(context2);
        System.out.println(context1 == context2);//true
    }

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

3. 功能：

1. 获取MIME类型：
   * MIME类型:在互联网通信过程中定义的一种文件数据类型
   * 格式： 大类型/小类型 如： text/html和 image/jpeg
   * 获取：String getMimeType(String file)
   例如：

   @WebServlet("/servletDemo")
   public class ServletDemo extends HttpServlet {
       protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           /*
               ServletContext功能：
                  1. 获取MIME类型：
                   * MIME类型:在互联网通信过程中定义的一种文件数据类型
                       * 格式： 大类型/小类型   text/html		image/jpeg
   
                   * 获取：String getMimeType(String file)
            */
   
           // 通过HttpServlet获取
           ServletContext context = this.getServletContext();
           // 定义文件名称
           String filename = "a.jpg";
           //4.获取MIME类型
           String mimeType = context.getMimeType(filename);
           System.out.println(mimeType);//image/jpeg
       }
   
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           this.doPost(request,response);
       }
   }
   

2. 域对象：共享数据

• setAttribute(String name,Object value)
• getAttribute(String name)
• removeAttribute(String name)

ServletContext对象范围：所有用户所有请求的数据

3.获取文件的真实(服务器)路径
方法：
String getRealPath(String path)

例如：
项目结构：

代码如下：

@WebServlet("/servletContextDemo")
public class ServletContextDemo extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
            ServletContext获取文件的真实(服务器)路径
         */

        // 通过HttpServlet获取
        ServletContext context = this.getServletContext();
        // 获取文件的服务器路径
        String b = context.getRealPath("/b.txt");//web目录下资源访问
        System.out.println(b);
        // File file = new File(realPath);
        String c = context.getRealPath("/WEB-INF/c.txt");//WEB-INF目录下的资源访问
        System.out.println(c);
        String a = context.getRealPath("/WEB-INF/classes/a.txt");//src目录下的资源访问
        System.out.println(a);
    }

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

结果如下：

注意：
1.类名.class.getClassLoader().getResourceAsStream(文件路径)；
 该方式只能获取src下的资源，不能请求web下的资源
2.获取文件的真实(服务器)路径对应着服务器启动后配置文件中的路径：
E:\project\servlet-context\out\artifacts\servlet_context_war_exploded

4. 案例：文件下载

1.文件下载需求：

• 页面显示超链接
• 点击超链接后弹出下载提示框
• 完成图片文件下载

分析：
1. 超链接指向的资源如果能够被浏览器解析，则在浏览器中展示，如果不能解析，则弹出下载提示框。不满足需求
2. 任何资源都必须弹出下载提示框
3. 使用响应头设置资源的打开方式：
 content-disposition:attachment;filename=xxx

2.步骤：

1. 定义页面，编辑超链接href属性，指向Servlet，传递资源名称filename
2. 定义Servlet
   1. 获取文件名称
   2. 使用字节输入流加载文件进内存
   3. 指定response的响应头： content-disposition:attachment;filename=xxx
   4. 将数据写出到response输出流

3.问题：
中文文件问题（用工具类解决）

解决思路：

1. 获取客户端使用的浏览器版本信息
2. 根据不同的版本信息，设置filename的编码方式不同

代码如下：
项目结构如下：

• 页面download.html代码：

  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <title>Title</title>
  </head>
  <body>
  
  <a href="/servlet/img/logo.jpg">图片</a>
  
  <a href="/servlet/img/视频.mp4">视频</a>
  <hr>
  <a href="/servlet/downloadServlet?filename=logo.jpg">图片</a>
  <a href="/servlet/downloadServlet?filename=视频.mp4">视频</a>
  </body>
  </html>
  

• 解决中文名称文件乱码的工具类DownLoadUtils：

  public class DownLoadUtils {
  
      public static String getFileName(String agent, String filename) throws UnsupportedEncodingException {
          if (agent.contains("MSIE")) {
              // IE浏览器
              filename = URLEncoder.encode(filename, "utf-8");
              filename = filename.replace("+", " ");
          } else if (agent.contains("Firefox")) {
              // firefox浏览器
              // firefox浏览器User-Agent字符串:
              // Mozilla/5.0 (Windows NT 6.1; WOW64; rv:36.0) Gecko/20100101
              // Firefox/36.0
              // 先去掉文件名称中的空格,然后转换编码格式为utf-8,保证不出现乱码,
              // 这个文件名称用于浏览器的下载框中自动显示的文件名
              filename = new String(filename.replaceAll(" ", "").getBytes("UTF-8"), "ISO8859-1");
          } else {
              // 其它浏览器
              filename = URLEncoder.encode(filename, "utf-8");
          }
          return filename;
      }
  }
  

• ServletContextDemo核心代码

  @WebServlet("/downloadServlet")
  public class ServletContextDemo extends HttpServlet {
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          //1.获取请求参数，文件名称
          String filename = request.getParameter("filename");
          //2.使用字节输入流加载文件进内存
          //2.1找到文件服务器路径
          ServletContext servletContext = this.getServletContext();
          String realPath = servletContext.getRealPath("/img/" + filename);
          //2.2用字节流关联
          FileInputStream fis = new FileInputStream(realPath);
  
          //3.设置response的响应头
          //3.1设置响应头类型：content-type
          String mimeType = servletContext.getMimeType(filename);//获取文件的mime类型
          response.setHeader("content-type",mimeType);
          //3.2设置响应头打开方式:content-disposition
          //解决中文文件名问题
          //3.2.1获取user-agent请求头、
          String agent = request.getHeader("user-agent");
          //3.2.2使用工具类方法编码文件名即可
          filename = DownLoadUtils.getFileName(agent, filename);
          response.setHeader("content-disposition","attachment;filename="+filename);
          //4.将输入流的数据写出到输出流中
          ServletOutputStream sos = response.getOutputStream();
          byte[] buff = new byte[1024 * 8];
          int len = 0;
          while((len = fis.read(buff)) != -1){
              sos.write(buff,0,len);
          }
          fis.close();
      }
  
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doPost(request,response);
      }
  }
  

• 效果如下：