一、JDBC 概述
1、JDBC基本介绍
JDBC为访问不同的数据库提统一的接口（Java的接口编程），为使用者屏蔽了细节问题。Java程序员使用JDBC，可以连接任何提供了JDBC驱动程序的数据库系统，如MySQL，Oracle，db2等，从而完成对数据库的各种操作。
2、模拟JDBC接口编程
//规定的jdbc接口(方法)----模拟Java对数据库厂家提供的接口
public interface JdbcInterface {
//连接方法
public Object getConnection() ;
//crud操作方法
public void crud();
//关闭连接方法
public void close();
}//mysql 数据库实现了jdbc接口 [模拟] 【mysql厂商开发】
public class MysqlJdbcImpl implements JdbcInterface{
@Override
public Object getConnection() {
System.out.println("得到 mysql 的连接");
return null;
}
@Override
public void crud() {
System.out.println("完成 mysql 增删改查");
}
@Override
public void close() {
System.out.println("关闭 mysql 的连接");
}
//模拟oracle数据库实现 jdbc
public class OracleJdbcImpl implements JdbcInterface {
@Override
public Object getConnection() {
System.out.println("得到 oracle的连接 升级");
return null;
}
@Override
public void crud() {
System.out.println("完成 对oracle的增删改查");
}
@Override
public void close() {
System.out.println("关闭 oracle的连接");
}
}import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.util.Scanner;
public class TestJDBC {
public static void main(String[] args) throws Exception {
//完成对mysql的操作
JdbcInterface jdbcInterface = new MysqlJdbcImpl();
jdbcInterface.getConnection(); //通过接口来调用实现类[动态绑定]
jdbcInterface.crud();
jdbcInterface.close();
//完成对oracle的操作
System.out.println("==============================");
jdbcInterface = new OracleJdbcImpl();
jdbcInterface.getConnection(); //通过接口来调用实现类[动态绑定]
jdbcInterface.crud();
jdbcInterface.close();
}
}3、JDBC 带来的好处
JDBC是Java提供的一套用于数据库操作的接口API，Java程序员只需要面向这套接口编程即可，提供不同厂家数据库的实现。
二、JDBC快速入门
1、JDBC 程序编写步骤
1、注册驱动--加载Driver类
2、获取连接--得到Connection对象
3、执行增删改查--发送SQL给MySQL执行
4、释放资源--关闭相关连接
2、JDBC 第一个程序
//第一个Jdbc 程序，完成简单的操作
public class Jdbc01 {
public static void main(String[] args) throws SQLException {
//前置工作： 在项目下创建一个文件夹比如 libs
// 将 mysql.jar 拷贝到该目录下，点击 add to project ..加入到项目中
//1. 注册驱动
Driver driver = new Driver(); //创建driver对象
//2. 得到连接
//(1) jdbc:mysql:// 规定好表示协议，通过jdbc的方式连接mysql
//(2) localhost 主机，可以是ip地址
//(3) 3306 表示mysql监听的端口
//(4) study_db01 连接到mysql dbms 的哪个数据库
//(5) mysql的连接本质就是socket连接
String url = "jdbc:mysql://localhost:3306/study_db01";
//将 用户名和密码放入到Properties 对象
Properties properties = new Properties();
//说明 user 和 password 是规定好，后面的值根据实际情况写
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "123"); //密码
Connection connect = driver.connect(url, properties);
//3. 执行sql
String sql = "insert into actor values(null, '刘德华', '男', '1970-11-11', '110')";
String sq2 = "update actor set name='周星驰' where id = 1";
String sq3 = "delete from actor where id = 1";
//statement 用于执行静态SQL语句并返回其生成的结果的对象
Statement statement = connect.createStatement();
int rows = statement.executeUpdate(sql); // 如果是 dml语句，返回的就是影响行数
System.out.println(rows > 0 ? "成功" : "失败");
//4. 关闭连接资源
statement.close();
connect.close();
}
}注意：
1、连接对象connect是由驱动对象driver.connect()方法实现，返回的是Connection类型的对象。需要指定哪个数据库的表以及用哪个用户和密码登录数据库。
2、connect对象和数据库建立连接后，调用connect.createStatement(url, properties)返回一个Statement对象statement对象就是用于执行SQL语句的。
statement.executeUpdate(sql)执行增删改语句，insert、update、delete
statement.executeQuery(sql)执行查找语句，select
3、需要关闭的资源有：statement和connect
3、获取JDBC连接的物种方式
3.1、连接方式一
public void connect01() throws SQLException {
Driver driver = new Driver(); //创建driver对象
String url = "jdbc:mysql://localhost:3306/studt_db01";
//将 用户名和密码放入到Properties 对象
Properties properties = new Properties();
//说明 user 和 password 是规定好，后面的值根据实际情况写
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "123"); //密码
Connection connect = driver.connect(url, properties);
System.out.println(connect);
}3.2、连接方式二
public void connect02() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
//使用反射加载Driver类 , 动态加载，更加的灵活，减少依赖性
Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver)aClass.newInstance();
String url = "jdbc:mysql://localhost:3306/study_db01";
//将 用户名和密码放入到Properties 对象
Properties properties = new Properties();
//说明 user 和 password 是规定好，后面的值根据实际情况写
properties.setProperty("user", "root");// 用户
properties.setProperty("password", "123"); //密码
Connection connect = driver.connect(url, properties);
System.out.println("方式2=" + connect);
}3.3、连接方式三
//方式3 使用DriverManager 替代 driver 进行统一管理
@Test
public void connect03() throws IllegalAccessException, InstantiationException, ClassNotFoundException, SQLException {
//使用反射加载Driver
Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver) aClass.newInstance();
//创建url 和 user 和 password
String url = "jdbc:mysql://localhost:3306/study_db01";
String user = "root";
String password = "123";
DriverManager.registerDriver(driver);//注册Driver驱动
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("第三种方式=" + connection);
}3.4、连接方式四
//方式4: 使用Class.forName 自动完成注册驱动，简化代码
//这种方式获取连接是使用的最多，推荐使用
@Test
public void connect04() throws ClassNotFoundException, SQLException {
//使用反射加载了 Driver类
//在加载 Driver类时，完成注册
/*
源码: 1. 静态代码块，在类加载时，会执行一次.
2. DriverManager.registerDriver(new Driver());
3. 因此注册driver的工作已经完成
static {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
*/
Class.forName("com.mysql.jdbc.Driver");
//创建url 和 user 和 password
String url = "jdbc:mysql://localhost:3306/study_db01";
String user = "root";
String password = "123";
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("第4种方式~ " + connection);
}3.5、连接方式五
//方式5 , 在方式4的基础上改进，增加配置文件，让连接mysql更加灵活
@Test
public void connect05() throws IOException, ClassNotFoundException, SQLException {
//通过Properties对象获取配置文件的信息
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//获取相关的值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
Class.forName(driver);//建议写上
Connection connection = DriverManager.getConnection(url, user, password);
System.out.println("方式5 " + connection);
}总结：
1、无论哪种方法最后都将实例化出一个Connection。
2、对于方式1，2中使用实例化出的Driver对象driver调用：
Connection connection =driver.connect(url,properties)
---用户名和密码由properties中的user和password对应的值决定（使用setProperty()实现设置ser和password对应的值）
3、对于方式3，4，5中使用DriverManager 替代 driver 进行统一管理：
DriverManager.registerDriver(driver);//注册Driver驱动，可以省略，因加载Driver类时会执行静态代码块，实现驱动自动注册。
Connection connection = DriverManager.getConnection(url, user, password);
其中的url，user和password由配置文件mysql.properties进行配置，只需要通过输入流读取并完成赋值。
//通过Properties对象获取配置文件的信息 Properties properties = new Properties(); properties.load(new FileInputStream("src\\mysql.properties")); //获取相关的值 String user = properties.getProperty("user"); String password = properties.getProperty("password"); String driver = properties.getProperty("driver"); String url = properties.getProperty("url");
mysql.properties文件配置：
4、ResultSet[结果集]
以上介绍的是对MySQL的DML操作，下面开始DQL查询操作，查询的内容放在结果集中ResultSet[结果集]
4.1、ResultSet[结果集]基本介绍
1、表示数据库结果集的数据表，通常通过执行查询数据库的语句生成【select】
2、ResultSet对象保持一个光标指向当前数据行，最初光标是位于第一行之前的。
3、next()方法将光标移动到下一行，并且由于再ResultSet对象中没有更多行时返回false，因此可以再while循环中使用循环来遍历结果（类似于集合中的迭代器iterator）
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
/**
* 演示select 语句返回 ResultSet ,并取出结果
*/
@SuppressWarnings({"all"})
public class ResultSet_ {
public static void main(String[] args) throws Exception {
//通过Properties对象获取配置文件的信息
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//获取相关的值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
//1. 注册驱动
Class.forName(driver);//建议写上
//2. 得到连接
Connection connection = DriverManager.getConnection(url, user, password);
//3. 得到Statement
Statement statement = connection.createStatement();
//4. 组织SqL
String sql1 = "insert into actor values(null, '刘德华', '男', '1970-11-11', '110')";
String sql2 = "insert into actor values(null, 'jack', '男', '1990-11-11', '110')";
String sql3 = "delete from actor";
// statement.executeUpdate(sql1);
// statement.executeUpdate(sql2);
// statement.executeUpdate(sql3);
String sql = "select id, name , sex, borndate from actor";
//执行给定的SQL语句，该语句返回单个 ResultSet对象
/*
+----+-----------+-----+---------------------+
| id | name | sex | borndate |
+----+-----------+-----+---------------------+-------+
| 4 | 刘德华 | 男 | 1970-12-12 00:00:00 |
| 5 | jack | 男 | 1990-11-11 00:00:00 |
+----+-----------+-----+---------------------+-------+
*/
/*
阅读debug 代码 resultSet 对象的结构
*/
ResultSet resultSet = statement.executeQuery(sql);
//5. 使用while取出数据
while (resultSet.next()) { // 让光标向后移动，如果没有更多行，则返回false
int id = resultSet.getInt(1); //获取该行的第1列
//int id1 = resultSet.getInt("id"); 通过列名来获取值, 推荐
String name = resultSet.getString(2);//获取该行的第2列
String sex = resultSet.getString(3);
Date date = resultSet.getDate(4);
System.out.println(id + "\t" + name + "\t" + sex + "\t" + date);
}
//6. 关闭连接
resultSet.close();
statement.close();
connection.close();
}
}5、Statement
5.1、Statement基本介绍与SQL注入问题
1、Statement对象用于执行静态SQL语句并返回其生成事务结果对象
Statement statement = connection.createStatement();
2、在建立连接DriverManager.getConnection(url,user,password)后，需要对数据库进行访问，执行命令或是SQL语句，可以通过Statement【存在SQL注入问题】
使用PrepareStatement预处理或者CallableStatement存储过程替换Statemen
3、Statement对象执行SQL语句，存在SQL注入风险
4、SQL注入是利用某些系统没有对用户输入数据进行充分检查，而在用户输入数据中注入非法的SQL语句段或命令，恶意攻击数据库【Statement执行的SQL语句要到的String“+”拼接】
5、要防范SQL注入，只要用PrepareStatement（从Statement扩展而来）取代Statement就可以了
-- 演示 sql 注入
-- 创建一张表
CREATE TABLE admin ( -- 管理员表
NAME VARCHAR(32) NOT NULL UNIQUE,
pwd VARCHAR(32) NOT NULL DEFAULT '') CHARACTER SET utf8; -- 添加数据
INSERT INTO admin VALUES('tom', '123'); -- 查找某个管理是否存在
SELECT *FROM admin
WHERE NAME = 'tom' AND pwd = '123
-- 输入用户名 为 1' or
-- 输入万能密码 为 or '1'= '1
SELECT * FROM admin
WHERE NAME = '1' OR' AND pwd = 'OR '1'= '1'
SELECT * FROM admin
当用户名输入的是： 1' or
用户密码输入的是: or '1'= '1
也能登录成功因为使用Statement在执行SQL语句，组织SQL语句是用的+号拼接String，可能会造成一定侵入破坏，该情况发生SQL注入问题。-----组织SQL语句不使用+号拼接：PrepareStatement
5.2、PreparedStatement介绍
String sql = "select * from admin where username = ? and password = ?";1、PreparedStatement执行的SQL语句中的参数用问号(?)来表示，调用PreparedStatement对象的setXxx()方法来对第几个问号(?)设置参数。setXxx()方法有两个参数，第一个参数是要设置的SQL语句中参数的索引（从1开始，即第几个问号？），第二个参数是设置SQL语句中参数的值。
2、调用executeUpdate()：执行更新，包括增删改
3、调用executeQuery()：返回ResultSet对象
预处理好处：
1、不再使用——拼接SQL语句，减少语法错误
2、有效的解决了SQL注入问题
3、大大减少了编译次数，效率较高
使用代码：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;
/**
* 演示PreparedStatement使用
*/
@SuppressWarnings({"all"})
public class PreparedStatement_ {
public static void main(String[] args) throws Exception {
//看 PreparedStatement类图
Scanner scanner = new Scanner(System.in);
//让用户输入管理员名和密码
System.out.print("请输入管理员的名字: "); //next(): 当接收到 空格或者 '就是表示结束
String admin_name = scanner.nextLine(); // 说明，如果希望看到SQL注入，这里需要用nextLine
System.out.print("请输入管理员的密码: ");
String admin_pwd = scanner.nextLine();
//通过Properties对象获取配置文件的信息
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//获取相关的值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
//1. 注册驱动
Class.forName(driver);//建议写上
//2. 得到连接
Connection connection = DriverManager.getConnection(url, user, password);
//3. 得到PreparedStatement
//3.1 组织SqL , Sql 语句的 ? 就相当于占位符
String sql = "select name , pwd from admin where name =? and pwd = ?";
//3.2 preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//3.3 给 ? 赋值
preparedStatement.setString(1, admin_name);
preparedStatement.setString(2, admin_pwd);
//4. 执行 select 语句使用 executeQuery
// 如果执行的是 dml(update, insert ,delete) executeUpdate()
// 这里执行 executeQuery ,不要在写 sql
ResultSet resultSet = preparedStatement.executeQuery(sql);
if (resultSet.next()) { //如果查询到一条记录，则说明该管理存在
System.out.println("恭喜， 登录成功");
} else {
System.out.println("对不起，登录失败");
}
//关闭连接
resultSet.close();
preparedStatement.close();
connection.close();
}
}PreparedStatement preparedStatement = connection.prepareStatement(sql);依然使用connection返回PreparedStatement对象，但是需要与SQL语句关联。
给SQL语句中的问号赋值：
preparedStatement.setString(1, admin_name);
preparedStatement.setString(2, admin_pwd)
// 使用preparedStatement做SQL的DML增删改语句
String sql1 = "insert into admin values(?, ?)";
//String sql2 = "update admin set pwd = ? where name = ?";
//String sql3 = "delete from admin where name = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql1);
preparedStatement.setString(1,"admin")
preparedStatement.setString(2,"123")
//返回的是影响sql语句的行数
int rows = preparedStatement.executeUpdate();
问题：1、每次都要建立一次连接
2、结果集遍历之后以关闭就不能用了
3、SQL语句只能一个一个送进去，问号也只能修改一个语句的几个位置（两条SQL语句都会有1。。。），虽然通过connection.prepareStatement（sql）关联了，但需要多建立几个PreparedStatement对象分别赋值
有没有解决办法？
6、JDBC 的相关 API 小结
三、封装JDBC工具类
1、工具类 JDBCUtils
在JDBC操作中，获取连接和释放资源是经常用到的，可以将其封装JDBC连接的工具类JDBCUtils。
1、连接参数：使用Properties配置文件加载
2、驱动注册：Class.forName(driver)建议写上-------driver = properties.getProperty("driver");
3、得到连接：Return DriverManager.getConnection(url,user,password)返回 Connection对象。
其中url,user,password都可以通过Properties配置文件加载，如同上driver
关闭连接：可能会涉及到ResultSet结果集、PrepareStatement执行SQL、Connection连接
动态绑定机制
public static void close(ResultSet set, Statement statement, Connection connection)可以传入PrepareStatement对象遵循动态绑定机制if(xx not null ){
xx.close();
}
工具类 JDBCUtils代码：
//工具类
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
/**
* 这是一个工具类，完成 mysql的连接和关闭资源
*/
public class JDBCUtils {
//定义相关的属性(4个), 因为只需要一份，因此，我们做成static
private static String user; //用户名
private static String password; //密码
private static String url; //url
private static String driver; //驱动名
//在static代码块去初始化
static {
try {
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//读取相关的属性值
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
} catch (IOException e) {
//在实际开发中，可以这样处理
//1. 将编译异常转成 运行异常
//2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
throw new RuntimeException(e);
}
}
//连接数据库, 返回Connection
public static Connection getConnection() {
try {
return DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
//1. 将编译异常转成 运行异常
//2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便.
throw new RuntimeException(e);
}
}
//关闭相关资源
/*
1. ResultSet 结果集
2. Statement 或者 PreparedStatement
3. Connection
4. 如果需要关闭资源，就传入对象，否则传入 null
*/
public static void close(ResultSet set, Statement statement, Connection connection) {
//判断是否为null
try {
if (set != null) {
set.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
//将编译异常转成运行异常抛出
throw new RuntimeException(e);
}
}
}工具类 JDBCUtils类使用：
import org.junit.jupiter.api.Test;
import java.sql.*;
/**
* 该类演示如何使用JDBCUtils工具类，完成dml 和 select
*/
public class JDBCUtils_Use {
@Test
public void testSelect() {
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "select * from actor where id = ?";
PreparedStatement preparedStatement = null;
ResultSet set = null;
//3. 创建PreparedStatement 对象
try {
connection = JDBCUtils.getConnection();
System.out.println(connection.getClass()); //com.mysql.jdbc.JDBC4Connection
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 1);//给?号赋值
//执行, 得到结果集
set = preparedStatement.executeQuery();
//遍历该结果集
while (set.next()) {
int id = set.getInt("id");
String name = set.getString("name");
String sex = set.getString("sex");
Date borndate = set.getDate("borndate");
String phone = set.getString("phone");
System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(set, preparedStatement, connection);
}
}
@Test
public void testDML() {//insert , update, delete
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "update actor set name = ? where id = ?";
// 测试 delete 和 insert .
PreparedStatement preparedStatement = null;
//3. 创建PreparedStatement 对象
try {
connection = JDBCUtils.getConnection();
preparedStatement = connection.prepareStatement(sql);
//给占位符赋值
preparedStatement.setString(1, "周星驰");
preparedStatement.setInt(2, 4);
//执行
preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(null, preparedStatement, connection);
}
}
}三、事务
1、事务基本介绍
1、JDBC程序中，当一个Connextion对象创建时，默认情况下时自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
2、JDBC程序中为了让多个SQL语句作为一个整体执行，需要使用事务。
3、调用Connection的setAutoCommit(false)可以取消自动提交事务。
4、在所有的SQL语句都执行成功后，调用Connection的commit()方法提交事务
5、在其中某个操作失败或者异常时，调用Connection的rollback()方法回滚事务
public void useTransaction() {
//操作转账的业务
//1. 得到连接
Connection connection = null;
//2. 组织一个sql
String sql = "update account set balance = balance - 100 where id = 1";
String sql2 = "update account set balance = balance + 100 where id = 2";
PreparedStatement preparedStatement = null;
//3. 创建PreparedStatement 对象
try {
connection = JDBCUtils.getConnection(); // 在默认情况下，connection是默认自动提交
//将 connection 设置为不自动提交
connection.setAutoCommit(false); //开启了事务
preparedStatement = connection.prepareStatement(sql);
preparedStatement.executeUpdate(); // 执行第1条sql
int i = 1 / 0; //抛出异常
preparedStatement = connection.prepareStatement(sql2);
preparedStatement.executeUpdate(); // 执行第3条sql
//这里提交事务
connection.commit();
} catch (SQLException e) {
//这里我们可以进行回滚，即撤销执行的SQL
//默认回滚到事务开始的状态.
System.out.println("执行发生了异常，撤销执行的sql");
try {
connection.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
e.printStackTrace();
} finally {
//关闭资源
JDBCUtils.close(null, preparedStatement, connection);
}
}四、批处理
1、基本介绍
1、当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许许多语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率。
2、JDBC的批量处理语句包括：
addBatch():添加需要批量处理的SQL语句或参数
executeBatch()：执行批量处理包
clearBatch():清空批处理包的语句
3、JDBC连接MySQL时，如果要使用批处理功能，请在url中加入参数
?rewriteBatchedStatements=true
4、批处理往往和PreparedStatement一起搭配使用，可以减少编译次数和运行次数，效率大大提高。
import com.hspedu.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* 演示java的批处理
*/
public class Batch_ {
//传统方法，添加5000条数据到admin
@Test
public void noBatch() throws Exception {
Connection connection = JDBCUtils.getConnection();
String sql = "insert into admin values(null, ?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
System.out.println("开始执行");
long start = System.currentTimeMillis();//开始时间
for (int i = 0; i < 5000; i++) {//5000执行
preparedStatement.setString(1, "jack" + i);
preparedStatement.setString(2, "666");
preparedStatement.executeUpdate();
}
long end = System.currentTimeMillis();
System.out.println("传统的方式 耗时=" + (end - start));//传统的方式 耗时=10702
//关闭连接
JDBCUtils.close(null, preparedStatement, connection);
}
//使用批量方式添加数据
@Test
public void batch() throws Exception {
Connection connection = JDBCUtils.getConnection();
String sql = "insert into admin values(null, ?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
System.out.println("开始执行");
long start = System.currentTimeMillis();//开始时间
for (int i = 0; i < 5000; i++) {//5000执行
preparedStatement.setString(1, "jack" + i);
preparedStatement.setString(2, "666");
//将sql 语句加入到批处理包中 -> 看源码
/*
//1. //第一就创建 ArrayList - elementData => Object[]
//2. elementData => Object[] 就会存放我们预处理的sql语句
//3. 当elementData满后,就按照1.5扩容
//4. 当添加到指定的值后，就executeBatch
//5. 批量处理会减少我们发送sql语句的网络开销，而且减少编译次数，因此效率提高
public void addBatch() throws SQLException {
synchronized(this.checkClosed().getConnectionMutex()) {
if (this.batchedArgs == null) {
this.batchedArgs = new ArrayList();
}
for(int i = 0; i < this.parameterValues.length; ++i) {
this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
}
this.batchedArgs.add(new PreparedStatement.BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
}
}
*/
preparedStatement.addBatch();
//当有1000条记录时，在批量执行
if((i + 1) % 1000 == 0) {//满1000条sql
preparedStatement.executeBatch();
//清空一把
preparedStatement.clearBatch();
}
}
long end = System.currentTimeMillis();
System.out.println("批量方式 耗时=" + (end - start));//批量方式 耗时=108
//关闭连接
JDBCUtils.close(null, preparedStatement, connection);
}
}
1458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
