Spring+SpringMVC+Mybatis SSM框架详解

一、JDBC编程

1、JDBC 简介

JDBC其实就是 Java 官方提供的一套规范（接口），用于帮助开发人员快速实现不同关系型数据库的连接。

程序运行的时候，数据都是在内存中的。当程序终止的时候，通常都需要将数据保存到磁盘上，无论是保存到本地磁盘，还是通过网络保存到服务器上，最终都会将数据写入磁盘文件。

而如何定义数据的存储格式就是一个大问题。如果我们自己来定义存储格式，比如保存一个班级所有学生的成绩单：

名字	成绩
Michael	99
Bob	85
Bart	59
Lisa	87

你可以用一个文本文件保存，一行保存一个学生，用,隔开：

Michael,99
Bob,85
Bart,59
Lisa,87

你还可以用JSON格式保存，也是文本文件：

[
    {"name":"Michael","score":99},
    {"name":"Bob","score":85},
    {"name":"Bart","score":59},
    {"name":"Lisa","score":87}
]

你还可以定义各种保存格式，但是问题来了：

存储和读取需要自己实现，JSON还是标准，自己定义的格式就各式各样了；

不能做快速查询，只有把数据全部读到内存中才能自己遍历，但有时候数据的大小远远超过了内存（比如蓝光电影，40GB的数据），根本无法全部读入内存。

为了便于程序保存和读取数据，而且，能直接通过条件快速查询到指定的数据，就出现了数据库（Database）这种专门用于集中存储和查询的软件。

数据库软件诞生的历史非常久远，早在1950年数据库就诞生了。经历了网状数据库，层次数据库，我们现在广泛使用的关系数据库是20世纪70年代基于关系模型的基础上诞生的。

关系模型有一套复杂的数学理论，但是从概念上是十分容易理解的。举个学校的例子：

假设某个XX省YY市ZZ县第一实验小学有3个年级，要表示出这3个年级，可以在Excel中用一个表格画出来：

每个年级又有若干个班级，要把所有班级表示出来，可以在Excel中再画一个表格：

这两个表格有个映射关系，就是根据Grade_ID可以在班级表中查找到对应的所有班级：

也就是Grade表的每一行对应Class表的多行，在关系数据库中，这种基于表（Table）的一对多的关系就是关系数据库的基础。

根据某个年级的ID就可以查找所有班级的行，这种查询语句在关系数据库中称为SQL语句，可以写成：

SELECT * FROM classes WHERE grade_id = '1';

结果也是一个表：

---------+----------+----------
grade_id | class_id | name
---------+----------+----------
1        | 11       | 一年级一班
---------+----------+----------
1        | 12       | 一年级二班
---------+----------+----------
1        | 13       | 一年级三班
---------+----------+----------

类似的，Class表的一行记录又可以关联到Student表的多行记录：

使用Java程序访问数据库时，Java代码并不是直接通过TCP连接去访问数据库，而是通过JDBC接口来访问，而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。

例如，我们在Java代码中如果要访问MySQL，那么必须编写代码操作JDBC接口。注意到JDBC接口是Java标准库自带的，所以可以直接编译。而具体的JDBC驱动是由数据库厂商提供的，例如，MySQL的JDBC驱动由Oracle提供。因此，访问某个具体的数据库，我们只需要引入该厂商提供的JDBC驱动，就可以通过JDBC接口来访问，这样保证了Java程序编写的是一套数据库访问代码，却可以访问各种不同的数据库，因为他们都提供了标准的JDBC驱动：

从代码来看，Java标准库自带的JDBC接口其实就是定义了一组接口，而某个具体的JDBC驱动其实就是实现了这些接口的类：

实际上，一个MySQL的JDBC的驱动就是一个jar包，它本身也是纯Java编写的。我们自己编写的代码只需要引用Java标准库提供的java.sql包下面的相关接口，由此再间接地通过MySQL驱动的jar包通过网络访问MySQL服务器，所有复杂的网络通讯都被封装到JDBC驱动中，因此，Java程序本身只需要引入一个MySQL驱动的jar包就可以正常访问MySQL服务器：

使用JDBC的好处是：

各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发；
Java程序编译期仅依赖java.sql包，不依赖具体数据库的jar包；
可随时替换底层数据库，访问数据库的Java代码基本不变。

2、JDBC API

1. JDBC 快速入门

package com.demo;

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1. 导入jar包
        // 2. 注册驱动
        // Class.forName("com.mysql.jdbc.Driver");  // Mysql5 驱动
        Class.forName("com.mysql.cj.jdbc.Driver");  // Mysql8 驱动

        // 3. 获取连接对象
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/world?serverTimezone=UTC", "root", "admin");

        // 4. 获取执行对象
        Statement statement = connection.createStatement();

        // 5. 执行SQL语句，并接收结果
        String sql = "select * from city limit 5";
        ResultSet resultSet = statement.executeQuery(sql);

        // 6. 处理结果
        while(resultSet.next()) {
            System.out.println(resultSet.getString("Name") + "\t" + resultSet.getString("Population"));
        }

        // 7. 释放资源
        statement.close();
        connection.close();
    }
}

2. DriverManager（驱动管理对象）

1）注册驱动（告诉程序该使用哪一个数据库驱动）

注册给定的驱动程序：static void registerDriver(Driver driver);
写代码时使用：Class.forName("com.mysql.jdbc.Driver");
通过查看源码发现：在 com.mysql.jdbc.Driver 类中存在以下静态代码块

static {
    try {
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}

我们不需要通过 DriverManager 调用静态方法 registerDriver，因为只要 Driver 类被使用，则会执行其静态代码块完成注册驱动。
Mysql5 之后可以省略注册驱动的步骤。因为在驱动 jar 包中，存在一个 javasql.Driver 配置文件，文件中指定了 com.mysqljdbc.Driver。

2）获取数据库连接对象

static Connection getConnection(String url, String user, String password);

url：指定连接的路径。语法：jdbc:mysql://ip地址(域名):端口号/库名
user：数据库用户名
password：数据库密码
返回值 Connection：数据库连接对象

3. Connection（数据库连接对象）

获取执行对象
- 获取普通执行对象：Statement createStatement();
- 获取预编译执行对象：PreparedStatement prepareStatement(String sql);
管理事务
- 开启事务：setAutoCommit(boolean autoCommit); // 参数为 false，则开启事务
- 提交事务：commit();
- 回滚事务：rollback();
释放资源
- 立即释放连接对象：void close();

4. Statement（SQL 执行对象）

执行 DML 语句：int executeUpdate(String sql);
- 返回值 int：返回影响的行数。
- 参数 sql：可以执行 insert、update、delete 语句
执行 DQL 语句：ResultSet executeQuery(String sql);
- 返回值 ResultSet：封装查询的结果。
- 参数 sql：可以执行select语句。
释放资源
- 立即释放执行对象：void close();

5. ResultSet（结果集对象）

判断结果集中是否还有数据：boolean next();
- 有数据则返回 true，并将索引向下移动一行
- 没有数据则返回 false
获取结果集中的数据：XXX getXxx("列名");
- XXX 代表要获取的某列数据的类型
- 例如：String getString("name");、int getInt("age");
释放资源
- 立即释放结果集对象：void close();

6. PreparedStatement 预编译

SQL 注入：

SQL 注入演示：在登录界面，输入一个错误的用户名或密码，也可以登录成功。

SQL 注入的原理：

按照正常道理来说，我们在密码处输入的所有内容，都应该作为密码（这个参数）。
但是现在 Statement 对象在执行 SQL 语句时，将输入的内容当做查询条件来执行了。

PreparedStatement 即预编译 SQL 语句的执行对象，是 SQL 注入的防御手段之一。其原理是：在执行 SQL 语句之前，将 SQL 语句进行提前编译，在明确 SQL 语句的格式（执行计划）后，就不会改变了。因此剩余的内容都会认为是参数。

参数使用?作为占位符：

为参数赋值的方法：setXxx(参数 1, 参数 2);
- 参数 1：? 的位置编号（编号从 1 开始）
- 参数 2：? 的实际参数
执行 SQL 语句的方法
- 执行 insert、update、delete 语句：int executeUpdate();
- 执行 select 语句：ResultSet executeQuery();

3、JDBC CRUD

1. JDBC查询

前面我们讲了Java程序要通过JDBC接口来查询数据库。JDBC是一套接口规范，它在哪呢？就在Java的标准库java.sql里放着，不过这里面大部分都是接口。接口并不能直接实例化，而是必须实例化对应的实现类，然后通过接口引用这个实例。那么问题来了：JDBC接口的实现类在哪？

因为JDBC接口并不知道我们要使用哪个数据库，所以，用哪个数据库，我们就去使用哪个数据库的“实现类”，我们把某个数据库实现了JDBC接口的jar包称为JDBC驱动。

因为我们选择了MySQL 5.x作为数据库，所以我们首先得找一个MySQL的JDBC驱动。所谓JDBC驱动，其实就是一个第三方jar包，我们直接添加一个Maven依赖就可以了：


    mysql
    mysql-connector-java
    5.1.47
    runtime

注意到这里添加依赖的scope是runtime，因为编译Java程序并不需要MySQL的这个jar包，只有在运行期才需要使用。如果把runtime改成compile，虽然也能正常编译，但是在IDE里写程序的时候，会多出来一大堆类似com.mysql.jdbc.Connection这样的类，非常容易与Java标准库的JDBC接口混淆，所以坚决不要设置为compile。

有了驱动，我们还要确保MySQL在本机正常运行，并且还需要准备一点数据。这里我们用一个脚本创建数据库和表，然后插入一些数据：

-- 创建数据库learjdbc:
DROP DATABASE IF EXISTS learnjdbc;
CREATE DATABASE learnjdbc;

-- 创建登录用户learn/口令learnpassword
CREATE USER IF NOT EXISTS learn@'%' IDENTIFIED BY 'learnpassword';
GRANT ALL PRIVILEGES ON learnjdbc.* TO learn@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;

-- 创建表students:
USE learnjdbc;
CREATE TABLE students (
  id BIGINT AUTO_INCREMENT NOT NULL,
  name VARCHAR(50) NOT NULL,
  gender TINYINT(1) NOT NULL,
  grade INT NOT NULL,
  score INT NOT NULL,
  PRIMARY KEY(id)
) Engine=INNODB DEFAULT CHARSET=UTF8;

-- 插入初始数据:
INSERT INTO students (name, gender, grade, score) VALUES ('小明', 1, 1, 88);
INSERT INTO students (name, gender, grade, score) VALUES ('小红', 1, 1, 95);
INSERT INTO students (name, gender, grade, score) VALUES ('小军', 0, 1, 93);
INSERT INTO students (name, gender, grade, score) VALUES ('小白', 0, 1, 100);
INSERT INTO students (name, gender, grade, score) VALUES ('小牛', 1, 2, 96);
INSERT INTO students (name, gender, grade, score) VALUES ('小兵', 1, 2, 99);
INSERT INTO students (name, gender, grade, score) VALUES ('小强', 0, 2, 86);
INSERT INTO students (name, gender, grade, score) VALUES ('小乔', 0, 2, 79);
INSERT INTO students (name, gender, grade, score) VALUES ('小青', 1, 3, 85);
INSERT INTO students (name, gender, grade, score) VALUES ('小王', 1, 3, 90);
INSERT INTO students (name, gender, grade, score) VALUES ('小林', 0, 3, 91);
INSERT INTO students (name, gender, grade, score) VALUES ('小贝', 0, 3, 77);

在控制台输入mysql -u root -p，输入root口令后以root身份，把上述SQL贴到控制台执行一遍就行。如果你运行的是最新版MySQL 8.x，需要调整一下CREATE USER语句。

1）JDBC连接

使用JDBC时，我们先了解什么是Connection。Connection代表一个JDBC连接，它相当于Java程序到数据库的连接（通常是TCP连接）。打开一个Connection时，需要准备URL、用户名和口令，才能成功连接到数据库。

URL是由数据库厂商指定的格式，例如，MySQL的URL是：

jdbc:mysql://:/?key1=value1&key2=value2

假设数据库运行在本机localhost，端口使用标准的3306，数据库名称是learnjdbc，那么URL如下：

jdbc:mysql://localhost:3306/learnjdbc?useSSL=false&characterEncoding=utf8

后面的两个参数表示不使用SSL加密，使用UTF-8作为字符编码（注意MySQL的UTF-8是utf8）。

要获取数据库连接，使用如下代码：

// JDBC连接的URL, 不同数据库有不同的格式:
String JDBC_URL = "jdbc:mysql://localhost:3306/test";
String JDBC_USER = "root";
String JDBC_PASSWORD = "password";
// 获取连接:
Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD);
// TODO: 访问数据库...
// 关闭连接:
conn.close();

核心代码是DriverManager提供的静态方法getConnection()。DriverManager会自动扫描classpath，找到所有的JDBC驱动，然后根据我们传入的URL自动挑选一个合适的驱动。

因为JDBC连接是一种昂贵的资源，所以使用后要及时释放。使用try (resource)来自动释放JDBC连接是一个好方法：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    ...
}

2）JDBC查询

获取到JDBC连接后，下一步我们就可以查询数据库了。查询数据库分以下几步：

第一步，通过Connection提供的createStatement()方法创建一个Statement对象，用于执行一个查询；

第二步，执行Statement对象提供的executeQuery("SELECT * FROM students")并传入SQL语句，执行查询并获得返回的结果集，使用ResultSet来引用这个结果集；

第三步，反复调用ResultSet的next()方法并读取每一行结果。

完整查询代码如下：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (Statement stmt = conn.createStatement()) {
        try (ResultSet rs = stmt.executeQuery("SELECT id, grade, name, gender FROM students WHERE gender=1")) {
            while (rs.next()) {
                long id = rs.getLong(1); // 注意：索引从1开始
                long grade = rs.getLong(2);
                String name = rs.getString(3);
                int gender = rs.getInt(4);
            }
        }
    }
}

注意要点：

Statment和ResultSet都是需要关闭的资源，因此嵌套使用try (resource)确保及时关闭；

rs.next()用于判断是否有下一行记录，如果有，将自动把当前行移动到下一行（一开始获得ResultSet时当前行不是第一行）；

ResultSet获取列时，索引从1开始而不是0；

必须根据SELECT的列的对应位置来调用getLong(1)，getString(2)这些方法，否则对应位置的数据类型不对，将报错。

3）SQL注入

使用Statement拼字符串非常容易引发SQL注入的问题，这是因为SQL参数往往是从方法参数传入的。

我们来看一个例子：假设用户登录的验证方法如下：

User login(String name, String pass) {
    ...
    stmt.executeQuery("SELECT * FROM user WHERE login='" + name + "' AND pass='" + pass + "'");
    ...
}

其中，参数name和pass通常都是Web页面输入后由程序接收到的。

如果用户的输入是程序期待的值，就可以拼出正确的SQL。例如：name = "bob"，pass = "1234"：

SELECT * FROM user WHERE login='bob' AND pass='1234'

但是，如果用户的输入是一个精心构造的字符串，就可以拼出意想不到的SQL，这个SQL也是正确的，但它查询的条件不是程序设计的意图。例如：name = "bob' OR pass=", pass = " OR pass='"：

SELECT * FROM user WHERE login='bob' OR pass=' AND pass=' OR pass=''

这个SQL语句执行的时候，根本不用判断口令是否正确，这样一来，登录就形同虚设。

要避免SQL注入攻击，一个办法是针对所有字符串参数进行转义，但是转义很麻烦，而且需要在任何使用SQL的地方增加转义代码。

还有一个办法就是使用PreparedStatement。使用PreparedStatement可以完全避免SQL注入的问题，因为PreparedStatement始终使用?作为占位符，并且把数据连同SQL本身传给数据库，这样可以保证每次传给数据库的SQL语句是相同的，只是占位符的数据不同，还能高效利用数据库本身对查询的缓存。上述登录SQL如果用PreparedStatement可以改写如下：

User login(String name, String pass) {
    ...
    String sql = "SELECT * FROM user WHERE login=? AND pass=?";
    PreparedStatement ps = conn.prepareStatement(sql);
    ps.setObject(1, name);
    ps.setObject(2, pass);
    ...
}

所以，PreparedStatement比Statement更安全，而且更快。

使用Java对数据库进行操作时，必须使用PreparedStatement，严禁任何通过参数拼字符串的代码！

我们把上面使用Statement的代码改为使用PreparedStatement：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (PreparedStatement ps = conn.prepareStatement("SELECT id, grade, name, gender FROM students WHERE gender=? AND grade=?")) {
        ps.setObject(1, "M"); // 注意：索引从1开始
        ps.setObject(2, 3);
        try (ResultSet rs = ps.executeQuery()) {
            while (rs.next()) {
                long id = rs.getLong("id");
                long grade = rs.getLong("grade");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
            }
        }
    }
}

使用PreparedStatement和Statement稍有不同，必须首先调用setObject()设置每个占位符?的值，最后获取的仍然是ResultSet对象。

另外注意到从结果集读取列时，使用String类型的列名比索引要易读，而且不易出错。

注意到JDBC查询的返回值总是ResultSet，即使我们写这样的聚合查询SELECT SUM(score) FROM ...，也需要按结果集读取：

ResultSet rs = ...
if (rs.next()) {
    double sum = rs.getDouble(1);
}

4）数据类型

有的童鞋可能注意到了，使用JDBC的时候，我们需要在Java数据类型和SQL数据类型之间进行转换。JDBC在java.sql.Types定义了一组常量来表示如何映射SQL数据类型，但是平时我们使用的类型通常也就以下几种：

SQL数据类型	Java数据类型
BIT, BOOL	boolean
INTEGER	int
BIGINT	long
REAL	float
FLOAT, DOUBLE	double
CHAR, VARCHAR	String
DECIMAL	BigDecimal
DATE	java.sql.Date, LocalDate
TIME	java.sql.Time, LocalTime

注意：只有最新的JDBC驱动才支持LocalDate和LocalTime。

总结：

JDBC接口的Connection代表一个JDBC连接；

使用JDBC查询时，总是使用PreparedStatement进行查询而不是Statement；

查询结果总是ResultSet，即使使用聚合查询也不例外。

2. JDBC更新

数据库操作总结起来就四个字：增删改查，行话叫CRUD：Create，Retrieve，Update和Delete。

查就是查询，我们已经讲过了，就是使用PreparedStatement进行各种SELECT，然后处理结果集。现在我们来看看如何使用JDBC进行增删改。

1）插入

插入操作是INSERT，即插入一条新记录。通过JDBC进行插入，本质上也是用PreparedStatement执行一条SQL语句，不过最后执行的不是executeQuery()，而是executeUpdate()。示例代码如下：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (PreparedStatement ps = conn.prepareStatement(
            "INSERT INTO students (id, grade, name, gender) VALUES (?,?,?,?)")) {
        ps.setObject(1, 999); // 注意：索引从1开始
        ps.setObject(2, 1); // grade
        ps.setObject(3, "Bob"); // name
        ps.setObject(4, "M"); // gender
        int n = ps.executeUpdate(); // 1
    }
}

设置参数与查询是一样的，有几个?占位符就必须设置对应的参数。虽然Statement也可以执行插入操作，但我们仍然要严格遵循绝不能手动拼SQL字符串的原则，以避免安全漏洞。

当成功执行executeUpdate()后，返回值是int，表示插入的记录数量。此处总是1，因为只插入了一条记录。

2）插入并获取主键

如果数据库的表设置了自增主键，那么在执行INSERT语句时，并不需要指定主键，数据库会自动分配主键。对于使用自增主键的程序，有个额外的步骤，就是如何获取插入后的自增主键的值。

要获取自增主键，不能先插入，再查询。因为两条SQL执行期间可能有别的程序也插入了同一个表。获取自增主键的正确写法是在创建PreparedStatement的时候，指定一个RETURN_GENERATED_KEYS标志位，表示JDBC驱动必须返回插入的自增主键。示例代码如下：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (PreparedStatement ps = conn.prepareStatement(
            "INSERT INTO students (grade, name, gender) VALUES (?,?,?)",
            Statement.RETURN_GENERATED_KEYS)) {
        ps.setObject(1, 1); // grade
        ps.setObject(2, "Bob"); // name
        ps.setObject(3, "M"); // gender
        int n = ps.executeUpdate(); // 1
        try (ResultSet rs = ps.getGeneratedKeys()) {
            if (rs.next()) {
                long id = rs.getLong(1); // 注意：索引从1开始
            }
        }
    }
}

观察上述代码，有两点注意事项：

一是调用prepareStatement()时，第二个参数必须传入常量Statement.RETURN_GENERATED_KEYS，否则JDBC驱动不会返回自增主键；

二是执行executeUpdate()方法后，必须调用getGeneratedKeys()获取一个ResultSet对象，这个对象包含了数据库自动生成的主键的值，读取该对象的每一行来获取自增主键的值。如果一次插入多条记录，那么这个ResultSet对象就会有多行返回值。如果插入时有多列自增，那么ResultSet对象的每一行都会对应多个自增值（自增列不一定必须是主键）。

3）更新

更新操作是UPDATE语句，它可以一次更新若干列的记录。更新操作和插入操作在JDBC代码的层面上实际上没有区别，除了SQL语句不同：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (PreparedStatement ps = conn.prepareStatement("UPDATE students SET name=? WHERE id=?")) {
        ps.setObject(1, "Bob"); // 注意：索引从1开始
        ps.setObject(2, 999);
        int n = ps.executeUpdate(); // 返回更新的行数
    }
}

executeUpdate()返回数据库实际更新的行数。返回结果可能是正数，也可能是0（表示没有任何记录更新）。

4）删除

删除操作是DELETE语句，它可以一次删除若干列。和更新一样，除了SQL语句不同外，JDBC代码都是相同的：

try (Connection conn = DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASSWORD)) {
    try (PreparedStatement ps = conn.prepareStatement("DELETE FROM students WHERE id=?")) {
        ps.setObject(1, 999); // 注意：索引从1开始
        int n = ps.executeUpdate(); // 删除的行数
    }
}

总结：

使用JDBC执行INSERT、UPDATE和DELETE都可视为更新操作；

更新操作使用PreparedStatement的executeUpdate()进行，返回受影响的行数。

3. JDBC事务

数据库事务（Transaction）是由若干个SQL语句构成的一个操作序列，有点类似于Java的synchronized同步。数据库系统保证在一个事务中的所有SQL要么全部执行成功，要么全部不执行，即数据库事务具有ACID特性：

Atomicity：原子性
Consistency：一致性
Isolation：隔离性
Durability：持久性

数据库事务可以并发执行，而数据库系统从效率考虑，对事务定义了不同的隔离级别。SQL标准定义了4种隔离级别，分别对应可能出现的数据不一致的情况：

Isolation Level	脏读（Dirty Read）	不可重复读（Non Repeatable Read）	幻读（Phantom Read）
Read Uncommitted	Yes	Yes	Yes
Read Committed	-	Yes	Yes
Repeatable Read	-	-	Yes
Serializable	-	-	-

对应用程序来说，数据库事务非常重要，很多运行着关键任务的应用程序，都必须依赖数据库事务保证程序的结果正常。

举个例子：假设小明准备给小红支付100，两人在数据库中的记录主键分别是123和456，那么用两条SQL语句操作如下：

UPDATE accounts SET balance = balance - 100 WHERE id = 123 AND balance >= 100;
UPDATE accounts SET balance = balance + 100 WHERE id = 456;

这两条语句必须以事务方式执行才能保证业务的正确性，因为一旦第一条SQL执行成功而第二条SQL失败的话，系统的钱就会凭空减少100，而有了事务，要么这笔转账成功，要么转账失败，双方账户的钱都不变。

要在JDBC中执行事务，本质上就是如何把多条SQL包裹在一个数据库事务中执行。我们来看JDBC的事务代码：

Connection conn = openConnection();
try {
    // 关闭自动提交:
    conn.setAutoCommit(false);
    // 执行多条SQL语句:
    insert(); update(); delete();
    // 提交事务:
    conn.commit();
} catch (SQLException e) {
    // 回滚事务:
    conn.rollback();
} finally {
    conn.setAutoCommit(true);
    conn.close();
}

其中，开启事务的关键代码是conn.setAutoCommit(false)，表示关闭自动提交。提交事务的代码在执行完指定的若干条SQL语句后，调用conn.commit()。要注意事务不是总能成功，如果事务提交失败，会抛出SQL异常（也可能在执行SQL语句的时候就抛出了），此时我们必须捕获并调用conn.rollback()回滚事务。最后，在finally中通过conn.setAutoCommit(true)把Connection对象的状态恢复到初始值。

实际上，默认情况下，我们获取到Connection连接后，总是处于“自动提交”模式，也就是每执行一条SQL都是作为事务自动执行的，这也是为什么前面几节我们的更新操作总能成功的原因：因为默认有这种“隐式事务”。只要关闭了Connection的autoCommit，那么就可以在一个事务中执行多条语句，事务以commit()方法结束。

如果要设定事务的隔离级别，可以使用如下代码：

// 设定隔离级别为READ COMMITTED:
conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

如果没有调用上述方法，那么会使用数据库的默认隔离级别。MySQL的默认隔离级别是REPEATABLE_READ。

数据库事务（Transaction）具有ACID特性：

Atomicity：原子性
Consistency：一致性
Isolation：隔离性
Durability：持久性

JDBC提供了事务的支持，使用Connection可以开启、提交或回滚事务。

4. JDBC Batch

使用JDBC操作数据库的时候，经常会执行一些批量操作。

例如，一次性给会员增加可用优惠券若干，我们可以执行以下SQL代码：

INSERT INTO coupons (user_id, type, expires) VALUES (123, 'DISCOUNT', '2030-12-31');
INSERT INTO coupons (user_id, type, expires) VALUES (234, 'DISCOUNT', '2030-12-31');
INSERT INTO coupons (user_id, type, expires) VALUES (345, 'DISCOUNT', '2030-12-31');
INSERT INTO coupons (user_id, type, expires) VALUES (456, 'DISCOUNT', '2030-12-31');
...

实际上执行JDBC时，因为只有占位符参数不同，所以SQL实际上是一样的：

for (var params : paramsList) {
    PreparedStatement ps = conn.preparedStatement("INSERT INTO coupons (user_id, type, expires) VALUES (?,?,?)");
    ps.setLong(params.get(0));
    ps.setString(params.get(1));
    ps.setString(params.get(2));
    ps.executeUpdate();
}

类似的还有，给每个员工薪水增加10%～30%：

UPDATE employees SET salary = salary * ? WHERE id = ?

通过一个循环来执行每个PreparedStatement虽然可行，但是性能很低。SQL数据库对SQL语句相同，但只有参数不同的若干语句可以作为batch执行，即批量执行，这种操作有特别优化，速度远远快于循环执行每个SQL。

在JDBC代码中，我们可以利用SQL数据库的这一特性，把同一个SQL但参数不同的若干次操作合并为一个batch执行。我们以批量插入为例，示例代码如下：

try (PreparedStatement ps = conn.prepareStatement("INSERT INTO students (name, gender, grade, score) VALUES (?, ?, ?, ?)")) {
    // 对同一个PreparedStatement反复设置参数并调用addBatch():
    for (Student s : students) {
        ps.setString(1, s.name);
        ps.setBoolean(2, s.gender);
        ps.setInt(3, s.grade);
        ps.setInt(4, s.score);
        ps.addBatch(); // 添加到batch
    }
    // 执行batch:
    int[] ns = ps.executeBatch();
    for (int n : ns) {
        System.out.println(n + " inserted."); // batch中每个SQL执行的结果数量
    }
}

执行batch和执行一个SQL不同点在于，需要对同一个PreparedStatement反复设置参数并调用addBatch()，这样就相当于给一个SQL加上了多组参数，相当于变成了“多行”SQL。

第二个不同点是调用的不是executeUpdate()，而是executeBatch()，因为我们设置了多组参数，相应地，返回结果也是多个int值，因此返回类型是int[]，循环int[]数组即可获取每组参数执行后影响的结果数量。

总结：

使用JDBC的batch操作会大大提高执行效率，对内容相同，参数不同的SQL，要优先考虑batch操作。

4、JDBC 案例

1. student 表

-- 创建student表
CREATE TABLE student(
    sid INT PRIMARY KEY AUTO_INCREMENT,  -- 学生id
    NAME VARCHAR(20),  -- 学生姓名
    age INT,  -- 学生年龄
    birthday DATE  -- 学生生日
);

-- 添加数据
INSERT INTO student VALUES (NULL,'张三',23,'1999-09-23'), (NULL,'李四',24,'1998-08-10'), (NULL,'王五',25,'1996-06-06'), (NULL,'赵六',26,'1994-10-20');

2. JDBC 配置信息

config.properties：

driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/world?serverTimezone=UTC
username=root
password=admin

3. domain 实体类

Student 实体类：

package com.bean;

import java.util.Date;

public class Student {

    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;

    public Student() {
    }

    public Student(Integer sid, String name, Integer age, Date birthday) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

4. JDBC 工具类

package com.utils;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

// JDBC 工具类
public class JdbcUtil {

    // 私有构造方法
    private JdbcUtil(){}

    // 声明所需要的配置变量
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;
    private static Connection connection;

    // 静态代码块：读取配置文件的信息为变量赋值，注册驱动
    static {
        try{
            // 读取配置文件
            InputStream resourceAsStream = JdbcUtil.class.getClassLoader().getResourceAsStream("config.properties");
            Properties properties = new Properties();
            properties.load(resourceAsStream);
            // 赋值
            driverClass = properties.getProperty("driverClass");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            // 注册驱动
            Class.forName(driverClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取数据库连接对象
    public static Connection getConnection() {
        try {
            connection = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    // 释放资源
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 释放资源
    public static void close(Connection connection, Statement statement) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

5. Dao 层

StudentDao.java：

package com.dao;

import com.bean.Student;

import java.util.ArrayList;

// Dao层接口
public interface StudentDao {
    // 查询所有学生信息
    public abstract ArrayList findAll();

    // 根据id条件查询
    public abstract Student findById(Integer id);

    // 新增学生信息
    public abstract int insert(Student student);

    // 修改学生信息
    public abstract int update(Student student);

    // 根据id删除学生信息
    public abstract int delete(Integer id);
}

StudentDaoImpl.java：

package com.dao;

import com.bean.Student;
import com.utils.JdbcUtil;

import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;


public class StudentDaoImpl implements StudentDao{

    // 查询所有学生信息
    @Override
    public ArrayList findAll() {
        ArrayList studentList = new ArrayList<>();
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            connection = JdbcUtil.getConnection();
            String sql = "select * from student";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            // 处理结果集
            while (resultSet.next()) {
                Integer sid = resultSet.getInt("sid");
                String name = resultSet.getString("name");
                Integer age = resultSet.getInt("age");
                Date birthday = resultSet.getDate("birthday");
                // 封装Student对象
                Student student = new Student(sid, name, age, birthday);
                // 将student对象保存到集合中
                studentList.add(student);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            JdbcUtil.close(connection, statement, resultSet);
        }
        // 返回集合对象
        return studentList;
    }

    // 条件查询，根据id查询学生信息
    @Override
    public Student findById(Integer id) {
        Student student = new Student();
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtil.getConnection();
            String sql = "select * from student where sid=?";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, id);
            resultSet = preparedStatement.executeQuery();
            // 处理结果集
            while (resultSet.next()) {
                Integer sid = resultSet.getInt("sid");
                String name = resultSet.getString("name");
                Integer age = resultSet.getInt("age");
                Date birthday = resultSet.getDate("birthday");
                // 封装Student对象
                student.setSid(sid);
                student.setName(name);
                student.setAge(age);
                student.setBirthday(birthday);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(connection, statement, resultSet);
        }
        return student;
    }

    // 添加学生信息
    @Override
    public int insert(Student student) {
        Connection connection = null;
        Statement statement = null;
        int result = 0;
        try {
            connection = JdbcUtil.getConnection();
            Date raw_birthday = student.getBirthday();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            String birthday = simpleDateFormat.format(raw_birthday);
            String sql = "insert into student (sid, name, age, birthday) values (?, ?, ?, ?)";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, student.getSid());
            preparedStatement.setString(2, student.getName());
            preparedStatement.setInt(3, student.getAge());
            preparedStatement.setDate(4, (java.sql.Date) student.getBirthday());
            result = preparedStatement.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(connection, statement);
        }
        return result;
    }

    // 修改学生信息
    @Override
    public int update(Student student) {
        Connection connection = null;
        Statement statement = null;
        int result = 0;
        try {
            connection = JdbcUtil.getConnection();
            Date raw_birthday = student.getBirthday();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            String birthday = simpleDateFormat.format(raw_birthday);
            String sql = "UPDATE student SET name=?, age=?, birthday=? WHERE sid=?";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, student.getName());
            preparedStatement.setInt(2, student.getAge());
            preparedStatement.setDate(3, (java.sql.Date) student.getBirthday());
            result = preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(connection, statement);
        }
        return result;
    }

    @Override
    public int delete(Integer id) {
        Connection connection = null;
        Statement statement = null;
        int result = 0;
        try {
            connection = JdbcUtil.getConnection();
            String sql = "delete from student where sid=?";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, id);
            result = preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.close(connection, statement);
        }
        return result;
    }
}

6. Service 层

StudentService.java：

package com.service;

import com.bean.Student;

import java.util.ArrayList;

// service 层接口
public interface StudentService {
    //查询所有学生信息
    public abstract ArrayList findAll();

    //条件查询，根据id获取学生信息
    public abstract Student findById(Integer id);

    //新增学生信息
    public abstract int insert(Student student);

    //修改学生信息
    public abstract int update(Student student);

    //删除学生信息
    public abstract int delete(Integer id);
}

StudentServiceImpl.java：

package com.service;

import com.bean.Student;
import com.dao.StudentDao;
import com.dao.StudentDaoImpl;

import java.util.ArrayList;

public class StudentServiceImpl implements StudentService {

    private StudentDao dao = new StudentDaoImpl();

    // 查询所有学生信息
    @Override
    public ArrayList findAll() {
        return dao.findAll();
    }

    // 根据id查询指定学生信息
    @Override
    public Student findById(Integer id) {
        return dao.findById(id);
    }

    // 添加学生信息
    @Override
    public int insert(Student student) {
        return dao.insert(student);
    }

    // 修改学生信息
    @Override
    public int update(Student student) {
        return dao.update(student);
    }

    // 删除学生信息
    @Override
    public int delete(Integer id) {
        return dao.delete(id);
    }
}

7. Controller 层

StudentController.java：

package com.controller;

import com.bean.Student;
import com.service.StudentService;
import com.service.StudentServiceImpl;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Date;

public class StudentController {

    private StudentService studentService = new StudentServiceImpl();

    // 查询所有学生信息
    @Test
    public void findAll() {
        ArrayList studentList = studentService.findAll();
        for (Student student: studentList) {
            System.out.println(student);
        }
    }

    // 根据id查询指定学生信息
    @Test
    public void findById() {
        Student student = studentService.findById(3);
        System.out.println("查询成功: "+student);
    }

    // 添加学生信息
    @Test
    public void insert() {
        Student student = new Student(5, "陈七", 19, new Date());
        int result = studentService.insert(student);
        if (result != 0) {
            System.out.println("学生信息添加成功！");
        } else {
            System.out.println("学生信息添加失败！");
        }
    }

    // 修改学生信息
    @Test
    public void update() {
        Student student = studentService.findById(1);
        student.setName("xiaoji");
        int result = studentService.update(student);
        if (result != 0) {
            System.out.println("学生信息修改成功！");
        } else {
            System.out.println("学生信息修改失败！");
        }
    }

    // 删除学生信息
    @Test
    public void delete() {
        int result = studentService.delete(1);
        if (result != 0) {
            System.out.println("学生信息删除成功！");
        } else {
            System.out.println("学生信息删除失败！");
        }
    }
}

5、JDBC事务管理

事务一般在 service 层控制管理，因为事务一般与业务耦合，而不是与通用的 dao 层耦合。

Service 接口

import java.util.List;

public interface UserService {
    /**
     * 批量添加
     * @param users
     */
    void batchAdd(List users);
}

ServiceImpl 实现类

@Override
public void batchAdd(List users) {
    // 获取数据库连接
    Connection connection = JDBCUtils.getConnection();
    try {
        // 开启事务
        connection.setAutoCommit(false);
        for (User user : users) {
            // 1.创建ID，并把UUID中的-替换
            String uid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
            // 2.给user的uid赋值
            user.setUid(uid);
            // 3.生成员工编号
            user.setUcode(uid);

            // 手动模拟异常
            //int n = 1 / 0;

            // 4.保存
            userDao.save(connection,user);
        }
        // 提交事务
        connection.commit();
    }catch (Exception e){
        try {
            // 若遇到异常，回滚事务
            connection.rollback();
        }catch (Exception ex){
            ex.printStackTrace();
        }
        e.printStackTrace();
    } finally {
        JDBCUtils.close(connection,null,null);
    }
}

6、JDBC 连接池

创建线程是一个昂贵的操作，如果有大量的小任务需要执行，并且频繁地创建和销毁线程，实际上会消耗大量的系统资源，往往创建和消耗线程所耗费的时间比执行任务的时间还长，所以，为了提高效率，可以用线程池。

类似的，在执行JDBC的增删改查的操作时，如果每一次操作都来一次打开连接，操作，关闭连接，那么创建和销毁JDBC连接的开销就太大了。为了避免频繁地创建和销毁JDBC连接，我们可以通过连接池（Connection Pool）复用已经创建好的连接。

数据库连接池是一种复用Connection的组件，它可以避免反复创建新连接，提高JDBC代码的运行效率。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。这项技术能解决建立数据库连接耗费资源和时间的问题，明显提高对数据库操作的性能。

数据库连接池原理：

JDBC连接池有一个标准的接口javax.sql.DataSource，注意这个类位于Java标准库中，但仅仅是接口。要使用JDBC连接池，我们必须选择一个JDBC连接池的实现。

常用的JDBC连接池有：

HikariCP
C3P0
BoneCP
Druid

1. HikariCP

目前使用最广泛的是HikariCP。我们以HikariCP为例，要使用JDBC连接池，先添加HikariCP的依赖如下：


    com.zaxxer
    HikariCP
    2.7.1

紧接着，我们需要创建一个DataSource实例，这个实例就是连接池：

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("password");
config.addDataSourceProperty("connectionTimeout", "1000"); // 连接超时：1秒
config.addDataSourceProperty("idleTimeout", "60000"); // 空闲超时：60秒
config.addDataSourceProperty("maximumPoolSize", "10"); // 最大连接数：10
DataSource ds = new HikariDataSource(config);

注意创建DataSource也是一个非常昂贵的操作，所以通常DataSource实例总是作为一个全局变量存储，并贯穿整个应用程序的生命周期。

有了连接池以后，我们如何使用它呢？和前面的代码类似，只是获取Connection时，把DriverManage.getConnection()改为ds.getConnection()：

try (Connection conn = ds.getConnection()) { // 在此获取连接
    ...
} // 在此“关闭”连接

通过连接池获取连接时，并不需要指定JDBC的相关URL、用户名、口令等信息，因为这些信息已经存储在连接池内部了（创建HikariDataSource时传入的HikariConfig持有这些信息）。一开始，连接池内部并没有连接，所以，第一次调用ds.getConnection()，会迫使连接池内部先创建一个Connection，再返回给客户端使用。当我们调用conn.close()方法时（在try(resource){...}结束处），不是真正“关闭”连接，而是释放到连接池中，以便下次获取连接时能直接返回。

因此，连接池内部维护了若干个Connection实例，如果调用ds.getConnection()，就选择一个空闲连接，并标记它为“正在使用”然后返回，如果对Connection调用close()，那么就把连接再次标记为“空闲”从而等待下次调用。这样一来，我们就通过连接池维护了少量连接，但可以频繁地执行大量的SQL语句。

通常连接池提供了大量的参数可以配置，例如，维护的最小、最大活动连接数，指定一个连接在空闲一段时间后自动关闭等，需要根据应用程序的负载合理地配置这些参数。此外，大多数连接池都提供了详细的实时状态以便进行监控。

2. C3P0

C3P0 是一个开源的 JDBC 连接池，使用它的开源项目有 Hibernate、Spring 等。

使用步骤：

导入 jar 包
导入配置文件（c3p0-config.xml，文件名不可改）到 src 目录下
创建 c3p0 连接池对象
获取数据库连接进行使用

使用示例：

c3p0-config.xml


  
  
  	
    com.mysql.jdbc.Driver
    jdbc:mysql://localhost:3306/world
    root
    admin
    
    
    
    5
    
    10
    
    3000
  

  
   
    
    com.mysql.jdbc.Driver
    jdbc:mysql://localhost:3306/world
    root
    admin
    
    
    5
    8
    1000

测试类

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Test {

    public static void main(String[] args) throws SQLException {
        // 创建c3p0连接池对象
        DataSource dataSource = new ComboPooledDataSource();

        // 获取数据库连接进行使用
        Connection con = dataSource.getConnection();

        // 查询全部学生信息
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();

        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        // 释放资源
        rs.close();
        pst.close();
        con.close();  // 将连接对象归还池中
    }
}

* **优化：抽取工具类**
~~~java
package com.itheima.util;

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

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util {
    // 得到一个数据源
    private static DataSource dataSource = new ComboPooledDataSource();
    
    
    public static DataSource getDataSource() {
        return dataSource;
    }

    //从数据源中得到一个连接对象
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException("服务器错误");
        }
    }
    
    public static void close(Connection conn, Statement stmt, ResultSet rs){
        // 关闭资源
        if(rs!=null){
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            stmt = null;
        }
        if(conn!=null){
            try {
                conn.close(); 
            } catch (Exception e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}

3. Druid

数据库连接池有很多选择，C3P0、DHCP 等，阿里巴巴开源的 druid 作为一名后起之秀，凭借其出色的性能，也逐渐印入了大家的眼帘。

Druid 基本概念及架构介绍

使用步骤：

导入 jar 包
通过 Properties 集合加载配置文件
通过 Druid 连接池工厂类获取数据库连接池对象
获取数据库连接，进行使用

示例：

druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/world
username=root
password=itheima
# 初始化连接数量
initialSize=5
# 最大连接数量
maxActive=10
# 超时时间
maxWait=3000

测试类

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class DruidTest {
    public static void main(String[] args) throws Exception {
        // 通过Properties集合加载配置文件
        InputStream is = DruidTest.class.getClassLoader().getResourceAsStream("druid.properties");
        Properties prop = new Properties();
        prop.load(is);

        // 通过Druid连接池工厂类获取数据库连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        // 获取数据库连接，进行使用
        Connection con = dataSource.getConnection();

        // 查询全部学生信息
        String sql = "SELECT * FROM student";
        PreparedStatement pst = con.prepareStatement(sql);
        ResultSet rs = pst.executeQuery();

        while(rs.next()) {
            System.out.println(rs.getInt("sid") + "\t" + rs.getString("name") + "\t" + rs.getInt("age") + "\t" + rs.getDate("birthday"));
        }

        // 释放资源
        rs.close();
        pst.close();
        con.close();    // 将连接对象归还池中
    }
}

优化：抽取工具类

public class DataSourceUtils {

    // 1.私有构造方法
    private DataSourceUtils(){}

    // 2.定义DataSource数据源变量
    private static DataSource dataSource;

    // 3.提供静态代码块，完成配置文件的加载和获取连接池对象
    static {
        try{
            // 加载配置文件
            InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
            Properties prop = new Properties();
            prop.load(is);

            // 获取数据库连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(prop);

        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 4.提供获取数据库连接的方法
    public static Connection getConnection() {
        Connection con = null;
        try {
            con = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }

    // 5.提供获取数据库连接池的方法
    public static DataSource getDataSource() {
        return dataSource;
    }

    // 6.提供DQL释放资源的方法
    public static void close(Connection con, Statement stat, ResultSet rs) {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(stat != null) {
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 提供DML释放资源的方法
    public static void close(Connection con, Statement stat) {
        close(con, stat, null);
    }
}

7、DBUtils

1. DBUtils 介绍

什么是 DBUtils ？

DBUtils 是 Apache 开源的 Java 编程中的数据库操作实用工具，小巧简单实用。

DBUtils 封装了对 JDBC 的操作，简化了 JDBC 操作，可以少写代码。

对于数据表的读操作，他可以把结果转换成 List、Array、Set 等 Java 集合，便于程序员操作。
对于数据表的写操作，也变得很简单（只需写 SQL 语句）。
可以使用数据源，使用 JNDI，数据库连接池等技术来优化性能--重用已经构建好的数据库连接对象。

DBUtils 的三个核心对象：

QueryRunner 类：提供对 SQL 语句操作的 API，它主要有三个方法：
- `query()：用于执行 select
- update()：用于执行 insert、update、delete
- batch()：批处理
ResultSetHandler 接口：用于定义 select 操作后怎样封装结果集。
DbUtils 类：一个工具类，定义了关闭资源与事务处理的方法。

2. 使用案例

DBUtils 使用步骤：

导入 jar 包
- c3p0-0.9.1.2.jar（其他连接对象均可）
- commons-logging-1.1.1.jar
- commons-beanutils-1.8.3.jar
- commons-dbutils-1.4.jar
创建 QueryRunner 对象
使用 query 方法执行 select 语句
使用 ResultSetHandler 封装结果集
使用 DbUtils 类释放资源

3. QueryRunner 类（执行对象）

构造函数：

new QueryRunner();
- 其事务可以手动控制。
- 此对象调用的方法（如 query、update、batrch）参数中要有 Connection 对象。
new QueryRunner(DataSource ds);
- 其事务是自动控制的（一个 SQL 一个事务）。
- 此对象调用的方法（如 query、update、batrch）参数中无需 Connection 对象。

示例：

C3P0Util.java

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

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util {
    // 得到一个数据源
    private static DataSource dataSource = new ComboPooledDataSource();


    public static DataSource getDataSource() {
        return dataSource;
    }

    //从数据源中得到一个连接对象
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException("服务器错误");
        }
    }

    public static void close(Connection conn, Statement stmt, ResultSet rs){
        // 关闭资源
        if(rs!=null){
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if(stmt!=null){
            try {
                stmt.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            stmt = null;
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }

}

DBUtil

import com.bean.Student;
import org.apache.commons.dbutils.QueryRunner;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.dbutils.ResultSetHandler;
import org.junit.jupiter.api.Test;
import org.apache.commons.dbutils.handlers.BeanListHandler;

public class DBUtil {

    @Test
    public void testDQL1() throws SQLException{
        //创建一个QueryRunner对象
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        //执行查询语句，并返回结果
        List list = qr.query("select * from student where sid=? and name=?", new BeanListHandler(Student.class), 3, "王五");
        for (Student student : list) {
            System.out.println(student);
        }
    }

    @Test
    public void testDQL2() throws SQLException{
        // 创建一个QueryRunner对象
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        List list = qr.query("select * from student", new ResultSetHandler>(){
            // 当query方法执行完select语句，就会将结果集以参数的形式传递进来
            public List handle(ResultSet rs) throws SQLException {
                List list  = new ArrayList();
                while(rs.next()){
                    Student student = new Student();
                    student.setSid(rs.getInt(1));
                    student.setName(rs.getString(2));
                    student.setAge(rs.getInt(3));
                    student.setBirthday(rs.getDate(4));
                    list.add(student);
                }
                return list;
            }
        });
        for (Student student : list) {
            System.out.println(student);
        }
    }

    @Test
    public void testDML() throws SQLException{
        //创建一个QueryRunner对象
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        // 返回影响行数
        qr.update("insert into student (sid,name,age,birthday) values(?,?,?,?)", "6", "王八", "4", new Date());
    }

    @Test
    public void testBatchDQL() throws SQLException{
        //创建一个QueryRunner对象
        QueryRunner qr = new QueryRunner(C3P0Util.getDataSource());
        Object[][] params = new Object[10][];  // 高维代表执行次数；低维代表
        for (int i=0; i<10; i++) {
            params[i] = new Object[]{10+i, "菜"+i, 10+i, new Date()};
        }
        // 返回影响行数
        qr.batch("insert into student (sid,name,age,birthday) values(?,?,?,?)", params);
    }

}

4. ResultSetHandler 接口（结果集对象）

ResultSetHandler 下的所有结果处理器：

对象名	说明
ArrayHandler	适合取 1 条记录。把该条记录的每列值封装到一个 Object[] 中
ArrayListHandler	适合取多条记录。把每条记录的每列值封装到一个 Object[] 中，再把数组封装到一个 List 中
ColumnListHandler	取某一列的数据。把该条记录的每列值封装到 List 中
KeyedHandler	取多条记录。每一条记录封装到一个 Map 中，再把这个 Map 封装到另外一个 Map 中，key 为指定的字段值
MapHandler	适合取1条记录。把当前记录的列名和列值放到一个 Map 中
MapListHandler	适合取多条记录。把每条记录封装到一个 Map 中，再把 Map 封装到 List 中
ScalarHandler	适合取单行单列数据
BeanHandler	取第一行数据
BeanListHandler	将每个数据封装到 List 集合中

示例：

import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import org.junit.Test;

public class ResultSetHandler {
     //ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
     @Test
     public void test1() throws SQLException {
          QueryRunner qr = new QueryRunner(c3p0.getDataSource());
          Object[] arr = qr.query("select * from users where id =?",new ArrayHandler(),5);
          for (Object o : arr) {
              System.out.println(o);
          }
     }

     //ArrayListHandler:适合取多条记录。把每条记录的每列值封装到一个数组中Object[]，把数组封装到一个List中
     @Test
     public void test2() throws SQLException {
          QueryRunner qr = new QueryRunner(c3p0.getDataSource());
          List list = qr.query("select * from users",new ArrayListHandler());
          for (Object[] o : list) {
              for(Object os : o){
                   System.out.println(os);
              }
              System.out.println("---------");
          }
     }
     
     //ColumnListHandler:取某一列的数据,封装到List中。
     @Test
     public void test3() throws SQLException {
          QueryRunner qr = new QueryRunner(c3p0.getDataSource());
          //参数的列数是指select语句中列的数
          List

注解	说明
@Component	使用在类上用于实例化 Bean
@Controller	使用在 web 层类上用于实例化 Bean
@Service	使用在 service 层类上用于实例化 Bean
@Repository	使用在 dao 层类上用于实例化 Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合 @Autowired 一起使用，用于根据名称进行依赖注入引用类型
@Resource	相当于 @Autowired + @Qualifier，按照名称进行注入引用类型
@Value	注入普通类型的属性
@Scope	标注 Bean 的作用范围
@PostConstruct	使用在方法上标注该方法是 Bean 的初始化方法
@PreDestroy	使用在方法上标注该方法是 Bean 的销毁方法

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解。用于指定 Spring 在初始化容器时要扫描的包。
@ComponentScan	作用和在 Spring 的 xml 配置文件中的一样。
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中。
@PropertySource	用于加载 .properties 文件中的配置。
@Import	用于导入其他配置类。

名称	标签	说明
前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	aop:after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	aop:around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都会执行
异常抛出通知	aop:throwing	用于配置异常执出通知。指定增强的方法在出现异常时执行
最终通知	aop:after	用于配置最终通知。无论增强方式执行是否有异常都会执行

名称	注解	说明
切面	@Aspect	标注切面类
AOP 自动代理	@EnableAspectJAutoProxy	设置 Spring 注解配置类开启 AOP 注解驱动的支持，加载AOP注解
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行
切点表达式抽取	@Pointcut	可以引用已抽取的切点表达式

数据类型	示例	格式
操作是否成功	true / false	格式 A
基本数据	数值、字符串	格式 B
对象数据	json 对象	格式 C
集合数据	json 数组	格式 D

Spring+SpringMVC+Mybatis SSM框架详解

一、JDBC编程

1、JDBC 简介

2、JDBC API

3、JDBC CRUD

4、JDBC 案例

5、JDBC事务管理

6、JDBC 连接池

7、DBUtils

二、Mybatis

1、Mybatis 简介

2、MyBatis API

3、Mybatis 入门案例

4、输入/输出映射详解

5、Mybatis Mapper 代理

6、动态 SQL

7、分页插件

8、Mybatis 多表操作

9、Mybatis 注解

三、Spring IOC

1、Spring 框架简介

2、Spring IoC

3、入门案例

4、IoC 配置

四、Spring 注解

1、注解简介

2、常用注解

3、整合第三方技术

4、IoC底层核心原理

五、Spring AOP

1、Spring AOP 简介

2、AOP 配置

3、AOP 注解使用

六、Spring 事务

1、Spring 事务核心对象

2、事务控制方式

3、事务传播行为

4、Spring 模板对象

5、Spring 事务底层原理

七、SpringMVC

1、SpringMVC 简介

2、SpringMVC 基础配置

3、请求

4、响应

5、Servlet 相关接口

6、异步调用

7、拦截器

8、异常处理

9、文件上传

10、Restful

11、表单校验框架

八、Spring开发实战

1、配置Spring MVC

2、编写Controller

3、使用REST

4、集成Filter

九、SSM框架整合案例

1、整合流程

2、环境准备

3、配置文件+注解开发

4、纯注解开发

5、Maven配置

你可能感兴趣的:(JavaEE,Spring,微信小程序,项目架构,mybatis,spring,java)