javaWeb学习笔记

Mysql

JDBC

1，JDBC概述

在开发中我们使用的是java语言，那么势必要通过java语言操作数据库中的数据。这就是接下来要学习的JDBC。

1.1 JDBC概念

JDBC 就是使用Java语言操作关系型数据库的一套API

全称：( Java DataBase Connectivity ) Java 数据库连接

我们开发的同一套Java代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是MySQL数据库，而上线时公司最终选用oracle数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的。我们要做到的是同一套Java代码操作不同的关系型数据库，而此时sun公司就指定了一套标准接口（JDBC），JDBC中定义了所有操作关系型数据库的规则。众所周知接口是无法直接使用的，我们需要使用接口的实现类，==而这套实现类（称之为：驱动）==就由各自的数据库厂商给出。

1.2 JDBC本质

• 官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口
• 各个数据库厂商去实现这套接口，提供数据库驱动jar包
• 我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

1.3 JDBC好处

• 各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
• 可随时替换底层数据库，访问数据库的Java代码基本不变

以后编写操作数据库的代码只需要面向JDBC（接口），操作哪儿个关系型数据库就需要导入该数据库的驱动包，如需要操作MySQL数据库，就需要再项目中导入MySQL数据库的驱动包。如下图就是MySQL驱动包

2，JDBC快速入门

先来看看通过Java操作数据库的流程

第一步：编写Java代码

第二步：Java代码将SQL发送到MySQL服务端

第三步：MySQL服务端接收到SQL语句并执行该SQL语句

第四步：将SQL语句执行的结果返回给Java代码

2.1 编写代码步骤

• 创建工程，导入驱动jar包

  

• 注册驱动

  Class.forName("com.mysql.jdbc.Driver");
  

• 获取连接

  Connection conn = DriverManager.getConnection(url, username, password);
  

  Java代码需要发送SQL给MySQL服务端，就需要先建立连接

• 定义SQL语句

  String sql =  “update…” ;
  

• 获取执行SQL对象

  执行SQL语句需要SQL执行对象，而这个执行对象就是Statement对象

  Statement stmt = conn.createStatement();
  

• 执行SQL

  stmt.executeUpdate(sql);  
  

• 处理返回结果

• 释放资源

2.2 具体操作

• 创建新的空的项目

• 定义项目的名称，并指定位置

• 对项目进行设置，JDK版本、编译版本

• 创建模块，指定模块的名称及位置

• 导入驱动包

  将mysql的驱动包放在模块下的lib目录（随意命名）下，并将该jar包添加为库文件

• 在添加为库文件的时候，有如下三个选项
  • Global Library ： 全局有效
  • Project Library : 项目有效
  • Module Library ： 模块有效

• 在src下创建类

• 编写代码如下

/**
 * JDBC快速入门
 */
public class JDBCDemo {

    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/db1";
        String username = "root";
        String password = "1234";
        Connection conn = DriverManager.getConnection(url, username, password);
        //3. 定义sql
        String sql = "update account set money = 2000 where id = 1";
        //4. 获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //5. 执行sql
        int count = stmt.executeUpdate(sql);//受影响的行数
        //6. 处理结果
        System.out.println(count);
        //7. 释放资源
        stmt.close();
        conn.close();
    }
}

3，JDBC API详解

3.1 DriverManager

DriverManager（驱动管理类）作用：

• 注册驱动

  

  registerDriver方法是用于注册驱动的，但是我们之前做的入门案例并不是这样写的。而是如下实现

  Class.forName("com.mysql.jdbc.Driver");
  

  我们查询MySQL提供的Driver类，看它是如何实现的，源码如下：

  

  在该类中的静态代码块中已经执行了 DriverManager 对象的 registerDriver() 方法进行驱动的注册了，那么我们只需要加载 Driver 类，该静态代码块就会执行。而 Class.forName("com.mysql.jdbc.Driver"); 就可以加载 Driver 类。

  提示：

  • MySQL 5之后的驱动包，可以省略注册驱动的步骤
  • 自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

• 获取数据库连接

  

  参数说明：

  • url ： 连接路径

    语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…

    示例：jdbc:mysql://127.0.0.1:3306/db1

    细节：

    • 如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对

    • 配置 useSSL=false 参数，禁用安全连接方式，解决警告提示

  • user ：用户名

  • poassword ：密码

3.2 Connection

Connection（数据库连接对象）作用：

• 获取执行 SQL 的对象
• 管理事务

3.2.1 获取执行对象

• 普通执行SQL对象

  Statement createStatement()
  

  入门案例中就是通过该方法获取的执行对象。

• 预编译SQL的执行SQL对象：防止SQL注入

  PreparedStatement  prepareStatement(sql)
  

  通过这种方式获取的 PreparedStatement SQL语句执行对象是我们一会重点要进行讲解的，它可以防止SQL注入。

• 执行存储过程的对象

  CallableStatement prepareCall(sql)
  

  通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的，而存储过程在MySQL中不常用，所以这个我们将不进行讲解。

3.2.2 事务管理

先回顾一下MySQL事务管理的操作：

• 开启事务 ： BEGIN; 或者 START TRANSACTION;
• 提交事务 ： COMMIT;
• 回滚事务 ： ROLLBACK;

MySQL默认是自动提交事务

接下来学习JDBC事务管理的方法。

Connection接口中定义了3个对应的方法：

• 开启事务

  

  参与autoCommit 表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。

• 提交事务

  

• 回滚事务

  

具体代码实现如下：

/** * JDBC API 详解：Connection */
public class JDBCDemo3_Connection {  

public static void main(String[] args) throws Exception {
	//1. 注册驱动        //
	Class.forName("com.mysql.jdbc.Driver");        
	//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写        
	String url = "jdbc:mysql:///db1?useSSL=false";        
	String username = "root";        
	
	String password = "1234";        
	Connection conn = DriverManager.getConnection(url, username, password);        
	//3. 定义sql        
	String sql1 = "update account set money = 3000 where id = 1";        
	String sql2 = "update account set money = 3000 where id = 2";        
	//4. 获取执行sql的对象 Statement        
	Statement stmt = conn.createStatement();        
	try {            
	// ============开启事务==========           
	conn.setAutoCommit(false);            
	//5. 执行sql            
	int count1 = stmt.executeUpdate(sql1);//受影响的行数            
	//6. 处理结果            
	System.out.println(count1);            
	int i = 3/0;            
	//5. 执行sql            
	int count2 = stmt.executeUpdate(sql2);//受影响的行数            
	//6. 处理结果           
    System.out.println(count2);            
    // ============提交事务==========            
    //程序运行到此处，说明没有出现任何问题，则需求提交事务            
    conn.commit();        
} catch (Exception e) {            
// ============回滚事务==========            
//程序在出现异常时会执行到这个地方，此时就需要回滚事务           
conn.rollback();            
e.printStackTrace();        
}        
//7. 释放资源        
stmt.close();        
conn.close();    
}}

3.3 Statement

3.3.1 概述

Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。

• 执行DDL、DML语句

  

• 执行DQL语句

  

  该方法涉及到了 ResultSet 对象，而这个对象我们还没有学习，一会再重点讲解。

3.3.2 代码实现

• 执行DML语句

  /**  * 执行DML语句  
  * @throws Exception  
  */
  @Testpublic 
  void testDML() throws  Exception {    
      //1. 注册驱动    //
      Class.forName("com.mysql.jdbc.Driver");    
      //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写    
      String url = "jdbc:mysql:///db1?useSSL=false";    
      String username = "root";    
      String password = "1234";    
      Connection conn = DriverManager.getConnection(url, username, password);    
      //3. 定义sql    
      String sql = "update account set money = 3000 where id = 1";    
      //4. 获取执行sql的对象 Statement    
      Statement stmt = conn.createStatement();    
      //5. 执行sql    
      int count = stmt.executeUpdate(sql);
      //执行完DML语句，受影响的行数    
      //6. 处理结果    //
      System.out.println(count);    
      if(count > 0){        
          System.out.println("修改成功~");    
      }else{        
          System.out.println("修改失败~");    
      }    
      //7. 释放资源    
      stmt.close();    
      conn.close();
  }
  

• 执行DDL语句

  /**  * 执行DDL语句  * @throws Exception  */
  @Testpublic 
  void testDDL() throws  Exception {    
      //1. 注册驱动    //
      Class.forName("com.mysql.jdbc.Driver");    
      //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写    
      String url = "jdbc:mysql:///db1?useSSL=false";    
      String username = "root";    
      String password = "1234";    
      Connection conn = DriverManager.getConnection(url, username, password);    
      //3. 定义sql    
      String sql = "drop database db2";   
      //4. 获取执行sql的对象 Statement    
      Statement stmt = conn.createStatement();    
      //5. 执行sql    
      int count = stmt.executeUpdate(sql);
      //执行完DDL语句，可能是0    
      //6. 处理结果    
      System.out.println(count);    
      //7. 释放资源    
      stmt.close();    
      conn.close();
  }
  

  注意：

  • 以后开发很少使用java代码操作DDL语句

3.4 ResultSet

3.4.1 概述

ResultSet（结果集对象）作用：

• 封装了SQL查询语句的结果。

而执行了DQL语句后就会返回该对象，对应执行DQL语句的方法如下：

ResultSet  executeQuery(sql)：执行DQL 语句，返回 ResultSet 对象

那么我们就需要从 ResultSet 对象中获取我们想要的数据。ResultSet 对象提供了操作查询结果数据的方法，如下：

boolean next()

• 将光标从当前位置向前移动一行
• 判断当前行是否为有效行

方法返回值说明：

• true ： 有效航，当前行有数据
• false ： 无效行，当前行没有数据

xxx getXxx(参数)：获取数据

• xxx : 数据类型；如： int getInt(参数) ；String getString(参数)
• 参数
  • int类型的参数：列的编号，从1开始
  • String类型的参数： 列的名称

如下图为执行SQL语句后的结果

一开始光标指定于第一行前，如图所示红色箭头指向于表头行。当我们调用了 next() 方法后，光标就下移到第一行数据，并且方法返回true，此时就可以通过 getInt("id") 获取当前行id字段的值，也可以通过 getString("name") 获取当前行name字段的值。如果想获取下一行的数据，继续调用 next() 方法，以此类推。

3.4.2 代码实现

/**  * 执行DQL  * @throws Exception  */
@Testpublic 
void testResultSet() throws  Exception {    
    //1. 注册驱动    //
    Class.forName("com.mysql.jdbc.Driver");   
    //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写    
    String url = "jdbc:mysql:///db1?useSSL=false";    
    String username = "root";    
    String password = "1234";    
    Connection conn = DriverManager.getConnection(url, username, password);    
    //3. 定义sql    
    String sql = "select * from account";    
    //4. 获取statement对象    
    Statement stmt = conn.createStatement();    
    //5. 执行sql    
    ResultSet rs = stmt.executeQuery(sql);    
    //6. 处理结果， 遍历rs中的所有数据    列数获取
    /* // 6.1 光标向下移动一行，并且判断当前行是否有数据        
    while (rs.next()){            
    //6.2 获取数据  getXxx()            
    int id = rs.getInt(1);           
    String name = rs.getString(2);            
    double money = rs.getDouble(3);            
    System.out.println(id);            
    System.out.println(name);            
    System.out.println(money);            
    System.out.println("--------------");        
}*/   
    // 6.1 光标向下移动一行，并且判断当前行是否有数据     字段名获取  
    while (rs.next()){        
        //6.2 获取数据  getXxx()        
        int id = rs.getInt("id");       
        String name = rs.getString("name");        
        double money = rs.getDouble("money");        
        System.out.println(id);        
        System.out.println(name);        
        System.out.println(money);        
        System.out.println("--------------");    
}    
    //7. 释放资源    
    rs.close();   
    stmt.close();    
    conn.close();}

3.5 案例

• 需求：查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中

  

• 代码实现

  /**  * 查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中  
  * 1. 定义实体类Account  
  * 2. 查询数据，封装到Account对象中  
  * 3. 将Account对象存入ArrayList集合中  */
  @Testpublic 
  void testResultSet2() throws  Exception {    
      //1. 注册驱动    //
      Class.forName("com.mysql.jdbc.Driver");    
      //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写    
      String url = "jdbc:mysql:///db1?useSSL=false";    
      String username = "root";    
      String password = "1234";    
      Connection conn = DriverManager.getConnection(url, username, password);    
      //3. 定义sql    
      String sql = "select * from account";    
      //4. 获取statement对象    
      Statement stmt = conn.createStatement();    
      //5. 执行sql   
      ResultSet rs = stmt.executeQuery(sql);    
      // 创建集合   
      List<Account> list = new ArrayList<>();      
      // 6.1 光标向下移动一行，并且判断当前行是否有数据   
      while (rs.next()){       
          Account account = new Account();      
          //6.2 获取数据  getXxx()    
          int id = rs.getInt("id");     
          String name = rs.getString("name");     
          double money = rs.getDouble("money");    
          //赋值      
          account.setId(id);        account.setName(name);        account.setMoney(money);     
          // 存入集合       
          list.add(account);   
  }    
      System.out.println(list);   
      //7. 释放资源  
      rs.close();   
      stmt.close(); 
      conn.close();
  }
  

3.6 PreparedStatement

PreparedStatement作用：

• 预编译SQL语句并执行：预防SQL注入问题

对上面的作用中SQL注入问题大家肯定不理解。那我们先对SQL注入进行说明.

3.6.1 SQL注入

SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。

3.6.2 代码模拟SQL注入问题

@Testpublic 
void testLogin() throws  Exception {    
    //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写    
    String url = "jdbc:mysql:///db1?useSSL=false";    
    String username = "root";    
    String password = "1234";    
    Connection conn = DriverManager.getConnection(url, username, password);    
    // 接收用户输入 用户名和密码    
    String name = "sjdljfld";    
    String pwd = "' or '1' = '1";    
    String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";    
    // 获取stmt对象   
    Statement stmt = conn.createStatement();  
    // 执行sql   
    ResultSet rs = stmt.executeQuery(sql);   
    // 判断登录是否成功  
    if(rs.next()){       
        System.out.println("登录成功~");  
    }else{      
        System.out.println("登录失败~"); 
}   
    //7. 释放资源 
    rs.close();  
    stmt.close(); 
    conn.close();
}

上面代码是将用户名和密码拼接到sql语句中，拼接后的sql语句如下

select * from tb_user where username = 'sjdljfld' and password = ''or '1' = '1'

从上面语句可以看出条件 username = 'sjdljfld' and password = '' 不管是否满足，而 or 后面的 '1' = '1' 是始终满足的，最终条件是成立的，就可以正常的进行登陆了。

接下来我们来学习PreparedStatement对象.

3.6.3 PreparedStatement概述

PreparedStatement作用：

• 预编译SQL语句并执行：预防SQL注入问题

• 获取 PreparedStatement 对象

  // SQL语句中的参数值，使用？占位符替代String sql = "select * from user where username = ? and password = ?";
  // 通过Connection对象获取，并传入对应的sql语句PreparedStatement pstmt = conn.prepareStatement(sql);
  

• 设置参数值

  上面的sql语句中参数使用 ? 进行占位，在执行之前肯定要设置这些 ? 的值。

  PreparedStatement对象：setXxx(参数1，参数2)：给 ? 赋值

  • Xxx：数据类型 ； 如 setInt (参数1，参数2)

  • 参数：

    • 参数1： ？的位置编号，从1 开始

    • 参数2： ？的值

• 执行SQL语句

  executeUpdate(); 执行DDL语句和DML语句

  executeQuery(); 执行DQL语句

  注意：

  • 调用这两个方法时不需要传递SQL语句，因为获取SQL语句执行对象时已经对SQL语句进行预编译了。

3.6.4 使用PreparedStatement改进

 @Test
public void testPreparedStatement() throws  Exception {   
    //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写   
    String url = "jdbc:mysql:///db1?useSSL=false";   
    String username = "root";   
    String password = "1234";   
    Connection conn = DriverManager.getConnection(url, username, password);   
    // 接收用户输入 用户名和密码   
    String name = "zhangsan";  
    String pwd = "' or '1' = '1";   
    // 定义sql    
    String sql = "select * from tb_user where username = ? and password = ?";  
    // 获取pstmt对象  
    PreparedStatement pstmt = conn.prepareStatement(sql);    
    // 设置？的值    
    pstmt.setString(1,name);  
    pstmt.setString(2,pwd);   
    // 执行sql  
    ResultSet rs = pstmt.executeQuery();   
    // 判断登录是否成功   
    if(rs.next()){    
        System.out.println("登录成功~");  
    }else{      
        System.out.println("登录失败~");  
}  
    //7. 释放资源  
    rs.close();  
    pstmt.close();   
    conn.close();
}

执行上面语句就可以发现不会出现SQL注入漏洞问题了。那么PreparedStatement又是如何解决的呢？它是将特殊字符进行了转义，转义的SQL如下：

select * from tb_user where username = 'sjdljfld' and password = '\'or \'1\' = \'1'

3.6.5 PreparedStatement原理

PreparedStatement 好处：

• 预编译SQL，性能更高
• 防止SQL注入：将敏感字符进行转义

Java代码操作数据库流程如图所示：

• 将sql语句发送到MySQL服务器端

• MySQL服务端会对sql语句进行如下操作

  • 检查SQL语句

    检查SQL语句的语法是否正确。

  • 编译SQL语句。将SQL语句编译成可执行的函数。

    检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果我们只是重新设置参数，那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。

  • 执行SQL语句

接下来我们通过查询日志来看一下原理。

• 开启预编译功能

  在代码中编写url时需要加上以下参数。而我们之前根本就没有开启预编译功能，只是解决了SQL注入漏洞。

  useServerPrepStmts=true
  

• 配置MySQL执行日志（重启mysql服务后生效）

  在mysql配置文件（my.ini）中添加如下配置(添加后MySQL无法重新启动 需要删除 junit无法用，因为版本不支持)

  log-output=FILEgeneral-log=1general_log_file="D:\mysql.log"slow-query-log=1slow_query_log_file="D:\mysql_slow.log"long_query_time=2
  

• java测试代码如下：

   /**   * PreparedStatement原理   * @throws Exception   */
  @Testpublic 
  void testPreparedStatement2() throws  Exception { 
      //2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写  
      // useServerPrepStmts=true 参数开启预编译功能   
      String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true"; 
      String username = "root";   
      String password = "1234";   
      Connection conn = DriverManager.getConnection(url, username, password);  
      // 接收用户输入 用户名和密码   
      String name = "zhangsan";   
      String pwd = "' or '1' = '1"; 
      // 定义sql   
      String sql = "select * from tb_user where username = ? and password = ?";  
      // 获取pstmt对象   
      PreparedStatement pstmt = conn.prepareStatement(sql);   
      Thread.sleep(10000);
      // 设置？的值  
      pstmt.setString(1,name);   
      pstmt.setString(2,pwd);   
      ResultSet rs = null;  
      // 执行sql   
      rs = pstmt.executeQuery();  
      // 设置？的值  
      pstmt.setString(1,"aaa");  
      pstmt.setString(2,"bbb");  
      // 执行sql  
      rs = pstmt.executeQuery(); 
      // 判断登录是否成功  
      if(rs.next()){     
          System.out.println("登录成功~"); 
  }else{     
          System.out.println("登录失败~"); 
  }   
      //7. 释放资源 
      rs.close(); 
      pstmt.close(); 
      conn.close();
  }
  

• 执行SQL语句，查看 D:\mysql.log 日志如下:

  

  上图中第三行中的 Prepare 是对SQL语句进行预编译。第四行和第五行是执行了两次SQL语句，而第二次执行前并没有对SQL进行预编译。

小结：

• 在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查，编译（这些步骤很耗时）
• 执行时就不用再进行这些步骤了，速度更快
• 如果sql模板一样，则只需要进行一次检查、编译

4，数据库连接池

4.1 数据库连接池简介

• 数据库连接池是个容器，负责分配、管理数据库连接(Connection)

• 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；

• 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏

• 好处

  • 资源重用
  • 提升系统响应速度
  • 避免数据库连接遗漏

之前我们代码中使用连接是没有使用都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。

而数据库使用了数据库连接池后，就能达到Connection对象的复用，如下图

连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度。

4.2 数据库连接池实现

• 标准接口：DataSource

  官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：

  Connection getConnection()
  

  那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。

• 常见的数据库连接池

  • DBCP
  • C3P0
  • Druid

  我们现在使用更多的是Druid，它的性能比其他两个会好一些。

• Druid（德鲁伊）

  • Druid连接池是阿里巴巴开源的数据库连接池项目

  • 功能强大，性能优秀，是Java语言最好的数据库连接池之一

4.3 Driud使用

• 导入jar包 druid-1.1.12.jar
• 定义配置文件
• 加载配置文件
• 获取数据库连接池对象
• 获取连接

现在通过代码实现，首先需要先将druid的jar包放到项目下的lib下并添加为库文件

项目结构如下：

编写配置文件如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=1234
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

使用druid的代码如下：

/** * Druid数据库连接池演示 */public class DruidDemo { 
    public static void main(String[] args) throws Exception {    
        //1.导入jar包        
        //2.定义配置文件        
        //3. 加载配置文件    
        Properties prop = new Properties();      
        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));       
        //4. 获取连接池对象        
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);        	   
        //5. 获取数据库连接 Connection       
        Connection connection = dataSource.getConnection();     
        System.out.println(connection); //获取到了连接后就可以继续做其他操作了        					                 //System.out.println(System.getProperty("user.dir"));
        //？？   
    }
}

5，JDBC练习

可以使用Properties[集合](https://so.csdn.net/so/search?q=集合&spm=1001.2101.3001.7020)中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用。

void load([InputStream](https://so.csdn.net/so/search?q=InputStream&spm=1001.2101.3001.7020) inStream)

void load(Read reader)

参数：

InputStream inStream：字节输入流，不能读取含有中文的键值对

Reader read：字符输入流，能读取含有中文的键值对

使用步骤：

\1. 创建Properties集合对象

\2. 使用Properties集合对象中的方法load读取保存键值对的文件

\3. 遍历Properties集合

5.1 需求

完成商品品牌数据的增删改查操作

• 查询：查询所有数据
• 添加：添加品牌
• 修改：根据id修改
• 删除：根据id删除

5.2 案例实现

5.2.1 环境准备

• 数据库表 tb_brand

  -- 删除tb_brand表
  drop table if exists tb_brand;
  -- 创建tb_brand表
  create table tb_brand (   
      -- id 主键    
      id int primary key auto_increment,    
      -- 品牌名称    
      brand_name varchar(20),    
      -- 企业名称    
      company_name varchar(20),    
      -- 排序字段    
      ordered int,    
      -- 描述信息    
      description varchar(100),    
      -- 状态：0：禁用  1：启用    
      status int);
      -- 添加数据
      insert into tb_brand (brand_name, company_name, ordered, description, status)values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),       ('小米', '小米科技有限公司', 50, 'are you ok', 1);
  

• 在pojo包下创建实体类 Brand

  /** * 品牌 * alt + 鼠标左键：整列编辑 * 在实体类中，基本数据类型建议使用其对应的包装类型 */
  public class Brand {   
      // id 主键    
      private Integer id;    
      // 品牌名称    
      private String brandName;    
      // 企业名称    
      private String companyName;    
      // 排序字段    
      private Integer ordered;    
      // 描述信息    
      private String description;    
      // 状态：0：禁用  1：启用   
  

5.2.2 增删改查

package com.xiaoxin.jdbc;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class jdbcPracticeCurd {

 public static void main(String[] arg)throws Exception {

 /**
    * 查询所有
    * 1. SQL：select * from tb_brand;
    * 2. 参数：不需要
    * 3. 结果：List<Brand>
    */
//        //1. 获取Connection
//        //3. 加载配置文件
//        Properties prop = new Properties();
//        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
//        //4. 获取连接池对象
//        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//
//        //5. 获取数据库连接 Connection
//        Connection conn = dataSource.getConnection();
//
//        //2. 定义SQL
//        String sql = "select * from tb_brand;";
//
//        //3. 获取pstmt对象
//        PreparedStatement pstmt = conn.prepareStatement(sql);
//
//        //4. 设置参数
//
//        //5. 执行SQL
//        ResultSet rs = pstmt.executeQuery();
//
//        //6. 处理结果 List<Brand> 封装Brand对象，装载List集合
//        Brand brand = null;
//        List<Brand> brands = new ArrayList<>();
//        while (rs.next()){
//            //获取数据
//            int id = rs.getInt("id");
//            String brandName = rs.getString("brand_name");
//            String companyName = rs.getString("company_name");
//            int ordered = rs.getInt("ordered");
//            String description = rs.getString("description");
//            int status = rs.getInt("status");
//            //封装Brand对象
//            brand = new Brand();
//            brand.setId(id);
//            brand.setBrandName(brandName);
//            brand.setCompanyName(companyName);
//            brand.setOrdered(ordered);
//            brand.setDescription(description);
//            brand.setStatus(status);
//
//            //装载集合
//            brands.add(brand);
//
//        }
//        System.out.println(brands);
//        //7. 释放资源
//        rs.close();
//        pstmt.close();
//        conn.close();




        /**
         * 添加
         * 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
         * 2. 参数：需要，除了id之外的所有参数信息
         * 3. 结果：boolean
         */

//        // 接收页面提交的参数
//        String brandName = "香飘飘";
//        String companyName = "香飘飘";
//        int ordered = 1;
//        String description = "绕地球一圈";
//        int status = 1;
//
//
//
//
//        //1. 获取Connection
//        //3. 加载配置文件
//        Properties prop = new Properties();
//        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
//        //4. 获取连接池对象
//        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//
//        //5. 获取数据库连接 Connection
//        Connection conn = dataSource.getConnection();
//
//        //2. 定义SQL
//        String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";
//
//        //3. 获取pstmt对象
//        PreparedStatement pstmt = conn.prepareStatement(sql);
//
//        //4. 设置参数
//        pstmt.setString(1,brandName);
//        pstmt.setString(2,companyName);
//        pstmt.setInt(3,ordered);
//        pstmt.setString(4,description);
//        pstmt.setInt(5,status);
//
//        //5. 执行SQL
//        int count = pstmt.executeUpdate(); // 影响的行数
//        //6. 处理结果
//        System.out.println(count > 0);
//
//
//        //7. 释放资源
//        pstmt.close();
//        conn.close();




        /**
         * 修改
         * 1. SQL：

         update tb_brand
         set brand_name  = ?,
         company_name= ?,
         ordered     = ?,
         description = ?,
         status      = ?
         where id = ?



         * 2. 参数：需要，所有数据
         * 3. 结果：boolean
         */
        // 接收页面提交的参数
//        String brandName = "香飘飘";
//        String companyName = "香飘飘";
//        int ordered = 1000;
//        String description = "绕地球三圈";
//        int status = 1;
//        int id = 4;
//
//
//
//
//        //1. 获取Connection
//        //3. 加载配置文件
//        Properties prop = new Properties();
//        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
//        //4. 获取连接池对象
//        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//
//        //5. 获取数据库连接 Connection
//        Connection conn = dataSource.getConnection();
//
//        //2. 定义SQL
//        String sql = " update tb_brand\n" +
//                "         set brand_name  = ?,\n" +
//                "         company_name= ?,\n" +
//                "         ordered     = ?,\n" +
//                "         description = ?,\n" +
//                "         status      = ?\n" +
//                "     where id = ?";
//
//        //3. 获取pstmt对象
//        PreparedStatement pstmt = conn.prepareStatement(sql);
//
//        //4. 设置参数
//        pstmt.setString(1,brandName);
//        pstmt.setString(2,companyName);
//        pstmt.setInt(3,ordered);
//        pstmt.setString(4,description);
//        pstmt.setInt(5,status);
//        pstmt.setInt(6,id);
//
//        //5. 执行SQL
//        int count = pstmt.executeUpdate(); // 影响的行数
//        //6. 处理结果
//        System.out.println(count > 0);
//
//
//        //7. 释放资源
//        pstmt.close();
//        conn.close();




        /**
         * 删除
         * 1. SQL：

         delete from tb_brand where id = ?

         * 2. 参数：需要，id
         * 3. 结果：boolean
         */
        // 接收页面提交的参数

        int id = 4;


        //1. 获取Connection
        //3. 加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //5. 获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        //2. 定义SQL
        String sql = " delete from tb_brand where id = ?";

        //3. 获取pstmt对象
        PreparedStatement pstmt = conn.prepareStatement(sql);

        //4. 设置参数

        pstmt.setInt(1,id);

        //5. 执行SQL
        int count = pstmt.executeUpdate(); // 影响的行数
        //6. 处理结果
        System.out.println(count > 0);


        //7. 释放资源
        pstmt.close();
        conn.close();


    }

}

druid配置详解

属性	说明	建议值
url	数据库的jdbc连接地址。一般为连接oracle/mysql。示例如下：
	mysql : jdbc:mysql://ip:port/dbname?option1&option2&…
	oracle : jdbc:oracle:thin:@ip:port:oracle_sid
username	登录数据库的用户名
password	登录数据库的用户密码
initialSize	启动程序时，在连接池中初始化多少个连接	10-50已足够
maxActive	连接池中最多支持多少个活动会话
maxWait	程序向连接池中请求连接时,超过maxWait的值后，认为本次请求失败，即连接池	100
	没有可用连接，单位毫秒，设置-1时表示无限等待
minEvictableIdleTimeMillis	池中某个连接的空闲时长达到 N 毫秒后, 连接池在下次检查空闲连接时，将	见说明部分
	回收该连接,要小于防火墙超时设置
	net.netfilter.nf_conntrack_tcp_timeout_established的设置
timeBetweenEvictionRunsMillis	检查空闲连接的频率，单位毫秒, 非正整数时表示不进行检查
keepAlive	程序没有close连接且空闲时长超过 minEvictableIdleTimeMillis,则会执	true
	行validationQuery指定的SQL,以保证该程序连接不会池kill掉,其范围不超
	过minIdle指定的连接个数。
minIdle	回收空闲连接时，将保证至少有minIdle个连接.	与initialSize相同
removeAbandoned	要求程序从池中get到连接后, N 秒后必须close,否则druid 会强制回收该	false,当发现程序有未
	连接,不管该连接中是活动还是空闲, 以防止进程不会进行close而霸占连接。	正常close连接时设置为true
removeAbandonedTimeout	设置druid 强制回收连接的时限，当程序从池中get到连接开始算起，超过此	应大于业务运行最长时间
	值后，druid将强制回收该连接，单位秒。
logAbandoned	当druid强制回收连接后，是否将stack trace 记录到日志中	true
testWhileIdle	当程序请求连接，池在分配连接时，是否先检查该连接是否有效。(高效)	true
validationQuery	检查池中的连接是否仍可用的 SQL 语句,drui会连接到数据库执行该SQL, 如果
	正常返回，则表示连接可用，否则表示连接不可用
testOnBorrow	程序 申请 连接时,进行连接有效性检查（低效，影响性能）	false
testOnReturn	程序 返还 连接时,进行连接有效性检查（低效，影响性能）	false
poolPreparedStatements	缓存通过以下两个方法发起的SQL:	true
	public PreparedStatement prepareStatement(String sql)
	public PreparedStatement prepareStatement(String sql,int resultSetType, int resultSetConcurrency)
maxPoolPrepareStatementPerConnectionSize	每个连接最多缓存多少个SQL	20
filters	这里配置的是插件,常用的插件有:	stat,wall,slf4j
	监控统计: filter:stat
	日志监控: filter:log4j 或者 slf4j
	防御SQL注入: filter:wall
connectProperties	连接属性。比如设置一些连接池统计方面的配置。
	druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
	比如设置一些数据库连接属性:

HTTP&Tomcat&Servlet

今日目标：

• 了解JavaWeb开发的技术栈
• 理解HTTP协议和HTTP请求与响应数据的格式
• 掌握Tomcat的使用
• 掌握在IDEA中使用Tomcat插件
• 理解Servlet的执行流程和生命周期
• 掌握Servlet的使用和相关配置

1，Web概述

1.1 Web和JavaWeb的概念

Web是全球广域网，也称为万维网(www)，能够通过浏览器访问的网站。
在我们日常的生活中，经常会使用浏览器去访问百度、京东、传智官网等这些网站，这些网站统称为Web网站。如下就是通过浏览器访问传智官网的界面:

我们知道了什么是Web，那么JavaWeb又是什么呢？顾名思义JavaWeb就是用Java技术来解决相关web互联网领域的技术栈。
等学习完JavaWeb之后，同学们就可以使用Java语言开发我们上述所说的网站。

1.2 JavaWeb技术栈

了解JavaWeb技术栈之前，有一个很重要的概念要介绍。

1.2.1 B/S架构

什么是B/S架构?
B/S 架构：Browser/Server，浏览器/服务器 架构模式，它的特点是，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web资源，服务器把Web资源发送给浏览器即可。大家可以通过下面这张图来回想下我们平常的上网过程:

• 打开浏览器访问百度首页，输入要搜索的内容，点击回车或百度一下，就可以获取和搜索相关的内容
• 思考下搜索的内容并不在我们自己的点上，那么这些内容从何而来？答案很明显是从百度服务器返回给我们的
• 日常百度的小细节，逢年过节百度的logo会更换不同的图片，服务端发生变化，客户端不需做任务事情就能获取最新内容
• 所以说B/S架构的好处:易于维护升级：服务器端升级后，客户端无需任何部署就可以使用到新的版本。
  了解了什么是B/S架构后，作为后台开发工程师的我们将来主要关注的是服务端的开发和维护工作。在服务端将来会放很多资源,都有哪些资源呢?

1.2.2 静态资源

• 静态资源主要包含HTML、CSS、JavaScript、图片等，主要负责页面的展示。
• 我们之前已经学过前端网页制作三剑客(HTML+CSS+JavaScript),使用这些技术我们就可以制作出效果比较丰富的网页，将来展现给用户。但是由于做出来的这些内容都是静态的，这就会导致所有的人看到的内容将是一模一样。
• 在日常上网的过程中，我们除了看到这些好看的页面以外，还会碰到很多动态内容，比如我们常见的百度登录效果:
  
  张三登录以后在网页的右上角看到的是 张三，而李四登录以后看到的则是李四。所以不同的用户访问相同的资源看到的内容大多数是不一样的，要想实现这样的效果，光靠静态资源是无法实现的。

1.2.3 动态资源

• 动态资源主要包含Servlet、JSP等，主要用来负责逻辑处理。
• 动态资源处理完逻辑后会把得到的结果交给静态资源来进行展示，动态资源和静态资源要结合一起使用。
• 动态资源虽然可以处理逻辑，但是当用户来登录百度的时候，就需要输入用户名和密码,这个时候我们就又需要解决的一个问题是，用户在注册的时候填入的用户名和密码、以及我们经常会访问到一些数据列表的内容展示(如下图所示)，这些数据都存储在哪里?我们需要的时候又是从哪里来取呢?
  

1.2.4 数据库

• 数据库主要负责存储数据。
• 整个Web的访问过程就如下图所示:
  
  (1)浏览器发送一个请求到服务端，去请求所需要的相关资源;
  (2)资源分为动态资源和静态资源,动态资源可以是使用Java代码按照Servlet和JSP的规范编写的内容;
  (3)Java代码可以进行业务处理也可以从数据库中读取数据;
  (4)拿到数据后，把数据交给HTML页面进行展示,再结合CSS和JavaScript使展示效果更好;
  (5)服务端将静态资源响应给浏览器;
  (6)浏览器将这些资源进行解析;
  (7)解析后将效果展示在浏览器，用户就可以看到最终的结果。
  在整个Web的访问过程中，会设计到很多技术，这些技术有已经学习过的，也有还未涉及到的内容，都有哪些还没有涉及到呢?

1.2.5 HTTP协议

• HTTP协议:主要定义通信规则
• 浏览器发送请求给服务器，服务器响应数据给浏览器，这整个过程都需要遵守一定的规则，之前大家学习过TCP、UDP，这些都属于规则，这里我们需要使用的是HTTP协议，这也是一种规则。

1.2.6 Web服务器

• Web服务器:负责解析 HTTP 协议，解析请求数据，并发送响应数据
• 浏览器按照HTTP协议发送请求和数据，后台就需要一个Web服务器软件来根据HTTP协议解析请求和数据，然后把处理结果再按照HTTP协议发送给浏览器
• Web服务器软件有很多，我们课程中将学习的是目前最为常用的Tomcat服务器

到这为止，关于JavaWeb中用到的技术栈我们就介绍完了，这里面就只有HTTP协议、Servlet、JSP以及Tomcat这些知识是没有学习过的，所以整个Web核心主要就是来学习这些技术。

1.3 Web核心课程

技术小栈

(1)Request是从客户端向服务端发出的请求对象，

(2)Response是从服务端响应给客户端的结果对象，

(3)JSP是动态网页技术,

(4)会话技术是用来存储客户端和服务端交互所产生的数据，

(5)过滤器是用来拦截客户端的请求,

(6)监听器是用来监听特定事件,

(7)Ajax、Vue、ElementUI都是属于前端技术

2, HTTP

2.1 简介

HTTP概念

HyperText Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间数据传输的规则。

• 数据传输的规则指的是请求数据和响应数据需要按照指定的格式进行传输。
• 如果想知道具体的格式，可以打开浏览器，点击F12打开开发者工具，点击Network来查看某一次请求的请求数据和响应数据具体的格式内容，如下图所示:

注意:在浏览器中如果看不到上述内容，需要清除浏览器的浏览数据。chrome浏览器可以使用ctrl+shift+Del进行清除。

所以学习HTTP主要就是学习请求和响应数据的具体格式内容。

HTTP协议特点

HTTP协议有它自己的一些特点，分别是:

• 基于TCP协议: 面向连接，安全

  TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议，在数据传输方面更安全。

• 基于请求-响应模型的:一次请求对应一次响应

  请求和响应是一一对应关系

• HTTP协议是无状态协议:对于事物处理没有记忆能力。每次请求-响应都是独立的

  无状态指的是客户端发送HTTP请求给服务端之后，服务端根据请求响应数据，响应完后，不会记录任何信息。这种特性有优点也有缺点，

  • 缺点:多次请求间不能共享数据
  • 优点:速度快

  请求之间无法共享数据会引发的问题，如:

  • 京东购物，加入购物车和去购物车结算是两次请求，
  • HTTP协议的无状态特性，加入购物车请求响应结束后，并未记录加入购物车是何商品
  • 发起去购物车结算的请求后，因为无法获取哪些商品加入了购物车，会导致此次请求无法正确展示数据

  具体使用的时候，我们发现京东是可以正常展示数据的，原因是Java早已考虑到这个问题，并提出了使用会话技术(Cookie、Session)来解决这个问题。具体如何来做，我们后面会详细讲到。刚才提到HTTP协议是规定了请求和响应数据的格式，那具体的格式是什么呢?

2.2 请求数据格式

2.2.1 格式介绍

请求数据总共分为三部分内容，分别是请求行、请求头、请求体

• 请求行: HTTP请求中的第一行数据，请求行包含三块内容，分别是 GET[请求方式] /[请求URL路径] HTTP/1.1[HTTP协议及版本]

  请求方式有七种,最常用的是GET和POST

• 请求头: 第二行开始，格式为key: value形式

  请求头中会包含若干个属性，常见的HTTP请求头有:

  Host: 表示请求的主机名
  User-Agent: 浏览器版本,例如Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko；
  Accept：表示浏览器能接收的资源类型，如text/*，image/*或者*/*表示所有；
  Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
  Accept-Encoding：表示浏览器可以支持的压缩类型，例如gzip, deflate等。
  

  这些数据有什么用处?

  举例说明:服务端可以根据请求头中的内容来获取客户端的相关信息，有了这些信息服务端就可以处理不同的业务需求，比如:

  • 不同浏览器解析HTML和CSS标签的结果会有不一致，所以就会导致相同的代码在不同的浏览器会出现不同的效果
  • 服务端根据客户端请求头中的数据获取到客户端的浏览器类型，就可以根据不同的浏览器设置不同的代码来达到一致的效果
  • 这就是我们常说的浏览器兼容问题

• 请求体: POST请求的最后一部分，存储请求参数

  

  如上图红线框的内容就是请求体的内容，请求体和请求头之间是有一个空行隔开。此时浏览器发送的是POST请求，为什么不能使用GET呢?这时就需要回顾GET和POST两个请求之间的区别了:

  • GET请求请求参数在请求行中，没有请求体，POST请求请求参数在请求体中
  • GET请求请求参数大小有限制，POST没有

2.2.2 实例演示

点击项目中的html\19-表单验证.html，使用浏览器打开，通过修改页面中form表单的method属性来测试GET请求和POST请求的参数携带方式。

2.3 响应数据格式

2.3.1 格式介绍

响应数据总共分为三部分内容，分别是响应行、响应头、响应体

• 响应行：响应数据的第一行,响应行包含三块内容，分别是 HTTP/1.1[HTTP协议及版本] 200[响应状态码] ok[状态码的描述]

• 响应头：第二行开始，格式为key：value形式

  响应头中会包含若干个属性，常见的HTTP响应头有:

  Content-Type：表示该响应内容的类型，例如text/html，image/jpeg；
  Content-Length：表示该响应内容的长度（字节数）；
  Content-Encoding：表示该响应压缩算法，例如gzip；
  Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒
  

• 响应体： 最后一部分。存放响应数据

  上图中…这部分内容就是响应体，它和响应头之间有一个空行隔开。

2.3.2 响应状态码

状态码大全

• 200 ok 客户端请求成功
• 404 Not Found 请求资源不存在
• 500 Internal Server Error 服务端发生不可预期的错误

状态码分类	说明
1xx	响应中——临时状态码，表示请求已经接受，告诉客户端应该继续请求或者如果它已经完成则忽略它
2xx	成功——表示请求已经被成功接收，处理已完成
3xx	重定向——重定向到其它地方：它让客户端再发起一个请求以完成整个处理。
4xx	客户端错误——处理发生错误，责任在客户端，如：客户端的请求一个不存在的资源，客户端未被授权，禁止访问等
5xx	服务器端错误——处理发生错误，责任在服务端，如：服务端抛出异常，路由出错，HTTP版本不支持等

状态码	英文描述	解释
200	OK	客户端请求成功，即处理成功，这是我们最想看到的状态码
302	Found	指示所请求的资源已移动到由Location响应头给定的 URL，浏览器会自动重新访问到这个页面
304	Not Modified	告诉客户端，你请求的资源至上次取得后，服务端并未更改，你直接用你本地缓存吧。隐式重定向
400	Bad Request	客户端请求有语法错误，不能被服务器所理解
403	Forbidden	服务器收到请求，但是拒绝提供服务，比如：没有权限访问相关资源
404	Not Found	请求资源不存在，一般是URL输入有误，或者网站资源被删除了
428	Precondition Required	服务器要求有条件的请求，告诉客户端要想访问该资源，必须携带特定的请求头
429	Too Many Requests	太多请求，可以限制客户端请求某个资源的数量，配合 Retry-After(多长时间后可以请求)响应头一起使用
431	Request Header Fields Too Large	请求头太大，服务器不愿意处理请求，因为它的头部字段太大。请求可以在减少请求头域的大小后重新提交。
405	Method Not Allowed	请求方式有误，比如应该用GET请求方式的资源，用了POST
500	Internal Server Error	服务器发生不可预期的错误。服务器出异常了，赶紧看日志去吧
503	Service Unavailable	服务器尚未准备好处理请求，服务器刚刚启动，还未初始化好
511	Network Authentication Required	客户端需要进行身份验证才能获得网络访问权限

2.3.3 自定义服务器**

在前面我们导入到IDEA中的http项目中，有一个Server.java类，这里面就是自定义的一个服务器代码，主要使用到的是ServerSocket和Socket

package com.itheima;

import sun.misc.IOUtils;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
/*
    自定义服务器
 */
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(8080); // 监听指定端口
        System.out.println("server is running...");
        while (true){
            Socket sock = ss.accept();
            System.out.println("connected from " + sock.getRemoteSocketAddress());
            Thread t = new Handler(sock);
            t.start();
        }
    }
}

class Handler extends Thread {
    Socket sock;

    public Handler(Socket sock) {
        this.sock = sock;
    }

    public void run() {
        try (InputStream input = this.sock.getInputStream()) {
            try (OutputStream output = this.sock.getOutputStream()) {
                handle(input, output);
            }
        } catch (Exception e) {
            try {
                this.sock.close();
            } catch (IOException ioe) {
            }
            System.out.println("client disconnected.");
        }
    }

    private void handle(InputStream input, OutputStream output) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output, StandardCharsets.UTF_8));
        // 读取HTTP请求:
        boolean requestOk = false;
        String first = reader.readLine();
        if (first.startsWith("GET / HTTP/1.")) {
            requestOk = true;
        }
        for (;;) {											//死循环
            String header = reader.readLine();
            if (header.isEmpty()) { // 读取到空行时, HTTP Header读取完毕
                break;
            }
            System.out.println(header);
        }
        System.out.println(requestOk ? "Response OK" : "Response Error");
        if (!requestOk) {
            // 发送错误响应:
            writer.write("HTTP/1.0 404 Not Found\r\n");
            writer.write("Content-Length: 0\r\n");
            writer.write("\r\n");
            writer.flush();
        } else {
            // 发送成功响应:

            //读取html文件，转换为字符串
            BufferedReader br = new BufferedReader(new FileReader("http/html/a.html"));
            StringBuilder data = new StringBuilder();
            String line = null;
            while ((line = br.readLine()) != null){
                data.append(line);
            }
            br.close();
            int length = data.toString().getBytes(StandardCharsets.UTF_8).length;

            writer.write("HTTP/1.1 200 OK\r\n");
            writer.write("Connection: keep-alive\r\n");
            writer.write("Content-Type: text/html\r\n");
            writer.write("Content-Length: " + length + "\r\n");
            writer.write("\r\n"); // 空行标识Header和Body的分隔
            writer.write(data.toString());
            writer.flush();
        }
    }
}

上面代码，大家不需要自己写，主要通过上述代码，只需要大家了解到服务器可以使用java完成编写，是可以接受页面发送的请求和响应数据给前端浏览器的，真正用到的Web服务器，我们不会自己写，都是使用目前比较流行的web服务器，比如Tomcat

小结

1. 响应数据中包含三部分内容，分别是响应行、响应头和响应体

2. 掌握200，404，500这三个响应状态码所代表含义，分布是成功、所访问资源不存在和服务的错误

3, Tomcat

3.1 简介

3.1.1 什么是Web服务器

Web服务器是一个应用程序（软件），对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是"提供网上信息浏览服务"。

Web服务器是安装在服务器端的一款软件，将来我们把自己写的Web项目部署到Web Tomcat服务器软件中，当Web服务器软件启动后，部署在Web服务器软件中的页面就可以直接通过浏览器来访问了。

Web服务器软件使用步骤

• 准备静态资源
• 下载安装Web服务器软件
• 将静态资源部署到Web服务器上
• 启动Web服务器使用浏览器访问对应的资源

上述内容在演示的时候，使用的是Apache下的Tomcat软件，至于Tomcat软件如何使用，后面会详细的讲到。而对于Web服务器来说，实现的方案有很多，Tomcat只是其中的一种，而除了Tomcat以外，还有很多优秀的Web服务器，比如:

Tomcat就是一款软件，我们主要是以学习如何去使用为主。具体我们会从以下这些方向去学习:

1. 简介: 初步认识下Tomcat

2. 基本使用: 安装、卸载、启动、关闭、配置和项目部署，这些都是对Tomcat的基本操作

3. IDEA中如何创建Maven Web项目

4. IDEA中如何使用Tomcat,后面这两个都是我们以后开发经常会用到的方式

首选我们来认识下Tomcat。

Tomcat

Tomcat的相关概念:

• Tomcat是Apache软件基金会一个核心项目，是一个开源免费的轻量级Web服务器，支持Servlet/JSP少量JavaEE规范。

• 概念中提到了JavaEE规范，那什么又是JavaEE规范呢?

  JavaEE: Java Enterprise Edition,Java企业版。指Java企业级开发的技术规范总和。包含13项技术规范:JDBC、JNDI、EJB、RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF。

• 因为Tomcat支持Servlet/JSP规范，所以Tomcat也被称为Web容器、Servlet容器。Servlet需要依赖Tomcat才能运行。

• Tomcat的官网: https://tomcat.apache.org/ 从官网上可以下载对应的版本进行使用。

小结

通过这一节的学习，我们需要掌握以下内容:

1. Web服务器的作用

封装HTTP协议操作，简化开发

可以将Web项目部署到服务器中，对外提供网上浏览服务

2. Tomcat是一个轻量级的Web服务器，支持Servlet/JSP少量JavaEE规范，也称为Web容器，Servlet容器。

3.2 基本使用

Tomcat总共分两部分学习，先来学习Tomcat的基本使用，包括Tomcat的下载、安装、卸载、启动和关闭。

3.2.1 下载

直接从官网下载

3.2.2 安装

Tomcat是绿色版,直接解压即可

• 在D盘的software目录下，将apache-tomcat-8.5.68-windows-x64.zip进行解压缩，会得到一个apache-tomcat-8.5.68的目录，Tomcat就已经安装成功。

  注意，Tomcat在解压缩的时候，解压所在的目录可以任意，但最好解压到一个不包含中文和空格的目录，因为后期在部署项目的时候，如果路径有中文或者空格可能会导致程序部署失败。

• 打开apache-tomcat-8.5.68目录就能看到如下目录结构，每个目录中包含的内容需要认识下,

  

  bin:目录下有两类文件，一种是以.bat结尾的，是Windows系统的可执行文件，一种是以.sh结尾的，是Linux系统的可执行文件。

  webapps:就是以后项目部署的目录

  到此，Tomcat的安装就已经完成。

3.2.3 卸载

卸载比较简单，可以直接删除目录即可

3.2.4 启动

双击: bin\startup.bat

启动后，通过浏览器访问 http://localhost:8080能看到Apache Tomcat的内容就说明Tomcat已经启动成功。

注意: 启动的过程中，控制台有中文乱码，需要修改conf/logging.prooperties

3.2.5 关闭

关闭有三种方式

• 直接x掉运行窗口:强制关闭[不建议]
• bin\shutdown.bat：正常关闭
• ctrl+c： 正常关闭

3.2.6 配置

修改端口

• Tomcat默认的端口是8080，要想修改Tomcat启动的端口号，需要修改 conf/server.xml

注: HTTP协议默认端口号为80，如果将Tomcat端口号改为80，则将来访问Tomcat时，将不用输入端口号。

启动时可能出现的错误

• Tomcat的端口号取值范围是0-65535之间任意未被占用的端口，如果设置的端口号被占用，启动的时候就会包如下的错误

  

• Tomcat启动的时候，启动窗口一闪而过: 需要检查JAVA_HOME环境变量是否正确配置

3.2.7 部署E:\soft\IntelliJIDEA2020.1\bin; IntelliJ IDEA

• Tomcat部署项目： 将项目放置到webapps目录下，即部署完成。

  • 将 资料/2. Tomcat/hello 目录拷贝到Tomcat的webapps目录下

  • 通过浏览器访问http://localhost/hello/a.html，能看到下面的内容就说明项目已经部署成功。

    

    但是呢随着项目的增大，项目中的资源也会越来越多，项目在拷贝的过程中也会越来越费时间，该如何解决呢?

• 一般JavaWeb项目会被打包称war包，然后将war包放到Webapps目录下，Tomcat会自动解压缩war文件

  • 将 资料/2. Tomcat/haha.war目录拷贝到Tomcat的webapps目录下

  • Tomcat检测到war包后会自动完成解压缩，在webapps目录下就会多一个haha目录

  • 通过浏览器访问http://localhost/haha/a.html，能看到下面的内容就说明项目已经部署成功。

    

至此，Tomcat的部署就已经完成了，至于如何获得项目对应的war包，后期我们会借助于IDEA工具来生成。

3.3 Maven创建Web项目

介绍完Tomcat的基本使用后，我们来学习在IDEA中如何创建Maven Web项目，学习这种方式的原因是以后Tomcat中运行的绝大多数都是Web项目，而使用Maven工具能更加简单快捷的把Web项目给创建出来，所以Maven的Web项目具体如何来构建呢?

在真正创建Maven Web项目之前，我们先要知道Web项目长什么样子，具体的结构是什么?

3.3.1 Web项目结构

Web项目的结构分为:开发中的项目和开发完可以部署的Web项目,这两种项目的结构是不一样的，我们一个个来介绍下:

• Maven Web项目结构: 开发中的项目

  

• 开发完成部署的Web项目

  

  • 开发项目通过执行Maven打包命令package,可以获取到部署的Web项目目录
  • 编译后的Java字节码文件和resources的资源文件，会被放到WEB-INF下的classes目录下
  • pom.xml中依赖坐标对应的jar包，会被放入WEB-INF下的lib目录下

3.3.2 创建Maven Web项目

介绍完Maven Web的项目结构后，接下来使用Maven来创建Web项目，创建方式有两种:使用骨架和不使用骨架

使用骨架

具体的步骤包含:

1.创建Maven项目

2.选择使用Web项目骨架

3.输入Maven项目坐标创建项目

4.确认Maven相关的配置信息后，完成项目创建

5.删除pom.xml中多余内容

6.补齐Maven Web项目缺失的目录结构

1. 创建Maven项目

   

2. 选择使用Web项目骨架

   

3. 输入Maven项目坐标创建项目

   

4. 确认Maven相关的配置信息后，完成项目创建

   

5. 删除pom.xml中多余内容，只留下面的这些内容，注意打包方式 jar和war的区别

   

6. 补齐Maven Web项目缺失的目录结构，默认没有java和resources目录，需要手动完成创建补齐，最终的目录结果如下

   

不使用骨架

具体的步骤包含:

1.创建Maven项目

2.选择不使用Web项目骨架

3.输入Maven项目坐标创建项目

4.在pom.xml设置打包方式为war

5.补齐Maven Web项目缺失webapp的目录结构

6.补齐Maven Web项目缺失WEB-INF/web.xml的目录结构

1. 创建Maven项目

   

2. 选择不使用Web项目骨架

   

3. 输入Maven项目坐标创建项目

   

4. 在pom.xml设置打包方式为war,默认是不写代表打包方式为jar

   

5. 补齐Maven Web项目缺失webapp的目录结构

   

6. 补齐Maven Web项目缺失WEB-INF/web.xml的目录结构

   

7. 补充完后，最终的项目结构如下:

   

上述两种方式，创建的web项目，都不是很全，需要手动补充内容，至于最终采用哪种方式来创建Maven Web项目，都是可以的，根据各自的喜好来选择使用即可。

3.4 IDEA使用Tomcat

• Maven Web项目创建成功后，通过Maven的package命令可以将项目打包成war包，将war文件拷贝到Tomcat的webapps目录下，启动Tomcat就可以将项目部署成功，然后通过浏览器进行访问即可。
• 然而我们在开发的过程中，项目中的内容会经常发生变化，如果按照上面这种方式来部署测试，是非常不方便的
• 如何在IDEA中能快速使用Tomcat呢?

在IDEA中集成使用Tomcat有两种方式，分别是集成本地Tomcat和Tomcat Maven插件

3.4.1 集成本地Tomcat

目标: 将刚才本地安装好的Tomcat8集成到IDEA中，完成项目部署，具体的实现步骤

1. 打开添加本地Tomcat的面板

   

2. 指定本地Tomcat的具体路径

   

3. 修改Tomcat的名称，此步骤可以不改，只是让名字看起来更有意义，HTTP port中的端口也可以进行修改，比如把8080改成80

   

4. 将开发项目部署项目到Tomcat中

   

   扩展内容： xxx.war和 xxx.war exploded这两种部署项目模式的区别?

   • war模式是将WEB工程打成war包，把war包发布到Tomcat服务器上

   • war exploded模式是将WEB工程以当前文件夹的位置关系发布到Tomcat服务器上

   • war模式部署成功后，Tomcat的webapps目录下会有部署的项目内容

   • war exploded模式部署成功后，Tomcat的webapps目录下没有，而使用的是项目的target目录下的内容进行部署

   • 建议大家都选war模式进行部署，更符合项目部署的实际情况

5. 部署成功后，就可以启动项目，为了能更好的看到启动的效果，可以在webapp目录下添加a.html页面

   

6. 启动成功后，可以通过浏览器进行访问测试

   

7. 最终的注意事项

   

至此，IDEA中集成本地Tomcat进行项目部署的内容我们就介绍完了，整体步骤如下，大家需要按照流程进行部署操作练习。

3.4.2 Tomcat Maven插件

在IDEA中使用本地Tomcat进行项目部署，相对来说步骤比较繁琐，所以我们需要一种更简便的方式来替换它，那就是直接使用Maven中的Tomcat插件来部署项目，具体的实现步骤，只需要两步，分别是:

1. 在pom.xml中添加Tomcat插件

   <build>
       <plugins>
       	<!--Tomcat插件 -->
           <plugin>
               <groupId>org.apache.tomcat.maven</groupId>
               <artifactId>tomcat7-maven-plugin</artifactId>
               <version>2.2</version>
           </plugin>
       </plugins>
   </build>
   

2. 使用Maven Helper插件快速启动项目，选中项目，右键–>Run Maven --> tomcat7:run

注意:

• 如果选中项目并右键点击后，看不到Run Maven和Debug Maven，这个时候就需要在IDEA中下载Maven Helper插件，具体的操作方式为: File --> Settings --> Plugins --> Maven Helper —> Install,安装完后按照提示重启IDEA，就可以看到了。

• Maven Tomcat插件目前只有Tomcat7版本，没有更高的版本可以使用
• 使用Maven Tomcat插件，要想修改Tomcat的端口和访问路径，可以直接修改pom.xml

<build>
    <plugins>
    	<!--Tomcat插件 -->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
            	<port>80</port><!--访问端口号 -->
                <!--项目访问路径
					未配置访问路径: http://localhost:80/tomcat-demo2/a.html
					配置/后访问路径: http://localhost:80/a.html
					如果配置成 /hello,访问路径会变成什么?
						答案: http://localhost:80/hello/a.html
				-->
                <path>/</path>
            </configuration>
        </plugin>
    </plugins>
</build>

小结

通过这一节的学习，大家要掌握在IDEA中使用Tomcat的两种方式，集成本地Tomcat和使用Maven的Tomcat插件。后者更简单，推荐大家使用，但是如果对于Tomcat的版本有比较高的要求，要在Tomcat7以上，这个时候就只能用前者了。

4， Servlet

4.1 简介

• Servlet是JavaWeb最为核心的内容，它是Java提供的一门动态web资源开发技术。

• 使用Servlet就可以实现，根据不同的登录用户在页面上动态显示不同内容。

• Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet

  

介绍完Servlet是什么以后，接下来我们就按照快速入门->执行流程->生命周期->体系结构->urlPattern配置->XML配置的学习步骤，一步步完成对Servlet的知识学习，首选我们来通过一个入门案例来快速把Servlet用起来。

4.2 快速入门

需求分析: 编写一个Servlet类，并使用IDEA中Tomcat插件进行部署，最终通过浏览器访问所编写的Servlet程序。

具体的实现步骤为:

1. 创建Web项目web-demo，导入Servlet依赖坐标

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <!--
      此处为什么需要添加该标签?
      provided指的是在编译和测试过程中有效,最后生成的war包时不会加入
       因为Tomcat的lib目录中已经有servlet-api这个jar包，如果在生成war包的时候生效就会和Tomcat中的jar包冲突，导致报错
    -->
    <scope>provided</scope>
</dependency>

2. 创建:定义一个类，实现Servlet接口，并（必须）重写接口中所有方法，并在service方法中输入一句话

package com.itheima.web;

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

public class ServletDemo1 implements Servlet {

    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

3. 配置:在类上使用@WebServlet注解，配置该Servlet的访问路径

@WebServlet("/demo1")

4. 访问:启动Tomcat,浏览器中输入URL地址访问该Servlet

http://localhost:8080/web-demo/demo1

5. 器访问后，在控制台会打印servlet hello world~ 说明servlet程序已经成功运行。

至此，Servlet的入门案例就已经完成，大家可以按照上面的步骤进行练习了。

4.3 执行流程

Servlet程序已经能正常运行，但是我们需要思考个问题: 我们并没有创建ServletDemo1类的对象，也没有调用对象中的service方法，为什么在控制台就打印了servlet hello world~这句话呢?

要想回答上述问题，我们就需要对Servlet的执行流程进行一个学习。

• 浏览器发出http://localhost:8080/web-demo/demo1请求，从请求中可以解析出三部分内容，分别是localhost:8080、web-demo、demo1
  • 根据localhost:8080可以找到要访问的Tomcat Web服务器
  • 根据web-demo可以找到部署在Tomcat服务器上的web-demo项目
  • 根据demo1可以找到要访问的是项目中的哪个Servlet类，根据@WebServlet后面的值进行匹配
• 找到ServletDemo1这个类后，Tomcat Web服务器就会为ServletDemo1这个类创建一个对象，然后调用对象中的service方法
  • ServletDemo1实现了Servlet接口，所以类中必然会重写service方法供Tomcat Web服务器进行调用
  • service方法中有ServletRequest和ServletResponse两个参数，ServletRequest封装的是请求数据，ServletResponse封装的是响应数据，后期我们可以通过这两个参数实现前后端的数据交互

小结

介绍完Servlet的执行流程，需要大家掌握两个问题：

1. Servlet由谁创建?Servlet方法由谁调用?

Servlet由web服务器创建，Servlet方法由web服务器调用

2. 服务器怎么知道Servlet中一定有service方法?

因为我们自定义的Servlet,必须实现Servlet接口并复写其方法，而Servlet接口中有service方法

4.4 生命周期

介绍完Servlet的执行流程后，我们知道Servlet是由Tomcat Web服务器帮我们创建的。

接下来咱们再来思考一个问题:Tomcat什么时候创建的Servlet对象?

要想回答上述问题，我们就需要对Servlet的生命周期进行一个学习。

• 生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。

• Servlet运行在Servlet容器(web服务器)中，其生命周期由容器来管理，分为4个阶段：

  1. 加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象

  默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，那么第一个访问的人等待的时间就比较长，用户的体验就比较差，那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?@WebServlet(urlPatterns = "/demo1",loadOnStartup = 1)
  loadOnstartup的取值有两类情况	
  （1）负整数:第一次访问时创建Servlet对象	
  （2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高
  

  2. 初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
  3. 请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的==service()==方法对请求进行处理
  4. 服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的==destroy()==方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

• 通过案例演示下上述的生命周期

  package com.itheima.web;
  import javax.servlet.*;
  import javax.servlet.annotation.WebServlet;
  import java.io.IOException;
  /*** Servlet生命周期方法*/
  @WebServlet(urlPatterns = "/demo2",loadOnStartup = 1)
  public class ServletDemo2 implements Servlet {  
      /**     *  初始化方法    
      *  1.调用时机：默认情况下，Servlet被第一次访问时调用     *      
      * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用     
      *  2.调用次数: 1次     
      * @param config    
      * @throws ServletException    
      */    
      public void init(ServletConfig config) throws ServletException {        
          System.out.println("init...");    
  }   
      
      /**     * 提供服务    
  * 1.调用时机:每一次Servlet被访问时调用     
  * 2.调用次数: 多次    
  * @param req    
  * @param res    
  * @throws ServletException    
  * @throws IOException   
  */    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {        System.out.println("servlet hello world~");   
  }    /**    
  * 销毁方法   
  * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用    
  * 2.调用次数: 1次    
  */    
      public void destroy() {       
      System.out.println("destroy...");  
  }    
      public ServletConfig getServletConfig() {   
          return null; 
  }   
      public String getServletInfo() {   
          return null; 
  }}
  

  注意:如何才能让Servlet中的destroy方法被执行？

  

在Terminal命令行中，先使用mvn tomcat7:run启动，然后再使用ctrl+c关闭tomcat

小结

这节中需要掌握的内容是:

1. Servlet对象在什么时候被创建的?

默认是第一次访问的时候被创建，可以使用@WebServlet(urlPatterns = “/demo2”,loadOnStartup = 1)的loadOnStartup 修改成在服务器启动的时候创建。

2. Servlet生命周期中涉及到的三个方法，这三个方法是什么?什么时候被调用?调用几次?

涉及到三个方法，分别是 init()、service()、destroy()

init方法在Servlet对象被创建的时候执行，只执行1次

service方法在Servlet被访问的时候调用，每访问1次就调用1次

destroy方法在Servlet对象被销毁的时候调用，只执行1次

4.5 方法介绍

Servlet中总共有5个方法，我们已经介绍过其中的三个，剩下的两个方法作用分别是什么？

我们先来回顾下前面讲的三个方法，分别是:

• 初始化方法，在Servlet被创建时执行，只执行一次

void init(ServletConfig config) 

• 提供服务方法， 每次Servlet被访问，都会调用该方法

void service(ServletRequest req, ServletResponse res)

• 销毁方法，当Servlet被销毁时，调用该方法。在内存释放或服务器关闭时销毁Servlet

void destroy() 

剩下的两个方法是:

• 获取Servlet信息

String getServletInfo() //该方法用来返回Servlet的相关信息，没有什么太大的用处，一般我们返回一个空字符串即可public String getServletInfo() {    return "";}

• 获取ServletConfig对象

ServletConfig getServletConfig()

ServletConfig对象，在init方法的参数中有，而Tomcat Web服务器在创建Servlet对象的时候会调用init方法，必定会传入一个ServletConfig对象，我们只需要将服务器传过来的ServletConfig进行返回即可。具体如何操作?

package com.itheima.web;import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
/** * Servlet方法介绍 */
@WebServlet(urlPatterns = "/demo3",loadOnStartup = 1)
public class ServletDemo3 implements Servlet {  
    private ServletConfig servletConfig;  
    /**     *  初始化方法   
    *  1.调用时机：默认情况下，Servlet被第一次访问时，调用      
    * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用    
    *  2.调用次数: 1次    
    * @param config    
    * @throws ServletException   
    */    
    public void init(ServletConfig config) throws ServletException {     
        this.servletConfig = config;     
        System.out.println("init...");  
    }
    public ServletConfig getServletConfig() {      
        return servletConfig;   
    }      
    /**  
    * 提供服务   
    * 1.调用时机:每一次Servlet被访问时，调用   
    * 2.调用次数: 多次   
    * @param req   
    * @param res  
    * @throws ServletException   
    * @throws IOException  
    */   
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 
        System.out.println("servlet hello world~");  
    }  
    /**    
    * 销毁方法   
    * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用    
    * 2.调用次数: 1次   
    */   
    public void destroy() {      
        System.out.println("destroy..."); 
    }       
    public String getServletInfo() {  
        return ""; 
    }}

getServletInfo()和getServletConfig()这两个方法使用的不是很多，大家了解下。

4.6 体系结构

通过上面的学习，我们知道要想编写一个Servlet就必须要实现Servlet接口，重写接口中的5个方法，虽然已经能完成要求，但是编写起来还是比较麻烦的，因为我们更关注的其实只有service方法，那有没有更简单方式来创建Servlet呢?

要想解决上面的问题，我们需要先对Servlet的体系结构进行下了解:

因为我们将来开发B/S架构的web项目，都是针对HTTP协议，所以我们自定义Servlet,会通过继承HttpServlet

具体的编写格式如下:

@WebServlet("/demo4")
public class ServletDemo4 extends HttpServlet {   
    @Override  
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
        //TODO GET 请求方式处理逻辑    
        System.out.println("get...");  
}    
    @Override   
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {     
        //TODO Post 请求方式处理逻辑   
        System.out.println("post...");  
}}

• 要想发送一个GET请求，请求该Servlet，只需要通过浏览器发送http://localhost:8080/web-demo/demo4,就能看到doGet方法被执行了
• 要想发送一个POST请求，请求该Servlet，单单通过浏览器是无法实现的，这个时候就需要编写一个form表单来发送请求，在webapp下创建一个a.html页面，内容如下:

<!DOCTYPE html>
<html lang="en"><head> 
    <meta charset="UTF-8">    
    <title>Title</title></head><body> 
    <form action="/web-demo/demo4" method="post">      
        <input name="username"/><input type="submit"/>
    </form></body></html>

启动测试，即可看到doPost方法被执行了。

Servlet的简化编写就介绍完了，接着需要思考两个问题:

1. HttpServlet中为什么要根据请求方式的不同，调用不同的方法?
2. 如何调用?

针对问题一，我们需要回顾之前的知识点前端发送GET和POST请求的时候，参数的位置不一致，GET请求参数在请求行中，POST请求参数在请求体中，为了能处理不同的请求方式，我们得在service方法中进行判断，然后写不同的业务处理，这样能实现，但是每个Servlet类中都将有相似的代码，针对这个问题，有什么可以优化的策略么?

package com.itheima.web;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/demo5")
public class ServletDemo5 implements Servlet {   
    public void init(ServletConfig config) throws ServletException {
    }   
    public ServletConfig getServletConfig() {   
        return null;  
    }    
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 
        //如何调用?     
        //获取请求方式，根据不同的请求方式进行不同的业务处理      
        HttpServletRequest request = (HttpServletRequest)req;     
        //1. 获取请求方式    
        String method = request.getMethod();       
        //2. 判断      
        if("GET".equals(method)){     
            // get方式的处理逻辑   
        }else if("POST".equals(method)){      
            // post方式的处理逻辑     
        }   
    }   
    public String getServletInfo() {     
        return null;  
    }   
    public void destroy() {  
    }}

要解决上述问题，我们可以对Servlet接口进行继承封装，来简化代码开发。

package com.itheima.web;import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;public class MyHttpServlet implements Servlet {  
    public void init(ServletConfig config) throws ServletException {  
    }    
    public ServletConfig getServletConfig() {     
        return null;  
    }   
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 
        HttpServletRequest request = (HttpServletRequest)req;       
        //1. 获取请求方式     
        
        String method = request.getMethod();   
        //2. 判断       
        if("GET".equals(method)){         
            // get方式的处理逻辑         
            doGet(req,res);     
        }else if("POST".equals(method)){         
            // post方式的处理逻辑        
            doPost(req,res);    
        }  
    }   
    protected void doPost(ServletRequest req, ServletResponse res) {   
    }   
    protected void doGet(ServletRequest req, ServletResponse res) {  
    }    
    public String getServletInfo() {     
        return null;  
    }    
    public void destroy() {   
    }}

有了MyHttpServlet这个类，以后我们再编写Servlet类的时候，只需要继承MyHttpServlet，重写父类中的doGet和doPost方法，就可以用来处理GET和POST请求的业务逻辑。接下来，可以把ServletDemo5代码进行改造

@WebServlet("/demo5")
public class ServletDemo5 extends MyHttpServlet {   
    @Override 
    protected void doGet(ServletRequest req, ServletResponse res) {  
        System.out.println("get...");  
    }    @Override   
    protected void doPost(ServletRequest req, ServletResponse res) {  
        System.out.println("post...");  
    }}

将来页面发送的是GET请求，则会进入到doGet方法中进行执行，如果是POST请求，则进入到doPost方法。这样代码在编写的时候就相对来说更加简单快捷。

类似MyHttpServlet这样的类Servlet中已经为我们提供好了，就是HttpServlet,翻开源码，大家可以搜索service()方法，你会发现HttpServlet做的事更多，不仅可以处理GET和POST还可以处理其他五种请求方式。

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 = req.getDateHeader(HEADER_IFMODSINCE);         
            if (ifModifiedSince < lastModified) {         
                // 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);  
    }  
}

小结

通过这一节的学习，要掌握:

1. HttpServlet的使用步骤

继承HttpServlet

重写doGet和doPost方法

2. HttpServlet原理

获取请求方式，并根据不同的请求方式，调用不同的doXxx方法

4.7 urlPattern配置

Servlet类编写好后，要想被访问到，就需要配置其访问路径（urlPattern）

• 一个Servlet,可以配置多个urlPattern

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ceSFIET-1661565663850)(Javaweb.assets\1627272805178.png)]

  package com.itheima.web;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  import javax.servlet.annotation.WebServlet;
  /*** urlPattern: 一个Servlet可以配置多个访问路径*/
  @WebServlet(urlPatterns = {"/demo7","/demo8"})
  public class ServletDemo7 extends MyHttpServlet {  
      @Override   
      protected void doGet(ServletRequest req, ServletResponse res) {     
          System.out.println("demo7 get...");   
      }   
      @Override  
      protected void doPost(ServletRequest req, ServletResponse res) {  
      }
  }
  

  在浏览器上输入http://localhost:8080/web-demo/demo7,http://localhost:8080/web-demo/demo8这两个地址都能访问到ServletDemo7的doGet方法。

• urlPattern配置规则

  • 精确匹配

    

    /** * UrlPattern: * * 精确匹配 */
    @WebServlet(urlPatterns = "/user/select")
    public class ServletDemo8 extends MyHttpServlet { 
        @Override   
      protected void doGet(ServletRequest req, ServletResponse res) {    
            System.out.println("demo8 get...");   
      }  
        @Override   
      protected void doPost(ServletRequest req, ServletResponse res) { 
        }
    }
    

    访问路径http://localhost:8080/web-demo/user/select

  • 目录匹配

    

    package com.itheima.web;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    /** * UrlPattern: * * 目录匹配: /user/* */
    @WebServlet(urlPatterns = "/user/*")
    public class ServletDemo9 extends MyHttpServlet {  
        @Override   
        protected void doGet(ServletRequest req, ServletResponse res) {     
            System.out.println("demo9 get...");  
      }   
        @Override   
      protected void doPost(ServletRequest req, ServletResponse res) {  
        }
    }
    

    访问路径http://localhost:8080/web-demo/user/任意

    思考:

    1. 访问路径http://localhost:8080/web-demo/user是否能访问到demo9的doGet方法?
  2. 访问路径http://localhost:8080/web-demo/user/a/b是否能访问到demo9的doGet方法?
  3. 访问路径http://localhost:8080/web-demo/user/select是否能访问到demo9还是demo8的doGet方法?

  答案是: 能、能、demo8，进而我们可以得到的结论是/user/*中的/*代表的是零或多个层级访问目录同时精确匹配优先级要高于目录匹配。

  • 扩展名匹配

    

    package com.itheima.web;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    /** * UrlPattern: * * 扩展名匹配: *.do */
    @WebServlet(urlPatterns = "*.do")
    public class ServletDemo10 extends MyHttpServlet {
        @Override  
      protected void doGet(ServletRequest req, ServletResponse res) {    
            System.out.println("demo10 get...");  
      }   
        @Override   
      protected void doPost(ServletRequest req, ServletResponse res) {   
        }
    }
    

    访问路径http://localhost:8080/web-demo/任意.do

    注意:

    1. 如果路径配置的不是扩展名，那么在路径的前面就必须要加/否则会报错

    

    2. 如果路径配置的是*.do,那么在*.do的前面不能加/,否则会报错

    

  • 任意匹配

    

    package com.itheima.web;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    /** * UrlPattern: * * 任意匹配： / */
    @WebServlet(urlPatterns = "/")
    public class ServletDemo11 extends MyHttpServlet {  
        @Override   
      protected void doGet(ServletRequest req, ServletResponse res) {   
            System.out.println("demo11 get...");   
      }   
        @Override  
      protected void doPost(ServletRequest req, ServletResponse res) {  
        }}
    

    
  访问路径`http://localhost:8080/demo-web/任意`
    
    ```java
    package com.itheima.web;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.annotation.WebServlet;
    /** * UrlPattern: * * 任意匹配： /* */
    @WebServlet(urlPatterns = "/*")
    public class ServletDemo12 extends MyHttpServlet {  
        @Override   
        protected void doGet(ServletRequest req, ServletResponse res) {    
            System.out.println("demo12 get...");   
        }   
        @Override   
        protected void doPost(ServletRequest req, ServletResponse res) {   
        }
    }
  

  访问路径`http://localhost:8080/demo-web/任意

  注意:/和/*的区别?

  1. 当我们的项目中的Servlet配置了 "/",会覆盖掉tomcat中的DefaultServlet,当其他的url-pattern都匹配不上时都会走这个Servlet
  
  2. 当我们的项目中配置了"/*",意味着匹配任意访问路径
  
  3. DefaultServlet是用来处理静态资源，如果配置了"/"会把默认的覆盖掉，就会引发请求静态资源的时候没有走默认的而是走了自定义的Servlet类，最终导致静态资源不能被访问
  

小结

1. urlPattern总共有四种配置方式，分别是精确匹配、目录匹配、扩展名匹配、任意匹配

2. 五种配置的优先级为 精确匹配 > 目录匹配> 扩展名匹配 > /* > / ,无需记，以最终运行结果为准。

4.8 XML配置（了解）

前面对应Servlet的配置，我们都使用的是@WebServlet,这个是Servlet从3.0版本后开始支持注解配置，3.0版本前只支持XML配置文件的配置方法。

对于XML的配置步骤有两步:

• 编写Servlet类

package com.itheima.web;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.annotation.WebServlet;public class ServletDemo13 extends MyHttpServlet {    @Override    protected void doGet(ServletRequest req, ServletResponse res) {        System.out.println("demo13 get...");    }    @Override    protected void doPost(ServletRequest req, ServletResponse res) {    }}

• 在web.xml中配置该Servlet

<?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>demo13</servlet-name>        <!--servlet的类全名-->        <servlet-class>com.itheima.web.ServletDemo13</servlet-class>    </servlet>    <!--         Servlet 访问路径    -->    <servlet-mapping>        <!-- servlet的名称，要和上面的名称一致-->        <servlet-name>demo13</servlet-name>        <!-- servlet的访问路径-->        <url-pattern>/demo13</url-pattern>    </servlet-mapping></web-app>

这种配置方式和注解比起来，确认麻烦很多，所以建议大家使用注解来开发。但是大家要认识上面这种配置方式，因为并不是所有的项目都是基于注解开发的。

今日目标

• 掌握Request对象的概念与使用
• 掌握Response对象的概念与使用
• 能够完成用户登录注册案例的实现
• 能够完成SqlSessionFactory工具类的抽取

1，Request和Response的概述

==Request是请求对象，Response是响应对象。==这两个对象在我们使用Servlet的时候有看到：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lf2gTj8T-1661565663854)(Javaweb.assets\1628735216156.png)]

此时，我们就需要思考一个问题request和response这两个参数的作用是什么?

• request:获取请求数据
  • 浏览器会发送HTTP请求到后台服务器[Tomcat]
  • HTTP的请求中会包含很多请求数据[请求行+请求头+请求体]
  • 后台服务器[Tomcat]会对HTTP请求中的数据进行解析并把解析结果存入到一个对象中
  • 所存入的对象即为request对象，所以我们可以从request对象中获取请求的相关参数
  • 获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务
• response:设置响应数据
  • 业务处理完后，后台就需要给前端返回业务处理的结果即响应数据
  • 把响应数据封装到response对象中
  • 后台服务器[Tomcat]会解析response对象,按照[响应行+响应头+响应体]格式拼接结果
  • 浏览器最终解析结果，把内容展示在浏览器给用户浏览

对于上述所讲的内容，我们通过一个案例来初步体验下request和response对象的使用。

@WebServlet("/demo3")
public class ServletDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用request对象 获取请求数据
        String name = request.getParameter("name");//url?name=zhangsan

        //使用response对象 设置响应数据
        response.setHeader("content-type","text/html;charset=utf-8");
        response.getWriter().write("<h1>"+name+",欢迎您！</h1>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

启动成功后就可以通过浏览器来访问，并且根据传入参数的不同就可以在页面上展示不同的内容:

小结

在这节中，我们主要认识了下request对象和reponse对象:

• request对象是用来封装请求数据的对象
• response对象是用来封装响应数据的对象

目前我们只知道这两个对象是用来干什么的，那么它们具体是如何实现的，就需要我们继续深入的学习。接下来，就先从Request对象来学习,主要学习下面这些内容:

• request继承体系

• request获取请求参数

• request请求转发

2，Request对象

2.1 Request继承体系

在学习这节内容之前，我们先思考一个问题，前面在介绍Request和Reponse对象的时候，比较细心的同学可能已经发现：

• 当我们的Servlet类实现的是Servlet接口的时候，service方法中的参数是ServletRequest和ServletResponse
• 当我们的Servlet类继承的是HttpServlet类的时候，doGet和doPost方法中的参数就变成HttpServletRequest和HttpServletReponse

那么，

• ServletRequest和HttpServletRequest的关系是什么?
• request对象是有谁来创建的?
• request提供了哪些API,这些API从哪里查?

首先，我们先来看下Request的继承体系:

从上图中可以看出，ServletRequest和HttpServletRequest都是Java提供的，所以我们可以打开JavaEE提供的API文档[参考: 资料/JavaEE7-api.chm],打开后可以看到:

所以ServletRequest和HttpServletRequest是继承关系，并且两个都是接口，接口是无法创建对象，这个时候就引发了下面这个问题:

这个时候，我们就需要用到Request继承体系中的RequestFacade:

• 该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。
• Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器[Tomcat]来调用的，所以Tomcat提供了方法参数接口的具体实现类，并完成了对象的创建
• 要想了解RequestFacade中都提供了哪些方法，我们可以直接查看JavaEE的API文档中关于ServletRequest和HttpServletRequest的接口文档，因为RequestFacade实现了其接口就需要重写接口中的方法

对于上述结论，要想验证，可以编写一个Servlet，在方法中把request对象打印下，就能看到最终的对象是不是RequestFacade,代码如下:

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

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

启动服务器，运行访问http://localhost:8080/request-demo/demo2,得到运行结果:

小结

• Request的继承体系为ServletRequest–>HttpServletRequest–>RequestFacade
• Tomcat需要解析请求数据，封装为request对象,并且创建request对象传递到service方法
• 使用request对象，可以查阅JavaEE API文档的HttpServletRequest接口中方法说明

2.2 Request获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体，对于这三部分内容的数据，分别该如何获取，首先我们先来学习请求行数据如何获取?

2.2.1 获取请求行数据

请求行包含三块内容，分别是请求方式、请求资源路径、HTTP协议及版本

对于这三部分内容，request对象都提供了对应的API方法来获取，具体如下:

• 获取请求方式: GET

String getMethod()

• 获取虚拟目录(项目访问路径): /request-demo

String getContextPath()

• 获取URL(统一资源定位符): http://localhost:8080/request-demo/req1

StringBuffer getRequestURL()

• 获取URI(统一资源标识符): /request-demo/req1

String getRequestURI()

• 获取请求参数(GET方式): username=zhangsan&password=123

String getQueryString()

介绍完上述方法后，咱们通过代码把上述方法都使用下:

/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // String getMethod()：获取请求方式： GET
        String method = req.getMethod();
        System.out.println(method);//GET
        // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
        StringBuffer url = req.getRequestURL();
        System.out.println(url.toString());
        // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
        String uri = req.getRequestURI();
        System.out.println(uri);
        // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
        String queryString = req.getQueryString();
        System.out.println(queryString);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}

启动服务器，访问http://localhost:8080/request-demo/req1?username=zhangsan&passwrod=123，获取的结果如下:

2.2.2 获取请求头数据

对于请求头的数据，格式为key: value如下:

所以根据请求头名称获取对应值的方法为:

String getHeader(String name)

接下来，在代码中如果想要获取客户端浏览器的版本信息，则可以使用

/** * request 获取请求数据 */
@WebServlet("/req1")public class RequestDemo1 extends HttpServlet { 
    @Override  
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        //获取请求头: user-agent: 浏览器的版本信息     
        String agent = req.getHeader("user-agent");	
        System.out.println(agent);  
    }   
    @Override  
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
    }
}

重新启动服务器后，http://localhost:8080/request-demo/req1?username=zhangsan&passwrod=123，获取的结果如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sGZod3eG-1661565663858)(Javaweb.assets\1628769145524.png)]

2.2.3 获取请求体数据

浏览器在发送GET请求的时候是没有请求体的，所以需要把请求方式变更为POST，请求体中的数据格式如下:

对于请求体中的数据，Request对象提供了如下两种方式来获取其中的数据，分别是:

• 获取字节输入流，如果前端发送的是字节数据，比如传递的是文件数据，则使用该方法

ServletInputStream getInputStream()该方法可以获取字节

• 获取字符输入流，如果前端发送的是纯文本数据，则使用该方法

BufferedReader getReader()

接下来，大家需要思考，要想获取到请求体的内容该如何实现?

具体实现的步骤如下:

1.准备一个页面，在页面中添加form表单,用来发送post请求

2.在Servlet的doPost方法中获取请求体数据

3.在doPost方法中使用request的getReader()或者getInputStream()来获取

4.访问测试

1. 在项目的webapp目录下添加一个html页面，名称为：req.html

<!DOCTYPE html>
<html lang="en"><head>    <meta charset="UTF-8">    <title>Title</title></head>
    <body>
        <!--     action:form表单提交的请求地址    method:请求方式，指定为post-->
        <form action="/request-demo/req1" method="post">    
            <input type="text" name="username">    
            <input type="password" name="password">    
            <input type="submit">
        </form>
    </body>
</html>

2. 在Servlet的doPost方法中获取数据

/** * request 获取请求数据 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {    
    @Override    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
    }    
    @Override    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        //在此处获取请求体中的数据  
    }
}

3. 调用getReader()或者getInputStream()方法，因为目前前端传递的是纯文本数据，所以我们采用getReader()方法来获取

/** * request 获取请求数据 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet { 
    @Override  
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
    }  
    @Override  
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        //获取post 请求体：请求参数     
        //1. 获取字符输入流   
        BufferedReader br = req.getReader();    
        //2. 读取数据    
        String line = br.readLine();     
        System.out.println(line);  
    }
}

注意

BufferedReader流是通过request对象来获取的，当请求完成后request对象就会被销毁，request对象被销毁后，BufferedReader流就会自动关闭，所以此处就不需要手动关闭流了。

4. 启动服务器，通过浏览器访问http://localhost:8080/request-demo/req.html

点击提交按钮后，就可以在控制台看到前端所发送的请求数据

小结

HTTP请求数据中包含了请求行、请求头和请求体，针对这三部分内容，Request对象都提供了对应的API方法来获取对应的值:

• 请求行
  • getMethod()获取请求方式
  • getContextPath()获取项目访问路径
  • getRequestURL()获取请求URL
  • getRequestURI()获取请求URI
  • getQueryString()获取GET请求方式的请求参数
• 请求头
  • getHeader(String name)根据请求头名称获取其对应的值
• 请求体
  • 注意: 浏览器发送的POST请求才有请求体
  • 如果是纯文本数据:getReader()
  • 如果是字节数据如文件数据:getInputStream()

2.2.4 获取请求参数的通用方式

在学习下面内容之前，我们先提出两个问题:

• 什么是请求参数?
• 请求参数和请求数据的关系是什么?

1.什么是请求参数?

为了能更好的回答上述两个问题，我们拿用户登录的例子来说明

1.1 想要登录网址，需要进入登录页面

1.2 在登录页面输入用户名和密码

1.3 将用户名和密码提交到后台

1.4 后台校验用户名和密码是否正确

1.5 如果正确，则正常登录，如果不正确，则提示用户名或密码错误

上述例子中，用户名和密码其实就是我们所说的请求参数。

2.什么是请求数据?

请求数据则是包含请求行、请求头和请求体的所有数据

3.请求参数和请求数据的关系是什么?

3.1 请求参数是请求数据中的部分内容

3.2 如果是GET请求，请求参数在请求行中

3.3 如果是POST请求，请求参数一般在请求体中

对于请求参数的获取,常用的有以下两种:

• GET方式:

String getQueryString()

• POST方式:

BufferedReader getReader();

有了上述的知识储备，我们来实现一个案例需求:

（1）发送一个GET请求并携带用户名，后台接收后打印到控制台

（2）发送一个POST请求并携带用户名，后台接收后打印到控制台

此处大家需要注意的是GET请求和POST请求接收参数的方式不一样，具体实现的代码如下:

@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {   
    @Override  
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {     
        String result = req.getQueryString();     
        System.out.println(result);  
    }  
    @Override  
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        BufferedReader br = req.getReader();   
        String result = br.readLine();        
        System.out.println(result); 
    }}

• 对于上述的代码，会存在什么问题呢?

• 如何解决上述重复代码的问题呢?

当然，也可以在doGet中调用doPost,在doPost中完成参数的获取和打印,另外需要注意的是，doGet和doPost方法都必须存在，不能删除任意一个。

GET请求和POST请求获取请求参数的方式不一样，在获取请求参数这块该如何实现呢?

要想实现，我们就需要思考:

GET请求方式和POST请求方式区别主要在于获取请求参数的方式不一样，是否可以提供一种统一获取请求参数的方式，从而统一doGet和doPost方法内的代码?

解决方案一:

@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {   
    @Override    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        
        //获取请求方式    
        String method = req.getMethod();  
        //获取请求参数   
        String params = "";   
        if("GET".equals(method)){    
            params = req.getQueryString();     
        }else if("POST".equals(method)){    
            BufferedReader reader = req.getReader();      
            params = reader.readLine();       
        }       
        //将请求参数进行打印控制台   
        System.out.println(params);      
    }    
    @Override   
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        this.doGet(req,resp);   
    }
}

使用request的getMethod()来获取请求方式，根据请求方式的不同分别获取请求参数值，这样就可以解决上述问题，但是以后每个Servlet都需要这样写代码，实现起来比较麻烦，这种方案我们不采用

解决方案二:

request对象已经将上述获取请求参数的方法进行了封装，并且request提供的方法实现的功能更强大，以后只需要调用request提供的方法即可，在request的方法中都实现了哪些操作?

(1)根据不同的请求方式获取请求参数，获取的内容如下:

(2)把获取到的内容进行分割，内容如下:

(3)把分割后端数据，存入到一个Map集合中:

注意:因为参数的值可能是一个，也可能有多个，所以Map的值的类型为String数组。

基于上述理论，request对象为我们提供了如下方法:

• 获取所有参数Map集合

Map<String,String[]> getParameterMap()

• 根据名称获取参数值（数组）

String[] getParameterValues(String name)

• 根据名称获取参数值(单个值)

String getParameter(String name)

接下来，我们通过案例来把上述的三个方法进行实例演示:

1.修改req.html页面，添加爱好选项，爱好可以同时选多个

<!DOCTYPE html>
<html lang="en"><head>
    <meta charset="UTF-8">  
    <title>Title</title>
    </head>
    <body>
        <form action="/request-demo/req2" method="get">  
            <input type="text" name="username"><br>   
            <input type="password" name="password"><br>   
            <input type="checkbox" name="hobby" value="1"> 游泳   
            <input type="checkbox" name="hobby" value="2"> 爬山 <br> 
            <input type="submit">
        </form>
    </body>
</html>

2.在Servlet代码中获取页面传递GET请求的参数值

2.1获取GET方式的所有请求参数

/** * request 通用方式获取请求参数 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {
    @Override   
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {      
        //GET请求逻辑    
        System.out.println("get....");   
        //1. 获取所有参数的Map集合    
        Map<String, String[]> map = req.getParameterMap();    
        for (String key : map.keySet()) {      
            // username:zhangsan lisi      
            System.out.print(key+":");    
            //获取值       
            String[] values = map.get(key);   
            for (String value : values) {    
                System.out.print(value + " ");  
            }         
            System.out.println();   
        }  
    }    @Override 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
    }
}

获取的结果为:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J07q1wJ7-1661565663863)(Javaweb.assets\1628780965283.png)]

2.2获取GET请求参数中的爱好，结果是数组值

/** * request 通用方式获取请求参数 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {  
    @Override 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
        //GET请求逻辑    
        //...        
        System.out.println("------------");      
        String[] hobbies = req.getParameterValues("hobby");  
        for (String hobby : hobbies) {    
            System.out.println(hobby);     
        }  
    }  
    @Override   
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
    }
}

获取的结果为:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TsMDm7HI-1661565663863)(Javaweb.assets\1628781031437.png)]

2.3获取GET请求参数中的用户名和密码，结果是单个值

/** * request 通用方式获取请求参数 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {   
    @Override   
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {    
        //GET请求逻辑      
        //...      
        String username = req.getParameter("username");   
        String password = req.getParameter("password");   
        System.out.println(username);    
        System.out.println(password);  
    } 
    @Override 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
    }}

获取的结果为:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Th7LkI8k-1661565663863)(Javaweb.assets\1628781176434.png)]

3.在Servlet代码中获取页面传递POST请求的参数值

3.1将req.html页面form表单的提交方式改成post

3.2将doGet方法中的内容复制到doPost方法中即可

小结

• req.getParameter()方法使用的频率会比较高

• 以后我们再写代码的时候，就只需要按照如下格式来编写:

public class RequestDemo1 extends HttpServlet {    
	@Override   
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {   
        //采用request提供的获取请求参数的通用方式来获取请求参数    
        //编写其他的业务代码...  
    }   
    @Override 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {    
        this.doGet(req,resp); 
    }}

2.3 IDEA快速创建Servlet

使用通用方式获取请求参数后，屏蔽了GET和POST的请求方式代码的不同，则代码可以定义如下格式:

由于格式固定，所以我们可以使用IDEA提供的模板来制作一个Servlet的模板，这样我们后期在创建Servlet的时候就会更高效，具体如何实现:

(1)按照自己的需求，修改Servlet创建的模板内容

（2）使用servlet模板创建Servlet类

2.4 请求参数中文乱码问题

问题展示:

(1)将req.html页面的请求方式修改为get

<!DOCTYPE html>
<html lang="en"><head>   
    <meta charset="UTF-8">  
    <title>Title</title>
    </head>
    <body>
        <form action="/request-demo/req2" method="get">   
            <input type="text" name="username"><br>   
            <input type="password" name="password"><br>  
            <input type="checkbox" name="hobby" value="1"> 游泳 
            <input type="checkbox" name="hobby" value="2"> 爬山 <br> 
            <input type="submit">
        </form>
    </body>
</html>

(2)在Servlet方法中获取参数，并打印

/** * 中文乱码问题解决方案 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {  
    @Override   
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        //1. 获取username   
        String username = request.getParameter("username");     
        System.out.println(username); 
    }   
    @Override 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        this.doGet(request, response);  
    }
}

（3）启动服务器，页面上输入中文参数

（4）查看控制台打印内容

（5）把req.html页面的请求方式改成post,再次发送请求和中文参数

（6）查看控制台打印内容，依然为乱码

通过上面的案例，会发现，不管是GET还是POST请求，在发送的请求参数中如果有中文，在后台接收的时候，都会出现中文乱码的问题。具体该如何解决呢？

2.4.1 POST请求解决方案

• 分析出现中文乱码的原因：
  • POST的请求参数是通过request的getReader()来获取流中的数据
  • TOMCAT在获取流的时候采用的编码是ISO-8859-1
  • ISO-8859-1编码是不支持中文的，所以会出现乱码
• 解决方案：
  • 页面设置的编码格式为UTF-8
  • 把TOMCAT在获取流数据之前的编码设置为UTF-8
  • 通过request.setCharacterEncoding(“UTF-8”)设置编码,UTF-8也可以写成小写

修改后的代码为:

/** * 中文乱码问题解决方案 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {
    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {       
        //1. 解决乱码: POST getReader()   
        //设置字符输入流的编码，设置的字符集要和页面保持一致  
        request.setCharacterEncoding("UTF-8");     
        //2. 获取username     
        String username = request.getParameter("username");   
        System.out.println(username);  
    }  
    @Override 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        this.doGet(request, response);  
    }}

重新发送POST请求，就会在控制台看到正常展示的中文结果。

至此POST请求中文乱码的问题就已经解决，但是这种方案不适用于GET请求，这个原因是什么呢，咱们下面再分析。

2.4.2 GET请求解决方案

刚才提到一个问题是POST请求的中文乱码解决方案为什么不适用GET请

求？

• GET请求获取请求参数的方式是request.getQueryString()
• POST请求获取请求参数的方式是request.getReader()
• request.setCharacterEncoding(“utf-8”)是设置request处理流的编码
• getQueryString方法并没有通过流的方式获取数据

所以GET请求不能用设置编码的方式来解决中文乱码问题，那问题又来了，如何解决GET请求的中文乱码呢?

1. 首先我们需要先分析下GET请求出现乱码的原因:

(1)浏览器通过HTTP协议发送请求和数据给后台服务器（Tomcat)

(2)浏览器在发送HTTP的过程中会对中文数据进行URL编码

(3)在进行URL编码的时候会采用页面<meta>标签指定的UTF-8的方式进行编码，张三编码后的结果为%E5%BC%A0%E4%B8%89

(4)后台服务器(Tomcat)接收到%E5%BC%A0%E4%B8%89后会默认按照ISO-8859-1进行URL解码

(5)由于前后编码与解码采用的格式不一样，就会导致后台获取到的数据为乱码。

思考: 如果把req.html页面的<meta>标签的charset属性改成ISO-8859-1,后台不做操作，能解决中文乱码问题么?

答案是否定的，因为ISO-8859-1本身是不支持中文展示的，所以改了标签的charset属性后，会导致页面上的中文内容都无法正常展示。

分析完上面的问题后，我们会发现，其中有两个我们不熟悉的内容就是URL编码和URL解码，什么是URL编码，什么又是URL解码呢?

URL编码

这块知识我们只需要了解下即可,具体编码过程分两步，分别是:

(1)将字符串按照编码方式转为二进制

(2)每个字节转为2个16进制数并在前边加上%

张三按照UTF-8的方式转换成二进制的结果为:

1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001

这个结果是如何计算的?

使用http://www.mytju.com/classcode/tools/encode_utf8.asp，输入张三

就可以获取张和三分别对应的10进制，然后在使用计算器，选择程序员模式，计算出对应的二进制数据结果:

在计算的十六进制结果中，每两位前面加一个%,就可以获取到%E5%BC%A0%E4%B8%89。

当然你从上面所提供的网站中就已经能看到编码16进制的结果了:

但是对于上面的计算过程，如果没有工具，纯手工计算的话，相对来说还是比较复杂的，我们也不需要进行手动计算，在Java中已经为我们提供了编码和解码的API工具类可以让我们更快速的进行编码和解码:

编码:

java.net.URLEncoder.encode("需要被编码的内容","字符集(UTF-8)")

解码:

java.net.URLDecoder.decode("需要被解码的内容","字符集(UTF-8)")

接下来咱们对张三来进行编码和解码

public class URLDemo {  public static void main(String[] args) throws UnsupportedEncodingException {        String username = "张三";        //1. URL编码        String encode = URLEncoder.encode(username, "utf-8");        System.out.println(encode); //打印:%E5%BC%A0%E4%B8%89       //2. URL解码       //String decode = URLDecoder.decode(encode, "utf-8");//打印:张三       String decode = URLDecoder.decode(encode, "ISO-8859-1");//打印:`å¼ ä¸ `       System.out.println(decode);    }}

到这，我们就可以分析出GET请求中文参数出现乱码的原因了，

• 浏览器把中文参数按照UTF-8进行URL编码
• Tomcat对获取到的内容进行了ISO-8859-1的URL解码
• 在控制台就会出现类上å¼ ä¸‰的乱码，最后一位是个空格

2. 清楚了出现乱码的原因，接下来我们就需要想办法进行解决

从上图可以看住，

• 在进行编码和解码的时候，不管使用的是哪个字符集，他们对应的%E5%BC%A0%E4%B8%89是一致的

• 那他们对应的二进制值也是一样的，为:

  • 1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001
    

• 为所以我们可以考虑把å¼ ä¸‰转换成字节，在把字节转换成张三，在转换的过程中是它们的编码一致，就可以解决中文乱码问题。

具体的实现步骤为:

1.按照ISO-8859-1编码获取乱码å¼ ä¸‰对应的字节数组

2.按照UTF-8编码获取字节数组对应的字符串

实现代码如下:

public class URLDemo { 
public static void main(String[] args) throws UnsupportedEncodingException {      
String username = "张三";      
//1. URL编码     
    String encode = URLEncoder.encode(username, "utf-8");   
    System.out.println(encode);      
    //2. URL解码     
    String decode = URLDecoder.decode(encode, "ISO-8859-1");     
    System.out.println(decode); //此处打印的是对应的乱码数据     
    //3. 转换为字节数据,编码    
    byte[] bytes = decode.getBytes("ISO-8859-1");    
    for (byte b : bytes) {     
        System.out.print(b + " ");   
    }	//此处打印的是:-27 -68 -96 -28 -72 -119    
    //4. 将字节数组转为字符串，解码     
    String s = new String(bytes, "utf-8");      
    System.out.println(s); //此处打印的是张三  
}}

说明:在第18行中打印的数据是-27 -68 -96 -28 -72 -119和张三转换成的二进制数据1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001为什么不一样呢？

其实打印出来的是十进制数据，我们只需要使用计算机换算下就能得到他们的对应关系，如下图:

至此对于GET请求中文乱码的解决方案，我们就已经分析完了，最后在代码中去实现下:

/** * 中文乱码问题解决方案 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet {   
    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        //1. 解决乱码：POST，getReader()   
        //request.setCharacterEncoding("UTF-8");
        //设置字符输入流的编码  
        //2. 获取username     
        String username = request.getParameter("username");   
        System.out.println("解决乱码前："+username);    
        //3. GET,获取参数的方式：getQueryString      
        // 乱码原因：tomcat进行URL解码，默认的字符集ISO-8859-1   
        /* //3.1 先对乱码数据进行编码：转为字节数组   
        byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);    
        //3.2 字节数组解码    
        username = new String(bytes, StandardCharsets.UTF_8);*/   
        username  = new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);        System.out.println("解决乱码后："+username); 
    }   
    @Override  
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {    
        this.doGet(request, response); 
    }}

注意

• 把request.setCharacterEncoding("UTF-8")代码注释掉后，会发现GET请求参数乱码解决方案同时也可也把POST请求参数乱码的问题也解决了
• 只不过对于POST请求参数一般都会比较多，采用这种方式解决乱码起来比较麻烦，所以对于POST请求还是建议使用设置编码的方式进行。

另外需要说明一点的是Tomcat8.0之后，已将GET请求乱码问题解决，设置默认的解码方式为UTF-8

小结

1. 中文乱码解决方案

• POST请求和GET请求的参数中如果有中文，后台接收数据就会出现中文乱码问题

  GET请求在Tomcat8.0以后的版本就不会出现了

• POST请求解决方案是:设置输入流的编码

  request.setCharacterEncoding("UTF-8");注意:设置的字符集要和页面保持一致
  

• 通用方式（GET/POST）：需要先解码，再编码

  new String(username.getBytes("ISO-8859-1"),"UTF-8");
  

2. URL编码实现方式:

• 编码:

  URLEncoder.encode(str,"UTF-8");
  

• 解码:

  URLDecoder.decode(s,"ISO-8859-1");
  

2.5 Request请求转发

1. 请求转发(forward):一种在服务器内部的资源跳转方式。

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A处理完请求后将请求发给资源B

(3)资源B处理完后将结果响应给浏览器

(4)请求从资源A到资源B的过程就叫请求转发

2. 请求转发的实现方式:

req.getRequestDispatcher("资源B路径").forward(req,resp);

具体如何来使用，我们先来看下需求:

针对上述需求，具体的实现步骤为:

1.创建一个RequestDemo5类，接收/req5的请求，在doGet方法中打印demo5

2.创建一个RequestDemo6类，接收/req6的请求，在doGet方法中打印demo6

3.在RequestDemo5的方法中使用

​ req.getRequestDispatcher(“/req6”).forward(req,resp)进行请求转发

4.启动测试

(1)创建RequestDemo5类

/** * 请求转发 */@WebServlet("/req5")
public class RequestDemo5 extends HttpServlet {   
    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {       
        System.out.println("demo5...");  
    }  
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {       
        this.doGet(request, response);    }}

(2)创建RequestDemo6类

/** * 请求转发 */@WebServlet("/req6")
public class RequestDemo6 extends HttpServlet {  
    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        System.out.println("demo6..."); 
    } 
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {    
        this.doGet(request, response);   
    }}

(3)在RequestDemo5的doGet方法中进行请求转发

/** * 请求转发 */@WebServlet("/req5")
public class RequestDemo5 extends HttpServlet { 
    @Override  
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        System.out.println("demo5..."); 
        //请求转发      
        request.getRequestDispatcher("/req6").forward(request,response);
    }  
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        this.doGet(request, response); 
    }}

(4)启动测试

访问http://localhost:8080/request-demo/req5,就可以在控制台看到如下内容:

说明请求已经转发到了/req6

3. 请求转发资源间共享数据:使用Request对象

此处主要解决的问题是把请求从/req5转发到/req6的时候，如何传递数据给/req6。

需要使用request对象提供的三个方法:

• 存储数据到request域[范围,数据是存储在request对象]中

void setAttribute(String name,Object o);

• 根据key获取值

Object getAttribute(String name);

• 根据key删除该键值对

void removeAttribute(String name);

接着上个需求来:

1.在RequestDemo5的doGet方法中转发请求之前，将数据存入request域对象中

2.在RequestDemo6的doGet方法从request域对象中获取数据，并将数据打印到控制台

3.启动访问测试

(1)修改RequestDemo5中的方法

@WebServlet("/req5")public class RequestDemo5 extends HttpServlet { 
    @Override   
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        System.out.println("demo5...");   
        //存储数据    
        request.setAttribute("msg","hello");   
        //请求转发      
        request.getRequestDispatcher("/req6").forward(request,response);   
    }  
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        this.doGet(request, response);   
    }}

(2)修改RequestDemo6中的方法

/** * 请求转发 */@WebServlet("/req6")
public class RequestDemo6 extends HttpServlet { 
    @Override 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        System.out.println("demo6...");    
        //获取数据     
        Object msg = request.getAttribute("msg");    
        System.out.println(msg);  
    }   
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {    
        this.doGet(request, response); 
    }}

(3)启动测试

访问http://localhost:8080/request-demo/req5,就可以在控制台看到如下内容:

此时就可以实现在转发多个资源之间共享数据。

4. 请求转发的特点

• 浏览器地址栏路径不发生变化

  虽然后台从/req5转发到/req6,但是浏览器的地址一直是/req5,未发生变化

  

• 只能转发到当前服务器的内部资源

  不能从一个服务器通过转发访问另一台服务器

• 一次请求，可以在转发资源间使用request共享数据

  虽然后台从/req5转发到/req6，但是这个只有一次请求

3，Response对象

前面讲解完Request对象，接下来我们回到刚开始的那张图:

• Request:使用request对象来获取请求数据
• Response:使用response对象来设置响应数据

Reponse的继承体系和Request的继承体系也非常相似:

介绍完Response的相关体系结构后，接下来对于Response我们需要学习如下内容:

• Response设置响应数据的功能介绍
• Response完成重定向
• Response响应字符数据
• Response响应字节数据

3.1 Response设置响应数据功能介绍

HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体，对于这三部分内容的数据，respone对象都提供了哪些方法来进行设置?

1. 响应行

对于响应头，比较常用的就是设置响应状态码:

void setStatus(int sc);

2. 响应头

设置响应头键值对：

void setHeader(String name,String value);

3. 响应体

对于响应体，是通过字符、字节输出流的方式往浏览器写，

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

介绍完这些方法后，后面我们会通过案例把这些方法都用一用，首先先来完成下重定向的功能开发。

3.2 Respones请求重定向

1. Response重定向(redirect):一种资源跳转方式。

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A现在无法处理该请求，就会给浏览器响应一个302的状态码+location的一个访问资源B的路径

(3)浏览器接收到响应状态码为302就会重新发送请求到location对应的访问地址去访问资源B

(4)资源B接收到请求后进行处理并最终给浏览器响应结果，这整个过程就叫重定向

2. 重定向的实现方式:

resp.setStatus(302);resp.setHeader("location","资源B的访问路径");

具体如何来使用，我们先来看下需求:

针对上述需求，具体的实现步骤为:

1.创建一个ResponseDemo1类，接收/resp1的请求，在doGet方法中打印resp1....

2.创建一个ResponseDemo2类，接收/resp2的请求，在doGet方法中打印resp2....

3.在ResponseDemo1的方法中使用

​ response.setStatus(302);

​ response.setHeader(“Location”,“/request-demo/resp2”) 来给前端响应结果数据

4.启动测试

(1)创建ResponseDemo1类

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

(2)创建ResponseDemo2类

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

(3)在ResponseDemo1的doGet方法中给前端响应数据

@WebServlet("/resp1")public class ResponseDemo1 extends HttpServlet { 
    @Override  
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        System.out.println("resp1....");    
        //重定向       
        //1.设置响应状态码 302   
        response.setStatus(302);      
        //2. 设置响应头 Location      
        response.setHeader("Location","/request-demo/resp2"); 
    }   
    @Override  
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        this.doGet(request, response);    }}

(4)启动测试

访问http://localhost:8080/request-demo/resp1,就可以在控制台看到如下内容:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jgu2p1nQ-1661565663875)(Javaweb.assets\1628861404699.png)]

说明/resp1和/resp2都被访问到了。到这重定向就已经完成了。

虽然功能已经实现，但是从设置重定向的两行代码来看，会发现除了重定向的地址不一样，其他的内容都是一模一样，所以request对象给我们提供了简化的编写方式为:

resposne.sendRedirect("/request-demo/resp2")

所以第3步中的代码就可以简化为：

@WebServlet("/resp1")public class ResponseDemo1 extends HttpServlet {   
    @Override    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        System.out.println("resp1....");     
        //重定向      
        resposne.sendRedirect("/request-demo/resp2")； 
}   
                                        
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {        this.doGet(request, response);    }}

3. 重定向的特点

• 浏览器地址栏路径发送变化

  当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化

  

• 可以重定向到任何位置的资源(服务内容、外部均可)

  因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。

• 两次请求，不能在多个资源使用request共享数据

  因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据

介绍完请求重定向和请求转发以后，接下来需要把这两个放在一块对比下:

以后到底用哪个，还是需要根据具体的业务来决定。

3.3 路径问题

1. 问题1：转发的时候路径上没有加/request-demo而重定向加了，那么到底什么时候需要加，什么时候不需要加呢?

其实判断的依据很简单，只需要记住下面的规则即可:

• 浏览器使用:需要加虚拟目录(项目访问路径)
• 服务端使用:不需要加虚拟目录

对于转发来说，因为是在服务端进行的，所以不需要加虚拟目录

对于重定向来说，路径最终是由浏览器来发送请求，就需要添加虚拟目录。

掌握了这个规则，接下来就通过一些练习来强化下知识的学习:

• <a href='路劲'>
• <form action='路径'>
• req.getRequestDispatcher(“路径”)
• resp.sendRedirect(“路径”)

答案:

1.超链接，从浏览器发送，需要加2.表单，从浏览器发送，需要加3.转发，是从服务器内部跳转，不需要加4.重定向，是由浏览器进行跳转，需要加。

2. 问题2：在重定向的代码中，/request-demo是固定编码的，如果后期通过Tomcat插件配置了项目的访问路径，那么所有需要重定向的地方都需要重新修改，该如何优化?

答案也比较简单，我们可以在代码中动态去获取项目访问的虚拟目录，具体如何获取，我们可以借助前面咱们所学习的request对象中的getContextPath()方法，修改后的代码如下:

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet { 
    @Override  
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        System.out.println("resp1....");   
        //简化方式完成重定向    
        //动态获取虚拟目录   
        String contextPath = request.getContextPath();    
        response.sendRedirect(contextPath+"/resp2");  
    }  
    @Override 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        this.doGet(request, response);  
    }}

重新启动访问测试，功能依然能够实现，此时就可以动态获取项目访问的虚拟路径，从而降低代码的耦合度。

3.4 Response响应字符数据

要想将字符数据写回到浏览器，我们需要两个步骤:

• 通过Response对象获取字符输出流： PrintWriter writer = resp.getWriter();

• 通过字符输出流写数据: writer.write(“aaa”);

接下来，我们实现通过些案例把响应字符数据给实际应用下:

1. 返回一个简单的字符串aaa

/** * 响应字符数据：设置字符数据的响应体 */
@WebServlet("/resp3")
public class ResponseDemo3 extends HttpServlet {  
    @Override   
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {      
        response.setContentType("text/html;charset=utf-8"); 
        //1. 获取字符输出流      
        PrintWriter writer = response.getWriter();	
        writer.write("aaa");    } 
    @Override   
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        this.doGet(request, response);  
    }}

2. 返回一串html字符串，并且能被浏览器解析

PrintWriter writer = response.getWriter();//content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签response.setHeader("content-type","text/html");writer.write("<h1>aaa</h1>");

==注意:==一次请求响应结束后，response对象就会被销毁掉，所以不要手动关闭流。

3. 返回一个中文的字符串你好，需要注意设置响应数据的编码为utf-8

//设置响应的数据格式及数据的编码response.setContentType("text/html;charset=utf-8");writer.write("你好");

3.3 Response响应字节数据

要想将字节数据写回到浏览器，我们需要两个步骤:

• 通过Response对象获取字节输出流：ServletOutputStream outputStream = resp.getOutputStream();

• 通过字节输出流写数据: outputStream.write(字节数据);

接下来，我们实现通过些案例把响应字符数据给实际应用下:

1. 返回一个图片文件到浏览器

/** * 响应字节数据：设置字节数据的响应体 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {  
    @Override    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {    
        //1. 读取文件     
        FileInputStream fis = new FileInputStream("d://a.jpg");  
        //2. 获取response字节输出流      
        ServletOutputStream os = response.getOutputStream();   
        //3. 完成流的copy    
        byte[] buff = new byte[1024];      
        int len = 0;    
        while ((len = fis.read(buff))!= -1){     
            os.write(buff,0,len);   
        }      
        fis.close();    
    }   
    @Override  
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        this.doGet(request, response);   
    }}

上述代码中，对于流的copy的代码还是比较复杂的，所以我们可以使用别人提供好的方法来简化代码的开发，具体的步骤是:

(1)pom.xml添加依赖

<dependency>   
    <groupId>commons-io</groupId>   
    <artifactId>commons-io</artifactId> 
    <version>2.6</version>
</dependency>

(2)调用工具类方法

//fis:输入流//os:输出流IOUtils.copy(fis,os);

优化后的代码:

/** * 响应字节数据：设置字节数据的响应体 */
@WebServlet("/resp4")public class ResponseDemo4 extends HttpServlet {  
    @Override   
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {   
        //1. 读取文件   
        FileInputStream fis = new FileInputStream("d://a.jpg");     
        //2. 获取response字节输出流       
        ServletOutputStream os = response.getOutputStream();    
        //3. 完成流的copy    
        IOUtils.copy(fis,os);     
        fis.close();  
    }  
    @Override  
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {     
        this.doGet(request, response);    
    }
}

Cookie&session

Filter&Listener