首页 > 代码库 > 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，在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
IT十八掌 复习