15天深度复习JavaWeb的详细笔记(一)——JDBC

demo01-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数据库的驱动包

2，JDBC快速入门

Java操作数据库的流程:

第一步：编写Java代码

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

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

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

2.1 编写代码步骤

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

  • 注意:在添加为库文件的时候，有如下三个选项,我们选择"模块有效"即可

    • Global Library ： 全局有效
    • Project Library : 项目有效
    • Module Library ： 模块有效

• 注册驱动

  • 通知java程序我们即将要连接的是那个品牌的数据库

• 获取连接

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

• 定义SQL语句

• 获取执行SQL语句的对象

  • 需要执行对象执行sql语句

• 执行SQL

  • 实际上就是将sql语句发送给mysql数据库,让他执行sql

• 处理返回结果

• 释放资源

2.2 具体操作

• 编写代码如下

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 = "root";
        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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3，JDBC API详解

3.1 DriverManager

DriverManager（驱动管理类）作用：

• 注册驱动

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

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

  我们查询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服务器,可以将127.0.0.1改为localhost:
      • jdbc:mysql://localhost:3306/db1

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

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

  • user ：用户名

  • poassword ：密码

3.2 Connection

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

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

3.2.1 获取执行对象

• 普通执行SQL对象

  Statement createStatement()
  1

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

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

  PreparedStatement  prepareStatement(sql)
  1

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

• 执行存储过程的对象(了解)

  CallableStatement prepareCall(sql)
  1

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

3.2.2 事务管理

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

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

MySQL默认是自动提交事务

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

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

• 开启事务
  • setAutoCommit(boolean autoCommit):表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。
• 提交事务
  • commit()
• 回滚事务
  • rollback()

具体代码实现如下：

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 = "root";
        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 throwables) {
            // 回滚事务
            conn.rollback();
            throwables.printStackTrace();
        }
        
        //7. 释放资源
        stmt.close();
        conn.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.3 Statement

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

• 执行DDL、DML语句
  • int executeUpdate(String sql),返回值:
    • DML语句影响的行数
    • DDL语句执行成功也可能返回0,比如:删除数据库,删除数据表
      • 注意:以后开发中很少用java代码操作ddl语句
• 执行DQL语句
  • ResultSet executeUpdate(String sql),返回ResultSet 结果集对象
  • 该方法涉及到了 ResultSet 对象，而这个对象我们还没有学习，一会再重点讲解。

3.4 ResultSet

3.4.1 概述

ResultSet（结果集对象）作用：

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

而执行了DQL语句后就会返回该对象，我们就需要从 ResultSet 对象中获取我们想要的数据。ResultSet 对象提供了操作查询结果数据的方法，如下:

boolean next()

• 将光标从当前位置向前移动一行(光标最开始是在第0行,这一点和迭代器挺像的)
• 判断当前行是否为有效行

方法返回值说明：

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

xxx getXxx(参数)：获取数据

• 参数
  • int类型的参数：列的编号，从1开始
  • String类型的参数： 列的名称,如getInt(“id”)->建议用这种:1.提高代码可读性2.输入完rs.getInt(“id”)按alt+enter此时idea会自动给我们的变量名设为id,比较方便

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

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

3.4.2 代码实现

public class JDBCDemo5_ResultSet {
    @Test
    public void testResultSet() throws  Exception {
       //Class.forName("com.mysql.jdbc.Driver");
       String url = "jdbc:mysql:///db1?useSSL=false";
       String username = "root";
       String password = "root";
       Connection conn = DriverManager.getConnection(url, username, password);
       String sql = "select * from account";
       Statement stmt = conn.createStatement();

       //执行sql
       ResultSet rs = stmt.executeQuery(sql);

       //处理结果，遍历rs中的所有数据
       while (rs.next()){
           //获取数据  getXxx()
           int id = rs.getInt(1);
           String name = rs.getString("name");
           int money = rs.getInt(3);
           System.out.println(id);
           System.out.println(name);
           System.out.println(money);
           System.out.println("--------------");

       }
       //7. 释放资源
       rs.close();
       stmt.close();
       conn.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

3.6 PreparedStatement

PreparedStatement作用：

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

3.6.1 SQL注入

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

public class JDBCDemo6_UserLogin {
    @Test
    public void testLogin() throws  Exception {
       String url = "jdbc:mysql:///db1?useSSL=false";
       String username = "root";
       String password = "root";
       Connection conn = DriverManager.getConnection(url, username, password);
       // 接收用户输入 用户名和密码
       String name = "zhangsan";
       String pwd = "' or '1' = '1";

       String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";
       System.out.println(sql);//select * from tb_user where username = 'zhangsan' and password = '' or '1' = '1'

       Statement stmt = conn.createStatement();
       ResultSet rs = stmt.executeQuery(sql);
       // 判断登录是否成功
       if(rs.next()){
           System.out.println("登录成功~");
       }else{
           System.out.println("登录失败~");
       }
       rs.close();
       stmt.close();
       conn.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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);
  1
  2
  3
  4

• 设置参数值

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

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

  • Xxx：数据类型

  • 参数：

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

    • 参数2： ？的值

• 执行SQL语句

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

  executeQuery(); 执行DQL语句

  注意：

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

3.6.4 使用PreparedStatement改进

public class JDBCDemo7_PreparedStatement {
    @Test
    public void testPreparedStatement() throws  Exception {
       String url = "jdbc:mysql:///db1?useSSL=false";
       String username = "root";
       String password = "root";
       Connection conn = DriverManager.getConnection(url, username, password);
        String name = "sjdljfld";
        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("登录失败~");
        }
        rs.close();
        pstmt.close();
        conn.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

执行上面语句就可以发现不会出现SQL注入漏洞问题了。那么PreparedStatement又是如何解决的呢:

• 它是将特殊字符进行了转义，转义的SQL如下：

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

这样转义后的单引号就没有了特殊含义,只是作为password参数值的一部分

3.6.5 PreparedStatement原理

PreparedStatement 好处：

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

防止SQL注入我们已经知道了,那为什么说PreparedStatement可以预编译使性能更高呢,下面来解释一下

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

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

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

  • 检查SQL语句

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

  • 编译SQL语句

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

  • 执行SQL语句

• 检查SQL和编译SQL花费的时间比执行SQL的时间还要长。
• 如果我们两次执行的sql只是重新设置参数值，但是两次执行sql前仍都要进行检查和编译,这是没有必要的,极度影响性能
  • 有没有一种办法可以让相同的sql语句(sql的参数值不同或相同,其他地方都相同)只检查和编译一次呢:通过预编译

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

• 开启预编译功能

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

  String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
  1

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

  在mysql配置文件（my.ini）中添加如下配置

  log-output=FILE
  general-log=1
  general_log_file="D:\mysql.log"
  slow-query-log=1
  slow_query_log_file="D:\mysql_slow.log"
  long_query_time=2
  1
  2
  3
  4
  5
  6

• java测试代码如下：

  public class JDBCDemo7_PreparedStatement {
      @Test
      public void testPreparedStatement2() throws  Exception {
          String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
          String username = "root";
          String password = "root";
          Connection conn = DriverManager.getConnection(url, username, password);
          String name = "zhangsan";
          String pwd = "' or '1' = '1";
          String sql = "select * from tb_user where username = ? and password = ?";
          PreparedStatement pstmt = conn.prepareStatement(sql);
          
          Thread.sleep(10000);//休眠十秒是为了证明预编译是在执行conn.prepareStatement(sql)时进行的
          
          // 设置？的值
          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();
          
          rs.close();
          pstmt.close();
          conn.close();
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32

• 执行代码，查看 D:\mysql.log 日志如下:

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

小结：

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

4，数据库连接池

4.1 数据库连接池简介

• 数据库连接池是个容器，负责分配、管理数据库连接(Connection)
  • 之前我们代码中用户需要连接数据库时都是自己创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的
  • 而数据库使用了数据库连接池后，就能达到Connection对象的复用:连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度
• 数据库连接池的好处
  • 资源重用
  • 提升系统响应速度
  • 避免数据库连接遗漏
    • 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏

4.2 数据库连接池实现

• 标准接口：DataSource

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

  Connection getConnection()
  1

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

• 常见的数据库连接池

  • DBCP
  • C3P0
  • Druid

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

• Druid（德鲁伊）

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

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

4.3 Driud使用

• 导入jar包 druid-1.1.12.jar
  • 添加为库文件时选择"Module Library(模块有效)"即可
• 定义配置文件
• 加载配置文件
• 获取数据库连接池对象
• 获取连接

项目结构如下：

编写配置文件如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=root
# 初始化连接数据
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间(程序向连接池中请求连接时,超过这个时间认为本次请求失败，即连接池中没有可用连接)
maxWait=3000
1
2
3
4
5
6
7
8
9
10

使用druid的代码如下：

public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件

        //3. 加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("demo01-jdbc/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"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 第8行new FileInputStream(“demo01-jdbc/src/druid.properties”)的参数是怎么来的呢:
  • druid.properties的真实路径:D:\study\java\code\system_study\JavaWeb\demo01-jdbc\src\druid.properties
  • 在代码中执行(注释掉其他代码,只执行第16行)System.out.println(System.getProperty(“user.dir”));会输出:
    • D:\study\java\code\system_study\JavaWeb
    • 也就是说使用相对路径时会在JavaWeb中找这个文件,所以参数是demo01-jdbc\src\druid.properties