『JavaWeb』JDBC编程

本篇博客主要介绍JDBC的简单使用。

什么是JDBC

---

JDBC，即Java DataBase Connectivity，Java数据库连接。是一种用于执行SQL语句的Java API，它是Java中的数据库连接规范。这个API由java.sql.*，javax.sql.*包中的一些类和接口组成，它为Java开发人员操作数据库提供了一个标准的API，可以为多种关系型数据库提供统一访问。

数据库编程必备条件

---

• 编程语言：如Java、C++、Python等；
• 数据库：如MySQL、Oracle、SQL Server等；
• 数据库驱动包：不同的数据库，对应不同的编程语言提供了不同的数据库驱动包，如：MySQL提供了Java的驱动包mysql-connector-java，如果需要使用Java操作MySQL则需要该驱动包。同样的，如果要操作Oracle数据库则需要Oracle数据库驱动包。

JDBC工作原理

---

JDBC为多种数据库提供了统一访问方式，作为特定厂商数据库访问API的一种高级抽象，它主要包含一些通用的接口类。
JDBC访问数据库层次结构：

JDBC优势

---

• Java语言访问数据库操作完全面向抽象接口编程；
• 开发数据库应用不用限定在特定数据库厂商的API；
• 程序的可移植性大大增强。

JDBC的简单使用

---

首先，我们准备数据库驱动包，并添加到项目的依赖中。
MySQL数据库驱动包
在项目中创建文件夹lib，并将依赖包mysql-connector-java-5.1.47.jar复制到lib中；右键项目选择Open Modules Settings；

点击Dependencies，然后点击右边的加号，选择JARs or directiories…

选择前面拷贝到lib中的.jar文件，然后点击Apply，最后点击OK。

然后，我们建立一个数据库连接。

// 加载JDBC驱动程序：反射，这样调用初始化com.mysql.jdbc.Driver类
// 即将该类加载到JVM方法区，并执行该类的静态方法块、静态属性
Class.forName("com.mysql.jdbc.Driver");

// 创建数据库连接
// MySQL数据库连接的URL参数格式如下：
// jbdc:mysql://服务器地址:端口号/数据库名?参数名=参数值
Connection connection = DriverManager.getConnection(url, user, password);

然后，我们创建操作命令。

Statement statement = connection.createStatement();

然后，我们执行SQL语句。

ResultSet resultSet = statement.executeQuery(
	"select id, name from student"
);

最后，我们来处理结果集。

while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");

    System.out.printf("id: %d, name: %s\n", id, name);
}

还有，不要忘了释放资源。

// 关闭结果集
if (resultSet != null) {
	try {
		resultSet.close();
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

// 关闭命令
if (statement != null) {
	try {
		statement.close();
	} catch (SQLExecption e) {
		e.printStackTrace();
	}
}

// 关闭连接命令
if (connection != null) {
	try {
		connection.close();
	} catch (SQLExecption e) {
		e.printStackTrace();
	}
}

完整代码如下：

import java.sql.*;

public class Test {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false";
    private static final String USER_NAME = "root";
    private static final String PASSWORD = "1";

    public static void main(String[] args) {

        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

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

                connection = DriverManager.getConnection(URL, USER_NAME, PASSWORD);
                statement = connection.createStatement();

                String sql = "select id, name from student";
                resultSet = statement.executeQuery(sql);
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");

                    System.out.printf("id: %d, name: %s\n", id, name);
                }
            } finally {
                if (resultSet != null)
                    resultSet.close();
                if (statement != null)
                    statement.close();
                if (connection != null)
                    connection.close();
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

JDBC使用步骤总结如下

---

• 创建数据库连接connection；
• 创建操作命令Statement；
• 使用操作命令来执行SQL；
• 处理结果集ResultSet；
• 释放资源。

两种创建数据库连接的方式

---

通过DriverManager（驱动管理类）的静态方法获取

---

我们直接来看代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false";
    private static final String USER_NAME = "root";
    private static final String PASSWORD = "1";

    public static Connection getConnection() {
        Connection connection = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection(URL, USER_NAME, PASSWORD);
            return connection;
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库连接失败");
    }
}

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection();
                statement = connection.createStatement();

                String sql = "select id, name from student";

                resultSet = statement.executeQuery(sql);
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");

                    System.out.printf("id: %d, name: %s\n", id, name);
                }
            } finally {
                if (resultSet != null)
                    resultSet.close();
                if (statement != null)
                    statement.close();
                if (connection != null)
                    connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

通过DataSource对象获取

---

通过DataSource获取，要求是同一个DataSource对象，所以这里，我们有两种实现方式：

使用静态属性的方式实现

---

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class DBUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false";
    private static final String USER_NAME = "root";
    private static final String PASSWORD = "1";

    private static DataSource dataSource = new MysqlDataSource();
    static {
        ((MysqlDataSource)dataSource).setUrl(URL);
        ((MysqlDataSource)dataSource).setUser(USER_NAME);
        ((MysqlDataSource)dataSource).setPassword(PASSWORD);
    }

    public static Connection getConnection() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库连接失败");
    }
}

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection();
                statement = connection.createStatement();

                String sql = "select id, name from student";

                resultSet = statement.executeQuery(sql);
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");

                    System.out.printf("id: %d, name: %s\n", id, name);
                }
            } finally {
                if (resultSet != null)
                    resultSet.close();
                if (statement != null)
                    statement.close();
                if (connection != null)
                    connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

使用单例模式实现

---

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;

public class DBUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/java12?useSSL=false";
    private static final String USER_NAME = "root";
    private static final String PASSWORD = "1";

    private DBUtil() {}

    private static DataSource dataSource = null;

    public static DataSource getDataSource() {
        if (dataSource == null) {
            dataSource = new MysqlDataSource();
            ((MysqlDataSource)dataSource).setUrl(URL);
            ((MysqlDataSource)dataSource).setUser(USER_NAME);
            ((MysqlDataSource)dataSource).setPassword(PASSWORD);
        }
        return dataSource;
    }
}

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                DataSource dataSource = DBUtil.getDataSource();
                connection = dataSource.getConnection();
                statement = connection.createStatement();

                String sql = "select id, name from student";

                resultSet = statement.executeQuery(sql);
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");

                    System.out.printf("id: %d, name: %s\n", id, name);
                }
            } finally {
                if (resultSet != null)
                    resultSet.close();
                if (statement != null)
                    statement.close();
                if (connection != null)
                    connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

两种方式的区别

---

• 使用DriverManager类来获取的Connection连接，是无法重复利用的，每次使用完以后释放资源时，通过connection.close()都是关闭物理连接；
• DataSource提供连接池的支持。连接池在初始化时将创建一定量的数据库连接，这些连接是可以重复利用的，每次使用完数据库连接，释放资源调用connection.close()都是将Connection连接对象回收。

DBUtil类

---

我们设计一个DBUtil类用来获取数据库连接。包含上述几种方式：

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;

import javax.sql.DataSource;
import java.sql.*;

public class DBUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false";
    private static final String USER_NAME = "root";
    private static final String PASSWORD = "1";

    public static Connection getConnection1() {
        Connection connection = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection(URL, USER_NAME, PASSWORD);
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库连接失败");
    }

    private static DataSource dataSource = new MysqlDataSource();
    static {
        ((MysqlDataSource)dataSource).setUrl(URL);
        ((MysqlDataSource)dataSource).setUser(USER_NAME);
        ((MysqlDataSource)dataSource).setPassword(PASSWORD);
    }
    public static Connection getConnection2() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库连接失败");
    }

    private DBUtil() {}
    private static DataSource dataSource2 = null;
    public static DataSource getDataSource() {
        if (dataSource2 == null) {
            dataSource2 = new MysqlDataSource();
            ((MysqlDataSource)dataSource2).setUrl(URL);
            ((MysqlDataSource)dataSource2).setUser(USER_NAME);
            ((MysqlDataSource)dataSource2).setPassword(PASSWORD);
        }

        return dataSource2;
    }

    public static void Close(Connection connection, Statement statement, ResultSet resultSet) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("数据库资源释放失败");
        }
    }
}

可以看到，我们在DBUtil类中添加了一个Close方法，该方法用来关闭数据库的一些资源在数据库不再使用的时候。
因为前面的关闭是有问题的，假如resultSet.close()操作抛了异常，那么后续的两个关闭操作将不会被执行，此时就会造成资源泄露。因此我们在DBUtil中封装一个方法专门用来释放资源，如果中间有资源释放失败，就向上层抛一个运行时异常来提醒调用者资源释放失败。

JDBC常用的接口和类

---

Statement对象

---

Statement对象主要是将SQL语句发送到数据库中。JDBC API中主要提供了三种Statement对象：

• Statement：用于执行不带参数的简单SQL语句；
• PreparedStatement：用于执行带或者不带参数的SQL语句；SQL语句会预编译在数据库系统；执行速度快于Statement对象；
• CallableStatement：用于执行数据库存储过程的调用。

SQL注入问题

---

下面我们来封装一个类，用户可以通过传入一个姓名然后就可以获得一个指定姓名的信息。

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Query {
    public static void main(String[] args) {
        query("范庄元");
    }

    public static void query(String stuName) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                statement = connection.createStatement();
                String sql = "select id, name, chinese, math, english " +
                        "from exam_result where name='" + stuName + "'";
                resultSet = statement.executeQuery(sql);

                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    BigDecimal chinese = resultSet.getBigDecimal("chinese");
                    BigDecimal math = resultSet.getBigDecimal("math");
                    BigDecimal english = resultSet.getBigDecimal("english");

                    System.out.printf("(%s)[%s]{%s, %s, %s}\n", id, name, chinese, math, english);
                }
            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

从代码可以看出，借助query方法我们可以通过传入一个姓名来获得该学生的信息，但是这个query方法是有问题的，我们来将代码修改一下，来观察一下：

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Query {
    public static void main(String[] args) {
        query("范庄元' or '1' = '1");
    }

    public static void query(String stuName) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                statement = connection.createStatement();
                String sql = "select id, name, chinese, math, english " +
                        "from exam_result where name='" + stuName + "'";
                resultSet = statement.executeQuery(sql);

                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    BigDecimal chinese = resultSet.getBigDecimal("chinese");
                    BigDecimal math = resultSet.getBigDecimal("math");
                    BigDecimal english = resultSet.getBigDecimal("english");

                    System.out.printf("(%s)[%s]{%s, %s, %s}\n", id, name, chinese, math, english);
                }
            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

可以看到我们通过传入"范庄元' or '1' = '1"这么一个字符串就会导致查询到表中所有的数据，这种问题我们称之为SQL注入。

什么是SQL注入？

• SQL注入是将Web页面的原URL、表单域或数据包输入的参数，修改拼接成SQL语句，传递给Web服务器，进而传给数据库服务器以执行数据库命令；
• 如果Web应用程序的开发人员对用户输入的数据或cookie等内容不进行过滤或验证（即存在注入点）就直接传输给数据库，就可能导致拼接的SQL被执行，获取数据库的信息或对数据库的提权，发生SQL注入攻击。

如何解决上述问题呢？我们可以使用PreparedStatement，下面来看代码：

import java.math.BigDecimal;
import java.sql.*;

public class Query {
    public static void main(String[] args) {
        query("范庄元' or '1'='1");
    }

    public static void query(String stuName) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                String sql = "select id, name, chinese, math, english " +
                        "from exam_result where name=?";
                // 此处会讲SQL语句送往数据库进行预编译
                statement = connection.prepareStatement(sql);
                statement.setString(1, stuName);

                resultSet = statement.executeQuery();

                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String name = resultSet.getString("name");
                    BigDecimal chinese = resultSet.getBigDecimal("chinese");
                    BigDecimal math = resultSet.getBigDecimal("math");
                    BigDecimal english = resultSet.getBigDecimal("english");

                    System.out.printf("(%s)[%s]{%s, %s, %s}\n", id, name, chinese, math, english);
                }
            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

此时就解决了上述的问题。

ResultSet对象

---

ResultSet对象被称为结加粗样式果集，它代表符合SQL语句条件的所有行，并且它通过一套getXXX方法提供了对这些行中数据的访问。可以将它理解成List<Map<String, Object>> ；
ResultSet里的数据一行一行排列，每行有多个字段，并且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。我们如果想要取得某一条记录，就要使用ResultSet的next()方法，如果我们想要得到ResultSet里的所有记录，就应该使用while循环。

两种执行SQL的方法

---

• executeQuery()方法执行后返回结果集，通常用于select语句；
• executeUpdate()方法返回值是一个整数，指示受影响的行数，通常用于update、insert、delete语句。

下面我们封装三个类来方便实现insert、update、delete操作：

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

public class Insert {
    public static void main(String[] args) {
        insert(9, "张欣", 99, 99, 99);
    }

    public static void insert(
        int stdId, String stuName,
        int stuChinese, int stuMath, int stuEnglish
    ) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                String sql = "insert into exam_result(id, name, chinese, math, english) " +
                        "values (?, ?, ?, ?, ?)";
                statement = connection.prepareStatement(sql);
                statement.setInt(1, stdId);
                statement.setString(2, stuName);
                statement.setInt(3, stuChinese);
                statement.setInt(4, stuMath);
                statement.setInt(5, stuEnglish);

                int ret = statement.executeUpdate();

                if (ret == 1) {
                    System.out.printf("Insert Successful, %d row affected!", ret);
                }

            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

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

public class Update {
    public static void main(String[] args) {
        update("张蔚澜", 66, 66, 66);
    }

    public static void update(
            String stuName, int stuChinese, int stuMath, int stuEnglish
    ) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                String sql = "update exam_result " +
                        "set chinese = ?, math = ?, english = ? " +
                        "where name = ?";
                statement = connection.prepareStatement(sql);
                statement.setInt(1, stuChinese);
                statement.setInt(2, stuMath);
                statement.setInt(3, stuEnglish);
                statement.setString(4, stuName);

                int ret = statement.executeUpdate();

                if (ret == 1) {
                    System.out.printf("Update Successful, %d row affected!", ret);
                }

            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

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

public class Delete {
    public static void main(String[] args) {
        delete("张欣");
    }

    public static void delete(String stuName) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            try {
                connection = DBUtil.getConnection2();
                String sql = "delete from exam_result where name = ?";
                statement = connection.prepareStatement(sql);
                statement.setString(1, stuName);

                int ret = statement.executeUpdate();

                if (ret == 1) {
                    System.out.printf("Delete Successful, %d row affected!", ret);
                }

            } finally {
                DBUtil.Close(connection, statement, resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}