IT十八掌 复习

Posted 2020-08-29

复习:

1.jdbc是什么，它有什么用?

java database connection

让java程序员可以直接通过java程序操作数据.

jdbc是标准，它是由类与接口组成，对于程序员只需要知道标准(Connection Statement PreparedStatement,ResultSet)

不需要了解具休实现就可以操作数据库。

2.jdbc入门代码

导入jar包

1.注册驱动

DriverManager.registDriver(Driver dirver);

不使用这种方式，使用反射

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

2.获取连接Connection

Connection con=DriverManager.getConnection(String url,String username,String password);

3.获取操作sql对象  Statement

Statement st=con.createStatement();

如果要得到滚动结果集，可以使用createStatement(int,int);

4.操作sql

DQL语句

ResultSet rs=st.executeQuery(String sql);

DML语句

int row=st.executeUpdate(String sql);

5.遍历结果集

while(rs.next()){

rs.getInt(int coulumnIndex);

rs.getString(String columnName);

}

6.释放资源

rs.close();

st.close();

con.close();

----------------------------------------------

PreparedStatement

1.怎样获取?

PreparedStatement pst=con.prepareStatement(String sql);

 

2.怎样给占位符"?"赋值

pst.setXxx(int,value)

3.执行

pst.executeQuery();

pst.executeUpdate();

=================================================================================================

事务:

问题:事务是什么，有什么用?

事务就是一个事情，组成这个事情可能有多个单元，要求这些单元，要么全都成功，要么全都不成功。

在开发中，有事务的存在，可以保证数据完整性。

问题:事务怎样操作

创建表:

create table account(

   id int primary key auto_increment,

   name varchar(20),

   money double

);

 

insert into account values(null,‘aaa‘,1000);

insert into account values(null,‘bbb‘,1000);

insert into account values(null,‘ccc‘,1000);

 

1.mysql下怎样操作

方式1:

start transaction  开启事务

rollback 事务回滚

commit 事务提交

方式2:

 show variables like ‘%commit%‘; 可以查看当前autocommit值

在mysql数据库中它的默认值是"on"代表自动事务.

自动事务的意义就是:执行任意一条sql语句都会自动提交事务.

测试:将autocommit的值设置为off

1.set autocommit=off 关闭自动事务。

2.必须手动commit才可以将事务提交。

注意:mysql默认autocommit=on  oracle默认的autocommit=off;

2.jdbc下怎样操作

java.sql.Connection接口中有几个方法是用于可以操作事务

1.setAutocommit(boolean flag);

如果flag=false;它就相当于start transaction;

2.rollBack()

事务回滚。

3.commit()

事务提交

 

案例：

//jdbc中事务操作

public class TransactionTest1 {

 

public static void main(String[] args) throws SQLException {

 

// 修改id=2这个人的money=500;

 

String sql = "update account set money=500 where id=2";

 

Connection con = JdbcUtils.getConnection();

con.setAutoCommit(false); //开启事务，相当于  start transaction;

 

Statement st = con.createStatement();

st.executeUpdate(sql);

//事务回滚

//con.rollback();

 

con.commit(); //事务提交

st.close();

con.close();

}

}

 

案例二

 

//jdbc中事务操作

public class TransactionTest2 {

 

public static void main(String[] args) {

 

// 修改id=2这个人的money=500;

 

String sql = "update account set money=500 where id=2";

 

Connection con = null;

Statement st = null;

 

try {

con = JdbcUtils.getConnection();

con.setAutoCommit(false); // 开启事务，相当于 start transaction;

 

st = con.createStatement();

st.executeUpdate(sql);

} catch (SQLException e) {

e.printStackTrace();

// 事务回滚

 try {

con.rollback();

} catch (SQLException e1) {

e1.printStackTrace();

}

} finally {

 

try {

con.commit(); // 事务提交

st.close();

con.close();

} catch (SQLException e) {

e.printStackTrace();

}

}

}

}

 

==============================================================================

事务特性(重点) ACID

?原子性（Atomicity）

原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

?一致性（Consistency）

事务前后数据的完整性必须保持一致。

?隔离性（Isolation）

事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。

?持久性（Durability）

持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

 

-------------------------------------

如果不考虑事务的隔离性，会出现什么问题?

1.脏读 一个事务读取到另一个事务的未提交数据。

2.不可重复读

两次读取的数据不一致(update)

3.虚读(幻读)

两次读取的数据一一致(insert)

4.丢失更新

两个事务对同一条记录进行操作，后提交的事务，将先提交的事务的修改覆盖了。

-----------------------------------------

演示以上问题，以及问题的解决方案

对于以上的问题，我们可以通过设置事务的隔离级别来解决。

1.事务的隔离级别有哪些?

1 Serializable：可避免脏读、不可重复读、虚读情况的发生。（串行化）

2 Repeatable read：可避免脏读、不可重复读情况的发生。（可重复读）不可以避免虚读

3 Read committed：可避免脏读情况发生（读已提交）

4 Read uncommitted：最低级别，以上情况均无法保证。(读未提交)

 

2.怎样设置事务的隔离级别?

1.mysql中设置

1.查看事务隔离级别

select @@tx_isolation查询当前事务隔离级别

mysql中默认的事务隔离级别是  Repeatable read.

扩展:oracle 中默认的事务隔离级别是  Read committed

2.mysql中怎样设置事务隔离级别

set session transaction isolation level 设置事务隔离级别

2.jdbc中设置

在jdbc中设置事务隔离级别

使用java.sql.Connection接口中提供的方法

void setTransactionIsolation(int level) throws SQLException

参数level可以取以下值:

level - 以下 Connection 常量之一：

Connection.TRANSACTION_READ_UNCOMMITTED、

Connection.TRANSACTION_READ_COMMITTED、

Connection.TRANSACTION_REPEATABLE_READ

Connection.TRANSACTION_SERIALIZABLE。

（注意，不能使用 Connection.TRANSACTION_NONE，因为它指定了不受支持的事务。）

 

--------------------------------------------------

3.演示

1.脏读

一个事务读取到另一个事务的为提交数据

设置A,B事务隔离级别为   Read uncommitted

set session transaction isolation level  read uncommitted;

1.在A事务中

start transaction;

update account set money=money-500 where name=‘aaa‘;

update account set money=money+500 where name=‘bbb‘;

2.在B事务中

start transaction;

select * from account;

这时，B事务读取时，会发现，钱已经汇完。那么就出现了脏读。

当A事务提交前，执行rollback，在commit， B事务在查询，就会发现，钱恢复成原样

也出现了两次查询结果不一致问题，出现了不可重复读.

2.解决脏读问题

将事务的隔离级别设置为 read committed来解决脏读

设置A,B事务隔离级别为   Read committed

set session transaction isolation level  read committed;

1.在A事务中

start transaction;

update account set money=money-500 where name=‘aaa‘;

update account set money=money+500 where name=‘bbb‘;

2.在B事务中

start transaction;

select * from account;

这时B事务中，读取信息时，是不能读到A事务未提交的数据的，也就解决了脏读。

让A事务，提交数据 commit;

这时，在查询，这次结果与上一次查询结果又不一样了，还存在不可重复读。

3.解决不可重复读

将事务的隔离级别设置为Repeatable read来解决不可重复读。

设置A,B事务隔离级别为   Repeatable read;

set session transaction isolation level  Repeatable read;

1.在A事务中

start transaction;

update account set money=money-500 where name=‘aaa‘;

update account set money=money+500 where name=‘bbb‘;

2.在B事务中

start transaction;

select * from account;

当A事务提交后commit;B事务在查询，与上次查询结果一致，解决了不可重复读。

4.设置事务隔离级别 Serializable ,它可以解决所有问题

set session transaction isolation level Serializable;

如果设置成这种隔离级别，那么会出现锁表。也就是说，一个事务在对表进行操作时，

其它事务操作不了。

--------------------------------------------------

总结:

脏读:一个事务读取到另一个事务为提交数据

不可重复读:两次读取数据不一致(读提交数据)---update

虚读:两次读取数据不一致(读提交数据)----insert

事务隔离级别:

read uncommitted 什么问题也解决不了.

read committed 可以解决脏读，其它解决不了.

Repeatable read 可以解决脏读，可以解决不可重复读,不能解决虚读.

Serializable 它会锁表，可以解决所有问题.

安全性：serializable > repeatable read > read committed > read uncommitted

性能 ：serializable < repeatable read < read committed < read uncommitted

 

结论： 实际开发中，通常不会选择 serializable 和 read uncommitted ，

mysql默认隔离级别 repeatable read ，oracle默认隔离级别 read committed