Java进阶学习第十八天——事物与连接池
2016-05-16 12:15
369 查看
文档版本 | 开发工具 | 测试平台 | 工程名字 | 日期 | 作者 | 备注 |
---|---|---|---|---|---|---|
V1.0 | 2016.05.13 | lutianfei | none |
事务
事务的概念
事务就是一个事情,组成这个事情可能有多个单元,要求这些单元,要么全都成功,要么全都不成功。在开发中,有事务的存在,可以保证数据完整性。
例如:A——B转帐,对应于如下两条sql语句
update account set money=money-100 where name=‘a’;
update account set money=money+100 where name=‘b’;
数据库默认事务是自动提交的,也就是发一条sql它就执行一条。如果想多条sql放在一个事务中执行,则需要使用如下语句。
Start transaction ... commit
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;
JDBC下操作事物
当Jdbc程序向数据库获得一个Connection对象时,默认情况下这个Connection对象会自动向数据库提交在它上面发送的SQL语句。若想关闭这种默认提交方式,让多条SQL在一个事务中执行,可使用下列语句:java.sql.Connection接口中有几个方法是用于可以操作事务
1.setAutocommit(boolean flag);
如果flag=false;它就相当于start transaction;
2.rollBack()
事务回滚。
3.commit()
事务提交
银行转帐案例
在JDBC代码中使如下转帐操作在同一事务中执行。update from account set money=money-100 where name=‘a’;
update from account set money=money+100 where name=‘b’;
设置事务回滚点
Savepoint sp = conn.setSavepoint();
Conn.rollback(sp);
Conn.commit(); //回滚后必须要提交
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);
事务特性(重点) ACID
原子性(Atomicity)原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
一致性(Consistency)
事务前后数据的完整性必须保持一致。
隔离性(Isolation)
事务的
隔离性是指多个用户并发访问数据库时,一个用户的事务不能被其它用户的事务所干扰,多个并发事务之间数据要相互隔离。
持久性(Durability)
持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响
事务的隔离级别
多个线程开启各自事务操作数据库中数据时,数据库系统要负责隔离操作,以保证各个线程在获取数据时的准确性。[b]如果不考虑隔离性,可能会引发的问题[/b]
1.脏读 一个事务读取到另一个事务的未提交数据。
这是非常危险的,假设A向B转帐100元,对应sql语句如下所示
1.update account set money=money+100 while name=‘b’;
2.update account set money=money-100 while name=‘a’;
当第1条sql执行完,第2条还没执行(A未提交时),如果此时B查询自己的帐户,就会发现自己多了100元钱。如果A等B走后再回滚,B就会损失100元。
2.不可重复读
在一个事务内读取表中的某一行数据,多次读取结果不同。(update)
例如银行想查询A帐户余额,第一次查询A帐户为200元,此时A向帐户存了100元并提交了,银行接着又进行了一次查询,此时A帐户为300元了。银行两次查询不一致,可能就会很困惑,不知道哪次查询是准的。
和脏读的区别是,脏读是读取前一事务未提交的脏数据,不可重复读是重新读取了前一事务已提交的数据。
很多人认为这种情况就对了,无须困惑,当然是后面的为准。我们可以考虑这样一种情况,比如银行程序需要将查询结果分别输出到电脑屏幕和写到文件中,结果在一个事务中针对输出的目的地,进行的两次查询不一致,导致文件和屏幕中的结果不一致,银行工作人员就不知道以哪个为准了。
3.虚读(幻读)
是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。(insert)
如丙存款100元未提交,这时银行做报表统计account表中所有用户的总额为500元,然后丙提交了,这时银行再统计发现帐户为600元了,造成虚读同样会使银行不知所措,到底以哪个为准。
4.丢失更新
两个或多个事务更新同一行,但这些事务彼此之间都不知道其它事务进行的修改,因此第二个更改覆盖了第一个修改
[b]事务隔离性的设置语句[/b]
数据库共定义了四种隔离级别:
Serializable:可避免脏读、不可重复读、虚读情况的发生。(串行化)
Repeatable read:可避免脏读、不可重复读情况的发生。不可以避免虚读
Read committed:可避免脏读情况发生(读已提交)
Read uncommitted:最低级别,以上情况均无法保证。(读未提交)
安全性:serializable > repeatable read > read committed > read uncommitted
性能 :serializable < repeatable read < read committed < read uncommitted
结论: 实际开发中,通常不会选择 serializable 和 read uncommitted ,
怎样设置事务的隔离级别?
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可以取以下值:
TRANSACTION_READ_UNCOMMITTED,指示可以发生脏读、不可重复读、虚读。
TRANSACTION_READ_COMMITTED:指示不可以发生脏读,但是不可重复读、虚读可以发生。
TRANSACTION_REPEATABLE_READ:指示不可以发生脏读、不可重复读,但是虚读可以发生。
TRANSACTION_SERIALIZABLE:指示不可以发生脏读、不可重复读和虚读的常量。
TRANSACTION_NONE,一般不使用,因为它指定了不受支持的事务。)
[b]隔离级别方案演示[/b]
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;
如果设置成这种隔离级别,那么会出现锁表。也就是说,一个事务在对表进行操作时,其它事务操作不了。
[b]案例:转账汇款—-使用事务[/b]
问题:service调用了dao中两个方法完成了一个业务操作,如果其中一个方法执行失败怎样办?
需要事务控制
问题:怎样进行事务控制?
我们在service层进行事务的开启,回滚以及提交操作。
问题:进行事务操作需要使用Connection对象,怎样保证,在service中与dao中所使用的是同一个Connection.
在service层创建出Connection对象,将这个对象传递到dao层.
注意:Connecton对象使用完成后,在service层的finally中关闭
而每一个PreparedStatement它们在dao层的方法中用完就关闭.
关于程序问题
1.对于转入与转出操作,我们需要判断是否成功,如果失败了,可以通过抛出自定义异常在servlet中判断,进行信息展示 。
问题:
在设置dao层时,
public interface AccountDao { public void accountOut(String accountOut, double money) throws Exception; public void accountIn(String accountIn, double money) throws Exception; }
那么我们自己去实现这个接口时,怎样处理,同一个Connection对象问题?
[b]使用ThreadLocal[/b]
将一个值或对象,绑定在一个线程当中,在这个线程的任何位置都可以获取这个值或对象。
ThreadLocal可以理解成是一个Map集合,
Map<Thread,Object>
set方法是向ThreadLocal中存储数据,那么当前的key值就是当前线程对象。
get方法是从ThreadLocal中获取数据,它是根据当前线程对象来获取值。
如果我们是在同一个线程中,只要在任意的一个位置存储了数据,在其它位置上,就可以获取到这个数据。
[b]bcUtils中使用ThreadLocal[/b]
1.声明一个
ThreadLocal
private static final ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
2.在
getConnection()方法中操作
Connection con = tl.get(); 直接从ThreadLocal中获取,第一次返回的是null
if (con == null) { // 2.获取连接 con = DriverManager.getConnection(URL, USERNAME, PASSWORD); tl.set(con); //将con装入到ThreadLocal中。 }
丢失更新
多个事务对同一条记录进行了操作,后提交的事务将先提交的事务操作覆盖了。[b]解决丢失更新可以采用两种方式[/b]
1.悲观锁
悲观锁: 假设丢失更新一定会发生 ,利用数据库内部锁机制,管理事务
提供的锁机制
1.共享锁:在此记录上可以添加多个锁
select * from table lock in share mode(读锁、共享锁)
2.排它锁:在此记录上只可以加一个锁
select * from table for update (写锁、排它锁)
update语句默认添加排它锁
2.乐观锁( Optimistic Locking )
乐观锁假设丢失更新不会发生 ,采用程序中添加版本字段解决丢失更新问题
解决丢失更新:在数据表添加版本字段(通过时间戳字段),每次修改过记录后,版本字段都会更新,如果读取是版本字段,与修改时版本字段不一致,说明别人进行修改过数据 (重改)
create table product ( id int, name varchar(20), updatetime timestamp ); insert into product values(1,'冰箱',null); update product set name='洗衣机' where id = 1;
连接池
连接池:就是创建一个容器,用于装入多个Connection对象,在使用连接对象时,从容器中获取一个Connection, 使用完成后,在将这个Connection重新装入到容器中。这个容器就是
连接池。(
DataSource)也叫做
数据源.
作用:我们可以通过连接池获取连接对象。
优点:
节省创建连接与释放连接造成的性能消耗 —- 连接池中连接起到复用的作用 ,提高程序性能
应用程序直接获取链接
应用程序直接获取链接的缺点
用户每次请求都需要向数据库获得链接,而数据库创建连接通常需要消耗相对较大的资源,创建时间也较长。假设网站一天10万访问量,数据库服务器就需要创建10万次连接,极大的浪费数据库的资源,并且极易造成数据库服务器内存溢出、拓机。
数据库连接池编写原理分析
编写连接池需实现javax.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法:
Connection getConnection()
Connection getConnection(String username, String password)
实现DataSource接口,并实现连接池功能的步骤:
在DataSource构造函数中批量创建与数据库的连接,并把创建的连接保存到一个集合对象中
实现getConnection方法,让getConnection方法每次调用时,从集合对象中取一个Connection返回给用户。
当用户使用完Connection,调用Connection.close()方法时,Collection对象应保证将自己返回到连接池的集合对象中,而不要把conn还给数据库。
原来由jdbcUtil创建连接,现在由dataSource创建连接,为实现不和具体数据为绑定,因此datasource也应采用配置文件的方法获得连接。
自定义连接池
1.创建一个MyDataSource类,在这个类中创建一个LinkedList<Connection>
2.在其构造方法中初始化List集合,并向其中装入5个Connection对象。
3.创建一个public Connection getConnection();从List集合中获取一个连接对象返回.
4.创建一个 public void readd(Connection) 这个方法是将使用完成后的Connection对象重新装入到List集合中.
代码问题:
1.连接池的创建是有标准的.
在
javax.sql包下定义了一个接口
DataSource
所有的连接池必须实现
javax.sql.DataSource接口,
2.我们操作时,要使用标准,怎样可以让 con.close()它不是销毁,而是将其重新装入到连接池.
要解决这个问题,其本质就是将Connection中的close()方法的行为改变。
怎样可以改变一个方法的行为(对方法功能进行增强)
1.继承
2.装饰模式
1.装饰类与被装饰类要实现同一个接口或继承同一个父类
2.在装饰类中持有一个被装饰类引用
3.对方法进行功能增强。
3.动态代理
可以对行为增强
Proxy.newProxyInstance(ClassLoacer ,Class[],InvocationHandler);
结论:Connection对象如果是从连接池中获取到的,那么它的close方法的行为已经改变了,不在是销毁,而是重新装入到连接池。
1.连接池必须实现javax.sql.DataSource接口。
2.要通过连接池获取连接对象 DataSource接口中有一个 getConnection方法.
3.将Connection重新装入到连接池 使用Connection的close()方法。
动态代理增强close示例
使用动态代理技术构建连接池中的connection
proxyConn = (Connection) Proxy.newProxyInstance(this.getClass() .getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler() { //此处为内部类,当close方法被调用时将conn还回池中,其它方法直接执行 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getName().equals("close")) { pool.addLast(conn); return null; } return method.invoke(conn, args); } });
补充:装饰类例子
//使用装饰进行增强 public class Demo2 { public static void main(String[] args) { Car car=new Bmw(); //给车增强 CarDerector cd=new CarDerector(car); cd.run(); } } interface Car { void run(); } class Bmw implements Car { public void run() { System.out.println("bmw run...."); } } class Benz implements Car { public void run() { System.out.println("benz run...."); } } // 使用装饰来完成 class CarDerector implements Car { private Car car; public CarDerector(Car car) { this.car = car; } public void run() { System.out.println("添加导航"); car.run(); } }
开源连接池
现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现,即连接池的实现。通常我们把DataSource的实现,按其英文含义称之为数据源,数据源中都包含了数据库连接池的实现。也有一些开源组织提供了数据源的独立实现:
DBCP 数据库连接池
C3P0 数据库连接池
Apache Tomcat内置的连接池(apache dbcp)
实际应用时不需要编写连接数据库代码,直接从数据源获得数据库的连接。程序员编程时也应尽量使用这些数据源的实现,以提升程序的数据库访问性能。
DBCP数据源(了解)
DBCP 是 Apache 软件基金组织下的开源连接池实现使用DBCP数据源,应用程序应在系统中增加如下两个 jar 文件:
Commons-dbcp-1.4.jar:连接池的实现
Commons-pool-1.5.6.jar:连接池实现的依赖库
Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用,也可由应用程序独立使用。
[b]dbcp连接池使用[/b]
1.手动配置(手动编码)
// 1.手动配置 @Test public void test1() throws SQLException { BasicDataSource bds = new BasicDataSource(); // 需要设置连接数据库最基本四个条件 bds.setDriverClassName("com.mysql.jdbc.Driver"); bds.setUrl("jdbc:mysql:///day18"); bds.setUsername("root"); bds.setPassword("abc"); // 得到一个Connection Connection con = bds.getConnection(); ResultSet rs = con.createStatement().executeQuery( "select * from account"); while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } rs.close(); con.close(); // 将Connection对象重新装入到连接池. }
2.自动配置(使用配置文件)
// 2.自动配置 @Test public void test2() throws Exception { Properties props = new Properties(); // props.setProperty("driverClassName", "com.mysql.jdbc.Driver"); // props.setProperty("url", "jdbc:mysql:///day18"); // props.setProperty("username", "root"); // props.setProperty("password", "abc"); FileInputStream fis = new FileInputStream( "D:\\java1110\\workspace\\day18_2\\src\\dbcp.properties"); props.load(fis); DataSource ds = BasicDataSourceFactory.createDataSource(props); // 得到一个Connection Connection con = ds.getConnection(); ResultSet rs = con.createStatement().executeQuery( "select * from account"); while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } rs.close(); con.close(); // 将Connection对象重新装入到连接池. }
C3P0数据源(必会)
C3P0是一个开源的JDBC连接池,它实现了数据源和JNDI绑定,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,Spring等。
c3p0与dbcp区别
dbcp没有自动回收空闲连接的功能
c3p0有自动回收空闲连接功能
1.导包
c3p0-0.9.1.2.jar
1.手动使用
ComboPooledDataSource cpds = new ComboPooledDataSource(); cpds.setDriverClass("com.mysql.jdbc.Driver"); cpds.setJdbcUrl("jdbc:mysql:///day18"); cpds.setUser("root"); cpds.setPassword("abc");
2.自动(使用配置文件)
c3p0的配置文件可以是properties也可以是xml。
c3p0的配置文件如果名称叫做
c3p0.propertiesor
c3p0-config.xml并且放置在classpath路径下(对于web应用就是classes目录)那么c3p0会自动查找。
注意:我们其时只需要将配置文件放置在
src下就可以。
使用:
ComboPooledDataSource cpds = new ComboPooledDataSource();
它会在指定的目录下查找指定名称的配置文件,并将其中内容加载。
<?xml version="1.0" encoding="UTF-8"?> <c3p0-config> <default-config> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql:///day18</property> <property name="user">root</property> <property name="password">abc</property> </default-config> </c3p0-config> @Test public void test2() throws PropertyVetoException, SQLException { ComboPooledDataSource cpds = new ComboPooledDataSource(); // 得到一个Connection Connection con = cpds.getConnection(); ResultSet rs = con.createStatement().executeQuery( "select * from account"); while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } rs.close(); con.close(); // 将Connection对象重新装入到连接池. // String path = this.getClass().getResource("/").getPath(); // System.out.println(path); }
配置Tomcat数据源
tomcat服务器内置连接池 (使用Apache DBCP)配置tomcat 内置连接池,通过JNDI方式 去访问tomcat的内置连接池
[b]JNDI技术简介[/b]
JNDI(Java Naming and Directory Interface),Java**命名和目录接口,它对应于**J2SE中的
javax.naming包。是JavaEE一项技术,允许将一个Java对象绑定到一个JNDI容器(tomcat)中,并且为对象指定一个名称,通过javax.naming 包 Context 对JNDI 容器中绑定的对象进行查找,通过指定名称找到绑定Java对象。
这套API的主要作用在于:它可以把Java对象放在一个容器中(支持JNDI容器 Tomcat),并为容器中的java对象取一个名称,以后程序想获得Java对象,只需通过名称检索即可。
其核心API为Context,它代表JNDI容器,其lookup方法为检索容器中对应名称的对象。
[b]配置操作步骤[/b]
1、配置使用tomcat 内置连接池 配置
<context>元素
context元素有三种常见配置位置
1) tomcat/conf/context.xml 所有虚拟主机,所有工程都可以访问该连接池
2) tomcat/conf/Catalina/localhost/context.xml 当前虚拟主机(localhost)下所有工程都可以使用该连接池
3) 当前工程/META-INF/context.xml 只有当前工程可以访问该连接池
<Context> <Resource name="jdbc/EmployeeDB" auth="Container" type="javax.sql.DataSource" username="root" password="abc" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql:///day14" maxActive="8" maxIdle="4"/> </Context>
必须先将mysql驱动jar包 复制tomcat/lib下
在tomcat启动服务器时,创建连接池对象,绑定 jdbc/EmployeeDB 指定名称上
2、通过运行在JNDI容器内部的程序(Servlet/JSP)去访问tomcat内置连接池
public class DataSourceServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { Context context = new InitialContext(); Context envCtx = (Context) context.lookup("java:comp/env"); // 固定路径 DataSource datasource = (DataSource) envCtx .lookup("jdbc/EmployeeDB");//自己定义的数据库名字 Connection con = datasource.getConnection(); ResultSet rs = con.createStatement().executeQuery( "select * from account"); while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } } catch (Exception e) { e.printStackTrace(); } } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } }
相关文章推荐
- dfs(JAVA)
- 第一次启动springboot的辛酸历程
- new Handler().postDelayed() 延迟intent跳转
- bfs(JAVA)
- Java中获取键盘输入值的方法
- Java中随机数的生成
- Java数组基础
- JAVA常用工具总结
- smartupload下载
- 跟着龙哥学JavaWeb(jSP底层分析和Helloworld)
- 一个.java源文件中可以有多个类吗?(内部类除外)有什么条件?
- java的封神之路[转载]
- Java堆内存
- 关于java中注解Annotation的分析介绍
- java+jsp导入excel
- maven基础篇(5)-eclipse构建maven-web项目
- Java并发编程—阻塞队列源码分析
- Java 堆内存和栈内存详解
- java中JLabel设置背景图片
- 【Java】Java NIO