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="提交">
	</form>

  </body>
</html>

看运行结果：

事务的丢失更新问题（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表上进