0
点赞
收藏
分享

微信扫一扫

Jdbc知识点全整理,你值得拥有 ​(2)

倚然君 2022-04-02 阅读 38

1 DAO模式

DAO(Data Access Object)模式就是写一个类,把访问数据库的代码封装起来。DAO在数据库与业务逻辑(Service)之间。

l 实体域,即操作的对象,例如我们操作的表是user表,那么就需要先写一个User类;

l DAO模式需要先提供一个DAO接口;

l 然后再提供一个DAO接口的实现类;

l 再编写一个DAO工厂,Service通过工厂来获取DAO实现。

2 代码

User.java

publicclass User {

private String uid;

private String username;

private String password;

}

UserDao.java

publicinterface UserDao {

publicvoid add(User user);

publicvoid mod(User user);

publicvoid del(String uid);

public User load(String uid);

public List<User> findAll();

}

UserDaoImpl.java

publicclass UserDaoImpl implements UserDao {

publicvoid add(User user) {

Connection con = null;

PreparedStatement pstmt = null;

try {

con = JdbcUtils.getConnection();

String sql = "insert into user value(?,?,?)";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, user.getUid());

pstmt.setString(2, user.getUsername());

pstmt.setString(3, user.getPassword());

pstmt.executeUpdate();

} catch(Exception e) {

thrownew RuntimeException(e);

} finally {

try {

if(pstmt != null) pstmt.close();

if(con != null) con.close();

} catch(SQLException e) {}

}

}

publicvoid mod(User user) {

Connection con = null;

PreparedStatement pstmt = null;

try {

con = JdbcUtils.getConnection();

String sql = "update user set username=?, password=? where uid=?";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, user.getUsername());

pstmt.setString(2, user.getPassword());

pstmt.setString(3, user.getUid());

pstmt.executeUpdate();

} catch(Exception e) {

thrownew RuntimeException(e);

} finally {

try {

if(pstmt != null) pstmt.close();

if(con != null) con.close();

} catch(SQLException e) {}

}

}

publicvoid del(String uid) {

Connection con = null;

PreparedStatement pstmt = null;

try {

con = JdbcUtils.getConnection();

String sql = "delete from user where uid=?";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, uid);

pstmt.executeUpdate();

} catch(Exception e) {

thrownew RuntimeException(e);

} finally {

try {

if(pstmt != null) pstmt.close();

if(con != null) con.close();

} catch(SQLException e) {}

}

}

public User load(String uid) {

Connection con = null;

PreparedStatement pstmt = null;

ResultSet rs = null;

try {

con = JdbcUtils.getConnection();

String sql = "select * from user where uid=?";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, uid);

rs = pstmt.executeQuery();

if(rs.next()) {

returnnew User(rs.getString(1), rs.getString(2), rs.getString(3));

}

returnnull;

} catch(Exception e) {

thrownew RuntimeException(e);

} finally {

try {

if(pstmt != null) pstmt.close();

if(con != null) con.close();

} catch(SQLException e) {}

}

}

public List<User> findAll() {

Connection con = null;

PreparedStatement pstmt = null;

ResultSet rs = null;

try {

con = JdbcUtils.getConnection();

String sql = "select * from user";

pstmt = con.prepareStatement(sql);

rs = pstmt.executeQuery();

List<User> userList = new ArrayList<User>();

while(rs.next()) {

userList.add(new User(rs.getString(1), rs.getString(2), rs.getString(3)));

}

return userList;

} catch(Exception e) {

thrownew RuntimeException(e);

} finally {

try {

if(pstmt != null) pstmt.close();

if(con != null) con.close();

} catch(SQLException e) {}

}

}

}

UserDaoFactory.java

publicclass UserDaoFactory {

privatestatic UserDao userDao;

static {

try {

InputStream in = Thread.currentThread().getContextClassLoader()

.getResourceAsStream("dao.properties");

Properties prop = new Properties();

prop.load(in);

String className = prop.getProperty("cn.itcast.jdbc.UserDao");

Class clazz = Class.forName(className);

userDao = (UserDao) clazz.newInstance();

} catch (Exception e) {

thrownew RuntimeException(e);

}

}

publicstatic UserDao getUserDao() {

returnuserDao;

}

}

dao.properties

cn.itcast.jdbc.UserDao=cn.itcast.jdbc.UserDaoImpl

时间类型

1 Java中的时间类型

java.sql包下给出三个与数据库相关的日期时间类型,分别是:

Date:表示日期,只有年月日,没有时分秒。会丢失时间;

Time:表示时间,只有时分秒,没有年月日。会丢失日期;

Timestamp:表示时间戳,有年月日时分秒,以及毫秒。

这三个类都是java.util.Date的子类。

2 时间类型相互

把数据库的三种时间类型赋给java.util.Date,基本不用换,因为这是把子类对象给父类的引用,不需要转换。

java.sql.Date date = …

java.util.Date d = date;

java.sql.Time time = …

java.util.Date d = time;

java.sql.Timestamp timestamp = …

java.util.Date d = timestamp;

当需要把java.util.Date换成数据库的三种时间类型时,这就不能直接赋值了,这需要使用数据库三种时间类型的构造器。java.sql包下的Date、Time、TimeStamp三个类的构造器都需要一个long类型的参数,表示毫秒值。创建这三个类型的对象,只需要有毫秒值即可。我们知道java.util.Date有getTime()方法可以获取毫秒值,那么这个转换也就不是什么问题了。

java.utl.Date d = new java.util.Date();

java.sql.Date date = new java.sql.Date(d.getTime());//会丢失时分秒

Time time = new Time(d.getTime());//会丢失年月日

Timestamp timestamp = new Timestamp(d.getTime());

3 代码

我们来创建一个dt表:

CREATE TABLE dt(

d DATE,

t TIME,

ts TIMESTAMP

)

下面是向dt表中插入数据的代码:

@Test

publicvoid fun1() throws SQLException {

Connection con = JdbcUtils.getConnection();

String sql = "insert into dt value(?,?,?)";

PreparedStatement pstmt = con.prepareStatement(sql);

java.util.Date d = new java.util.Date();

pstmt.setDate(1, new java.sql.Date(d.getTime()));

pstmt.setTime(2, new Time(d.getTime()));

pstmt.setTimestamp(3, new Timestamp(d.getTime()));

pstmt.executeUpdate();

}

下面是从dt表中查询数据的代码:

@Test

publicvoid fun2() throws SQLException {

Connection con = JdbcUtils.getConnection();

String sql = "select * from dt";

PreparedStatement pstmt = con.prepareStatement(sql);

ResultSet rs = pstmt.executeQuery();

rs.next();

java.util.Date d1 = rs.getDate(1);

java.util.Date d2 = rs.getTime(2);

java.util.Date d3 = rs.getTimestamp(3);

System.out.println(d1);

System.out.println(d2);

System.out.println(d3);

}

大数据(sql)

1 什么是大数据

所谓大数据,就是大的字节数据,或大的字符数据。标准SQL中提供了如下类型来保存大数据类型:

类型

长度

tinyblob

28--1B(256B)

blob

216-1B(64K)

mediumblob

224-1B(16M)

longblob

232-1B(4G)

tinyclob

28--1B(256B)

clob

216-1B(64K)

mediumclob

224-1B(16M)

longclob

232-1B(4G)

但是,在mysql中没有提供tinyclob、clob、mediumclob、longclob四种类型,而是使用如下四种类型来处理文本大数据:

类型

长度

tinytext

28--1B(256B)

text

216-1B(64K)

mediumtext

224-1B(16M)

longtext

232-1B(4G)

首先我们需要创建一张表,表中要有一个mediumblob(16M)类型的字段。

CREATE TABLE tab_bin(

idINTPRIMARY KEY AUTO_INCREMENT,

filenameVARCHAR(100),

dataMEDIUMBLOB

);

向数据库插入二进制数据需要使用PreparedStatement为原setBinaryStream(int, InputSteam)方法来完成。

con = JdbcUtils.getConnection();

String sql = "insert into tab_bin(filename,data) values(?, ?)";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, "a.jpg");

InputStream in = new FileInputStream("f:\\a.jpg");

pstmt.setBinaryStream(2, in);

pstmt.executeUpdate();

读取二进制数据,需要在查询后使用ResultSet类的getBinaryStream()方法来获取输入流对象。也就是说,PreparedStatement有setXXX(),那么ResultSet就有getXXX()。

con = JdbcUtils.getConnection();

String sql = "select filename,data from tab_bin where id=?";

pstmt = con.prepareStatement(sql);

pstmt.setInt(1, 1);

rs = pstmt.executeQuery();

rs.next();

String filename = rs.getString("filename");

OutputStream out = new FileOutputStream("F:\\" + filename);

InputStream in = rs.getBinaryStream("data");

IOUtils.copy(in, out);

out.close();

还有一种方法,就是把要存储的数据包装成Blob类型,然后调用PreparedStatement的setBlob()方法来设置数据

con = JdbcUtils.getConnection();

String sql = "insert into tab_bin(filename,data) values(?, ?)";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, "a.jpg");

File file = new File("f:\\a.jpg");

byte[] datas = FileUtils.getBytes(file);//获取文件中的数据

Blob blob = new SerialBlob(datas);//创建Blob对象

pstmt.setBlob(2, blob);//设置Blob类型的参数

pstmt.executeUpdate();


con = JdbcUtils.getConnection();

String sql = "select filename,data from tab_bin where id=?";

pstmt = con.prepareStatement(sql);

pstmt.setInt(1, 1);

rs = pstmt.executeQuery();

rs.next();

String filename = rs.getString("filename");

File file = new File("F:\\" + filename) ;

Blob blob = rs.getBlob("data");

byte[] datas = blob.getBytes(0, (int)file.length());

FileUtils.writeByteArrayToFile(file, datas);

批处理

1 Statement批处理

批处理就是一批一批的处理,而不是一个一个的处理!

当你有10条SQL语句要执行时,一次向服务器发送一条SQL语句,这么做效率上很差!处理的方案是使用批处理,即一次向服务器发送多条SQL语句,然后由服务器一次性处理。

批处理只针对更新(增、删、改)语句,批处理没有查询什么事儿!

可以多次调用Statement类的addBatch(String sql)方法,把需要执行的所有SQL语句添加到一个“批”中,然后调用Statement类的executeBatch()方法来执行当前“批”中的语句。

void addBatch(String sql):添加一条语句到“批”中;

int[] executeBatch():执行“批”中所有语句。返回值表示每条语句所影响的行数据;

void clearBatch():清空“批”中的所有语句。

for(int i = 0; i < 10; i++) {

String number = "S_10" + i;

String name = "stu" + i;

int age = 20 + i;

String gender = i % 2 == 0 ? "male" : "female";

String sql = "insert into stu values('" + number + "', '" + name + "', " + age + ", '" + gender + "')";

stmt.addBatch(sql);

}

stmt.executeBatch();

当执行了“批”之后,“批”中的SQL语句就会被清空!也就是说,连续两次调用executeBatch()相当于调用一次!因为第二次调用时,“批”中已经没有SQL语句了。

还可以在执行“批”之前,调用Statement的clearBatch()方法来清空“批”!

2 PreparedStatement批处理

PreparedStatement的批处理有所不同,因为每个PreparedStatement对象都绑定一条SQL模板。所以向PreparedStatement中添加的不是SQL语句,而是给“?”赋值。

con = JdbcUtils.getConnection();

String sql = "insert into stu values(?,?,?,?)";

pstmt = con.prepareStatement(sql);

for(int i = 0; i < 10; i++) {

pstmt.setString(1, "S_10" + i);

pstmt.setString(2, "stu" + i);

pstmt.setInt(3, 20 + i);

pstmt.setString(4, i % 2 == 0 ? "male" : "female");

pstmt.addBatch();

}

pstmt.executeBatch();

jdbc事务

事务概述

为了方便演示事务,我们需要创建一个account表:

CREATE TABLE account(

id INT PRIMARY KEY AUTO_INCREMENT,

NAME VARCHAR(30),

balance NUMERIC(10.2)

);

INSERT INTO account(NAME,balance) VALUES('zs', 100000);

INSERT INTO account(NAME,balance) VALUES('ls', 100000);

INSERT INTO account(NAME,balance) VALUES('ww', 100000);

SELECT * FROM account;

1 什么是事务

银行账!张三转10000块到李四的账户,这其实需要两条SQL语句:

l 给张三的账户减去10000元;

l 给李四的账户加上10000元。

如果在第一条SQL语句执行成功后,在执行第二条SQL语句之前,程序被中断了(可能是抛出了某个异常,也可能是其他什么原因),那么李四的账户没有加上10000元,而张三却减去了10000元。这肯定是不行的!

你现在可能已经知道什么是事务了吧!事务中的多个操作,要么完全成功,要么完全失败!不可能存在成功一半的情况!也就是说给张三的账户减去10000元如果成功了,那么给李四的账户加上10000元的操作也必须是成功的;否则给张三减去10000元,以及给李四加上10000元都是失败的!

2 事务的四大特性(ACID)

面试!

事务的四大特性是:

原子性(Atomicity):事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功,要么全部执行失败。

一致性(Consistency):事务执行后,数据库状态与其它业务规则保持一致。如账业务,无论事务执行成功与否,参与转账的两个账号余额之和应该是不变的。

隔离性(Isolation):隔离性是指在并发操作中,不同事务之间应该隔离开来,使每个并发中的事务不会相互干扰。

持久性(Durability):一旦事务提交成功,事务中所有的数据操作都必须被持久化到数据库中,即使提交事务后,数据库马上崩溃,在数据库重启时,也必须能保证通过某种机制恢复数据。

3 MySQL中的事务

在默认情况下,MySQL每执行一条SQL语句,都是一个单独的事务。如果需要在一个事务中包含多条SQL语句,那么需要开启事务和结束事务。

l 开启事务:​start transaction​;

l 结束事务:​commit​或​rollback​。

在执行SQL语句之前,先执行strat transaction,这就开启了一个事务(事务的起点),然后可以去执行多条SQL语句,最后要结束事务,commit表示提交,即事务中的多条SQL语句所做出的影响会持久化到数据库中。或者rollback,表示回滚,即回滚到事务的起点,之前做的所有操作都被撤消了!

下面演示zs给li账10000元的示例:

START TRANSACTION;

UPDATE account SET balance=balance-10000 WHERE id=1;

UPDATE account SET balance=balance+10000 WHERE id=2;

ROLLBACK;

START TRANSACTION;

UPDATE account SET balance=balance-10000 WHERE id=1;

UPDATE account SET balance=balance+10000 WHERE id=2;

COMMIT;

START TRANSACTION;

UPDATE account SET balance=balance-10000 WHERE id=1;

UPDATE account SET balance=balance+10000 WHERE id=2;

quit;


JDBC事务

1 JDBC中的事务

Connection的三个方法与事务相关:

setAutoCommit(boolean):设置是否为自动提交事务,如果true(默认值就是true)表示自动提交,也就是每条执行的SQL语句都是一个单独的事务,如果设置false,那么就相当于开启了事务了;

commit():提交结束事务;

rollback():回滚结束事务。

publicvoid transfer(boolean b) {

Connection con = null;

PreparedStatement pstmt = null;

try {

con = JdbcUtils.getConnection();

//手动提交

con.setAutoCommit(false);

String sql = "update account set balance=balance+? where id=?";

pstmt = con.prepareStatement(sql);

//操作

pstmt.setDouble(1, -10000);

pstmt.setInt(2, 1);

pstmt.executeUpdate();

// 在两个操作中抛出异常

if(b) {

thrownew Exception();

}

pstmt.setDouble(1, 10000);

pstmt.setInt(2, 2);

pstmt.executeUpdate();

//提交事务

con.commit();

} catch(Exception e) {

//回滚事务

if(con != null) {

try {

con.rollback();

} catch(SQLException ex) {}

}

thrownew RuntimeException(e);

} finally {

//关闭

JdbcUtils.close(con, pstmt);

}

}

2 保存点(了解)

保存点是JDBC3.0的东西!当要求数据库服务器支持保存点方式的回滚。

校验数据库服务器是否支持保存点!

boolean b = con.getMetaData().supportsSavepoints();

保存点的作用是允许事务回滚到指定的保存点位置。在事务中设置好保存点,然后回滚时可以选择回滚到指定的保存点,而不是回滚整个事务!​注意,回滚到指定保存点并没有结束事务!!!只有回滚了整个事务才算是结束事务了!

Connection类的设置保存点,以及回滚到指定保存点方法:

设置保存点:Savepoint setSavepoint();

回滚到指定保存点:void rollback(Savepoint)。

/*

* 李四对张三说,如果你给我1W,我就给你转100W。

* ==========================================

*

* 张三给李四1W(张三减去1W,李四加上1W)

* 设置保存点!

* 李四给张三100W(李四减去100W,张三加上100W)

* 查看李四余额为负数,那么回滚到保存点。

* 提交事务

*/

@Test

publicvoid fun() {

Connection con = null;

PreparedStatement pstmt = null;

try {

con = JdbcUtils.getConnection();

//手动提交

con.setAutoCommit(false);

String sql = "update account set balance=balance+? where name=?";

pstmt = con.prepareStatement(sql);

//操作1(张三减去1W)

pstmt.setDouble(1, -10000);

pstmt.setString(2, "zs");

pstmt.executeUpdate();

//操作2(李四加上1W)

pstmt.setDouble(1, 10000);

pstmt.setString(2, "ls");

pstmt.executeUpdate();

// 设置保存点

Savepoint sp = con.setSavepoint();

//操作3(李四减去100W)

pstmt.setDouble(1, -1000000);

pstmt.setString(2, "ls");

pstmt.executeUpdate();

//操作4(张三加上100W)

pstmt.setDouble(1, 1000000);

pstmt.setString(2, "zs");

pstmt.executeUpdate();

//操作5(查看李四余额)

sql = "select balance from account where name=?";

pstmt = con.prepareStatement(sql);

pstmt.setString(1, "ls");

ResultSet rs = pstmt.executeQuery();

rs.next();

double balance = rs.getDouble(1);

//如果李四余额为负数,那么回滚到指定保存点

if(balance < 0) {

con.rollback(sp);

System.out.println("张三,你上当了!");

}

//提交事务

con.commit();

} catch(Exception e) {

//回滚事务

if(con != null) {

try {

con.rollback();

} catch(SQLException ex) {}

}

thrownew RuntimeException(e);

} finally {

//关闭

JdbcUtils.close(con, pstmt);

}

}

事务隔离级别

事务的并发读问题

l 脏读:读取到另一个事务未提交数据;

l 不可重复读:两次读取不一致;

l 幻读(虚读):读到另一事务已提交数据。

2 并发事务问题

因为并发事务导致的问题大致有5类,其中两类是更新问题,三类是读问题。

脏读(dirty read):​读到未提交更新数据,即读取到了脏数据;

不可重复读(unrepeatable read):​对同一记录的两次读取不一致,因为另一事务对该记录做了修改;

幻读(phantom read):​对同一张表的两次查询不一致,因为另一事务插入了一条记录;

脏读

事务1:张三给李四账100元

事务2:李四查看自己的账户

t1:事务1:开始事务

t2:事务1:张三给李四账100元

t3:事务2:开始事务

t4:事务2:李四查看自己的账户,看到账户多出100元(脏读)

t5:事务2:提交事务

t6:事务1:回滚事务,回到账之前的状态

不可重复读

事务1:酒店查看两次1048号房间状态

事务2:预订1048号房间

t1:事务1:开始事务

t2:事务1:查看1048号房间状态为空闲

t3:事务2:开始事务

t4:事务2:预定1048号房间

t5:事务2:提交事务

t6:事务1:再次查看1048号房间状态为使用

t7:事务1:提交事务

对同一记录的两次查询结果不一致!

幻读

事务1:对酒店房间预订记录两次统计

事务2:添加一条预订房间记录

t1:事务1:开始事务

t2:事务1:统计预订记录100条

t3:事务2:开始事务

t4:事务2:添加一条预订房间记录

t5:事务2:提交事务

t6:事务1:再次统计预订记录为101记录

t7:事务1:提交

对同一表的两次查询不一致!

不可重复读和幻读的区别:

不可重复读是读取到了另一事务的更新;

幻读是读取到了另一事务的插入(MySQL中无法测试到幻读);

3 四大隔离级别

4个等级的事务隔离级别,在相同数据环境下,使用相同的输入,执行相同的工作,根据不同的隔离级别,可以导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力是不同的。

1 SERIALIZABLE(串行化)

不会出现任何并发问题,因为它是对同一数据的访问是串行的,非并发访问的;

性能最差;

2 REPEATABLE READ(可重复读)

防止脏读和不可重复读;(不能处理幻读)

性能比SERIALIZABLE好

3 READ COMMITTED(读已提交数据)

防止脏读;(不能处理不可重复读、幻读)

性能比REPEATABLE READ好

4 READ UNCOMMITTED(读未提交数据)

可能出现任何事务并发问题

性能最好

MySQL的默认隔离级别为REPEATABLE READ,这是一个很不错的选择吧!

4MySQL隔离级别

MySQL的默认隔离级别为Repeatable read,可以通过下面语句查看:

select @@tx_isolation

也可以通过下面语句来设置当前连接的隔离级别:

set transaction isolationlevel [4先1]

5JDBC设置隔离级别

con. setTransactionIsolation(int level)

参数可选值如下:

Connection.TRANSACTION_READ_UNCOMMITTED;

Connection.TRANSACTION_READ_COMMITTED;

Connection.TRANSACTION_REPEATABLE_READ;

Connection.TRANSACTION_SERIALIZABLE。

Jdbc知识点全整理,你值得拥有 ​(2)_java

事务总结:

事务的特性:ACID;

事务开始边界与结束边界:开始边界(con.setAutoCommit(false)),结束边界(con.commit()或con.rollback());

事务的隔离级别: READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE。多个事务并发执行时才需要考虑并发事务。


举报

相关推荐

0 条评论