[Java知识库] 五、JavaWeb基础(servlet、http协议、request和response请求详解、ServletContext对象)

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 五、JavaWeb基础(servlet、http协议、request和response请求详解、ServletContext对象) -> 正文阅读

[Java知识库]五、JavaWeb基础(servlet、http协议、request和response请求详解、ServletContext对象)

一、Servlet：server applet

1. 概念：

运行在服务器端的小程序
在这里插入图片描述

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

2. Servlet简单案例入门：

实现步骤：

创建JavaEE项目
定义一个类，实现Servlet接口
public class ServletDemo1 implements Servlet
实现接口中的抽象方法
配置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了。

步骤：

创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
定义一个类，实现Servlet接口
复写方法
在类上使用@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"})

② 路径定义规则：

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

在这里插入图片描述

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

1. 概念：

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

2.特点：

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

历史版本：

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. 相对安全

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

请求头名称: 请求头值

常见的请求头：

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

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. 请求转发：一种在服务器内部的资源跳转方式

步骤：

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

特点：

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

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工具类中的方法：

void setProperty()
String getProperty()
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对象的功能：设置响应消息

① 设置响应行

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

② 设置响应头：

?setHeader(String name, String value)

③ 设置响应体：

使用步骤：

获取输出流
* 字符输出流：PrintWriter getWriter()
* 字节输出流：ServletOutputStream getOutputStream()
使用输出流，将数据输出到客户端浏览器

⑵ 案例：

① 完成重定向

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对象来共享数据

路径写法：

相对路径：通过相对路径不可以确定唯一资源
?? * 如：./index.html
??* 不以/开头，以.开头路径
?? * 规则：找到当前资源和目标资源之间的相对位置关系
?????* ./：当前目录
?????* ../:后退一级目录
绝对路径：通过绝对路径可以确定唯一资源
???* 如：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);
    }
}

结果如下：
在这里插入图片描述

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

步骤：

获取字节输出流
输出数据

代码如下：

@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);
    }
}

结果如下：
在这里插入图片描述

④ 验证码

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

验证码页面：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. 获取：

通过request对象获取
request.getServletContext();
通过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. 功能：

获取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.步骤：

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

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

解决思路：

获取客户端使用的浏览器版本信息
根据不同的版本信息，设置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);
    }
}