JavaWeb笔记Day7------Servlet，Request和Response

web相关概念回顾

软件架构

1. C/S：客户端/服务器端
2. B/S：浏览器/服务器端

资源分类

1. 静态资源：所有用户访问后，得到的结果都是一样的，称为静态资源，静态资源可以直接被浏览器解析
   • 如：HTML，css，JavaScript
2. 动态资源：每个用户访问相同资源后，得到的结果可能不一样。称为动态资源。动态资源被访问后，需要先转换为静态资源，再返回给浏览器
   • 如servlet/jsp，php，asp...

网络通信三要素

1. IP：电子设备（计算机）在网络中的唯一标识
2. 端口：应用程序在计算机中的唯一标识 0~65536
3. 传输协议：规定了数据传输的规则
   1. 基础协议：
      1. tcp：安全协议，三次握手。速度稍慢
      2. udp：不安全协议。速度快

web服务器软件

• 服务器：安装了服务器软件的计算机

• 服务器软件：接收用户的请求，处理请求，做出响应

• web服务器软件：接收用户的请求，处理请求，做出响应

  • 在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目
  • web容器

• 常见的Java相关的web服务器软件

  • webLogic：oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
  • webSphere：IBM公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
  • JBOSS：JBOSS公司的，大型的JavaEE服务器，支持所有的JavaEE规范，收费的。
  • Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范servlet/jsp。开源的，免费的。

• JavaEE：Java语言在企业级开发中使用的技术规范的总和，一共规定了13项大的规范

Tomcat

概念

web服务器软件

使用

1. 下载：http://tomcat.apache.org/

2. 安装：解压压缩包即可。

   • 注意：安装目录建议不要有中文和空格

3. 卸载：删除目录就行了

4. 启动：

   • bin/startup.bat 双击运行即可

   • 访问：浏览器输入：

     • http://localhost:8080
     • http://别人的ip:8080

   • 可能遇到的问题

     1. 黑窗口一闪而过：

        • 原因：没有正确配置JAVA_HOME环境变量
        • 解决方案：正确配置JAVA_HOME环境变量

     2. 启动报错：

        1. 暴力：找到占用的端口号，并且找到对应的进程，杀死该进程

           netstat -ano|findstr "端口号"
           taskkill /f /t /im PID号

        2. 温柔：修改自身的端口号（conf/server.xml）

           <Connector port="8888" protocol="HTTP/1.1"
           connectionTimeout="20000"
                      redirectPort="8445" />

        3. 一般会将tomcat的默认端口号修改为80。80端口号是http协议的默认端口号

           • 好处：在访问时就不用输入端口号

5. 关闭

   • 正常关闭：
     • bin/shutdown.bat
     • ctrl+c
   • 强制关闭：
     • 点击启动窗口的x

6. 配置

   • 部署项目的方式：

     1. 直接将项目放到webapps目录下即可

        • /hello：项目的访问路径--＞虚拟路径
        • 简化部署：将项目打成一个war包，再将war包放置到webapps目录下
          • war包会自动解压缩

     2. 配置conf/server.xml文件

        在<host>标签体中配置

        <Context docBase="D:\hello path="/hehe" />

        • docBase：项目存放的路径
        • path：虚拟目录

     3. 在conf\Catalina\localhost创建任意名称的xml文件。在文件中编写
        <Context docBase="D:\hello />

        • 虚拟目录：xml的文件名称

目录结构

Java动态项目的目录结构

---- 项目根目录

​ ---- WEB-INF目录：

​ ----web.xml：web项目的核心配置文件

​ ----classes目录：放置字节码文件的目录

​ ----lib目录：放置依赖的jar包

Servlet：server applet

概念

运行在服务器端的小程序

• Servlet就是一个接口，定义了Java类被浏览器访问（Tomcat识别）到的规则。
• 将来我们自定义一个类，实现Servlet接口，复写方法

步骤

1. 创建JavaEE项目

2. 定义一个类，实现Servlet接口

   package web.servlet;
    
   import javax.servlet.*;
   import java.io.IOException;
    
   public class ServletDemo1 implements Servlet {
    
       @Override
       public void init(ServletConfig servletConfig) throws ServletException {
    
       }
    
       @Override
       public ServletConfig getServletConfig() {
           return null;
       }
    
       //提供服务的方法
       @Override
       public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
           System.out.println("Hello Servlet！");
       }
    
       @Override
       public String getServletInfo() {
           return null;
       }
    
       @Override
       public void destroy() {
    
       }
   }

3. 实现接口中的抽象方法

4. 配置Servlet

   • 在web.xml中配置

         <!--配置Servlet-->
         <servlet>
             <servlet-name>helloServlet</servlet-name>
             <!--全类名-->
             <servlet-class>web.servlet.ServletDemo1</servlet-class>
         </servlet>
      
         <servlet-mapping>
             <servlet-name>helloServlet</servlet-name>
             <!--访问路径-->
             <url-pattern>/hello</url-pattern>
         </servlet-mapping>

执行原理

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

Servlet中的生命周期

1. 被创建：执行init方法（一般用于加载资源），只执行一次

   • Servlet什么时候被创建

     • 默认情况下，第一次被访问时，Servlet被创建

     • 可以配置执行Servlet的创建时机

       • 在servlet标签下配置

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

         <load-on-startup>-1</load-on-startup>

   • Servlet的init方法，只执行一次，说明一个servlet在内存中只存在一个对象，Servlet是单例的

     • 多个用户同时访问时，可能存在线程安全问题
     • 解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对其修改值

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

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

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

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

package web.servlet;
 
import javax.servlet.*;
import java.io.IOException;
 
public class ServletDemo2 implements Servlet {
    /**
     * 初始化方法
     * 在Servlet被创建时，执行。只会执行一次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("ServletDemo2 init");
    }
 
    /**
     * 获取ServletConfig对象
     * ServletConfig对象是Servlet的配置对象
     * @return
     */
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
 
    /**
     * 提供服务方法
     * 每一次Servlet被访问时，执行。执行多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("ServletDemo2 service");
    }
 
    /**
     * 获取Servlet的一些信息,版本,作者等等...
     * @return
     */
    @Override
    public String getServletInfo() {
        return null;
    }
 
    /**
     * 销毁方法
     * 在Servlet被销毁时（服务器正常关闭时），执行。执行一次
     */
    @Override
    public void destroy() {
        System.out.println("ServletDemo2 destroy");
    }
}

Servlet3.0

好处

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

步骤

1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml

2. 定义一个类，实现Servlet接口

3. 复写方法

4. 在类上使用@WebServlet注解，进行配置

   @WebServlet("资源路径")
   @WebServlet(urlPatterns = "资源路径")

IDEA与Tomcat的相关配置

Servlet的体系结构

• Servlet------接口
  |
  GenericServlet------抽象类
  |
  HttpServlet-----抽象类

• GenericServlet：将Servlet接口中其他的方法做了默认空实现

  • 将来定义Servlet类可以继承GenericServlet，实现service()方法即可

• HttpServlet：对http协议的一种封装，简化操作

  1. 定义类继承HTTPServlet

  2. 复写doGet/doPost方法

     

  • 源码如下：

     /**
     * javax.servlet.http.HttpServlet protected void service(@NotNull HttpServletRequest req,
     *                        HttpServletResponse resp) throws ServletException, IOException
     * 从公共service方法接收标准 HTTP 请求，并将它们分派到此类中定义的do Method方法。此方法是javax.servlet.Servlet.service方法的 HTTP    特定版本。无需重写此方法。
     *
     * 参形：
     *      req – HttpServletRequest对象，其中包含客户端对 servlet 发出的请求
     *     resp – HttpServletResponse对象，其中包含 servlet 返回给客户端的响应
     * 抛出：
     *      IOException – 如果在 servlet 处理 HTTP 请求时发生输入或输出错误
     *      ServletException – 如果无法处理 HTTP 请求
     * 请参阅：
     *      javax.servlet.Servlet.service
     * 推断注解：
     *      @org.jetbrains.annotations.NotNull
     * apache-tomcat-9.0.8-src
     */
        protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
     
            String method = req.getMethod();
     
            if (method.equals(METHOD_GET)) {
                long lastModified = getLastModified(req);
                if (lastModified == -1) {
                    // servlet doesn't support if-modified-since, no reason
                    // to go through further expensive logic
                    doGet(req, resp);
                } else {
                    long ifModifiedSince;
                    try {
                        ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                    } catch (IllegalArgumentException iae) {
                        // Invalid date header - proceed as if none was set
                        ifModifiedSince = -1;
                    }
                    if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                        // If the servlet mod time is later, call doGet()
                        // Round down to the nearest second for a proper compare
                        // A ifModifiedSince of -1 will always be less
                        maybeSetLastModified(resp, lastModified);
                        doGet(req, resp);
                    } else {
                        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    }
                }
     
            } else if (method.equals(METHOD_HEAD)) {
                long lastModified = getLastModified(req);
                maybeSetLastModified(resp, lastModified);
                doHead(req, resp);
     
            } else if (method.equals(METHOD_POST)) {
                doPost(req, resp);
     
            } else if (method.equals(METHOD_PUT)) {
                doPut(req, resp);
     
            } else if (method.equals(METHOD_DELETE)) {
                doDelete(req, resp);
     
            } else if (method.equals(METHOD_OPTIONS)) {
                doOptions(req,resp);
     
            } else if (method.equals(METHOD_TRACE)) {
                doTrace(req,resp);
     
            } else {
                //
                // Note that this means NO servlet supports whatever
                // method was requested, anywhere on this server.
                //
     
                String errMsg = lStrings.getString("http.method_not_implemented");
                Object[] errArgs = new Object[1];
                errArgs[0] = method;
                errMsg = MessageFormat.format(errMsg, errArgs);
     
                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
            }
        }

Servlet相关配置

1. urlpartten：Servlet访问路径
   1. 一个Servlet可以定义多个访问路径：@WebServlet({"/d4","/dd4","/ddd4"})
   2. 路径定义规则：
      1. /xxx
      2. /xxx/xxx：多层路径，目录结构
      3. *.do

HTTP协议

概念

Hyper Text Transfer Protocal 超文本传输协议

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

• 特点：

  1. 基于TCP/IP的高级协议
  2. 默认端口号：80
  3. 基于请求响应模型的：一次请求对应一次响应
  4. 无状态的：每次请求之间相互独立，不能交互数据

• 历史版本：

  • 1.0：每一次请求响应都会建立新的连接

  • 1.1：复用连接

请求消息

概念

客户端发送给服务器端的数据

数据格式

1. 请求行

   请求方式	请求url	请求协议/版本
   GET	/login.html	HTTP/1.1

   • 请求方式：
     • http协议有7种请求方式，常用的有两种
       • GET：
         1. 请求参数在请求行中，在url后。
         2. 请求的url长度有限制的
         3. 不太安全
       • POST：
         1. 请求参数在请求体中
         2. 请求的url长度没有限制的
         3. 相对安全

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

   请求头名称：请求头值

   • 常见的请求头：

     1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息

        • 可以在服务器端获取该头的信息,解决浏览器的兼容性问题

        

     2. Referer：http://localhost/login.html

        • 告诉服务器，我（当前请求）从哪里来？
          1. 防盗链：
          2. 统计工作：
        • 防盗链：

        

3. 请求空行

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

4. 请求体（正文）

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

响应消息

• 概念：服务器端发送给客户端的数据
• 数据格式：

  1. 响应行

     1. 组成：协议/版本 响应状态码 状态码描述
     2. 响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态

        1. 状态码都是三位数字

        2. 分类：

           • 1xx：服务器接收客户端消息，但没有接收完成，等待一段时间后，发送1xx状态码

           • 2xx：成功。代表：200

           • 3xx：重定向。代表：302（重定向），304（访问缓存）

           • 4xx：客户端错误。代表：404（请求路径没有对应的资源）405（请求方式没有对应的doXxx方法）

           • 5xx：服务器端错误。代表：500（服务器内部出现异常）

  2. 响应头：

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

  3. 响应空行

  4. 响应体：传输的数据

Request

request对象和response对象的原理

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

request对象继承体系结构

request功能

获取请求消息

获取请求行数据

• GET /day14/demo1?name=zhangsan HTTP/1.1
• 方法：

  1. 获取请求方式：GET

     String getMethod();

  2. 获取虚拟目录：/day14

     String getContextPath();

  3. 获取Servlet路径：demo1

     String getServletPath();

  4. 获取get方式请求参数：name=zhangsan

     String getQueryString();

  5. 获取请求URI：/day14/demo1

     //day14/demo1
     String getRequestURI();
     //http://localhost/day14/demo1
     StringBuffer getRequestURL();

     • URL：统一资源定位符：http://localhost/day14/demo1

     • URI：统一资源标识符：day14/demo1

  6. 获取协议及版本：HTTP/1.1

     String getProtocol();
      

  7. 获取客户机的IP地址：

     String getRemoteAddr();

获取请求头数据

• 方法：

  //通过请求头的名称获取请求头的值
  String getHeader(String name);
   
  //获取所有的请求头名称
  Enumeration<String> getHeaderNames();

获取请求体数据

• 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数

• 步骤：

  1. 获取流对象

     //获取字符输入流,只能操作字符数据
     BufferedReader getReader();
      
     //获取字节输入流,可以操作所有类型数据
     ServletInputStream getInputStream();

  2. 再从流对象中拿数据

其他功能

获取请求参数通用方式

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

//根据参数名称获取参数值 username=zs&password=123
String getParameter(String name);
 
//根据参数名称获取参数值的数组
String[] getParameterValues(String name);
 
//获取所有请求的参数名称
Enumration<String> getParameterNames();
 
//获取所有参数的Map集合
Map<String,String[]>getParameterMap();

• 中文乱码问题：

  • get方式：Tomcat8已经将get方式乱码问题解决了

  • post方式：会乱码

    • 解决：在获取参数前，设置请求request的编码

      request.setCharacterEncoding("utf-8");

请求转发

• 概念：一种在服务器内部的资源跳转方式

• 步骤：

  1. 通过request对象获取请求转发器对象：

     RequestDispatcher getRequestDispatcher(String path);

  2. 使用RequestDispatcher对象来进行转发

     forward(ServletRequest request,Servlet Response response);

• 特点：

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

共享数据

• 域对象：一个有作用范围的对象，可以在范围内共享数据

• request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据

• 方法：

//存储数据
void setAttribute(String name,Object obj);
//通过键获取值
Object getAttitude(String name);
//通过键移除键值对
void removeAttribute(String name);

获取ServletContext

ServletContext getServletContext();

案例：用户登录

需求

1. 编写login.html登录页面

   username & password 两个输入框

2. 使用Druid数据库连接池技术,操作mysql，day14数据库中user表

3. 使用JdbcTemplate技术封装JDBC

4. 登录成功跳转到SuccessServlet展示：登录成功！用户名,欢迎您

5. 登录失败跳转到FailServlet展示：登录失败，用户名或密码错误

分析

步骤

1. 创建项目，导入html页面，配置文件，jar包

2. 创建数据库环境

   CREATE DATABASE Login;
   USE Login;
   CREATE TABLE USER(
              id INTEGER PRIMARY KEY AUTO_INCREMENT,
              username VARCHAR(32) UNIQUE NOT NULL,
              PASSWORD VARCHAR(32) NOT NULL
   );
   INSERT user VALUES('1','admin','123456');

3. 创建包和User类

   package web.test.domain;
    
   /**
    * 用户的实体类
    */
   public class User {
       private int id;
       private String username;
       private String password;
    
       public int getId() {
           return id;
       }
    
       public void setId(int id) {
           this.id = id;
       }
    
       public String getUsername() {
           return username;
       }
    
       public void setUsername(String username) {
           this.username = username;
       }
    
       public String getPassword() {
           return password;
       }
    
       public void setPassword(String password) {
           this.password = password;
       }
   }

4. 创建包和UserDao类

   package web.test.dao;
    
   import org.springframework.dao.DataAccessException;
   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   import org.springframework.jdbc.core.JdbcTemplate;
   import web.test.domain.User;
   import web.test.util.JDBCUtils;
    
   /**
    * 操作数据库中User表的类
    */
   public class UserDao {
    
       //声明JDBCTemplate对象共用
       private JdbcTemplate template=new JdbcTemplate(JDBCUtils.getDataSource());
    
    
       /**
        * 登录方法
        * @param loginUser 只有用户名和密码
        * @return user包含用户全部数据
        */
       public User login(User loginUser){
           try {
               //1.编写sql
               String sql="SELECT *FROM user WHERE username=? AND PASSWORD=?";
               //调用query方法
               User user=template.queryForObject(sql,
                       new BeanPropertyRowMapper<>(User.class),
                       loginUser.getUsername(),loginUser.getPassword());
               return user;
           } catch (DataAccessException e) {
               e.printStackTrace();//记录日志
               return null;
           }
       }
   }
    
    

5. 编写LoginServlet类

   package web.test.web.servlet;
    
   import web.test.dao.UserDao;
   import web.test.domain.User;
    
   import javax.servlet.*;
   import javax.servlet.http.*;
   import javax.servlet.annotation.*;
   import java.io.IOException;
    
   @WebServlet(name = "LoginServlet", value = "/LoginServlet")
   public class LoginServlet extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           //1.设置编码
           request.setCharacterEncoding("utf-8");
           //2.获取请求参数
           String username = request.getParameter("username");
           String password = request.getParameter("password");
           //3.封装user对象
           User loginUser = new User();
           loginUser.setUsername(username);
           loginUser.setPassword(password);
    
           //4.调用UserDao的login方法
           UserDao dao=new UserDao();
           User user=dao.login(loginUser);
    
           //5.判断user
           if (user==null){
               //登录失败
               request.getRequestDispatcher("/FailServlet").forward(request,response);
           }else {
               //登录成功
               //存储数据
               request.setAttribute("user",user);
               //转发
               request.getRequestDispatcher("/SuccessServlet").forward(request,response);
           }
       }
    
       @Override
       protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           this.doGet(request,response);
       }
   }

6. 编写FailServlet和SuccessServlet类

7. login.html中form表单的写法

   • 虚拟目录+Servlet的资源路径

BeanUtils

概念

• 成员变量
• 属性：setter和getter方法截取后的产物
  • 例如：getUsername()---->Username---->username

用途

工具类---简化数据封装，用于封装JavaBean。

JavaBean------标准的Java类

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

方法

setProperty();
getProperty();
//将map集合的键值对信息，封装到对应的JavaBean对象中
populate();

案例

//2. 获取所有请求参数
Map<String, String[]>map=request.getParameterMap();
//3.创建User对象
User loginUser=new User();
//3.1使用BeanUtils封装
try {
    BeanUtils.populate(loginUser,map);
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (InvocationTargetException e) {
    e.printStackTrace();
}

Respouse对象

功能

设置响应消息

设置响应行

1. 格式：HTTP/1.1 200 ok

2. 设置状态码

   setStatus(int sc);

设置响应头

setHeader(String name,String value);

设置响应体

使用步骤：

1. 获取输出流

   //字符输出流
   PrintWriter getWriter();
   //字节输出流
   ServletOutputStream getOutputStream();

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

案例

完成重定向

• 重定向：资源跳转的方式
  

• 代码：

  package web.response;
   
  import javax.servlet.*;
  import javax.servlet.http.*;
  import javax.servlet.annotation.*;
  import java.io.IOException;
   
  @WebServlet(name = "responseDemo1", value = "/responseDemo1")
  public class responseDemo1 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doPost(request,response);
      }
   
      @Override
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          System.out.println("demo1....");
   
          //访问/responseDemo1,会自动跳转到/responseDemo2资源
  //        //1. 设置状态码为302
  //        response.setStatus(302);
  //        //2. 设置响应头location
  //        response.setHeader("location","/StudyJavaWeb01/responseDemo2");
   
          //简单的重定向方法
          //动态获取虚拟目录
          String contextPath=request.getContextPath();
          response.sendRedirect(contextPath+"/responseDemo2");
      }
  }

• 重定向的特点：redirect

  1. 地址栏发生变化
  2. 重定向可以访问其他站点（服务器）的资源
  3. 重定向是两次请求。不能使用request对象来共享数据

• 转发的特点：forward

  1. 转发地址栏路径不变
  2. 转发只能访问当前服务器下的资源
  3. 转发是一次请求。可以使用request对象来共享数据

• 路径的写法：

  1. 路径分类

     1. 相对路径：通过相对路径不可以确定唯一资源

        • 如：./index.html
        • 不以/开头，以.开头路径
        • 规则：找到当前资源和目标资源之间的相对位置关系
          • ./：当期资源
          • ../：后退一级目录

     2. 绝对路径：通过绝对路径可以确定唯一资源

        • 如：http://localhost/response/demo1 /response/demo1

        • 以/开头的路径

        • 规则：判断定义的路径是给谁用的？判断请求将来从哪儿发出

          • 给客户端浏览器使用：需要加虚拟目录（项目的访问路径）

            • 建议虚拟目录动态获取

              String contextPath=request.getContextPath();

            • <a>，<form>重定向。。。

          • 给服务器使用：不需要加虚拟目录

            • 转发路径

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

• 步骤：

  1. 获取字符输出流

  2. 输出数据

     //简单的形式,设置编码,在获取流之前设置
     response.setContentType("text/html;charset=utf-8");

  

• 注意：

  乱码问题：

  1. PrintWriter pw=response.getWriter();获取的流的默认编码是ISO-8859-1
  2. 设置该流的默认编码
  3. 告诉浏览器响应体使用的编码

• 代码：

  package web.response;
   
  import javax.servlet.*;
  import javax.servlet.http.*;
  import javax.servlet.annotation.*;
  import java.io.IOException;
  import java.io.PrintWriter;
   
  @WebServlet(name = "responseDemo3", value = "/responseDemo3")
  public class responseDemo3 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  //        获取流对象之前,设置流的默认编码
  //        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("<h1>Hello response你好<h1>");
      }
   
      @Override
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doGet(request,response);
      }
  }

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

• 步骤：

  1. 获取字符输出流

  2. 输出数据

验证码

1. 本质：图片

2. 目的：防止恶意表单注册

3. 代码

   • 生成验证码

     package web.response;
      
     import javax.imageio.ImageIO;
     import javax.servlet.*;
     import javax.servlet.http.*;
     import javax.servlet.annotation.*;
     import java.awt.*;
     import java.awt.image.BufferedImage;
     import java.io.IOException;
     import java.util.Random;
      
     @WebServlet(name = "CheckCodeServlet", value = "/CheckCodeServlet")
     public class CheckCodeServlet extends HttpServlet {
         @Override
         protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
             this.doPost(request,response);
         }
      
         @Override
         protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
             int width = 100;
             int height =50;
             //1. 创建对象,在内存中画图(验证码图片)
             BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
      
             //2.美化图片
             //2.1 填充背景色
             Graphics g=image.getGraphics();//画笔对象
             g.setColor(Color.YELLOW);//填充颜色
             g.fillRect(0,0,width,height);//填充矩形
      
             //2.2画边框
             g.setColor(Color.BLUE);//设置画笔颜色
             g.drawRect(0,0,width-1,height-1);//画矩形
      
             String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
      
             //生成随机角标
             Random random = new Random();
             for (int i = 1; i <= 4; i++) {
                 int index = random.nextInt(str.length());
                 //获取字符
                 char ch=str.charAt(index);
                 //2.3 写验证码
                 g.drawString(ch+"",width/5*i,height/2);
             }
      
             //2.4 画干扰线
             g.setColor(Color.RED);
      
             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);
             }
      
             //3.将图片输出到页面展示
             ImageIO.write(image, "jpg", response.getOutputStream());
         }
     }

   • 绑定事件

     <!DOCTYPE html>
     <html lang="en">
     <head>
         
         <title>Title</title>
     </head>
      
     <script>
         /**
          * 分析:
          *      点击超链接或者图片,需要换一张
          *      1.给超链接或者图片绑定单击事件
          *
          *      2.重新设置图片的src属性值
          */
      
         window.onload = function(){
             //1.获取图片对象
             var img = document.getElementById("checkCode");
             //2.绑定单击事件
             img.onclick=function(){
                 //加时间戳
                 var data = new Date().getTime();
      
                 img.src = "/StudyJavaWeb01/CheckCodeServlet?a="+data;
             }
      
             var change=document.getElementById("change");
             change.onclick=function(){
                 var data = new Date().getTime();
                 img.src = "/StudyJavaWeb01/CheckCodeServlet?a="+data;
             }
      
      
         }
     </script>
      
     <body>
     <img src="/StudyJavaWeb01/CheckCodeServlet" alt="" id="checkCode">
     <a id="change" href="javascript:void (0)">看不清?换一张</a>
     </body>
     </html>

ServletContext对象

概念

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

获取

1. 通过request对象获取

功能

1. 获取MIME类型：

   • MIME类型：在互联网通信过程中定义的一种文件数据类型

     • 格式：大类型/小类型 text/html image/jepg

   • 获取：

     String getMimeType(String file);

2. 域对象：共享数据

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

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

3. 获取文件的真实（服务器）路径

   方法：

   String getRealPath(String path)
    

案例----文件下载

需求

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

分析

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

步骤

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

中文文件名称问题

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

代码

主类

package web.servletcontext;
 
import web.utils.DownLoadUtils;
 
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.FileInputStream;
import java.io.IOException;
 
@WebServlet(name = "DownloadServlet", value = "/DownloadServlet")
public class DownloadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
 
    @Override
    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 fileInputStream = new FileInputStream(realPath);
 
        //3.设置response响应头
        //3.1设置响应头类型:content-type
        String mimeType = ServletContext.getMimeType(realPath);
        response.setHeader("content-type", mimeType);//获取文件的mime类型
        //3.2设置响应头打开方式:content-disposition
 
        //解决中文文件名问题
        //1.获取user-agent请求头
        String userAgent = request.getHeader("user-agent");
        //2.使用工具类编码文件名
        fileName=DownLoadUtils.getFileName(userAgent, fileName);
 
        response.setHeader("content-disposition", "attachment;filename=" + fileName);
 
 
 
        //4.将输入流的数据写到输出流中
        ServletOutputStream outputStream = response.getOutputStream();
        byte[] bytes = new byte[1024*8];
        int len = 0;
        while ((len = fileInputStream.read(bytes)) != -1) {
            outputStream.write(bytes, 0, len);
        }
 
        fileInputStream.close();
    }
}

下载页面

<!DOCTYPE html>
<html lang="en">
<head>
    
    <title>Title</title>
</head>
<body>
<a href="/StudyJavaWeb01/DownloadServlet?filename=图片20220120085920.jpg">图片</a>
</body>
</html>

工具类

package web.utils;
 
import java.util.Base64;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
 
 
 
 
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")) {
            // 火狐浏览器
            Base64.Encoder encoder = Base64.getEncoder();
            filename = "=?utf-8?B?" + encoder.encodeToString(filename.getBytes("utf-8")) + "?=";
        } else {
            // 其它浏览器
            filename = URLEncoder.encode(filename, "utf-8");
        }
        return filename;
    }
}