吴荣昌个人博客|Java JDBC

[[ $t(slide_text) ]]

[[ item.c ]]

Java JDBC

[[ $t('发布时间') ]]：2023-02-23 [[ $t('作者') ]]：吴荣昌 [[ $t('来源') ]]：吴荣昌个人博客

Java

# 1、什么是JDBC？
Java DataBase Connectivity

在java语言中编写sql语句，对mysql数据库中的数据进行CRUD操作。

JDBC就是一堆**接口**，负责连接数据库的.

# 2、JDBC相关的类库在哪里？

```java
java.sql.*;
```

# 3、JDBC本质上是一堆什么呢？
`java.sql.*;`这个包下都是JDBC的接口，SUN公司制定的！

JDBC是体现“接口作用”的非常经典的例子。

JDBC降低了**耦合度**，提高了**扩展力**。

对于java程序员来说，不需要关心数据库是哪个品牌。只要面向JDBC接口编程就行！

-----

JDBC整个程序的结构当中有三波人!

1. 第一波：SUN公司，负责制定JDBC接口。这些接口已经写好了，在java.sql.*;
 2. 第二波：java.sql.*下面的所有接口都要有实现类，这些实现类是数据库厂家编写的【简称jar包】。
 3. 第三波：我们java程序员，面向JDBC接口写代码就行！

-----

# JDBC开发之前的准备工作？
**eg.** IDEA工具：

创建lib文件夹，把jar包复制进去，然后鼠标右击jar包，选择add as library...
![在这里插入图片描述](https://img-blog.csdnimg.cn/92b222703c094283b99f8e603f03f33b.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5LiA5Liq5b-r5LmQ55qE6YeO5oyH6ZKIfg==,size_6,color_FFFFFF,t_70,g_se,x_16)

# JDBC编程六步

1. 注册驱动
 2. 获取链接
 3. 获取数据库对象
 4. 执行SQL语句
 5. 处理查询结果集【**注：** 只有执行select语句才有第5步】
 6. 释放资源

# 6、JDBC代码模板

```java
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
    //1、注册驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2、获取数据库连接
    conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库名", "用户名", "密码");
    //3、获取数据库对象
    stmt = conn.createStatement();
    //4、执行sql语句
    String sql = "SQL语句";
    //int count = stmt.executeUpdate(sql);//执行insert、update、delete时用
    rs = stmt.executeQuery(sql);//执行select时用
    //5、处理操作结果集
    while (rs.next()){
        //操作
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //6、释放资源
    if (rs != null) {
        try {
            rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (stmt != null) {
        try {
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
```

# 9、Statement和PreparedStatement的区别
## 9.1、前言：什么是SQL注入？

```java
模拟用户登录：
	用户名：fdsa
	密码：fdsa'or'1'='1
	select * from t_user where login_name='fdsa' and login_pud='fdsa' or '1'='1'
登录成功！
```

以上随意输一个用户名和密码，登录成功了，这种现象被称为SQL注入现象！

### 9.1.1、号致SQL注人的想本原团是什么？怎么解决？
导致SQL注人的根本原因是：用户不是一般的用户，用户是懂得程序的，输入的用户名信息以及密码信息中含有SQL语句的**关键字**，这个SQL语句的关键字和底层的SQL语句进行“**字符串拼接**”，导致原SQL语句的含义被扭曲了。

最最最最最最主要的原因是：**用户提供的信息参与了SQL 语句的编译**。

### 9.1.2、主要团素是
这个程序是**先**进行的**字符的拼接**，然**后**再进行**SQL语句的编译**，正好被注入。|

## 9.2、Statement【父接口】
java.sql.Statement接口的特点：**先进行字符的拼接，然后再进行sqL语句的编译**。
**优点：** 使用statement 可以进行sql 语句的拼接。
**缺点：** 因为拼接的存在，导致可能给不法分子机会。
## 9.3、PreparedStatement【子接口】【可以避免SQL注入】
java.sql.PreparedStatement接口的特点：**先进行SQL 语句的编译，然后再进行SQL语句的传值**。
**优点：** 避免SQL注入。
**缺点：** 没有办法进行sql语句的拼接，只能给sql语句传值。

## 9.4、★Statement例子

```java
 //1、注册驱动
 Class.forName("com.mysql.jdbc.Driver");
 //2、获取连接
 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库名", "用户名", "密码");
 //3、获取数据库操作对象
 stmt = conn.createStatement();
 //4、执行sql语句
  String sql = "select * from t_user where login_name = '" + loginName + "' and login_pwd = '" + loginPwd + "'";
 //程序执行到此处，才会将以上的sql语句发送到DBMS上。DBMS进行sql语句的编译。
 rs = stmt.executeQuery(sql);
 //5、处理操作结果集
 while (rs.next()){
     //操作
 }
```

## 9.5、★PreparedStatement例子
**注意：注释部分尤其重要！**
```java
 //1、注册驱动
 Class.forName("com.mysql.jdbc.Driver");
 //2、获取连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库名", "用户名", "密码");
 //3、获取预编译的数据库操作对象
 // 注意：一个问号？是一个占位符，一个占位符只能接收一个“值/数据”
 // 占位符 ? 两边不能有单引号。'?'这样是错误的。
 String sql = "select * from t_user where login_name = ? and login_pwd = ?";
 ps = conn.prepareStatement(sql);// 此时会发送sql给DBMS，进行sql语句的编译
 //给占位符?传值
 //JDBC中所有下标从1开始
 //怎么解决sql注入的：即使用户信息中有sql关键字，但是不参加编译就没事。
 ps.setString(1, loginName);// 1代表第1个问号 ?
 ps.setString(2, loginPwd);// 2代表第2个问号 ?
 /**
 * setString()
 * sql语句是这样的："select * from t_user where login_pwd = ‘123’";
 * setInt()
 * sql语句是这样的："select * from t_user where login_pwd = 123";
 *
 * 区别在于String会自动加上单引号，int不会。
 */
 //4、执行sql语句
 rs = ps.executeQuery();//这个方法不需要将sql语句传进去。
 //5、处理操作结果集
 while (rs.next()){
 //操作
 }
```

# 9.6、使用Statement进行模糊查询

```java
//FLN为用户输入的名字
stmt = conn.createStatement();
String sql = "select empno, ename from emp where ename like '%" + FLN + "%'";
rs = stmt.executeQuery(sql);
```

# 9.7、使用PreparedStatement进行模糊查询

```java
//FLN为用户输入的名字
String sql = "select empno, ename from emp where ename like ?";//注意此处是 ? 而不是'%?%'
//如果是'%?%'，里面的?不会被视为占位符，会被视为一个字符串?.
ps = conn.prepareStatement(sql);
ps.setString(1, "%" + FLN + "%");
rs = ps.executeQuery();
```

# 9.8、Statement和PreparedStatement该如何选择？

- **如果进行sql语句的拼接，不涉及传值就使用Statement。**
 - **如果涉及sql语句的传值【如：出现等号】，建议使用PreparedStatement，避免SQL注入。**

# 9.9、总结

1. Statement主要是进行sql语句的拼接
 2. PreparedStatement可以避免sql注入，主要进行传值。

# 10、关于JDBC的事务问题

**JDBC默认情况下支持事务自动提交**

## 10.2、模板

**注意：注意禁用事务、提交事务、回滚事务在代码里出现的位置！**

在实际开发中必须JDBC的自动提交机制**关闭**掉，改成手动提交。
**当一个完整的事务结束之后，再提交。**

```java
public static void main(String[] args) {
    Connection conn = null;
    PreparedStatement ps = null;
    try {
        //1、注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2、获取连接
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库名", "用户名", "密码");
        
        //开启事务：将自动提交机制关闭。
        conn.setAutoCommit(false);

//3、获取预编译的数据库对象
        String sql = "update t_act set balance = ? where actno = ?";
        ps = conn.prepareStatement(sql);
        //给 ? 传值
        ps.setInt(1, 10000);
        ps.setString(2, "A");
        int count = ps.executeUpdate();

//            Thread.sleep(1000 * 20);
        //模拟异常
        String s = null;
        s.toString();

ps.setInt(1, 10000);
        ps.setString(2, "B");
        count += ps.executeUpdate();

System.out.println(count == 2 ? "转账成功！" : "转账失败！");

//代码能够执行到此处，说明上面的代码没有出现在何异常，表示都成功了，手动提交。
        //手动提交，事务结束。
        conn.commit();

} catch (Exception e) {
        //出异常，为了保险起见，这里需要回滚！
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }

e.printStackTrace();
    } finally {
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
```

# 11、封装JDBC工具类【为了便于以后的开发】【可直接用】

```java
package jdbc.util;

import java.sql.*;
import java.util.ResourceBundle;

/*
数据库工具类。便于JDBC代码的编写
 */
public class DBUtil {
    //工具类中的构造方法一般部是私有化的，为什么？
    //构造方法私有化是为了防止new对象，为什么要防止new对象？
    //因为工具类中的方法都是静态的，不需要new对象，直接使用"类名."的方式调用。
    // Suppresses default constructor, ensuring non-instantiability.
    private DBUtil() {}

//类加载时绑定属性资源文件
    private static ResourceBundle bundle = ResourceBundle.getBundle("jdbc/resources/db");

//注册驱动
    static{
        try {
            Class.forName(bundle.getString("driver"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

/**
     * 获取数据库连接对象
     * @return 返回数据库连接对象
     * @throws SQLException
     */
    public static Connection getConnect() throws SQLException {
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");
        Connection conn = DriverManager.getConnection(url, user, password);
        return conn;
    }

/**
     * 释放资源
     * @param conn 数据库连接对象
     * @param stmt 执行sql语句对象
     * @param rs 结果集对象
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

/**
 * 重载上面的close方法，更方便。【直接使用父接口】
 * Connection、Statement、ResultSet父接口都是AutoCloseable
 * 而AutoCloseable里面有close方法
 * @param args 统一接口，需要释放的对象
 */
 public static void close(AutoCloseable ...args){
 for (int i = 0; i < args.length; i++){
 try {
 if(args[i] != null) {
 args[i].close();
 }
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }
}

```

# 12、测试JDBC工具类

```java
import jdbc.util.DBUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/*
测试DBUtil工具类
 */
public class JDBCTest09 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtil.getConnect();
            String sql = "select empno, ename from emp where ename like ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "%O%");
            rs = ps.executeQuery();
            while (rs.next()){
                System.out.println(rs.getInt( "empno") + ", " + rs.getString("ename"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
//            DBUtil.close(conn, ps, rs);//未重载的close方法
            //未重载的close方法:没有结果集这么做：
            //DBUtil.close(conn, ps, null);

DBUtil.close(rs, ps , conn);//重载的close方法
            //重载的close方法:没有结果集这么做：
//            DBUtil.close(ps , conn);
        }
    }
}

```

# 13、关于DQL语句的悲观锁【MySQL知识，不属于JDBC的内容】

## 13.1、前言
对于一个DQI语句来说，末尾是可以添加这样一个关键字的：`for update`

**eg.**
```java
select ename，sal from emp where job='MANAGER' for update；
```

以上SQL语句的含义是：
在本次事务的执行过程当中，job='MANAGER'的记录被查询，这些记录在我查询的过程中，任何人，任何事务都**不能对这些记录进行修改操作**。**直到我当前事务结束**。

这种机制被称为：**行级锁机制**（又叫做**悲观锁**！）

## 13.2、for update注意点
当使用select..…where...for update..…时，mysql进行row lock还是table lock只取决于是否能使用索引（例如主键，unique字段），能则为行锁，否则为表锁：未查到数据则无锁。而使用'<>'，'like'，等操作时，索引会失效，自然进行的是table lock。

**所以慎用for update。**

整个表锁住的时候会导致性能降低。谨慎使用！

使用for update的时候，最好是锁**主键值**，或者具有**unique约束**的字段，锁别的字段可能会导致整个表锁住。

[[ $t("上一篇") ]]：PTA-找鞍点 [[ $t("下一篇") ]]：PTA-统计大写辅音字母

[[ $t('你觉得文章怎么样') ]]