在进入主题之前我们首先来了解一下JNDI和连接池~
一、JNDI
1）是一组在Java应用中访问命名和目录服务的API(Java命名与目录接口)
命名服务将名称和对象联系起来，使得我们可以通过名称访问对象。
目录服务是命名服务的扩展，两者之间的关键差别是目录服务中对象可以有属性(例如:用户有email地址)，而命名服务中对象没有属性。
2）JNDI API提供了一种统一的方式，可以在本地或网络上查找和访问服务
各种服务在命名服务器上注册一个名称，需要使用服务的应用程序通过JNDI找到对应服务就可以使用。
3）远程服务可以是任何的企业服务
DNS、LDAP(Lightweight Directory Access Protocol 轻型目录访问协议)、 CORBA对象服务、数据源对象，文件系统、Windows XP/2000/NT/Me/9x的注册表、RMI、EJB、JMS……
4）JNDI主要有两部分组成：应用程序编程接口和服务供应商接口。
应用程序编程接口提供了Java应用程序访问各种命名和目录服务的功能(API)
服务供应商接口提供了任意一种服务的供应商使用的功能(SPI:service provider interface)
JDBC与JNDI区别：
1）在JNDI中注册能操作数据(JDBC)的服务，应用程序找到服务访问数据
JDBC：本地有驱动程序，知道数据在哪里，只有一个应用程序能用
JNDI：可以获得访问数据相关的对象，从而操作数据。本地不需要驱动，也不需要知道数据在哪里，所有需要访问数据库的都可以用
2）JNDI中的数据访问
驱动代码的加载由服务提供方负责
应用程序需要URL找到指定的服务
3）JNDI API使应用程序可以通过逻辑名称获得指定的数据源
4）JNDI API提供数据库源服务需要以下内容：
与数据源关联的数据库驱动程序
数据源对象的引用名称
JDBC数据源接口
javax.sql.DataSource接口是在Java程序设计时使用JNDI获得数据库连接的工具
应用程序使用JNDI通过注册名称获得的就是DataSource实现类对象
通过DataSource实现类对象可以获得数据库连接对象(Connection)
所有需要访问数据库的应用程序都可以使用此服务，所以需要同时返回多个连接对象—连接池
由驱动程序供应商实现
实现DataSource接口的对象在基于JNDI API的命名服务中注册后，应用程序就可以通过JNDI获得相关对象，从而访问数据库服务器。
JNDI的范例程序也很少，在网上广泛流传的是一些与应用服务器结合的实例，如在Tomcat、JBoss、WebLogic中配置了JNDI的数据源，然后在程序中
去发现使用。这些例子大家都会，没意思。
能否在没有应用服务器的程序中使用JNDI技术呢？经过验证，答案是：可以！
package com.cn;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
public class TestFileSystemJNDI {
public static void main(String[] args) throws NamingException {
Hashtable env = new Hashtable();
String name = "F:\\denghbjar\\fscontext-1_2-beta3.zip";
// 文件系统服务的提供者
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
Context ctx = new InitialContext(env);
// 通过上下文查找名称对应的对象
Object obj = ctx.lookup(name);
System.out.println("名称：[" + name + "]绑定的对象是:" + obj);
}
}
名称：[F:\邓海波jar\fscontext-1_2-beta3.zip]绑定的对象是:F:\邓海波jar\fscontext-1_2-beta3.zip
因此还需要安装文件系统服务。这个例子我不用安装什么服务，下载个文件服务包就行了。其中的两个jar文件包：fscontext.jar和providerutil.jar
二、连接池
1）是缓存在内存中的多个可重复使用的数据库连接
2）客户端请求连接池获得一个连接对象(Connection)，然后就可以使用连接对象访问数据库
不需要客户端注册驱动程序
3）大大提高了数据访问性能
连接对象拿来就直接使用，不需要注册驱动及使用驱动创建连接对象
配置连接池：
连接池应该是在服务器或中间件中使用，客户端通过连接池获得连接对象用来访问数据库
使用DBCP实现连接池
commons-collections-3.2.1.jar
commons-dbcp-1.4.jar
commons-pool-1.6.jar
数据库驱动(mysql-connector-java-5.1.18-bin.jar)
创建xxx.properties文件对连接池属性进行配置
使用DBCP连接池，在xxx.properties文件中对连接池属性进行配置：
driverClassName=com.mysql.jdbc.Driver //配置驱动类
url=jdbc:mysql://localhost:3306/test //配置连接字符串
username=root //登陆数据库的用户名
password=root //登陆数据库的密码
maxActive=50 //最大活动连接数，设为0为没有限制
maxIdle=20 //最大空闲连接数，设为0为没有限制
maxWait=60000 //最大等待毫秒数，设为-1为没有限制
……
package com.cn;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
public class Test {
public static void main(String[] args) {
//创建属性文件对象
Properties p=new Properties();
//连接
Connection conn=null;
//预编译
PreparedStatement pst=null;
//结果集
ResultSet rs=null;
String sql = "select * from score;";
/*
* File f=new File("jdbc.properties");
* InputStream is=new FileInputStream(f);
* pro.load(is);
*/
try {
// 从输入流中读取属性列表（键和元素对）。
p.load(new FileInputStream("jdbc.properties"));
//得到数据源
DataSource ds=BasicDataSourceFactory.createDataSource(p);
//得到连接对象
conn=ds.getConnection();
//预编译，执行sql得到结果集
pst=conn.prepareStatement(sql);
rs=pst.executeQuery();
System.out.println("id\tChinese\tEnglish\thistory");
while(rs.next()){
System.out.print(rs.getInt("id")+"\t");
System.out.print(rs.getInt("Chinese")+"\t");
System.out.print(rs.getInt("English")+"\t");
System.out.println(rs.getInt("history")+"\t");
}
conn.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
1. 分布式事务
事务可分为本地事务和分布式事务(Spring中对应局部事务和全局事务).
本地事务和分布式事务的区别在于：本地事务只用于处理单一数据源事务（比如单个数据库），
分布式事务可以处理多种异构的数据源，比如某个业务操作中同时包含了
JDBC和JMS或者某个操作需要访问多个不同的数据库。
一个事务处理定义了一个工作逻辑单元，要么彻底成功要么不产生任何结果。
一个分布式事务处理只是一个在两个或更多网络资源上访问和更新数据的事务处理，
因此它在那些资源之间必然是等价的。
对于下面这个应用场景: 将用户 A 账户中的 500 元人民币转移到用户 B 的账户中，其操作流程如下
1. 将 A 账户中的金额减少 500
2. 将 B 账户中的金额增加 500
这两个操作必须保正 ACID 的事务属性：即要么全部成功，要么全部失败；
假若没有事务保障，用户的账号金额将可能发生问题：
假如第一步操作成功而第二步失败，那么用户 A 账户中的金额将就减少 500 元而
用户 B 的账号却没有任何增加（不翼而飞）；同样如果第一步出错 而第二步成功，
那么用户 A 的账户金额不变而用户 B 的账号将增加 500 元（凭空而生）。
上述任何一种错误都会产生严重的数据不一致问题，
事务的缺失对于一个稳定的生产系统是不可接受的。
针对上面的应用场景
(1) 对于本地事务(账户A和账户B存储在同一个数据库中),
我们需要获取一个普通的Connection连接,然后调用Connection的
setAutoCommit(false);conn.commit();conn.rollback();等方法即可实现事务控制.
如代码1所示.
(2)分布式事务处理(账户A和账户B分别在连接为connA和connB的数据库中),这时
实现分布式事务,需要事务管理器(TransactionManager),用户事务(UserTransaction,处理分布式事务),
分布式资源管理器(XADatasource),产生符合特定需求的资源(XAResource,能被TransactionManager管理的).
其中分布式资源用于产生分布式资源(如connA和connB的数据库连接).通过UserTransaction实现分布式事务.
如下代码2所示.
代码1（本地事务）
public void transferAccount()
{
Connection conn = null;
Statement stmt = null;
try
{
conn = getDataSource().getConnection();
// 将自动提交设置为 false，
// 若设置为 true 则数据库将会把每一次数据更新认定为一个事务并自动提交
conn.setAutoCommit(false);
stmt = conn.createStatement();
// 将 A 账户中的金额减少 500
stmt.execute("update t_account set amount = amount - 500 where account_id = 'A'");
// 将 B 账户中的金额增加 500
stmt.execute("update t_account set amount = amount + 500 where account_id = 'B'");
// 提交事务
conn.commit();
// 事务提交：转账的两步操作同时成功
} catch(SQLException sqle)
{
try
{
// 发生异常，回滚在本事务中的操做
conn.rollback();
// 事务回滚：转账的两步操作完全撤销
stmt.close();
conn.close();
}
catch(Exception ignore)
{
}
sqle.printStackTrace();
}
} 代码2(分布式事务)
public void transferAccount()
{
UserTransaction userTx = null;
Connection connA = null;
Statement stmtA = null;
Connection connB = null;
Statement stmtB = null;
try
{
// 获得 Transaction 管理对象
userTx = (UserTransaction)getContext().lookup("\
java:comp/UserTransaction");
// 从数据库 A 中取得数据库连接
connA = getDataSourceA().getConnection();
// 从数据库 B 中取得数据库连接
connB = getDataSourceB().getConnection();
// 启动事务
userTx.begin();
// 将 A 账户中的金额减少 500
stmtA = connA.createStatement();
stmtA.execute("
update t_account set amount = amount - 500 where account_id = 'A'");
// 将 B 账户中的金额增加 500
stmtB = connB.createStatement();
stmtB.execute("\
update t_account set amount = amount + 500 where account_id = 'B'");
// 提交事务
userTx.commit();
// 事务提交：转账的两步操作同时成功（数据库 A 和数据库 B 中的数据被同时更新）
}
catch(SQLException sqle)
{
try
{
// 发生异常，回滚在本事务中的操纵
userTx.rollback();
// 事务回滚：转账的两步操作完全撤销
//( 数据库 A 和数据库 B 中的数据更新被同时撤销）
stmt.close();
conn.close();
...
}catch(Exception ignore)
{
}
sqle.printStackTrace();
} catch(Exception ne)
{
e.printStackTrace();
}
}
3. JTA
上文中说过,实现分布式事务,需要事务管理器(TransactionManager),用户事务(UserTransaction,处理分布式事务),
分布式资源管理器(XADatasource),产生符合特定需求的资源(XAResource,能被TransactionManager管理的).
JDBC中只定义了分布式事务所需要的资源(XAResource)机器管理器(XADatasource),
还有事务管理器(TransactionManager),用户事务(UserTransaction)等则没有涉及,而这部分正是
JTA主要关注的.
JTA(Java Transaction API)定义了一种标准的API，应用系统由此可以存取各种事务监控。
4. 分布式事务的关键角色
资源管理器,主要用于产生符合接口的资源XAResource.比如上文中说的XADatasource.这个是JDBC中的规定的接口,
各大数据库厂商提供的数据库驱动需要实现这个接口.貌似有的数据库驱动不支持XA规范.还有的数据库驱动提供
普通版本的JDBC驱动和实现了XA的驱动(支持分布式事务的驱动).
事务管理器,在JTA中定义,TransactionManager,由JTA的实现者负责实现,比如JOTM的实现.
开发人员事务接口:UserTransaction,提供给开发人员的接口,也在JTA中定义.
要理解 JTA 的实现原理首先需要了解其架构：
它包括事务管理器（Transaction Manager）和一个或多个支持 XA 协议的
资源管理器 ( Resource Manager ) 两部分，
我们可以将资源管理器看做任意类型的持久化数据存储；
事务管理器则承担着所有事务参与单元的协调与控制。
根据所面向对象的不同，我们可以将 JTA 的事务管理器和资源管理器理解为两个方面：
面向开发人员的使用接口（事务管理器）和面向服务提供商的实现接口（资源管理器）。
其中开发接口的主要部分即为上述示例中引用的 UserTransaction 对象，
开发人员通过此接口在信息系统中实现分布式事务；
而实现接口则用来规范提供商（如数据库连接提供商）所提供的事务服务，
它约定了事务的资源管理功能，使得 JTA 可以在异构事务资源之间执行协同沟通。
以数据库为例，IBM 公司提供了实现分布式事务的数据库驱动程序，Oracle 也提供了实现分布式事务的数据库驱动程序，
在同时使用 DB2 和 Oracle 两种数据库连接时， JTA 即可以根据约定的接口协调者两种事务资源从而实现分布式事务。
正是基于统一规范的不同实现使得 JTA 可以协调与控制不同数据库或者 JMS 厂商的事务资源，其架构如下
开发人员使用开发人员接口，实现应用程序对全局事务的支持；各提供商（数据库，JMS 等）
依据提供商接口的规范提供事务资源管理功能；
事务管理器（ TransactionManager ）将应用对分布式事务的使用映射到实际的事务
资源并在事务资源间进行协调与控制。
下面，本文将对包括 UserTransaction、Transaction 和 TransactionManager
在内的三个主要接口以及其定义的方法进行介绍。
面向开发人员的接口为 UserTransaction （使用方法如上例所示），
开发人员通常只使用此接口实现 JTA 事务管理，其定义了如下的方法：
begin()- 开始一个分布式事务，
在后台 TransactionManager 会创建一个 Transaction 事务对象
并把此对象通过 ThreadLocale 关联到当前线程上
commit()- 提交事务
在后台 TransactionManager 会从当前线程下取出事务对象并把此对象所代表的事务提交
rollback()- 回滚事务
在后台 TransactionManager 会从当前线程下取出事务对象并把此对象所代表的事务回滚
getStatus()- 返回关联到当前线程的分布式事务的状态
Status 对象里边定义了所有的事务状态，感兴趣的读者可以参考 API 文档
setRollbackOnly()- 标识关联到当前线程的分布式事务将被回滚
面向提供商的实现接口主要涉及到
TransactionManager 和 Transaction 两个对象
Transaction 代表了一个物理意义上的事务，
在开发人员调用 UserTransaction.begin() 方法时
TransactionManager 会创建一个 Transaction 事务对象（标志着事务的开始）
并把此对象通过 ThreadLocale 关联到当前线程。
UserTransaction 接口中的 commit()、rollback()，getStatus()
等方法都将最终委托给 Transaction 类的对应方法执行。
Transaction 接口定义了如下的方法：
commit()- 协调不同的事务资源共同完成事务的提交
rollback()- 协调不同的事务资源共同完成事务的回滚
setRollbackOnly()- 标识关联到当前线程的分布式事务将被回滚
getStatus()- 返回关联到当前线程的分布式事务的状态
enListResource(XAResource xaRes, int flag)- 将事务资源加入到当前的事务中
在上述示例中，在对数据库 A 操作时 其所代表的事务资源将被关联到当前事务中，
同样，在对数据库 B 操作时其所代表的事务资源也将被关联到当前事务中
delistResourc(XAResource xaRes, int flag)- 将事务资源从当前事务中删除
registerSynchronization(Synchronization sync)- 回调接口，
Hibernate 等 ORM 工具都有自己的事务控制机制来保证事务，
但同时它们还需要一种回调机制以便在事务完成时得到通知从而触发一些处理工作，
如清除缓存等。这就涉及到了 Transaction 的回调接口 registerSynchronization。
工具可以通过此接口将回调程序注入到事务中，当事务成功提交后，回调程序将被激活。
TransactionManager 本身并不承担实际的事务处理功能，
它更多的是充当用户接口和实现接口之间的桥梁。
下面列出了 TransactionManager 中定义的方法，
可以看到此接口中的大部分事务方法与 UserTransaction 和 Transaction 相同。
在开发人员调用 UserTransaction.begin() 方法时 TransactionManager
会创建一个 Transaction 事务对象（标志着事务的开始）并把此对象通过 ThreadLocale 关联到当前线程上；
同样 UserTransaction.commit() 会调用 TransactionManager.commit()，
方法将从当前线程下取出事务对象 Transaction 并把此对象所代表的事务提交，
即调用 Transaction.commit()
begin()- 开始事务
commit()- 提交事务
rollback()- 回滚事务
getStatus()- 返回当前事务状态
setRollbackOnly()
getTransaction()- 返回关联到当前线程的事务
setTransactionTimeout(int seconds)- 设置事务超时时间
resume(Transaction tobj)- 继续当前线程关联的事务
suspend()- 挂起当前线程关联的事务
在系统开发过程中会遇到需要将事务资源暂时排除的操作，此时就需要调用 suspend() 方法将当前的事务挂起：
在此方法后面所做的任何操作将不会被包括在事务中，在非事务性操作完成后调用 resume()以继续事务
注： 要进行此操作需要获得 TransactionManager 对象， 其获得方式在不同的 J2EE 应用服务器上是不一样的
下面将通过具体的代码向读者介绍 JTA 实现原理。
下图列出了示例实现中涉及到的 Java 类，
其中 UserTransactionImpl 实现了 UserTransaction 接口，
TransactionManagerImpl 实现了 TransactionManager 接口，
TransactionImpl 实现了 Transaction 接口
清单 3. 开始事务 - UserTransactionImpl implenments UserTransaction
public void begin() throws NotSupportedException, SystemException
{
// 将开始事务的操作委托给 TransactionManagerImpl
TransactionManagerImpl.singleton().begin();
} // 此处 transactionHolder 用于将 Transaction 所代表的事务对象关联到线程上
private static ThreadLocal<TransactionImpl> transactionHolder
= new ThreadLocal<TransactionImpl>();
//TransacationMananger 必须维护一个全局对象，因此使用单实例模式实现
private static TransactionManagerImpl singleton = new TransactionManagerImpl();
private TransactionManagerImpl()
{
}
public static TransactionManagerImpl singleton()
{
return singleton;
}
public void begin() throws NotSupportedException, SystemException
{
//XidImpl 实现了 Xid 接口，其作用是唯一标识一个事务
XidImpl xid = new XidImpl();
// 创建事务对象，并将对象关联到线程
TransactionImpl tx = new TransactionImpl(xid);
transactionHolder.set(tx);
} public void commit() throws RollbackException, HeuristicMixedException,
HeuristicRollbackException, SecurityException,
IllegalStateException, SystemException
{
// 检查是否是 Roll back only 事务，如果是回滚事务
if(rollBackOnly)
{
rollback();
return;
}
else
{
// 将提交事务的操作委托给 TransactionManagerImpl
TransactionManagerImpl.singleton().commit();
}
} public void commit() throws RollbackException, HeuristicMixedException,
HeuristicRollbackException, SecurityException,
IllegalStateException, SystemException
{
// 取得当前事务所关联的事务并通过其 commit 方法提交
TransactionImpl tx = transactionHolder.get();
tx.commit();
} public void transferAccount()
{
UserTransaction userTx = null;
Connection mySqlConnection = null;
Statement mySqlStat = null;
Connection connB = null;
Statement stmtB = null;
try
{
// 获得 Transaction 管理对象
userTx = (UserTransaction)getContext().lookup("java:comp/UserTransaction");
// 以本地方式获得 mySql 数据库连接
mySqlConnection = DriverManager.getConnection("localhost:1111");
// 从数据库 B 中取得数据库连接， getDataSourceB 返回应用服务器的数据源
connB = getDataSourceB().getConnection();
// 启动事务
userTx.begin();
// 将 A 账户中的金额减少 500
//mySqlConnection 是从本地获得的数据库连接，不会被包含在全局事务中
mySqlStat = mySqlConnection.createStatement();
mySqlStat.execute("
update t_account set amount = amount - 500 where account_id = 'A'");
//connB 是从应用服务器得的数据库连接，会被包含在全局事务中
stmtB = connB.createStatement();
stmtB.execute("
update t_account set amount = amount + 500 where account_id = 'B'");
// 事务提交：connB 的操作被提交，mySqlConnection 的操作不会被提交
userTx.commit();
} catch(SQLException sqle){
// 处理异常代码
} catch(Exception ne){
e.printStackTrace();
}
}图 3. 事务资源类图
应用程序从支持分布式事务的数据源获得的数据库连接是 XAConnection 接口的实现，
而由此数据库连接创建的会话（Statement）也为了支持分布式事务而增加了功能，如下代码所示：
清单 8. JTA 事务资源处理
public void transferAccount()
{
UserTransaction userTx = null;
Connection conn = null;
Statement stmt = null;
try
{
// 获得 Transaction 管理对象
userTx = (UserTransaction)getContext().lookup("java:comp/UserTransaction");
// 从数据库中取得数据库连接， getDataSourceB 返回支持分布式事务的数据源
conn = getDataSourceB().getConnection();
// 会话 stmt 已经为支持分布式事务进行了功能增强
stmt = conn.createStatement();
// 启动事务
userTx.begin();
stmt.execute("update t_account ... where account_id = 'A'");
userTx.commit();
} catch(SQLException sqle){
// 处理异常代码
} catch(Exception ne){
e.printStackTrace();
}
} public void execute(String sql)
{
// 对于每次数据库操作都检查此会话所在的数据库连接是否已经被加入到事务中
associateWithTransactionIfNecessary();
try
{
// 处理数据库操作的代码
....
} catch(SQLException sqle){
// 处理异常代码
} catch(Exception ne){
e.printStackTrace();
}
}
public void associateWithTransactionIfNecessary()
{
// 获得 TransactionManager
TransactionManager tm = getTransactionManager();
Transaction tx = tm.getTransaction()；
// 检查当前线程是否有分布式事务
if(tx != null){
// 在分布式事务内，通过 tx 对象判断当前数据连接是否已经被包含在事务中，
//如果不是那么将此连接加入到事务中
Connection conn = this.getConnection();
//tx.hasCurrentResource， xaConn.getDataSource() 不是标准的 JTA
// 接口方法，是为了实现分布式事务而增加的自定义方法
if(!tx.hasCurrentResource(conn)){
XAConnection xaConn = (XAConnection)conn;
XADataSource xaSource = xaConn.getDataSource();
// 调用 Transaction 的接口方法，将数据库事务资源加入到当前事务中
tx.enListResource(xaSource.getXAResource(), 1);
}
}
} public void commit() throws RollbackException, HeuristicMixedException,
HeuristicRollbackException, SecurityException,
IllegalStateException, SystemException
{
// 得到当前事务中的所有事务资源
List<XAResource> list = getAllEnlistedResouces();
// 通知所有的事务资源管理器，准备提交事务
// 对于生产级别的实现，此处需要进行额外处理以处理某些资源准备过程中出现的异常
for(XAResource xa : list)
{
xa.prepare();
}
// 所有事务性资源，提交事务
for(XAResource xa : list)
{
xa.commit();
}
}
原文地址：http://blog.csdn.net/victor_cindy1/article/details/46673935
