JDBC
该文档是:JDBC的使用
日期:2020-11-26
1. JDBC概述
2. JDBC的本质
本质其实就是SUN公司把接口规范定制出来后,各大数据库厂家对这个接口进行实现!
模拟SUN公司:定制一套接口供各厂商去实现
模拟MYSQL厂商:实现JDBC(SUN公司定制的接口)
模拟Oracle厂商:实现JDBC(SUN公司定制的接口)
模拟SQLServer厂商:实现JDBC(SUN公司定制的接口)
模拟我们Java程序员该干什么!:不需要关心具体是哪个品牌的数据库,只需要面相JDBC接口写代码
结果:
优化上边的代码!!!!使用反射机制创建对象,可以将要数据写在配置文件当中!:
下面代码:JDBC jdbc = (JDBC)c.newInstance()为什么可以强转成JDBC?:
为什么要写JDBC,不直接写Oracle或者Mysql...,因为读取的配置文件,文件中可能配置的是Oracle也可能是Mysql,所以写JDBC比较灵活,JDBC是他们的父类!
.class文件就是驱动文件(实现类),如果删除就会报错:
驱动非常重要!
3. JDBC编程六步
3.1 编程五步案例
因为是插入语句,所以只有五步,第五步是处理查询的结果集,select语句才会用到(这个方式注册驱动并不常用):
3.2 常用的JDBC注册驱动的方式
注册驱动的方法:
3.3 从配置文件中获取链接和注册驱动
3.4 查询案例(六步)
将这三个定义在try外边,因为如果定义在try里的话,finally里无法获取。
1~4步:
第五步.处理查询结果集:
这是查询结果集的样子,用他的next方法,当下一个有数据的时候会返回true,没有就返回false。
最后第六步释放资源,这里就不弄出来了。
4. 做一个JDBC工具类
因为存在大量重复代码,所以把获取连接和关闭的方法单独抽出来:
/**
* JDBC工具类,简化JDBC编程
*/
public class DBUtil {
private DBUtil(){ //因为是工具类 没必要创建对象 直接把构造方法私有
}
static {//因为注册驱动只需要执行一次就行了 ,所以用静态代码块
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");
String drive = bundle.getString("drive"); //drive=com.mysql.jdbc.Driver
try {
Class.forName(drive);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//弄一个方法可以获取连接对象
/**
*
* @param url
* @param user 用户名
* @param password 密码
* @return 返回一个cConnection连接镀锡
* @throws SQLException
*/
//因为外边有try catch所以异常可以丢出去
public static Connection getConnection(String url,String user,String password) throws SQLException {
return DriverManager.getConnection(url, user, password);
}
/**
* 关闭连接的方法
* @param con 连接对象
* @param sta
* @param rs 结果集对象
*/
//这里写Statement比较通用,写Statement既可以传入PreparedStatement也可以传入Statement(PreparedStatement继承了Statement)
public static void close(Connection con, Statement sta, ResultSet rs){
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (sta != null) {
try {
sta.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (con != null) {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
5. 登录案例(SQL注入问题)(重要*)
用户表:
未优化版登录案例(使用Statement):
这个版本的登录案例存在SQL注入问题,如果按照以下图片输入用户名和密码,也同样会显示登陆成功。
该错误发生的原因,在sql语句上打上断点使用debug查看以下当前sql语句变成什么样了:
这条语句的意思是 WHERE loginName=fdsa AND loginPwd=fdsa 或者 1=1,那么1=1肯定成立,所以会返回true。
代码:
优化后的登录案例(使用PreparedStatement):
如何防止SQL注入问题:
解决SQL注入问题后的结果:
代码:
6. 对比Statement和PreparedStatement
- -Statement存在sql注入问题:PreparedStatement解决了SQL注入问题
- -Statement是编译一次执行一次。PreparedStatement是编译一次,可执行N次(因为每次预编译的时候语句都一样),PreparedStatement效率高一些
- -PreparedStatement会在编译阶段做类型的安全检查,例如:
因为用的是setString方法,所以只能是String,而Statement就不会进行检查。
7. 什么情况下使用Statement
业务方面要求必须支持SQL注入的时候。
Statement支持SQL注入,凡是业务方面要求需要进行sql语句拼接的,必须使用Statement。
例子:
PreparedStatement比如要给占位符?传入String的时候 会自动带上'值',而Statement可以直接进行拼接,所以做升序降序功能的时候
需要用到Statement。因为如果是SELECT FROM XXX 'desc'语法是错误的,SELECT FROM XXX desc这样才正确。
代码:
8. 用PreparedStatement完成增删改
properties文件
drive=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/bjpowernode
user=root
password=123456
未优化的增删改案例:
public class ZengJiaTest01 {
public static void main(String[] args) {
//准备工作
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
String url = bundle.getString("url");
String user = bundle.getString("user");
String password = bundle.getString("password");
Connection connection=null;
PreparedStatement sta=null; //改为PreparedStatement解决SQL注入问题,它可以预编译SQL语句的框架
ResultSet re=null;
try {
//1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
connection = DBUtil.getConnection(url, user, password);
//2.获取预编译的数据库操作对象
//sql语句的框子。其中一个?代表一个占位符,一个?将来接受一个‘值’,注意:占位符不能使用单引号括起来
String sql="INSERT INTO dept(deptno,dname,loc) VALUES(?,?,?)";//sql语句
//程序执行到此处,会发送sql语句框子给DBMS进行sql语句的预先编译
sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
//给占位符?传值(第1个问号的下标是1,第2个问号的下标是2,JDBC中所有下标从1开始。)
sta.setInt(1,50);
sta.setString(2,"销售部");
sta.setString(3,"伤害");
//3.执行sql语句
int count = sta.executeUpdate();//返回增加的条数
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBUtil.close(connection,sta,re);//传入连接对象,数据库操作对象,结果集对象进行关闭
}
}
}
优化后的增删改案例(抽出增删改为一个方法):
public class YouHuaZengJiaTest01 {
public static void main(String[] args) {
String sql = "INSERT INTO dept(deptno,dname,loc) VALUES(?,?,?)";
int count = update(sql, 50, "帅哥部", "台州");
System.out.println("成功修改 :"+count+"条数据");
}
//通用的增、删、改方法 (1,可以增、删、改;2,也可以针对于不同的表使用)
//需要传入sql语句,和参数(参数的数量可能不同,所以使用可变参数,因为不知道可能接收到什么参数,所以用Object)
public static int update(String sql,Object... objects){
//准备工作
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");
String url = bundle.getString("url");
String user = bundle.getString("user");
String password = bundle.getString("password");
Connection connection=null;
PreparedStatement sta=null;
int count = 0 ;//在外边定义好需要返回的增删改的条数
try {
//1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
connection = DBUtil.getConnection(url, user, password);
//2.获取预编译的数据库操作对象
sta = connection.prepareStatement(sql);
//3.填充占位符
//因为参数的数量就是可变参数objects数组的长度,所以使用循环给?占位符传参
for (int i = 0; i < objects.length; i++) {
sta.setObject(i+1,objects[i]);//因为传占位符是从1开始,所以得+1
}
//3.执行sql语句
count = sta.executeUpdate();//返回增加的条数
} catch (SQLException e) {
e.printStackTrace();
} finally {
DBUtil.close(connection,sta,null);//传入连接对象,数据库操作对象,结果集对象进行关闭
}
return count; //返回增删改的条数
}
}
9 ResultSet与ResultSetMetaData
9.1 ResultSet
- 查询需要调用PreparedStatement 的 executeQuery() 方法,查询结果是一个ResultSet 对象
- ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集,ResultSet 接口由数据库厂商提供实现
- ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
- ResultSet 对象维护了一个指向当前数据行的游标,初始的时候,游标在第一行之前,可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效,该方法返回 true,且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
- 例如: getInt(1), getString("name")
- 注意:Java与数据库交互涉及到的相关Java API中的索引都从1开始。
ResultSet 接口的常用方法:
- boolean next()
- getString()
- …
9.2 ResultSetMetaData
- 可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
ResultSetMetaData meta = rs.getMetaData();
- getColumnName(int column):获取指定列的名称
- getColumnLabel(int column):获取指定列的别名
- getColumnCount():返回当前 ResultSet 对象中的列数。
- getColumnTypeName(int column):检索指定列的数据库特定的类型名称。
- getColumnDisplaySize(int column):指示指定列的最大标准宽度,以字符为单位。
- isNullable(int column):指示指定列中的值是否可以为 null。
- isAutoIncrement(int column):指示是否自动为指定列进行编号,这样这些列仍然是只读的。
问题1:得到结果集后, 如何知道该结果集中有哪些列 ? 列名是什么?
需要使用一个描述 ResultSet 的对象, 即 ResultSetMetaData
问题2:关于ResultSetMetaData
- 如何获取 ResultSetMetaData: 调用 ResultSet 的 getMetaData() 方法即可
- 获取 ResultSet 中有多少列:调用 ResultSetMetaData 的 getColumnCount() 方法
- 获取 ResultSet 每一列的列的别名是什么:调用 ResultSetMetaData 的getColumnLabel() 方法
10. 改良版的PreparedStatement查询
10.1 优化版本1:
需要先创建对应列名的类:
public class Deptno {
private int deptno;
private String dname;
private String loc;
}
返回一条数据相同的表的时候的通用查询 表的字段名和对应的类的属性名相同。(两个技术:结果集元数据,反射)
//对dept(部门表)单条数据查询的通用方法(因为每个表的结构有对应的类,所以这个方法只是对部门表通用)
public Deptno selectOneFromDeptno (String sql,Object... objects){
//准备工作
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
String url = bundle.getString("url");
String user = bundle.getString("user");
String password = bundle.getString("password");
Connection connection = null;
PreparedStatement sta = null;
ResultSet re = null;
try {
//1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
connection = DBUtil.getConnection(url, user, password);
//2.获取预编译的数据库操作对象
sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
//3. 给占位符?传值
for (int i = 0; i < objects.length; i++) {
sta.setObject(i+1,objects[i]);
}
//4.执行sql语句
re = sta.executeQuery();
//5.处理结果集(关键点)
// 获取结果集的元数据(修饰现有数据的数据) String name = "Tom"核心数据是Tom,那么String和name一定程度上都是来修饰Tom,是Tom的两个元数据
ResultSetMetaData rsmd = re.getMetaData();
// 从元数据中获取有几列,那么可以获得对应要取多少个值。
int columnCount = rsmd.getColumnCount();
if (re.next()) {//如果有下一个
//创建deptno对象
Deptno deptno=new Deptno();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) { //遍历每一列
Object columnValue = re.getObject(i + 1);// 获取列值
// 将一个结果集封装到 对应的Deptno类中,因为不知道查询几条,可能是1条可能是2条,所以没法使用构造方法构造对象
// 而你也不知道参数的具体名字是什么,也不能使用 get set,这时候只能使用反射来给对象的属性赋值
String columnName = rsmd.getColumnName(i + 1);// 获取每个列的列名
// 给deptno对象指定的columnName(列名),赋值为columnValue(列值),通过反射
Field declaredField = Deptno.class.getDeclaredField(columnName); //通过反射传入列名(对应类的每个属性)获取Field对象
declaredField.setAccessible(true);//设置后可以访问私有的
declaredField.set(deptno,columnValue); //给deptno这个对象的这个Field属性设置columnValue值
}
return deptno; //封装成为对象后返回
}
} catch (SQLException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} finally {
DBUtil.close(connection, sta, re);//传入连接对象,数据库操作对象,结果集对象进行关闭
}
return null;
}
10.2 优化版本2:
流程:
数据库的表:
创建一个类,不一定要属性和列名对上:
public class Deptno {
private int no;
private String name;
private String dizhi;
}
返回一条数据相同的表的时候的通用查询(封装成对象返回),可以针对于表的字段名与类的属性名不同的情况。(两个技术:结果集元数据,反射)
/*
* 针对于表的字段名与类的属性名不相同的情况:(例如数据库表的列名是dname 而类中是name)
* 1. 必须声明sql时,使用类的属性名来命名字段的别名
* 2. 使用ResultSetMetaData时,需要使用getColumnLabel()来替换getColumnName(),获取列的别名。
* 说明:如果sql中没有给字段其别名,getColumnLabel()获取的就是列名
*/
//通过在sql语句查询的时候给列起一个别名达到和类属性名字一致的操作进行 单条数据查询
public static Deptno selectOneFromDeptno2 (String sql,Object... objects){
//准备工作
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
String url = bundle.getString("url");
String user = bundle.getString("user");
String password = bundle.getString("password");
Connection connection = null;
PreparedStatement sta = null;
ResultSet re = null;
try {
//1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
connection = DBUtil.getConnection(url, user, password);
//2.获取预编译的数据库操作对象
sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
//3. 给占位符?传值
for (int i = 0; i < objects.length; i++) {
sta.setObject(i+1,objects[i]);
}
//4.执行sql语句
re = sta.executeQuery();
//5.处理结果集(关键点)
// 获取结果集的元数据(修饰现有数据的数据) String name = "Tom"核心数据是Tom,那么String和name一定程度上都是来修饰Tom,是Tom的两个元数据
ResultSetMetaData rsmd = re.getMetaData();
// 从元数据中获取有几列,那么可以获得对应要取多少个值。
int columnCount = rsmd.getColumnCount();
if (re.next()) {//如果有下一个
//创建deptno对象
Deptno deptno=new Deptno();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) { //遍历每一列
Object columnValue = re.getObject(i + 1);// 获取列值
// 将一个结果集封装到 对应的Deptno类中,因为不知道查询几条,可能是1条可能是2条,所以没法使用构造方法构造对象
// 而你也不知道参数的具体名字是什么,也不能使用 get set,这时候只能使用反射来给对象的属性赋值
//获取列的列名:getColumnName() --不推荐使用
//获取列的别名:getColumnLabel()
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给deptno对象指定的columnLabel(列别名),赋值为columnValue(列值),通过反射
Field declaredField = Deptno.class.getDeclaredField(columnLabel); //通过反射传入列别名(对应类的每个属性)获取Field对象
declaredField.setAccessible(true);//设置后可以访问私有的
declaredField.set(deptno,columnValue); //给deptno这个对象的这个Field属性设置columnValue值
}
return deptno; //封装成为对象后返回
}
} catch (SQLException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} finally {
DBUtil.close(connection, sta, re);//传入连接对象,数据库操作对象,结果集对象进行关闭
}
return null;
}
10.3 优化版本3:
参数里增加了一个Class<T> clazz,可以传入对应表结构的类,成功实现针对于不同的表的通用的查询操作,返回表中的一条记录(封装成对象返回)。
/**
*
* @Description 针对于不同的表的通用的查询操作,把表中的数据封装成对象并返回一条。
* @param clazz
* @param sql
* @param args
* @return
*/
//<T> t表示返回的类型是泛型,可以是各种类。 Class<T> 表示可以传入任何类的字节码文件。
public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection(); //JDBCUtils已经做好了getConnection(url, user, password);操作 直接获得连接对象
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性,赋值为columValue:通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
}
10.4 最终版本:
成功实现针对于不同的表的通用的查询操作,将多条数据封装成为多个对象,再将多个对象封装到集合中并且返回。
数据库表:
测试代码中传入的类是:
public class Deptno {
private int no;
private String name;
private String dizhi;
}
查询结果:
代码:
public class ChaXunZui最终版Test01 {
@Test
public void testGetForList(){
String sql = "SELECT deptno,dname,loc FROM dept WHERE deptno < ?";
List<Deptno> forList = getForList(Deptno.class, sql, 50);
for (Deptno deptno : forList) {
System.out.println(deptno);
}
}
/**
* @Description 针对于不同的表的通用的查询操作,将表中的多条记录并封装成对象放入集合中并返回
* @param clazz
* @param sql
* @param args
* @param <T>
* @return
*/
//<T> t表示返回的类型是泛型,可以是各种类。 Class<T> 表示可以传入任何类的字节码文件。
public <T> List<T> getForList(Class<T> clazz, String sql, Object... args){
ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容(可以省去properties)
String url = bundle.getString("url");
String user = bundle.getString("user");
String password = bundle.getString("password");
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = DBUtil.getConnection(url,user,password);
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
//创建集合对象
ArrayList<T> list = new ArrayList<T>();
while (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性,赋值为columValue:通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
list.add(t); //把对象加入集合中
}
return list; //返回集合
} catch (Exception e) {
e.printStackTrace();
} finally {
DBUtil.close(conn, ps, rs);
}
return null;
}
}
11. 操作BLOB类型字段
11.1 MySQL BLOB类型
- MySQL中,BLOB是一个二进制大型对象,是一个可以存储大量数据的容器,它能容纳不同大小的数据。
- 插入BLOB类型的数据必须使用PreparedStatement,因为BLOB类型的数据无法使用字符串拼接写的。
- MySQL的四种BLOB类型(除了在存储的最大信息量上不同外,他们是等同的)
- 实际使用中根据需要存入的数据大小定义不同的BLOB类型。
- 需要注意的是:如果存储的文件过大,数据库的性能会下降。
- 如果在指定了相关的Blob类型以后,还报错:xxx too large,那么在mysql的安装目录下,找my.ini文件加上如下的配置参数: max_allowed_packet=16M。同时注意:修改了my.ini文件之后,需要重新启动mysql服务。
11.2 向数据表中插入大数据类型
//获取连接
Connection conn = JDBCUtils.getConnection();
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
// 填充占位符
ps.setString(1, "徐海强");
ps.setString(2, "xhq@126.com");
ps.setDate(3, new Date(new java.util.Date().getTime()));
// 操作Blob类型的变量
FileInputStream fis = new FileInputStream("xhq.png");
ps.setBlob(4, fis);
//执行
ps.execute();
fis.close();
JDBCUtils.closeResource(conn, ps);
11.3 修改数据表中的Blob类型字段
Connection conn = JDBCUtils.getConnection();
String sql = "update customers set photo = ? where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);
// 填充占位符
// 操作Blob类型的变量
FileInputStream fis = new FileInputStream("coffee.png");
ps.setBlob(1, fis);
ps.setInt(2, 25);
ps.execute();
fis.close();
JDBCUtils.closeResource(conn, ps);
11.4 从数据表中读取大数据类型
String sql = "SELECT id, name, email, birth, photo FROM customer WHERE id = ?";
conn = getConnection();
ps = conn.prepareStatement(sql);
ps.setInt(1, 8);
rs = ps.executeQuery();
if(rs.next()){
Integer id = rs.getInt(1);
String name = rs.getString(2);
String email = rs.getString(3);
Date birth = rs.getDate(4);
Customer cust = new Customer(id, name, email, birth);
System.out.println(cust);
//读取Blob类型的字段
Blob photo = rs.getBlob(5);
InputStream is = photo.getBinaryStream();
OutputStream os = new FileOutputStream("c.jpg");
byte [] buffer = new byte[1024];
int len = 0;
while((len = is.read(buffer)) != -1){
os.write(buffer, 0, len);
}
JDBCUtils.closeResource(conn, ps, rs);
if(is != null){
is.close();
}
if(os != null){
os.close();
}
}
12. 批量插入
12.1 批量执行SQL语句
当需要成批插入或者更新记录时,可以采用Java的批量更新机制,这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率
JDBC的批量处理语句包括下面三个方法:
- addBatch(String):添加需要批量处理的SQL语句或是参数;
- executeBatch():执行批量处理语句;
- clearBatch():清空缓存的数据
通常我们会遇到两种批量执行SQL语句的情况:
- 多条SQL语句的批量处理;
- 一个SQL语句的批量传参;
12.2 高效的批量插入
举例:向数据表中插入20000条数据
- 数据库中提供一个goods表。创建如下:
CREATE TABLE goods(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);
12.2.1 实现层次一:使用Statement
Connection conn = JDBCUtils.getConnection();
Statement st = conn.createStatement();
for(int i = 1;i <= 20000;i++){
String sql = "insert into goods(name) values('name_' + "+ i +")";
st.executeUpdate(sql);
}
12.2.2 实现层次二:使用PreparedStatement
long start = System.currentTimeMillis();
Connection conn = JDBCUtils.getConnection();
String sql = "insert into goods(name)values(?)";
PreparedStatement ps = conn.prepareStatement(sql);
for(int i = 1;i <= 20000;i++){
ps.setString(1, "name_" + i);
ps.executeUpdate();
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));//82340
JDBCUtils.closeResource(conn, ps);
12.2.3 实现层次三
/*
* 修改1: 使用 addBatch() / executeBatch() / clearBatch()
* 修改2:mysql服务器默认是关闭批处理的,我们需要通过一个参数,让mysql开启批处理的支持。
* ?rewriteBatchedStatements=true 写在配置文件的url后面
* 修改3:使用更新的mysql 驱动:mysql-connector-java-5.1.37-bin.jar
*
*/
@Test
public void testInsert1() throws Exception{
long start = System.currentTimeMillis();
Connection conn = JDBCUtils.getConnection();
String sql = "insert into goods(name)values(?)";
PreparedStatement ps = conn.prepareStatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setString(1, "name_" + i);
//1.“攒”sql
ps.addBatch();
if(i % 500 == 0){
//2.执行
ps.executeBatch();
//3.清空
ps.clearBatch();
}
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));//20000条:625 //1000000条:14733
JDBCUtils.closeResource(conn, ps);
}
12.2.4 实现层次四
/*
* 层次四:在层次三的基础上操作
* 使用Connection 的 setAutoCommit(false) / commit()
*/
@Test
public void testInsert2() throws Exception{
long start = System.currentTimeMillis();
Connection conn = JDBCUtils.getConnection();
//1.设置为不自动提交数据
conn.setAutoCommit(false);
String sql = "insert into goods(name)values(?)";
PreparedStatement ps = conn.prepareStatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setString(1, "name_" + i);
//1.“攒”sql
ps.addBatch();
if(i % 500 == 0){
//2.执行
ps.executeBatch();
//3.清空
ps.clearBatch();
}
}
//2.提交数据
conn.commit();
long end = System.currentTimeMillis();
System.out.println("花费的时间为:" + (end - start));//1000000条:4978
JDBCUtils.closeResource(conn, ps);
}
13. 数据库事务
13.1 数据库事务介绍
- 事务:一组逻辑操作单元,使数据从一种状态变换到另一种状态。
- 事务处理(事务操作):保证所有事务都作为一个工作单元来执行,即使出现了故障,都不能改变这种执行方式。当在一个事务中执行多个操作时,要么所有的事务都被提交(commit),那么这些修改就永久地保存下来;要么数据库管理系统将放弃所作的所有修改,整个事务回滚(rollback)到最初状态。
- 为确保数据库中数据的一致性,数据的操纵应当是离散的成组的逻辑单元:当它全部完成时,数据的一致性可以保持,而当这个单元中的一部分操作失败,整个事务应全部视为错误,所有从起始点以后的操作应全部回退到开始状态。
13.2 JDBC事务处理
- 数据一旦提交,就不可回滚。
数据什么时候意味着提交?
- 当一个连接对象被创建时,默认情况下是自动提交事务:每次执行一个 SQL 语句时,如果执行成功,就会向数据库自动提交,而不能回滚。
- 关闭数据库连接,数据就会自动的提交。如果多个操作,每个操作使用的是自己单独的连接,则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
JDBC程序中为了让多个 SQL 语句作为一个事务执行:
- 调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
- 在所有的 SQL 语句都成功执行后,调用 commit(); 方法提交事务
- 在出现异常时,调用 rollback(); 方法回滚事务
若此时 Connection 没有被关闭,还可能被重复使用,则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时,执行close()方法前,建议恢复自动提交状态。
【案例:用户AA向用户BB转账100】
public void testJDBCTransaction() {
Connection conn = null;
try {
// 1.获取数据库连接
conn = JDBCUtils.getConnection(); //JDBCUtils中已经做好资源绑定等事可以直接获得连接
// 2.开启事务
conn.setAutoCommit(false);
// 3.进行数据库操作
String sql1 = "update user_table set balance = balance - 100 where user = ?";
update(conn, sql1, "AA");
// 模拟网络异常
//System.out.println(10 / 0);
String sql2 = "update user_table set balance = balance + 100 where user = ?";
update(conn, sql2, "BB");
// 4.若没有异常,则提交事务
conn.commit();
} catch (Exception e) {
e.printStackTrace();
// 5.若有异常,则回滚事务
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
} finally {
try {
//6.恢复每次DML操作的自动提交功能
conn.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
//7.关闭连接
JDBCUtils.closeResource(conn, null, null);
}
}
其中,对数据库操作的方法为:
//使用事务以后的通用的增删改操作(version 2.0)
public void update(Connection conn ,String sql, Object... args) { //需要传入连接
PreparedStatement ps = null;
try {
// 1.获取PreparedStatement的实例 (或:预编译sql语句)
ps = conn.prepareStatement(sql);
// 2.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
// 3.执行sql语句
ps.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4.关闭资源
JDBCUtils.closeResource(null, ps); //JDBCUtils已经做好了关闭连接的功能
}
}
13.3 事务的ACID属性
- 原子性(Atomicity)
原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。 - 一致性(Consistency)
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。 - 隔离性(Isolation)
事务的隔离性是指一个事务的执行不能被其他事务干扰,即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。 - 持久性(Durability)
持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来的其他操作和数据库故障不应该对其有任何影响。
13.3.1 数据库的并发问题
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
- 脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
- 不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
- 幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
- 数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
- 一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
13.3.2 四种隔离级别
- 数据库提供的4种事务隔离级别:
- Oracle 支持的 2 种事务隔离级别:READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED 。
- Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。
13.3.3 在MySql中设置隔离级别
- 每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别。
查看当前的隔离级别:
SELECT @@tx_isolation;
设置当前 mySQL 连接的隔离级别:
set transaction isolation level read committed;
设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed;
补充操作:
创建mysql数据库用户:
create user tom identified by 'abc123';
授予权限
#授予通过网络方式登录的tom用户,对所有库所有表的全部权限,密码设为abc123. grant all privileges on *.* to tom@'%' identified by 'abc123'; #给tom用户使用本地命令行方式,授予atguigudb这个库下的所有表的插删改查的权限。 grant select,insert,delete,update on atguigudb.* to tom@localhost identified by 'abc123';