关于Java的JDBC编程

Author： Kim
发布时间：July 17, 2023
122 views
No comments
39948 words
Categories： Java路途开发贫道

# JDBC概述

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范

JDBC提供了一种基准,据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。

JDBC需要连接驱动，驱动是两个设备要进行通信，满足一定通信数据格式，数据格式由设备提供商规定，设备提供商为设备提供驱动软件，通过软件可以与该设备进行通信。

# JDBC原理

Java提供访问数据库规范称为JDBC，而生产厂商提供规范的实现类称为驱动。

![JDBC原理](https://resource.if010.com/jdbc_study_01.png)

JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。

# JDBC开发步骤

1. 注册驱动
2. 获得连接
3. 获得语句执行平台
4. 执行sql语句
5. 处理结果
6. 释放资源

## 驱动下载

官网下载：[https://dev.mysql.com/downloads/connector/j/](https://dev.mysql.com/downloads/connector/j/)

![官网下载页面](https://resource.if010.com/jdbc_study_02.png)

这里我们使用的是MySQL的驱动[mysql-connector-j-8.0.33](https://resource.if010.com/jar_tools/mysql-connector-j-8.0.33.zip)

## 导入驱动jar包

创建lib目录，用于存放当前项目需要的所有jar包，选择jar包，右键执行build path -> Add to Build Path

![jar包导入操作图](https://resource.if010.com/jdbc_study_03.png)

## API详解：注册驱动

`代码：Class.forName("com.mysql.cj.jdbc.Driver");`

JDBC规范定义驱动接口：java.sql.Driver，MySql驱动包提供了实现类：com.mysql.jdbc.Driver

DriverManager工具类，提供注册驱动的方法 registerDriver()，方法的参数是java.sql.Driver，所以我们可以通过如下语句进行注册:

`DriverManager.registerDriver(new com.mysql.jdbc.Driver());`

以上代码不推荐使用，存在两方面不足

1. 硬编码，后期不易于程序扩展和维护
2. 驱动会被注册两次。

通常开发我们使用Class.forName() 加载一个使用字符串描述的驱动类。

如果使用Class.forName()将类加载到内存，该类的静态代码将自动执行。

通过查询com.mysql.jdbc.Driver源码，我们发现Driver类“主动”将自己进行注册

```java
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
	static {
		try {
			java.sql.DriverManager.registerDriver(new Driver());
		} catch (SQLException E) {
			throw new RuntimeException("Can't register driver!");
		}
	}
……
}
```

## API详解：获得链接

`代码：Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);`

获取连接需要方法 DriverManager.getConnection(url,username,password)，三个参数分别表示，url 需要连接数据库的位置（网址），user用户名，password 密码

url比较复杂，下面是mysql的url：`jdbc:mysql://localhost:3306/test`

JDBC规定url的格式由三部分组成，每个部分中间使用冒号分隔。第一部分是jdbc，这是固定的；第二部分是数据库名称，那么连接mysql数据库，第二部分当然是mysql了；第三部分是由数据库厂商规定的，我们需要了解每个数据库厂商的要求，mysql的第三部分分别由数据库服务器的IP地址（localhost）、端口号（3306），以及DATABASE名称(test)组成。

## API详解：获得语句执行平台

`String sql = "某SQL语句";`

`获取Statement语句执行平台：Statement stmt = con.createStatement();`

常用方法：

* int executeUpdate(String sql); --执行insert update delete语句
* ResultSet executeQuery(String sql); --执行select语句
* boolean execute(String sql); --执行select返回true 执行其他的语句返回false

## API详解：处理结果集

<span style='color:red'>注意：执行insert、update、delete无需处理</span>

ResultSet实际上就是一张二维的表格，我们可以调用其boolean next()方法指向某行记录，当第一次调用next()方法时，便指向第一行记录的位置，这时就可以使用ResultSet提供的getXXX(int col)方法(与索引从0开始不同个，列从1开始)来获取指定列的数据：

```java
rs.next(); //指向第一行
rs.getInt(1); //获取第一行第一列的数据
```

常用方法：

* Object getObject(int index) / Object getObject(String name) --获得任意对象
* String getString(int index) / Object getObject(String name) --获得字符串
* int getInt(int index) / Object getObject(String name) --获得整形
* double getDouble(int index) / Object getObject(String name) --获得双精度浮点型

## API详解：释放资源

与IO流一样，使用后的东西都需要关闭！关闭的顺序是先得到的后关闭，后得到的先关闭。

```java
rs.close();
stmt.close();
con.close();
```

## 开发示例

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * JDBC操作数据库的步骤
 * 1、注册驱动
 *  告知JVM使用哪个数据库的驱动
 * 2、获得连接
 *  使用JDBC中的类，完成对数据库的连接
 * 3、获得语句执行平台
 *  通过连接对象获取对SQL语句的执行者对象
 * 4、执行sql语句
 *  使用执行者对象，向数据库执行SQL语句，获取到数据库执行后的结果
 * 5、处理结果
 * 6、释放资源
 */
public class JDBCDemo {
    public static void main(String[] args) throws Exception {
        //1、注册驱动（反射技术，将驱动类加入到内容）
        //使用java.sql.DriverManager类静态方法，registerDriver Driver(driver)
        //Driver是一个接口，传递参数应该是MySQL驱动的实现类
        //DriverManager.registerDriver(new Driver());
        //驱动类源码，注册2次驱动程序
        Class.forName("com.mysql.cj.jdbc.Driver");

//2、获得数据库连接 DriverManager类中静态方法
        //static Connection getConnection(String url, String username, String password)
        //返回值Connection接口的实现类，实现类是MySQL驱动里提供的
        //url 数据库地址 jdbc:mysql://IP地址:端口号/数据库名称
        String url = "jdbc:mysql://127.0.0.1:3306/test";
        String username = "root";
        String password = "123456";
        Connection conn = DriverManager.getConnection(url, username, password);

//3、获得语句执行平台，通过数据库连接对象Connection，获取到获取到SQL语句的执行者对象
        //Connection对象调用方法 Statement createStatement() 获取Statement对象，将SQL语句发送到数据库
        //返回值Statement接口的实现类，实现类是MySQL驱动里提供的
        Statement stat = conn.createStatement();

//4、执行sql语句
        //通过执行者对象调用方法执行SQL语句，获取结果
        //int executeUpdate(String sql) 仅限于执行insert、update、delete这三种SQL语句
        //返回值int是操作成功了多少行数据
        int row = stat.executeUpdate("INSERT INTO user(username,password) VALUES ('admin','123456');");
        System.out.println("成功执行：" + row + "条数据");

//ResultSet executeQuery(String sql) 仅限于执行select这种SQL语句
        //返回值ResultSet接口的实现类，实现类是MySQL驱动里提供的
        ResultSet rs = stat.executeQuery("SELECT * FROM user WHERE username='admin';");

//5、处理结果
        //ResultSet接口方法boolean next()，返回true则为有结果，反之false则为没有结果
        while(rs.next()) {
            //获取每列数据，使用ResultSet接口的方法getXXX
            System.out.println(
                    rs.getString("username") + "  " + rs.getString("password")
            );
        }

//6、释放资源
        rs.close();
        stat.close();
        conn.close();
    }
}
```

# SQL注入问题

假设有登录案例SQL语句如下：

`SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;`

此时，当用户输入正确的账号与密码后，查询到了信息则让用户登录。但是当用户输入的账号为XXX 密码为：XXX’  OR ‘a’=’a时，则真正执行的代码变为：

`SELECT * FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’  OR ’a’=’a’;`

此时，上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了，显然我们不希望看到这样的结果，这便是SQL注入问题，为此，我们使用PreparedStatement预处理对象来解决对应的问题。

# PreparedStatement预处理对象

使用PreparedStatement预处理对象时，建议每条sql语句所有的实际参数，都使用逗号分隔。

```java
String sql = "insert into sort(sid,sname) values(?,?)";;
PreparedStatement预处理对象代码：
PreparedStatement psmt = conn.prepareStatement(sql)
```

执行SQL语句:

* int executeUpdate(); --执行insert update delete语句.
* ResultSet executeQuery(); --执行select语句.
* boolean execute(); --执行select返回true 执行其他的语句返回false.

设置实际参数

* void **set****Xxx**(int index, Xxx xx) 将指定参数设置为给定Java的xx值。在将此值发送到数据库时，驱动程序将它转换成一个 SQL Xxx类型值。例如：`setString(2, "家用电器") 把SQL语句中第2个位置的占位符？替换成实际参数 "家用电器"`

## executeQuery方法

### 查询记录：select

```java
import java.sql.*;

/**
 * Statement接口实现类，用作执行SQL语句，返回对应结果
 * 有一个子接口PreparedStatement，SQL预编译存储，多次高效执行SQL语句
 * PreparedStatement的实现类在数据库的驱动当中，是Connection连接数据库对象的方法
 * PreparedStatement preparedStatement(String sql)
 */
public class PreparedStatementSelectDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获得连接
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://127.0.0.1:3306/test",
                "root",
                "123456"
        );

//调用Connection接口方法PreparedStatement，获取PreparedStatement接口的实现类
        //方法中的参数，SQL语句中的全部参数采用？(占位符)
        //调用PreparedStatement的set方法设置占位符的参数
        String sql = "select * from user where username=? and password=?";
        PreparedStatement pstat = conn.prepareStatement(sql);
        pstat.setObject(1,"admin");
        pstat.setObject(2,"admin");

//执行sql语句
        ResultSet rs = pstat.executeQuery();

//处理结果
        while(rs.next()) {
            System.out.println(
                    rs.getString("username") + "  " + rs.getString("password")
            );
        }

//释放资源
        rs.close();
        pstat.close();
        conn.close();
    }
}
```

## executeUpdate方法

### 插入记录：insert

```java
import java.sql.*;

public class PreparedStatementInsertDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获得连接
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://127.0.0.1:3306/test",
                "root",
                "123456"
        );

//PreparedStatement接口实现数据添加
        String sql = "INSERT INTO user(username,password) VALUES (?,?);";
        PreparedStatement pstat = conn.prepareStatement(sql);
        pstat.setString(1,"admin");
        pstat.setString(2,"123456");

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

### 更新记录：update

```java
import java.sql.*;

public class PreparedStatementUpdateDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获得连接
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://127.0.0.1:3306/test",
                "root",
                "123456"
        );

//PreparedStatement接口实现数据更新
        String sql = "update user set username=?,password=? where id=?";
        PreparedStatement pstat = conn.prepareStatement(sql);
        pstat.setObject(1,"admin");
        pstat.setString(2,"123456");
        pstat.setInt(3,1);

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

### 删除记录：delete

```java
import java.sql.*;

public class PreparedStatementDeleteDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //获得连接
        Connection conn = DriverManager.getConnection(
                "jdbc:mysql://127.0.0.1:3306/test",
                "root",
                "123456"
        );

//PreparedStatement接口实现数据删除
        String sql = "delete from user where id=?;";
        PreparedStatement pstat = conn.prepareStatement(sql);
        pstat.SetInt(1,1);

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

# 自建JDBC工具类

“获得数据库连接”操作，将在以后的增删改查所有功能中都存在，可以封装工具类JDBCUtils。提供获取连接对象的方法，从而达到代码的重复利用。

该工具类提供方法：`public static Connection getConnection()`

```java
import java.sql.*;

/**
 * 实现JDBC工具类
 * 定义方法，直接返回数据库连接对象
 */
public class JDBCUtils {
    private JDBCUtils(){}
    private static Connection conn;

static {
        try {
            try {
                Class.forName("com.mysql.cj.jdbc.Driver");
            } catch (ClassNotFoundException e){
                System.out.println("数据库驱动注册失败！");
            }
            String url = "jdbc:mysql://127.0.0.1:3306/test";
            String username = "root";
            String password = "123456";
            conn = DriverManager.getConnection(url, username, password);
        } catch (Exception e){
            throw new RuntimeException(e+"数据库连接失败！");
        }
    }

/**
     * 定义静态方法，返回数据库的连接对象
     */
    public static Connection getConnection(){
        return conn;
    }

/**
     * 定义静态方法，实现executeQuery方面的释放资源
     * 关闭顺序 ResultSet -> Statement -> Connection
     * @param conn 数据库连接对象
     * @param stat 数据预处理对象
     * @param rs 数据结果集
     */
    public static void cloes(Connection conn, Statement stat, ResultSet rs){
        if (rs != null){
            try{
                rs.close();
            } catch (SQLException e){
                System.out.println("ResultSet释放失败！");
            }
        }

if (stat != null){
            try{
                stat.close();
            } catch (SQLException e){
                System.out.println("Statement释放失败！");
            }
        }

if (conn != null){
            try{
                conn.close();
            } catch (SQLException e){
                System.out.println("Connection释放失败！");
            }
        }
    }

/**
     * 定义静态方法，实现executeUpdate方面的释放资源
     * 关闭顺序 Statement -> Connection
     * @param conn
     * @param stat
     */
    public static void cloes(Connection conn, Statement stat){
        if (stat != null){
            try{
                stat.close();
            } catch (SQLException e){
                System.out.println("Statement释放失败！");
            }
        }

if (conn != null){
            try{
                conn.close();
            } catch (SQLException e){
                System.out.println("Connection释放失败！");
            }
        }
    }
}
```

```java
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class TestJDBCUtils {
    public static void main(String[] args) throws Exception {
        Connection conn = JDBCUtils.getConnection();
        String sql = "select * from user";
        PreparedStatement pst = conn.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();

while (rs.next()){
            System.out.println(rs.getInt("id")+"   "+rs.getString("username"));
        }

JDBCUtils.cloes(conn,pst,rs);
    }
}
```

## 使用properties配置文件

开发中获得连接的4个参数（驱动、URL、用户名、密码）通常都存在配置文件中，方便后期维护，程序如果需要更换数据库，只需要修改配置文件即可。

通常情况下，我们习惯使用properties文件，此文件我们将做如下要求：

1. 文件位置：任意，建议src下
2. 文件名称：任意，扩展名为properties
3. 文件内容：一行一组数据，格式是“key=value”.
   * key命名自定义，如果是多个单词，习惯使用点分隔。例如：jdbc.driver
   * value值不支持中文，如果需要使用非英文字符，将进行unicode转换

### 创建配置文件

在项目根目录下，文件夹”config“，然后再创建文件“db.properties”

```properties
url=jdbc:mysql://localhost:3306/test
user=root
password=123456
```

### 加载配置文件

对应properties文件处理，开发中也使用Properties对象进行。我们将采用加载properties文件获得流，然后使用Properties对象进行处理

```java
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.sql.*;
import java.util.Properties;

/**
 * 实现JDBC工具类
 * 定义方法，连接数据库的方法和释放资源的方法
 * 加载properties配置文件，IO读取文件键值对存储到集合
 * 从集合中以键值对方式获取数据库连接信息，完成数据库的连接
 * 返回数据库连接对象
 */
public class JDBCUtils {
    private JDBCUtils(){}
    private static Connection conn;
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

static {
        try {
            //使用Properties处理流,使用load()方法加载指定的流
            Properties dbconfig = new Properties();
            Reader rd = new FileReader("./config/db.properties");
            dbconfig.load(rd);

//获取配置信息，键值对
            driver = dbconfig.getProperty("driver");
            url = dbconfig.getProperty("url");
            username = dbconfig.getProperty("username");
            password = dbconfig.getProperty("password");

try {
                try {
                    Class.forName(driver);
                } catch (ClassNotFoundException e){
                    System.out.println("数据库驱动注册失败！");
                }
                conn = DriverManager.getConnection(url, username, password);
            } catch (Exception e){
                throw new RuntimeException(e+"数据库连接失败！");
            }
        } catch (IOException e){
            throw new RuntimeException(e+"数据库配置信息读取失败！");
        }
    }

/**
     * 定义静态方法，返回数据库的连接对象
     */
    public static Connection getConnection(){
        return conn;
    }

if (stat != null){
            try{
                stat.close();
            } catch (SQLException e){
                System.out.println("Statement释放失败！");
            }
        }

if (conn != null){
            try{
                conn.close();
            } catch (SQLException e){
                System.out.println("Connection释放失败！");
            }
        }
    }

# DBUtils

如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。

DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。

## 驱动下载

官网下载：[https://commons.apache.org/proper/commons-dbutils/download_dbutils](https://commons.apache.org/proper/commons-dbutils/download_dbutils)

![官网下载页面](https://resource.if010.com/jdbc_study_04.png)

这里我们使用[commons-dbutils-1.6-bin](https://resource.if010.com/jar_tools/commons-dbutils-1.6-bin.zip)

## 概述

DBUtils是java编程中的数据库操作实用工具，小巧简单实用，DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码

Dbutils三个核心功能介绍

* QueryRunner中提供对sql语句操作的API.
* ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
* DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法

## QueryRunner核心类

### 实现添加、更新、删除操作

以下示例使用上述提到的JDBCUtils工具类获取数据库连接对象，自定义的工具类传递

#### 插入记录：insert

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner类，实现对数据表的
 *  insert、update、delete
 * 调用QueryRunner类的方法update(Connection conn, String sql, Object...param)
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 */
public class QueryRunnerDemo {
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //定义SQL语句
        String sql = "INSERT INTO user(username,password) VALUES (?,?);";
        //将占位符的实际参数以数组的方式存储
        Object[] param = {"admin","123456"};
        //获取数据库连接
        Connection conn = JDBCUtils.getConnection();
        //调用QueryRunner类的方法update执行SQL语句
        int row = queryRunner.update(conn, sql, param);
        //释放资源，并输出执行结果数
        conn.close();
        System.out.println("成功执行：" + row + "条数据");
    }
}
```

#### 更新记录：update

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner类，实现对数据表的
 *  insert、update、delete
 * 调用QueryRunner类的方法update(Connection conn, String sql, Object...param)
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 */
public class QueryRunnerDemo {
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //定义SQL语句
        String sql = "UPDATE user SET password=? WHERE id=?;";
        //将占位符的实际参数以数组的方式存储
        Object[] param = {"123456", 1};
        //获取数据库连接
        Connection conn = JDBCUtils.getConnection();
        //调用QueryRunner类的方法update执行SQL语句
        int row = queryRunner.update(conn, sql, param);
        //释放资源，并输出执行结果数
        conn.close();
        System.out.println("成功执行：" + row + "条数据");
    }
}
```

#### 删除记录：delete

**如果删除没有符合条件的数据，返回的数字为0**

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner类，实现对数据表的
 *  insert、update、delete
 * 调用QueryRunner类的方法update(Connection conn, String sql, Object...param)
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 */
public class QueryRunnerDemo {
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //定义SQL语句
        String sql = "DELETE from user WHERE id=?;";
        //将占位符的实际参数以数组的方式存储
        Object[] param = {1};
        //获取数据库连接
        Connection conn = JDBCUtils.getConnection();
        //调用QueryRunner类的方法update执行SQL语句
        int row = queryRunner.update(conn, sql, param);
        //释放资源，并输出执行结果数
        conn.close();
        System.out.println("成功执行：" + row + "条数据");
    }
}
```

### 实现查询操作

#### ResultSetHandler结果集处理类

| 实现类            | 描述                                                                                             |
| ----------------- | ------------------------------------------------------------------------------------------------ |
| ArrayHandler      | 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值 |
| ArrayListHandler  | 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中                   |
| BeanHandler       | 将结果集中第一条记录封装到一个指定的javaBean中                                                   |
| BeanListHandler   | 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中                     |
| ColumnListHandler | 将结果集中指定的列的字段值，封装到一个List集合中                                                 |
| ScalarHandle      | 它是用于单数据。例如select count(\*) from 表 操作                                               |
| MapHandler        | 将结果集第一行封装到Map集合中,Key列名, Value该列数据                                            |
| MapListHandler    | 将结果集第一行封装到Map集合中,Key列名, Value该列数据,Map集合存储到List集合                       |

#### JavaBean

JavaBean就是一个类(概念类)，在开发中常用封装数据。具有如下特性

1. 需要实现接口：java.io.Serializable ，通常实现接口这步骤省略了，不会影响程序
2. 提供私有字段：private 类型 字段名
3. 提供getter/setter方法
4. 提供无参构造

#### ArrayHandler与ArrayListHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * 使用QueryRunner类，实现对数据表的查询操作
 * 调用QueryRunner类的方法query(Connection conn, String sql, ResultSetHandler r, Object...param)
 *  ResultSetHandler r 结果集的处理方式，传递ResultSetHandler接口的实现类
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 * 注意：query方法返回的结果是 <T>T 泛型，具体返回值类型，跟随结果集处理方式的变化
 */
public class QueryRunnerDemo2 {
    private static Connection conn = JDBCUtils.getConnection();
    private static String sql = "SELECT * FROM user;";

/**
     * ResultSetHandler接口的实现类ArrayHandler查询方法
     * 将结果集的第一行存储到Object[]类型对象数组中
     */
    public static void arrayHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递连接对象、SQL语句、结果集处理方式的实现类,返回对象数组
        Object[] result = queryRunner.query(conn, sql, new ArrayHandler());

//可以通过数组长度判断是否有结果，如果数据长度为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果数组长度："+result.length);

//输出结果
        for(Object obj : result){
            System.out.print(obj+"\t");
        }
    }

/**
     * ResultSetHandler接口的实现类ArrayListHandler查询方法
     * 将结果集的每一行封装到对象数组当中，对象数据会存储到List集合中
     */
    public static void arrayListHandler() throws SQLException{
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递连接对象、SQL语句、结果集处理方式的实现类,返回List集合类型,结合里装的是对象数组
        List<Object[]> result = queryRunner.query(conn, sql, new ArrayListHandler());

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for(Object[] objs : result){
            for (Object obj : objs) {
                System.out.print(obj+"\t");
            }
            System.out.println();
        }
    }

public static void main(String[] args) throws SQLException {
        arrayHandler();
        arrayListHandler();
    }
}
```

#### BeanHandler与BeanListHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
     * ResultSetHandler接口的实现类BeanHandler查询方法
     * 将结果集的第一行封装成JavaBean对象
     * 注意：被封装成JavaBean对象，必须要有空参构造器
     */
    public static void beanHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递结果集实现类BeanHandler
        //BeanHandler
        User u = queryRunner.query(conn, sql, new BeanHandler<User>(User.class));

//可以通过对象是否为null判断是否有查询到数据
        if (u == null){
            System.out.println("查询不到相关数据");
        }

//输出结果
        System.out.println(u);
    }

/**
     * ResultSetHandler接口的实现类BeanListHandler查询方法
     * 将结果集的每一行封装成JavaBean对象，再将JavaBean对象封装到List集合当中
     */
    public static void beanListHandler() throws SQLException{
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递连接对象、SQL语句、结果集处理方式的实现类,返回List集合类型,结合里装的是对象数组
        List<User> result = queryRunner.query(conn, sql, new BeanListHandler<User>(User.class));

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for(User u : result){
            System.out.println(u);
        }
    }

public static void main(String[] args) throws SQLException {
	beanHandler();
        beanListHandler();
    }
}
```

#### ColumnListHandler与ScalarHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
     * ResultSetHandler接口的实现类ColumnListHandler查询方法
     * 将结果集的指定列存储到List集合当中，List<Object>每个列的数据类型都不同
     */
    public static void columnListHandler () throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递结果集实现类ColumnListHandler
        List<Object> result = queryRunner.query(conn, sql, new ColumnListHandler<Object>("username"));

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for (Object username : result) {
            System.out.println(username);
        }
    }

/**
     * ResultSetHandler接口的实现类ScalarHandler查询方法，适用于单数据结果
     */
    public static void scalarHandler() throws SQLException{
        QueryRunner queryRunner = new QueryRunner();
        sql = "SELECT COUNT(*) FROM user;";
        //调用方法query执行查询，传递连接对象、SQL语句、结果集处理方式的实现类
        Long result = queryRunner.query(conn, sql, new ScalarHandler<Long>());

//输出结果
        System.out.println(result);
    }

public static void main(String[] args) throws SQLException {
        columnListHandler();
        scalarHandler();
    }
}
```

#### MapHandler与MapListHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
     * ResultSetHandler接口的实现类MapHandler查询方法
     * 将结果集的第一行结果封装到Map集合当中
     * Map<key:value> key->列  value->数据
     */
    public static void mapHandler() throws SQLException {
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递结果集实现类MapHandler，继承于LinkedHashMap,有序
        Map<String,Object> result = queryRunner.query(conn, sql, new MapHandler());

//可以通过集合是否为null判断是否有结果,如果为null直接输出，则会报错
        if (result != null){
            System.out.println("结果集合大小："+result.size());

//输出结果
            for (String key : result.keySet()){
                System.out.println(key+":"+result.get(key));
            }
        }
    }

/**
     * ResultSetHandler接口的实现类MapListHandler查询方法
     * 将结果集的每一行结果封装到一个Map集合当中，再将Map集合添加到List集合当中
     * Map<key:value> key->列  value->数据
     */
    public static void mapListHandler() throws SQLException{
        QueryRunner queryRunner = new QueryRunner();
        //调用方法query执行查询，传递连接对象、SQL语句、结果集处理方式的实现类,返回List集合类型,结合里装的是Map集合
        //继承于LinkedHashMap,有序
        List<Map<String,Object>> result = queryRunner.query(conn, sql, new MapListHandler());

//输出结果
        for (Map<String,Object> map : result) {
            for (String key : map.keySet()) {
                System.out.print(key+":"+map.get(key)+"\t");
            }
            System.out.println();
        }
    }

public static void main(String[] args) throws SQLException {
        mapHandler();
        mapListHandler();
    }
}
```

# 连接池

实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池

## 连接池概述

### 概念

用池来管理Connection，这样可以重复使用Connection。有了池，所以我们就不用自己来创建Connection，而是通过池来获取Connection对象。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。

![JDBC数据库连接池概念图](https://resource.if010.com/jdbc_study_05.png)

### 规范

Java为数据库连接池提供了公共的接口：**javax.sql.DataSource**，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

常见的连接池：DBCP、C3P0

## DBCP连接池开发

DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池

### 驱动下载

Commons-DBCP官网下载：[https://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi](https://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi)

Commons-Pool官网下载：[https://commons.apache.org/proper/commons-dbcp/download_pool.cgi](https://commons.apache.org/proper/commons-dbcp/download_pool.cgi)

Commons-Logging官网下载：[https://commons.apache.org/proper/commons-logging/download_logging.cgi](https://commons.apache.org/proper/commons-logging/download_logging.cgi)

![官网下载页面](https://resource.if010.com/jdbc_study_06.png)

![官网下载页面](https://resource.if010.com/jdbc_study_07.png)

![官网下载页面](https://resource.if010.com/jdbc_study_08.png)

这里我们使用[commons-dbcp2-2.9.0-bin](https://resource.if010.com/jar_tools/commons-dbcp2-2.9.0-bin.zip)、[commons-pool2-2.11.1-bin](https://resource.if010.com/jar_tools/commons-pool2-2.11.1-bin.zip)、[commons-logging-1.2-bin](https://https://resource.if010.com/jar_tools/commons-logging-1.2-bin.zip)

### 常见配置项

| 属性            | 描述           | 是否必须设置 |
| --------------- | -------------- | ------------ |
| driverClassName | 数据库驱动名称 | 是           |
| url             | 数据库的地址   | 是           |
| username        | 用户名         | 是           |
| password        | 密码           | 是           |
| maxActive       | 最大连接数量   | 否           |
| minIdle         | 最小空闲连接   | 否           |
| maxIdle         | 最大空闲连接   | 否           |
| initialSize     | 初始化连接     | 否           |

参考文档：[http://commons.apache.org/proper/commons-dbcp/configuration.html](http://commons.apache.org/proper/commons-dbcp/configuration.html)

### 编写实现类

```java
import org.apache.commons.dbcp2.BasicDataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 在连接池dbcp包中定义了BasicDataSource类，实现了数据源的规范接口javax.sql.DataSource
 */
public class DataSourceDemo {
    public static void main(String[] args) throws SQLException {
        //创建DataSource接口的实现类对象BasicDataSource
        BasicDataSource dataSource = new BasicDataSource();

//设置连接数据库最基本的4个参数,driver、url、username、password
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");

//调用对象方法getConnection获取数据库连接
        Connection conn = dataSource.getConnection();

}
}
```

### 编写工具类

```java
import org.apache.commons.dbcp2.BasicDataSource;
import javax.sql.DataSource;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Properties;

/**
 * 使用DBCP实现数据库连接池
 * 连接池配置读取db.properties文件
 */
public class JDBCUtils2 {
    private static BasicDataSource dataSource = new BasicDataSource();

static {
        try {
            //使用Properties处理流,使用load()方法加载指定的流
            Properties dbConfig = new Properties();
            Reader rd = new FileReader("./config/db.properties");
            dbConfig.load(rd);

//读取db.properties文件对连接池进行配置
            dataSource.setDriverClassName(dbConfig.getProperty("driver"));
            dataSource.setUrl(dbConfig.getProperty("url"));
            dataSource.setUsername(dbConfig.getProperty("username"));
            dataSource.setPassword(dbConfig.getProperty("password"));

dataSource.setInitialSize(Integer.parseInt(dbConfig.getProperty("InitialSize")));
            dataSource.setMaxIdle(Integer.parseInt(dbConfig.getProperty("MaxIdle")));
            dataSource.setMinIdle(Integer.parseInt(dbConfig.getProperty("MinIdle")));
        } catch (IOException e) {
            throw new RuntimeException(e+"数据库配置信息读取失败！");
        }
    }

public static DataSource getConnection(){
        return dataSource;
    }
}
```

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import java.sql.SQLException;
import java.util.List;

/**
 * 测试JDBCUtils2工具类
 * JDBCUtils2工具类提供的是一个DataSource接口的数据源
 * QueryRunner类构造方法可以接收DataSource接口的实现类，然后调用update、query方法，无需传递他们Connection对象
 */
public class JDBCUtils2Test {
    private static QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getConnection());
    public static void main(String[] args) {
        insert();
        select();
    }
    public static void insert(){
        String sql = "INSERT INTO user(username,password) VALUES (?,?)";
        Object[] param = {"admin","123123"};
        try {
            int result = queryRunner.update(sql,param);
            System.out.println("【提示】成功插入"+result+"条数据");
        } catch (SQLException e){
            throw new RuntimeException(e+"数据添加失败!");
        }
    }

public static void select(){
        String sql = "SELECT * FROM user";
        List<Object[]> result = null;
        try {
            result = queryRunner.query(sql, new ArrayListHandler());
        } catch (SQLException e) {
            throw new RuntimeException(e+"查询异常或错误");
        }
        if (result.size() != 0) {
            for (Object[] objs : result) {
                for (Object obj : objs){
                    System.out.print(obj+"\t");
                }
                System.out.println();
            }
        } else {
            System.out.println("查询不到相关记录");
        }
    }
}
```

# 关于报错

如果数据库服务没有正常运行连接不上，则会提示以下报错信息：

```java
java.sql.SQLException: Cannot create PoolableConnectionFactory (Communications link failure

The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.)
	at org.apache.commons.dbcp2.BasicDataSource.createPoolableConnectionFactory(BasicDataSource.java:653)
	at org.apache.commons.dbcp2.BasicDataSource.createDataSource(BasicDataSource.java:531)
	at org.apache.commons.dbcp2.BasicDataSource.getConnection(BasicDataSource.java:731)
	at com.if010.test.DataSourceDemo.main(DataSourceDemo.java:23)
Caused by: com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure
```

如果数据库名称输入有误连接不上，则会提示以下报错信息：

```java
java.sql.SQLException: Cannot create PoolableConnectionFactory (Unknown database 'atest')
	at org.apache.commons.dbcp2.BasicDataSource.createPoolableConnectionFactory(BasicDataSource.java:653)
	at org.apache.commons.dbcp2.BasicDataSource.createDataSource(BasicDataSource.java:531)
	at org.apache.commons.dbcp2.BasicDataSource.getConnection(BasicDataSource.java:731)
	at com.if010.test.DataSourceDemo.main(DataSourceDemo.java:23)
```

如果数据库连接的用户名或密码输入有误导致连接不上，则会提示以下报错信息：

```java
java.sql.SQLException: Cannot create PoolableConnectionFactory (Access denied for user 'roota'@'172.17.0.1' (using password: YES))
	at org.apache.commons.dbcp2.BasicDataSource.createPoolableConnectionFactory(BasicDataSource.java:653)
	at org.apache.commons.dbcp2.BasicDataSource.createDataSource(BasicDataSource.java:531)
	at org.apache.commons.dbcp2.BasicDataSource.getConnection(BasicDataSource.java:731)
	at com.if010.test.DataSourceDemo.main(DataSourceDemo.java:23)
```

如果SQL语句中的占位符与传入参数的个数不对，则会提示以下报错信息：

```java
Exception in thread "main" java.sql.SQLException: Wrong number of parameters: expected 2, was given 1 Query: DELETE from user SET password=? WHERE id=?; Parameters: [123456]
	at org.apache.commons.dbutils.AbstractQueryRunner.rethrow(AbstractQueryRunner.java:392)
	at org.apache.commons.dbutils.QueryRunner.update(QueryRunner.java:491)
	at org.apache.commons.dbutils.QueryRunner.update(QueryRunner.java:404)
	at com.if010.test.QueryRunnerDemo.main(QueryRunnerDemo.java:24)
```

如果SQL语句有错误，或者传入占位符的参数类型与SQL语句不对应，则会提示以下报错信息：

```java
Exception in thread "main" java.sql.SQLException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SET password=1 WHERE id=1' at line 1 Query: DELETE from user SET password=? WHERE id=?; Parameters: [1, 1]
	at org.apache.commons.dbutils.AbstractQueryRunner.rethrow(AbstractQueryRunner.java:392)
	at org.apache.commons.dbutils.QueryRunner.update(QueryRunner.java:491)
	at org.apache.commons.dbutils.QueryRunner.update(QueryRunner.java:404)
	at com.if010.test.QueryRunnerDemo.main(QueryRunnerDemo.java:24)
```

关于BeanHandler中传入的类没有空参构造，则会提示以下报错信息：

```java
Exception in thread "main" java.sql.SQLException: Cannot create com.if010.test.User: com.if010.test.User Query: SELECT * FROM user; Parameters: []
	at org.apache.commons.dbutils.AbstractQueryRunner.rethrow(AbstractQueryRunner.java:392)
	at org.apache.commons.dbutils.QueryRunner.query(QueryRunner.java:351)
	at org.apache.commons.dbutils.QueryRunner.query(QueryRunner.java:226)
	at com.if010.test.QueryRunnerDemo2.beanHandler(QueryRunnerDemo2.java:30)
	at com.if010.test.QueryRunnerDemo2.main(QueryRunnerDemo2.java:63)
```

Last modification：July 20, 2023

关于Java的JDBC编程

Kim • 2023 年 07 月 17 日

# JDBC概述

JDBC提供了一种基准,据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。

# JDBC原理

Java提供访问数据库规范称为JDBC，而生产厂商提供规范的实现类称为驱动。

![JDBC原理](https://resource.if010.com/jdbc_study_01.png)

# JDBC开发步骤

1. 注册驱动
2. 获得连接
3. 获得语句执行平台
4. 执行sql语句
5. 处理结果
6. 释放资源

## 驱动下载

官网下载：[https://dev.mysql.com/downloads/connector/j/](https://dev.mysql.com/downloads/connector/j/)

![官网下载页面](https://resource.if010.com/jdbc_study_02.png)

这里我们使用的是MySQL的驱动[mysql-connector-j-8.0.33](https://resource.if010.com/jar_tools/mysql-connector-j-8.0.33.zip)

## 导入驱动jar包

创建lib目录，用于存放当前项目需要的所有jar包，选择jar包，右键执行build path -> Add to Build Path

![jar包导入操作图](https://resource.if010.com/jdbc_study_03.png)

## API详解：注册驱动

`代码：Class.forName("com.mysql.cj.jdbc.Driver");`

JDBC规范定义驱动接口：java.sql.Driver，MySql驱动包提供了实现类：com.mysql.jdbc.Driver

DriverManager工具类，提供注册驱动的方法 registerDriver()，方法的参数是java.sql.Driver，所以我们可以通过如下语句进行注册:

`DriverManager.registerDriver(new com.mysql.jdbc.Driver());`

以上代码不推荐使用，存在两方面不足

1. 硬编码，后期不易于程序扩展和维护
2. 驱动会被注册两次。

通常开发我们使用Class.forName() 加载一个使用字符串描述的驱动类。

如果使用Class.forName()将类加载到内存，该类的静态代码将自动执行。

通过查询com.mysql.jdbc.Driver源码，我们发现Driver类“主动”将自己进行注册

## API详解：获得链接

`代码：Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);`

获取连接需要方法 DriverManager.getConnection(url,username,password)，三个参数分别表示，url 需要连接数据库的位置（网址），user用户名，password 密码

url比较复杂，下面是mysql的url：`jdbc:mysql://localhost:3306/test`

## API详解：获得语句执行平台

`String sql = "某SQL语句";`

`获取Statement语句执行平台：Statement stmt = con.createStatement();`

常用方法：

## API详解：处理结果集

<span style='color:red'>注意：执行insert、update、delete无需处理</span>

```java
rs.next(); //指向第一行
rs.getInt(1); //获取第一行第一列的数据
```

常用方法：

## API详解：释放资源

与IO流一样，使用后的东西都需要关闭！关闭的顺序是先得到的后关闭，后得到的先关闭。

```java
rs.close();
stmt.close();
con.close();
```

## 开发示例

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

//6、释放资源
        rs.close();
        stat.close();
        conn.close();
    }
}
```

# SQL注入问题

假设有登录案例SQL语句如下：

`SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;`

`SELECT * FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’  OR ’a’=’a’;`

# PreparedStatement预处理对象

使用PreparedStatement预处理对象时，建议每条sql语句所有的实际参数，都使用逗号分隔。

```java
String sql = "insert into sort(sid,sname) values(?,?)";;
PreparedStatement预处理对象代码：
PreparedStatement psmt = conn.prepareStatement(sql)
```

执行SQL语句:

* int executeUpdate(); --执行insert update delete语句.
* ResultSet executeQuery(); --执行select语句.
* boolean execute(); --执行select返回true 执行其他的语句返回false.

设置实际参数

## executeQuery方法

### 查询记录：select

```java
import java.sql.*;

//执行sql语句
        ResultSet rs = pstat.executeQuery();

//处理结果
        while(rs.next()) {
            System.out.println(
                    rs.getString("username") + "  " + rs.getString("password")
            );
        }

//释放资源
        rs.close();
        pstat.close();
        conn.close();
    }
}
```

## executeUpdate方法

### 插入记录：insert

```java
import java.sql.*;

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

### 更新记录：update

```java
import java.sql.*;

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

### 删除记录：delete

```java
import java.sql.*;

//PreparedStatement接口实现数据删除
        String sql = "delete from user where id=?;";
        PreparedStatement pstat = conn.prepareStatement(sql);
        pstat.SetInt(1,1);

//执行sql语句
        int result = pstat.executeUpdate();

//处理结果
        System.out.println("成功执行：" + result + "条数据");

//释放资源
        pstat.close();
        conn.close();
    }
}
```

# 自建JDBC工具类

“获得数据库连接”操作，将在以后的增删改查所有功能中都存在，可以封装工具类JDBCUtils。提供获取连接对象的方法，从而达到代码的重复利用。

该工具类提供方法：`public static Connection getConnection()`

```java
import java.sql.*;

/**
 * 实现JDBC工具类
 * 定义方法，直接返回数据库连接对象
 */
public class JDBCUtils {
    private JDBCUtils(){}
    private static Connection conn;

/**
     * 定义静态方法，返回数据库的连接对象
     */
    public static Connection getConnection(){
        return conn;
    }

if (stat != null){
            try{
                stat.close();
            } catch (SQLException e){
                System.out.println("Statement释放失败！");
            }
        }

if (conn != null){
            try{
                conn.close();
            } catch (SQLException e){
                System.out.println("Connection释放失败！");
            }
        }
    }

```java
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

while (rs.next()){
            System.out.println(rs.getInt("id")+"   "+rs.getString("username"));
        }

JDBCUtils.cloes(conn,pst,rs);
    }
}
```

## 使用properties配置文件

开发中获得连接的4个参数（驱动、URL、用户名、密码）通常都存在配置文件中，方便后期维护，程序如果需要更换数据库，只需要修改配置文件即可。

通常情况下，我们习惯使用properties文件，此文件我们将做如下要求：

### 创建配置文件

在项目根目录下，文件夹”config“，然后再创建文件“db.properties”

```properties
url=jdbc:mysql://localhost:3306/test
user=root
password=123456
```

### 加载配置文件

对应properties文件处理，开发中也使用Properties对象进行。我们将采用加载properties文件获得流，然后使用Properties对象进行处理

```java
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.sql.*;
import java.util.Properties;

/**
     * 定义静态方法，返回数据库的连接对象
     */
    public static Connection getConnection(){
        return conn;
    }

if (stat != null){
            try{
                stat.close();
            } catch (SQLException e){
                System.out.println("Statement释放失败！");
            }
        }

if (conn != null){
            try{
                conn.close();
            } catch (SQLException e){
                System.out.println("Connection释放失败！");
            }
        }
    }

# DBUtils

如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JDBC开发，本案例我们讲采用apache commons组件一个成员：DBUtils。

DBUtils就是JDBC的简化开发工具包。需要项目导入commons-dbutils-1.6.jar才能够正常使用DBUtils工具。

## 驱动下载

官网下载：[https://commons.apache.org/proper/commons-dbutils/download_dbutils](https://commons.apache.org/proper/commons-dbutils/download_dbutils)

![官网下载页面](https://resource.if010.com/jdbc_study_04.png)

这里我们使用[commons-dbutils-1.6-bin](https://resource.if010.com/jar_tools/commons-dbutils-1.6-bin.zip)

## 概述

DBUtils是java编程中的数据库操作实用工具，小巧简单实用，DBUtils封装了对JDBC的操作，简化了JDBC操作，可以少写代码

Dbutils三个核心功能介绍

## QueryRunner核心类

### 实现添加、更新、删除操作

以下示例使用上述提到的JDBCUtils工具类获取数据库连接对象，自定义的工具类传递

#### 插入记录：insert

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

#### 更新记录：update

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner类，实现对数据表的
 *  insert、update、delete
 * 调用QueryRunner类的方法update(Connection conn, String sql, Object...param)
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 */
public class QueryRunnerDemo {
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //定义SQL语句
        String sql = "UPDATE user SET password=? WHERE id=?;";
        //将占位符的实际参数以数组的方式存储
        Object[] param = {"123456", 1};
        //获取数据库连接
        Connection conn = JDBCUtils.getConnection();
        //调用QueryRunner类的方法update执行SQL语句
        int row = queryRunner.update(conn, sql, param);
        //释放资源，并输出执行结果数
        conn.close();
        System.out.println("成功执行：" + row + "条数据");
    }
}
```

#### 删除记录：delete

**如果删除没有符合条件的数据，返回的数字为0**

```java
import org.apache.commons.dbutils.QueryRunner;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 使用QueryRunner类，实现对数据表的
 *  insert、update、delete
 * 调用QueryRunner类的方法update(Connection conn, String sql, Object...param)
 *  Object...param 可变参数，Object类型，为SQL中出现的？占位符进行赋值，没有占位符可不传参数
 */
public class QueryRunnerDemo {
    public static void main(String[] args) throws SQLException {
        //创建QueryRunner对象
        QueryRunner queryRunner = new QueryRunner();
        //定义SQL语句
        String sql = "DELETE from user WHERE id=?;";
        //将占位符的实际参数以数组的方式存储
        Object[] param = {1};
        //获取数据库连接
        Connection conn = JDBCUtils.getConnection();
        //调用QueryRunner类的方法update执行SQL语句
        int row = queryRunner.update(conn, sql, param);
        //释放资源，并输出执行结果数
        conn.close();
        System.out.println("成功执行：" + row + "条数据");
    }
}
```

### 实现查询操作

#### ResultSetHandler结果集处理类

#### JavaBean

JavaBean就是一个类(概念类)，在开发中常用封装数据。具有如下特性

#### ArrayHandler与ArrayListHandler查询

//可以通过数组长度判断是否有结果，如果数据长度为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果数组长度："+result.length);

//输出结果
        for(Object obj : result){
            System.out.print(obj+"\t");
        }
    }

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for(Object[] objs : result){
            for (Object obj : objs) {
                System.out.print(obj+"\t");
            }
            System.out.println();
        }
    }

public static void main(String[] args) throws SQLException {
        arrayHandler();
        arrayListHandler();
    }
}
```

#### BeanHandler与BeanListHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//可以通过对象是否为null判断是否有查询到数据
        if (u == null){
            System.out.println("查询不到相关数据");
        }

//输出结果
        System.out.println(u);
    }

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for(User u : result){
            System.out.println(u);
        }
    }

public static void main(String[] args) throws SQLException {
	beanHandler();
        beanListHandler();
    }
}
```

#### ColumnListHandler与ScalarHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//可以通过集合大小判断是否有结果，如果集合大小为0，则表示无结果，若大于0，则表示有结果
        System.out.println("结果集合大小："+result.size());

//输出结果
        for (Object username : result) {
            System.out.println(username);
        }
    }

//输出结果
        System.out.println(result);
    }

public static void main(String[] args) throws SQLException {
        columnListHandler();
        scalarHandler();
    }
}
```

#### MapHandler与MapListHandler查询

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

//可以通过集合是否为null判断是否有结果,如果为null直接输出，则会报错
        if (result != null){
            System.out.println("结果集合大小："+result.size());

//输出结果
            for (String key : result.keySet()){
                System.out.println(key+":"+result.get(key));
            }
        }
    }

public static void main(String[] args) throws SQLException {
        mapHandler();
        mapListHandler();
    }
}
```

# 连接池

## 连接池概述

### 概念

![JDBC数据库连接池概念图](https://resource.if010.com/jdbc_study_05.png)

### 规范

常见的连接池：DBCP、C3P0

## DBCP连接池开发

DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池

### 驱动下载

Commons-DBCP官网下载：[https://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi](https://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi)

Commons-Pool官网下载：[https://commons.apache.org/proper/commons-dbcp/download_pool.cgi](https://commons.apache.org/proper/commons-dbcp/download_pool.cgi)

Commons-Logging官网下载：[https://commons.apache.org/proper/commons-logging/download_logging.cgi](https://commons.apache.org/proper/commons-logging/download_logging.cgi)

![官网下载页面](https://resource.if010.com/jdbc_study_06.png)

![官网下载页面](https://resource.if010.com/jdbc_study_07.png)

![官网下载页面](https://resource.if010.com/jdbc_study_08.png)

### 常见配置项

参考文档：[http://commons.apache.org/proper/commons-dbcp/configuration.html](http://commons.apache.org/proper/commons-dbcp/configuration.html)

### 编写实现类

```java
import org.apache.commons.dbcp2.BasicDataSource;
import java.sql.Connection;
import java.sql.SQLException;

//调用对象方法getConnection获取数据库连接
        Connection conn = dataSource.getConnection();

}
}
```

### 编写工具类

```java
import org.apache.commons.dbcp2.BasicDataSource;
import javax.sql.DataSource;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Properties;

/**
 * 使用DBCP实现数据库连接池
 * 连接池配置读取db.properties文件
 */
public class JDBCUtils2 {
    private static BasicDataSource dataSource = new BasicDataSource();

public static DataSource getConnection(){
        return dataSource;
    }
}
```

```java
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import java.sql.SQLException;
import java.util.List;

# 关于报错

如果数据库服务没有正常运行连接不上，则会提示以下报错信息：

```java
java.sql.SQLException: Cannot create PoolableConnectionFactory (Communications link failure

如果数据库名称输入有误连接不上，则会提示以下报错信息：

如果数据库连接的用户名或密码输入有误导致连接不上，则会提示以下报错信息：

如果SQL语句中的占位符与传入参数的个数不对，则会提示以下报错信息：

如果SQL语句有错误，或者传入占位符的参数类型与SQL语句不对应，则会提示以下报错信息：

关于BeanHandler中传入的类没有空参构造，则会提示以下报错信息：

关于Java的JDBC编程

Leave a Comment Cancel reply
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

百度云学习资源共享

OpenStack的Windows镜像制作

百度云学习工具资源共享

Oracle单机部署方案

Openstack虚拟机磁盘创建超时

Redis服务入侵记

中创系统生产上线注意事项

Redis的四种部署方案

Openstack虚拟机磁盘创建超时

Linux扩展根分区

关于Java的JDBC编程

Leave a Comment Cancel reply 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

关于Java的JDBC编程

Leave a Comment Cancel reply
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款