首页 > 代码库 > JAVAWEB开发之事务详解(mysql与JDBC下使用方法、事务的特性、锁机制)和连接池的详细使用(dbcp以d3p0)

JAVAWEB开发之事务详解(mysql与JDBC下使用方法、事务的特性、锁机制)和连接池的详细使用(dbcp以d3p0)

事务简介

 事务的概念:事务指逻辑上的一组操作,组成这组操作的各个单元,要么全部成功,要么全部不成功
在开发中,有事务的存在,可以保证数据的完整性。
注意:数据库默认事务是自动提交的,也就是发一条SQL 就执行一条。如果想多条SQL语句放在一个事务中执行,需要添加事务有关的语句。

如何开启事务?

事务的操作方式:
创建表:
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);


(一)MySQL下如何开启事务
方式一:
      start  transaction   开启事务
      rollback    事务回滚(将数据恢复到事务开始时的状态)
      commit    事务提交(对事务中进行操作,进行确认操作,事务在提交后,数据就不可再进行恢复)
方式二:
     show variables like ‘%commit%‘;   可以查看当前autocommit 值
     在MySQL数据库中它的默认值是 "on" 代表自动事务。
     自动事务的意义就是:执行任意一条SQL语句都会自动提交事务。
     测试:将autocommit的值设置成off
           1. set autocommit=off  
           2. 必须手动commit才可以将事务提交
           注意:MySQL 默认autocommit=on   oracle默认的autocommit=off
                     如果设置autocommit 为 off,意味着以后每条SQL 都会处于一个事务中,相当于每条SQL执行前 都执行                      start transaction  
在MySQL客户端测试如下:
验证方式一:
技术分享    测试方式二:
技术分享
(二)jdbc下使用事务
当JDBC程序向数据库获得一个Connection(java.sql.Connection)对象时,默认情况下这个Connection对象会自动向数据库提交它上面发送的SQL语句。若想关闭这种默认提交方式,可使用下列语句:
  JDBC中的java.sql.Connection接口中有几个方是用于操作事务的:
(1)setAutoCommit(boolean  flag);  如果flag为false,它就相当于start transaction;
(2)rollback();   事务回滚
(3)commit();    提交事务

新建一个项目,导入MySQL数据库驱动 mysql-connector-java-5.1.28-bin.jar
在src下新建一个资源文件 jdbc.properties资源文件
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql:///mydb1
username=root
password=root

#driverClass=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:XE
#username=system
#password=system

新建cn.itcast.utils工具包,在包内封装数据库连接的工具类
package cn.itcast.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ResourceBundle;

//使用配置文件

public class JdbcUtils {

	private static final String DRIVERCLASS;
	private static final String URL;
	private static final String USERNAME;
	private static final String PASSWORD;

	static {
		DRIVERCLASS = ResourceBundle.getBundle("jdbc").getString("driverClass");
		URL = ResourceBundle.getBundle("jdbc").getString("url");
		USERNAME = ResourceBundle.getBundle("jdbc").getString("username");
		PASSWORD = ResourceBundle.getBundle("jdbc").getString("password");
	}

	static {
		try {
			// 将加载驱动操作,放置在静态代码块中.这样就保证了只加载一次.
			Class.forName(DRIVERCLASS);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public static Connection getConnection() throws SQLException {

		// 2.获取连接
		Connection con = DriverManager.getConnection(URL, USERNAME, PASSWORD);

		return con;
	}
	
	//关闭操作
	public static void closeConnection(Connection con) throws SQLException{
		if(con!=null){
			con.close();
		}
	}
	public static void closeStatement(Statement st) throws SQLException{
		if(st!=null){
			st.close();
		}
	}
	public static void closeResultSet(ResultSet rs) throws SQLException{
		if(rs!=null){
			rs.close();
		}
	}
}
新建简单测试类TransactionTest1.java
package cn.itcast.transaction;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import cn.itcast.utils.JdbcUtils;

//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();
		
	}
}
技术分享
真是的步骤是在出异常时进行回滚 如下代码所示:
package cn.itcast.transaction;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

import cn.itcast.utils.JdbcUtils;

//jdbc中事务操作
public class TransactionTest2 {

	public static void main(String[] args) {

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

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

		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):事务的隔离性是指多个用户并发访问数据库时,一个用户的事务不能被其它用户的事务所干扰,多个并发事务之间数据要相互隔离。
  • 持久性(Durablity):持久性是指一个事务一旦被提交,它对数据库中的数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响。
事务的隔离级别:
  多个线程开启各自事务操作数据库中数据时,数据库系统要负责隔离操作,以保证各个线程在获取数据时的准确性。
如果不考虑隔离性,可能会引发如下问题:
(1)脏读:指一个事务读取另一个事务未提交的数据
         A转账给B100,未提交
         B查询账户多了100
         A回滚
         B 查询账户那100不见了
(2)不可重复读:在一个事务先后两次读取发生数据不一致情况,第二次读取到另一个事务已经提交的数据(强调            数据更新update)
        A查询账户5000
        B 向A账户转入5000
        A查询账户10000
(3)虚读(幻读):在一个事务中,第二次读取发生数据记录数的不同,读取到另一个事务已经提交数据(强调数据记          录变化insert)
        A第一次读取 存在5条记录
        B向A插入一条新的记录
        A第二次读取 存在6条记录

 数据库内部定义了四种隔离级别,用于解决三种隔离问题
   (1)Serializable:可避免脏读、不可重复读、虚读情况的发生。(串行化)
   (2)Repeatable read:可避免脏读、不可重复读情况的发生,(可避免不可重复读)不可以避免虚读。
   (3)Read  commited:可避免脏读情况发生(读已提交)
   (4)Read uncommitted:最低级别,以上情况均无法保证(读未提交)

操作数据库内部隔离级别:
     set session transaction isolation level 隔离级别;   设置事务隔离级别
     select  @@tx_isolation    查询当前事务隔离级别
     注意:MySQL中默认的事务隔离级别是Repeatable read   oracle中默认的事务隔离级别是Read commited

实验一:演示脏读发生
在A窗口 将隔离级别设置read uncommitted
A、B窗口同时开启事务
A窗口执行转账操作 update account set money=money-500  where name=‘aaa‘;
update account set money=money+500 where name=‘bbb‘;  未提交事务
B窗口查询select * from account; 查询到转账结果(脏读)
A 回滚 rollback
B 窗口查询 金钱丢失
实例如下:
技术分享
   
实验二:解决脏读并演示不可重复读发生
将事务的隔离级别设置为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
这时,再次查询,B事务这次的查询结果与上次查询结果又不一样了,还存在着不可重复读。
技术分享

实验三:演示解决不可重复读
解决方案:将事务的隔离级别设置为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事务再查询 ,与上次查询结果一致,解决了不可重复读
技术分享

实验四:演示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

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,因为它指定了不受支持的事务。) 

实例演示事务操作——转账操作

实例结构和流程大致如下图所示:
技术分享

问题:service调用了dao中两个方法完成了一个业务操作,如果其中一个方法执行失败怎样办?
    需要事务控制
问题:怎样进行事务控制?
   我们在service层进行事务的开启,回滚以及提交操作。
问题:进行事务操作需要使用Connection对象,那么,怎样保证,在service中与dao中所使用的是同一个Connection.
在service层创建出Connection对象,将这个对象传递到dao层.
注意:Connecton对象使用完成后,在service层的finally中关闭,而每一个PreparedStatement它们在dao层的方法中用完就关闭.
关于程序问题
    对于转入与转出操作,我们需要判断是否成功,如果失败了,可以通过抛出自定义异常在servlet中判断,进行信息展示 。
问题:在设置dao层时,由于接口一般由别人设计,很难考虑到参数Connection
public interface AccountDao {
public void accountOut(String accountOut, double money) throws Exception;
        public void accountIn(String accountIn, double money) throws Exception;
}
那么我们自己去实现这个接口时,怎样处理,同一个Connection对象问题?
使用ThreadLocal
ThreadLocal可以理解成是一个Map集合
Map<Thread,Object>
set方法是向ThreadLocal中存储数据,那么当前的key值就是当前线程对象.
get方法是从ThreadLocal中获取数据,它是根据当前线程对象来获取值。
    如果我们是在同一个线程中,只要在任意的一个位置存储了数据,在其它位置上,就可以获取到这个数据。
关于JdbcUtils中使用ThreadLocal
    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中。
}

简单项目示例如下:
技术分享


带参数的模拟真实实现类_AccountDaoImpl
package cn.itcast.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import cn.itcast.exception.AccountException;
//没有使用ThreadLocal来获取Connection。
public class _AccountDaoImpl {

	// 从accountOut账户转出money
	public void accountOut(Connection con, String accountOut, double money)
			throws SQLException, AccountException {
		String sql = "update account set money=money-? where name=?";

		PreparedStatement pst = con.prepareStatement(sql);
		pst.setDouble(1, money);
		pst.setString(2, accountOut);
		int row = pst.executeUpdate();
		if (row == 0) {
			throw new AccountException("转出失败");
		}
		pst.close();
	}

	// 向accountIn账户转入money
	public void accountIn(Connection con, String accountIn, double money)
			throws SQLException, AccountException {
		String sql = "update account set money=money+? where name=?";

		PreparedStatement pst = con.prepareStatement(sql);
		pst.setDouble(1, money);
		pst.setString(2, accountIn);
		int row = pst.executeUpdate();
		if (row == 0) {
			throw new AccountException("转入失败");
		}
		pst.close();
	}

}
真实的实现类实现自别人设计的DAO接口,一般不会考虑到Connection
AccountDao接口如下:
package cn.itcast.dao;

import java.sql.Connection;

public interface AccountDao {
	public void accountOut(String accountOut, double money) throws Exception;

	public void accountIn(String accountIn, double money) throws Exception;

}
真实DAO实现类实现了AccountDao接口
package cn.itcast.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import cn.itcast.exception.AccountException;
import cn.itcast.utils.JdbcUtils;

public class AccountDaoImpl implements AccountDao {

	// 从accountOut账户转出money
	public void accountOut(String accountOut, double money)
			throws SQLException, AccountException {
		String sql = "update account set money=money-? where name=?";
		Connection con=JdbcUtils.getConnection();
		PreparedStatement pst = con.prepareStatement(sql);
		pst.setDouble(1, money);
		pst.setString(2, accountOut);
		int row = pst.executeUpdate();
		if (row == 0) {
			throw new AccountException("转出失败");
		}
		pst.close();
	}

	// 向accountIn账户转入money
	public void accountIn( String accountIn, double money)
			throws SQLException, AccountException {
		String sql = "update account set money=money+? where name=?";
		Connection con=JdbcUtils.getConnection();
		PreparedStatement pst = con.prepareStatement(sql);
		pst.setDouble(1, money);
		pst.setString(2, accountIn);
		int row = pst.executeUpdate();
		if (row == 0) {
			throw new AccountException("转入失败");
		}
		pst.close();
	}

}
AccountException.java  (自定义异常)
package cn.itcast.exception;

public class AccountException extends Exception {

	public AccountException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public AccountException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public AccountException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public AccountException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}

}
JdbcUtils.java   (封装Connection连接对象)
package cn.itcast.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ResourceBundle;

public class JdbcUtils {

	private static final String DRIVERCLASS;
	private static final String URL;
	private static final String USERNAME;
	private static final String PASSWORD;

	private static final ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
	static {
		DRIVERCLASS = ResourceBundle.getBundle("jdbc").getString("driverClass");
		URL = ResourceBundle.getBundle("jdbc").getString("url");
		USERNAME = ResourceBundle.getBundle("jdbc").getString("username");
		PASSWORD = ResourceBundle.getBundle("jdbc").getString("password");
	}

	static {
		try {
			// 将加载驱动操作,放置在静态代码块中.这样就保证了只加载一次.
			Class.forName(DRIVERCLASS);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public static Connection getConnection() throws SQLException {
		Connection con = tl.get();// 从ThreadLocal中获取Connection。第一次获取得到的是null.

		if (con == null) {
			// 2.获取连接
			con = DriverManager.getConnection(URL, USERNAME, PASSWORD);
			tl.set(con); // 将con装入到ThreadLocal中。
		}

		// tl.remove(); //解除
		return con;
	}

	// 关闭操作
	public static void closeConnection(Connection con) throws SQLException {
		if (con != null) {
			con.close();
		}
	}

	public static void closeStatement(Statement st) throws SQLException {
		if (st != null) {
			st.close();
		}
	}

	public static void closeResultSet(ResultSet rs) throws SQLException {
		if (rs != null) {
			rs.close();
		}
	}
}
AccountServlet.java   
package cn.itcast.web.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import cn.itcast.exception.AccountException;
import cn.itcast.service.AccountService;

public class AccountServlet extends HttpServlet {

	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.setContentType("text/html;charset=utf-8");

		// 1.得到请求参数
		String accountIn = request.getParameter("accountin");
		String accountOut = request.getParameter("accountout");

		double money = Double.parseDouble(request.getParameter("money"));

		// 2.调用service,完成汇款操作
		AccountService service = new AccountService();

		try {
			service.account(accountIn, accountOut, money);
			response.getWriter().write("转账成功");
			return;
		} catch (AccountException e) {
			e.printStackTrace();
			response.getWriter().write(e.getMessage());
			return;
		}
	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}

}

account.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    
    <title>My JSP ‘index.jsp‘ starting page</title>
  </head>
  
  <body>
	
	<form action="${pageContext.request.contextPath}/account" method="post">
		转入账户:<input type="text" name="accountin"><br>
		转出账户:<input type="text" name="accountout"><br>
		金额:<input type="text" name="money"><br>
		<input type="submit" value=http://www.mamicode.com/"提交">>看运行结果:
技术分享技术分享技术分享

事务的丢失更新问题(Lost Update)

两个或多个事务更新同一行,但这些事务彼此之间都不知道其他事务进行的修改,因此第二个更改覆盖了第一个修改。
技术分享
如何解决事务的丢失更新问题?
解决事务的丢失更新可以采用两种方式

方式一:悲观锁

       悲观锁(假设丢失更新一定会发生)——利用数据库内部锁机制,管理事务提供的锁机制
      (1)共享锁
                select  * from table lock  in  share mode  (读锁、共享锁)
      (2)排它锁
                select  * from table for update  (写锁、排它锁)
 悲观锁详解:  
       MySQL锁机制分为表级锁(例如  事务隔离级别中的Serializable)和行级锁。
共享锁又称为读锁,简称S锁,顾名思义,共享锁就是多个事务对于同一数据可以共享一把锁,都能访问到数据,但是只能读不能修改。
      排它锁又称为写锁,简称X锁,顾名思义,排他锁就是不能与其他锁并存,如一个事务获取了一个数据行的排他锁,其他事务就不能再获取该行的其他锁,包括共享锁和排他锁,但是获取排他锁的事务是可以对数据就行读取和修改。
  其实共享锁就是多个事务只能读数据不能改数据。对于排它锁而言,当排它锁锁住一行数据后 并不是说其他事务不能读取和修改这行数据,排它锁指的是一个事务在一行数据上加上排它锁后,其他事务不能在其上面加任何其他的锁。MySQL引擎默认的修改数据语句(update、insert、delete)都会自动给涉及到的数据加上排它锁,select 语句默认不会加任何锁类型,如果加排它锁可以使用select ... for update语句,加共享锁可以使用select ... lock in share mode语句。所以加过排它锁的数据行在其他事务中是不能修改数据的,也不能通过 for  update 和lock in share mode锁的方式查询数据,但是可以直接通过select ...  from ... 查询数据,因为普通查询默认没有任何锁机制。
实例演示如下:
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | aaa  |  1000 |
|  2 | bbb  |  1000 |
|  3 | ccc  |  1000 |
+----+------+-------+
3 rows in set (0.00 sec)
新建一个窗口 开启事务 对名字为aaa的数据进行排他查询,使用start transaction; 开启事务 先不关闭,因为提交事务或回滚事务就会释放锁。
技术分享
会查询到一条数据,现在打开另一个查询窗口,对同一数据分别使用排他查和共享锁查询两种方式查询

排他查:
技术分享
共享查:
技术分享
发现排它锁查询和共享锁查询都会出于阻塞状态,因为name=‘aaa‘的数据已经被加上了排它锁,此处阻塞是在等待排它锁的释放。
如果再开启一个不加锁的查询, 效果如下:
技术分享
是可以直接查询到数据的。
------------------------------------------------------------------------------------------------------------------------------------
接下来测试验证:一个事务获取了共享锁,在其他查询中也只能加共享锁或不加锁。
技术分享
接着打开窗口加共享锁进行查询
技术分享
不加锁查询
技术分享
可以看到是可以查询到数据结果的,但是加排它锁就查询不到,因为排它锁与共享锁不能存在于同一条记录上。
会出现阻塞 如下所示
技术分享
-------------------------------------------------------------------------------------------------------------------------------------------
最后验证MySQL中更新数据的语句自动加排它锁的问题:
技术分享

技术分享

此处共享查询处于阻塞,等待排它锁的释放,但是普通查询能查询到数据,因为没用上锁机制不与排它锁互斥,但查询到的数据时修改数据之前的数据。
技术分享

提交数据,释放排他锁看下修改后的数据,此时可用排他查,共享查和普通查询, 因为事务提交后该行数据释放排他锁
技术分享
 
提交事务后释放锁,再次查询如下:
技术分享       

方式二:乐观锁

采用记录的版本字段,来判断记录是否修改过 -------------- timestamp 
timestamp 可以自动更新
create table product (
   id int,
   name varchar(20),
   updatetime timestamp
);
insert into product values(1,‘冰箱‘,null);
update product set name=‘洗衣机‘ where id = 1;

 timestamp 在插入和修改时 都会自动更新为当前时间 
解决丢失更新:在数据表添加版本字段,每次修改过记录后,版本字段都会更新,如果读取是版本字段,与修改时版本字段不一致,说明别人进行修改过数据 (重改)
图解如下:
技术分享

数据库连接池

应用程序直接获取链接的缺点
技术分享
缺点:用户每次请求都需要向数据库获得链接,而数据库创建连接通常需要需要消耗相对较大的资源,创建的时间也比较长。假设网站一天10万访问量,数据库服务器也就需要创建10万次的连接,极大的浪费数据库的资源,并且极易造成数据库服务器内存溢出、拓机。
就需要引入连接池,所谓的连接池就是创建一个容器,用于装入多个Connection对象,在使用连接对象时,从容器中获取一个Connection,使用完成后,再将这个Connection重新装入容器中。这个容器就是连接池,也叫数据源(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接口,
 我们的自定义连接池必须实现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()方法。
(演示一)演示继承增强
package cn.itcast.zq;

//使用继承增强
public class Demo1 {

	public static void main(String[] args) {
		Person1 p=new Student1();
		
		p.eat();
	}
	
}

class Person1{
	
	public void eat(){
		System.out.println("吃两个馒头");
	}
}

class Student1 extends Person1{
	
	@Override
	public void eat(){
		super.eat();
		System.out.println("加两个鸡腿");
	}
}
技术分享

(演示二)演示装饰模式增强类行为
package cn.itcast.zq;

//使用装饰进行增强
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();
		
	}
}
技术分享

(演示三)演示动态代理增强类行为
package cn.itcast.zq;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import cn.itcast.utils.JdbcUtils;

public class Demo3 {

	public static void main(String[] args) throws SQLException, ClassNotFoundException {
		
		Class.forName("com.mysql.jdbc.Driver"); //注册驱动
				
		final Connection con = DriverManager.getConnection("jdbc:mysql:///mydb1","root","root");
		
		Connection proxy = (Connection) Proxy.newProxyInstance(con.getClass()
				.getClassLoader(), con.getClass().getInterfaces(),
				new InvocationHandler() {

					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {

						return method.invoke(con, args);
					}
				});

		System.out.println(proxy);

	}
}
运行发现出现了如下错误:
技术分享
这个异常出现的原因在于我使用的MySQL数据库驱动的问题,由于数据库驱动不同,Connection.class.getInterfaces()返回的结果也不同,它返回的是一个Class[]数组,然而此数组的第一个元素必须是Connection才能把创建的代理类转为Connection对象,否则就会报错。
 所以可以采用一个替代方式替代con.getClass().getInterfaces(),即new Class[]{Connection.class}  这样无论数据库驱动是什么版本的驱动,都能保证这个类型转换不出错。
修改后如下所示:
package cn.itcast.zq;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import cn.itcast.utils.JdbcUtils;

public class Demo3 {

	public static void main(String[] args) throws SQLException, ClassNotFoundException {
		
		Class.forName("com.mysql.jdbc.Driver"); //注册驱动
				
		final Connection con = DriverManager.getConnection("jdbc:mysql:///mydb1","root","root");
		
		Connection proxy = (Connection) Proxy.newProxyInstance(con.getClass()
				.getClassLoader(), new Class[]{Connection.class},
				new InvocationHandler() {

					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {

						return method.invoke(con, args);
					}
				});

		System.out.println(proxy);

	}
}
技术分享

------------------------------------------------------------------------------------------------------
开始自定义数据库连接池(DataSource)
package cn.itcast.datasource;

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;

import javax.sql.DataSource;

import cn.itcast.utils.JdbcUtils;

public class MyDataSource implements DataSource {

	private LinkedList<Connection> ll; // 用于装Connection对象的容器。

	public MyDataSource() throws SQLException {

		ll = new LinkedList<Connection>();
		// 当创建MyDateSource对象时,会向ll中装入5个Connection对象。

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

			Connection con = JdbcUtils.getConnection();

			ll.add(con);

		}

	}

	// 获取连接方法
	public Connection getConnection() throws SQLException {

		if (ll.isEmpty()) {
			for (int i = 0; i < 3; i++) {

				Connection con = JdbcUtils.getConnection();

				ll.add(con);

			}
		}

		final Connection con = ll.removeFirst();

		Connection proxyCon = (Connection) Proxy.newProxyInstance(con
				.getClass().getClassLoader(), new Class[]{ Connection.class},
				new InvocationHandler() {

					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						if ("close".equals(method.getName())) {

							// 这代表是close方法,它要做的事情是将con对象重新装入到集合中.

							ll.add(con);
							System.out.println("重新将连接对象装入到集合中");

							return null;

						} else {
							return method.invoke(con, args);// 其它方法执行原来操作
						}
					}
				});

		return proxyCon;
	}

	// 将Connection对象重新装入.
	// public void readd(Connection con) {
	//
	// ll.addLast(con);
	//
	// }

	// public int getSize() {
	// return ll.size();
	// }

	public Connection getConnection(String username, String password)
			throws SQLException {
		return null;
	}

	public PrintWriter getLogWriter() throws SQLException {
		return null;
	}

	public void setLogWriter(PrintWriter out) throws SQLException {

	}

	public void setLoginTimeout(int seconds) throws SQLException {

	}

	public int getLoginTimeout() throws SQLException {
		return 0;
	}

	public <T> T unwrap(Class<T> iface) throws SQLException {
		return null;
	}

	public boolean isWrapperFor(Class<?> iface) throws SQLException {
		return false;
	}

	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
		// TODO Auto-generated method stub
		return null;
	}

}
新建测试类,测试刚才新建的数据库连接池
package cn.itcast.datasource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

//测试自己定义的连接池
public class MyDataSourceTest {

	public static void main(String[] args) throws SQLException {
		DataSource mds = new MyDataSource(); // 创建一个连接池

		// 获取一个连接对象
		Connection con = mds.getConnection();

		// 操作
		ResultSet rs = con.createStatement().executeQuery(
				"select * from account");

		while (rs.next()) {

			System.out.println(rs.getInt("id") + "  " + rs.getString("name"));
		}

		rs.close();

		// 将连接对象重新装入到连接池
		// mds.readd(con);

		con.close(); // 原来作用是将Connection对象销毁,我们在使用连接池,获取Connection对象后,在调用close方法,就不在是销毁,而是将其重新放回到连接池。
		// System.out.println(mds.getSize());
	}
}
技术分享

DBCP连接池

DBCP是Apache软件基金组织下的开源连接池实现,使用DBCP数据源,应用程序应在系统中增加如下两个jar文件:
 commons-dbcp.jar:连接池的实现
 commons-pool.jar:连接池实现的依赖库
Tomcat的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用,也可以由应用程序独立使用。
DBCP连接池, 核心类:BasicDataSource
任何数据库连接池,都需要数据库连接,必须通过JDBC四个基本参数构造。
(1)手动设置参数
    // 使用连接池
   BasicDataSource  basicDataSource = new BasicDataSource();
  // 设置JDBC四个基本参数
   basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
   basicDataSource.setUrl("jdbc:mysql:///mydb1");
   basicDataSource.setUsername("root");
   basicDataSource.setPassword("root");
(2)通过配置文件
   // 根据属性参数 获得连接池
   InputStream in = DBCPTest.class.getResourceAsStream("/dbcp.properties");
   Properties properties = new Properties();
    // 装载输入流
    properties.load(in);
   DataSource dataSource = BasicDataSourceFactory.createDataSource(properties)
在src下新建dbcp.properties资源文件
 内容如下:
技术分享
配置内容可以查看doc文档查看,最简单的方法是 根据手动设置的参数进行按驼峰式的规则进行抽取即可。
导入dbcp和pooljar包
新建测试类如下:
package cn.itcast.datasource;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.junit.Test;

public class DbcpTest {

	// 1.手动配置
	@Test
	public void test1() throws SQLException {

		BasicDataSource bds = new BasicDataSource();

		// 需要设置连接数据库最基本四个条件
		bds.setDriverClassName("com.mysql.jdbc.Driver");
		bds.setUrl("jdbc:mysql:///mydb1");
		bds.setUsername("root");
		bds.setPassword("root");

		// 得到一个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.自动配置
	@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");
		
		InputStream fis = this.getClass().getResourceAsStream("/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绑定,支持JDBC2和JDBC3的标准扩展,目前使用它的开源项目有Hibernate,Spring等。
C3P0和DBCP的区别:
  DBCP 没有自动回收空闲连接的功能
  C3P0有自动回收空闲连接的功能
C3P0连接池的使用:
   导包:c3p0-x.x.x.x.jar
(1)手动
   ComboPooledDataSource cpds = new ComboPooledDataSource();
   cpds.setDriverClass("com.mysql.jdbc.Driver");
   cpds.setJdbcUrl("jdbc:mysql:///mydb1");
   cpds.setUser("root");
   cpds.setPassword("root");
(2)自动
          c3p0的配置文件可以是properties也可以是xml.
          c3p0的配置文件如果名称叫做 c3p0.properties or c3p0-config.xml 并且放置在classpath路径下(对于web应用就           是classes目录)
          那么c3p0会自动查找。
          注意:我们其时只需要将配置文件放置在src下就可以。
          使用:
ComboPooledDataSource cpds = new ComboPooledDataSource();
它会在指定的目录下查找指定名称的配置文件,并将其中内容加载。
          具体可以查看DOC文档
代码示例如下:
在src下新建c3p0-config.xml文件 配置内容如下:
<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql:///mydb1</property>
		<property name="user">root</property>
		<property name="password">root</property>
	</default-config>

</c3p0-config>
	
测试类如下:
package cn.itcast.datasource;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.junit.Test;

import com.mchange.v2.c3p0.ComboPooledDataSource;

//c3p0连接池
public class C3p0Test {

	//
	@Test
	public void test1() throws PropertyVetoException, SQLException {
		ComboPooledDataSource cpds = new ComboPooledDataSource();

		cpds.setDriverClass("com.mysql.jdbc.Driver");
		cpds.setJdbcUrl("jdbc:mysql:///mydb1");
		cpds.setUser("root");
		cpds.setPassword("root");

		// 得到一个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对象重新装入到连接池.

	}

	@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);
	}
}
技术分享
有关c3p0的详细配置如下(可以根据需要进行添加)
<c3p0-config>
 <default-config>
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement">3</property>

<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
 <property name="acquireRetryAttempts">30</property>

<!--两次连接中间隔时间,单位毫秒。Default: 1000 -->
 <property name="acquireRetryDelay">1000</property>

<!--连接关闭时默认将所有未提交的操作回滚。Default: false -->
 <property name="autoCommitOnClose">false</property>

<!--c3p0将建一张名为Test的空表,并使用其自带的查询语句进行测试。如果定义了这个参数那么
 属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作,它将只供c3p0测试
 使用。Default: null-->
<property name="automaticTestTable">Test</property>

<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
 保留,并在下次调用getConnection()的时候继续尝试获取连接。如果设为true,那么在尝试
 获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
<property name="breakAfterAcquireFailure">false</property>

<!--当连接池用完时客户端调用getConnection()后等待获取新连接的时间,超时后将抛出
SQLException,如设为0则无限期等待。单位毫秒。Default: 0 -->
<property name="checkoutTimeout">100</property>

<!--通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。
Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester-->
<property name="connectionTesterClassName"></property>

<!--指定c3p0 libraries的路径,如果(通常都是这样)在本地即可获得那么无需设置,默认null即可
Default: null-->
<property name="factoryClassLocation">null</property>

<!--Strongly disrecommended. Setting this to true may lead to subtle and bizarre bugs.
(文档原文)作者强烈建议不使用的一个属性-->
<property name="forceIgnoreUnresolvedTransactions">false</property>

<!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
<property name="idleConnectionTestPeriod">60</property>

<!--初始化时获取三个连接,取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize">3</property>

<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
<property name="maxIdleTime">60</property>

<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize">15</property>

<!--JDBC的标准参数,用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
 如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default: 0-->
<property name="maxStatements">100</property>

<!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0 -->
<property name="maxStatementsPerConnection"></property>

<!--c3p0是异步操作的,缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
 通过多线程实现多个操作同时被执行。Default: 3-->
 <property name="numHelperThreads">3</property>

<!--当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0
的数据源时。Default: null-->
<property name="overrideDefaultUser">root</property>

<!--与overrideDefaultUser参数对应使用的一个参数。Default: null-->
<property name="overrideDefaultPassword">password</property>

<!--密码。Default: null-->
<property name="password"></property>

<!--定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意:
 测试的表必须在初始数据源的时候就存在。Default: null-->
 <property name="preferredTestQuery">select id from test where id=1</property>

<!--用户修改系统配置参数执行前最多等待300秒。Default: 300 -->
<property name="propertyCycle">300</property>

<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
 时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。Default: false -->
<property name="testConnectionOnCheckout">false</property>

<!--如果设为true那么在取得连接的同时将校验连接的有效性。Default: false -->
<property name="testConnectionOnCheckin">true</property>

<!--用户名。Default: null-->
<property name="user">root</property>

<!--早期的c3p0版本对JDBC接口采用动态反射代理。在早期版本用途广泛的情况下这个参数
 允许用户恢复到动态反射代理以解决不稳定的故障。最新的非反射代理更快并且已经开始
 广泛的被使用,所以这个参数未必有用。现在原先的动态反射与新的非反射代理同时受到
 支持,但今后可能的版本可能不支持动态反射代理。Default: false-->
<property name="usesTraditionalReflectiveProxies">false</property>

 <property name="automaticTestTable">con_test</property>
 <property name="checkoutTimeout">30000</property>
 <property name="idleConnectionTestPeriod">30</property>
 <property name="initialPoolSize">10</property>
 <property name="maxIdleTime">30</property>
 <property name="maxPoolSize">25</property>
 <property name="minPoolSize">10</property>
 <property name="maxStatements">0</property>
 <user-overrides user="swaldman">
 </user-overrides>
 </default-config>
 <named-config name="dumbTestConfig">
 <property name="maxStatements">200</property>
 <user-overrides user="poop">
 <property name="maxStatements">300</property>
 </user-overrides>
 </named-config>
 </c3p0-config>


JAVAWEB开发之事务详解(mysql与JDBC下使用方法、事务的特性、锁机制)和连接池的详细使用(dbcp以d3p0)