首页 > 代码库 > IT十八掌 复习

IT十八掌 复习

复习:

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,在commitB事务在查询,就会发现,钱恢复成原样

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


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


IT十八掌 复习