8 MyBatis數(shù)據(jù)源與連接池#
8.1 MyBatis數(shù)據(jù)源DataSource分類##
MyBatis數(shù)據(jù)源實現(xiàn)是在以下四個包中：
MyBatis把數(shù)據(jù)源DataSource分為三種：
UNPOOLED 不使用連接池的數(shù)據(jù)源
POOLED 使用連接池的數(shù)據(jù)源
JNDI 使用JNDI實現(xiàn)的數(shù)據(jù)源
即：
相應(yīng)地糟秘，MyBatis內(nèi)部分別定義了實現(xiàn)了java.sql.DataSource接口的UnpooledDataSource，PooledDataSource類來表示UNPOOLED球散、POOLED類型的數(shù)據(jù)源尿赚。 如下圖所示：
對于JNDI類型的數(shù)據(jù)源DataSource，則是通過JNDI上下文中取值。
8.2 數(shù)據(jù)源DataSource的創(chuàng)建過程##
MyBatis數(shù)據(jù)源DataSource對象的創(chuàng)建發(fā)生在MyBatis初始化的過程中凌净。下面讓我們一步步地了解MyBatis是如何創(chuàng)建數(shù)據(jù)源DataSource的悲龟。
在mybatis的XML配置文件中，使用<dataSource>元素來配置數(shù)據(jù)源：
- MyBatis在初始化時冰寻，解析此文件须教，根據(jù)<dataSource>的type屬性來創(chuàng)建相應(yīng)類型的的數(shù)據(jù)源DataSource，即：
type=”POOLED” ：MyBatis會創(chuàng)建PooledDataSource實例
type=”UNPOOLED” ：MyBatis會創(chuàng)建UnpooledDataSource實例
type=”JNDI” ：MyBatis會從JNDI服務(wù)上查找DataSource實例斩芭，然后返回使用
- 順便說一下轻腺，MyBatis是通過工廠模式來創(chuàng)建數(shù)據(jù)源DataSource對象的，MyBatis定義了抽象的工廠接口:org.apache.ibatis.datasource.DataSourceFactory,通過其getDataSource()方法返回數(shù)據(jù)源DataSource：
public interface DataSourceFactory {
void setProperties(Properties props);
// 生產(chǎn)DataSource
DataSource getDataSource();
}
上述三種不同類型的type秒旋，則有對應(yīng)的以下dataSource工廠：
POOLED PooledDataSourceFactory
UNPOOLED UnpooledDataSourceFactory
JNDI JndiDataSourceFactory
其類圖如下所示：
- MyBatis創(chuàng)建了DataSource實例后约计，會將其放到Configuration對象內(nèi)的Environment對象中，供以后使用迁筛。
8.3 DataSource什么時候創(chuàng)建Connection對象##
當我們需要創(chuàng)建SqlSession對象并需要執(zhí)行SQL語句時煤蚌，這時候MyBatis才會去調(diào)用dataSource對象來創(chuàng)建java.sql.Connection對象。也就是說细卧，java.sql.Connection對象的創(chuàng)建一直延遲到執(zhí)行SQL語句的時候尉桩。
比如，我們有如下方法執(zhí)行一個簡單的SQL語句：
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.selectList("SELECT * FROM STUDENTS");
前4句都不會導(dǎo)致java.sql.Connection對象的創(chuàng)建贪庙，只有當?shù)?句sqlSession.selectList("SELECT * FROM STUDENTS")蜘犁，才會觸發(fā)MyBatis在底層執(zhí)行下面這個方法來創(chuàng)建java.sql.Connection對象：
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
}
setDesiredAutoCommit(autoCommmit);
}
8.4 不使用連接池的UnpooledDataSource##
當 <dataSource>的type屬性被配置成了”UNPOOLED”，MyBatis首先會實例化一個UnpooledDataSourceFactory工廠實例止邮，然后通過.getDataSource()方法返回一個UnpooledDataSource實例對象引用这橙，我們假定為dataSource。
使用UnpooledDataSource的getConnection(),每調(diào)用一次就會產(chǎn)生一個新的Connection實例對象导披。
UnPooledDataSource的getConnection()方法實現(xiàn)如下：
/*
* UnpooledDataSource的getConnection()實現(xiàn)
*/
public Connection getConnection() throws SQLException
{
return doGetConnection(username, password);
}
private Connection doGetConnection(String username, String password) throws SQLException
{
//封裝username和password成properties
Properties props = new Properties();
if (driverProperties != null)
{
props.putAll(driverProperties);
}
if (username != null)
{
props.setProperty("user", username);
}
if (password != null)
{
props.setProperty("password", password);
}
return doGetConnection(props);
}
/*
* 獲取數(shù)據(jù)連接
*/
private Connection doGetConnection(Properties properties) throws SQLException
{
//1.初始化驅(qū)動
initializeDriver();
//2.從DriverManager中獲取連接屈扎，獲取新的Connection對象
Connection connection = DriverManager.getConnection(url, properties);
//3.配置connection屬性
configureConnection(connection);
return connection;
}
如上代碼所示，UnpooledDataSource會做以下事情：
初始化驅(qū)動：判斷driver驅(qū)動是否已經(jīng)加載到內(nèi)存中撩匕，如果還沒有加載鹰晨，則會動態(tài)地加載driver類，并實例化一個Driver對象止毕，使用DriverManager.registerDriver()方法將其注冊到內(nèi)存中模蜡，以供后續(xù)使用。
創(chuàng)建Connection對象：使用DriverManager.getConnection()方法創(chuàng)建連接扁凛。
配置Connection對象：設(shè)置是否自動提交autoCommit和隔離級別isolationLevel讼稚。
返回Connection對象冤今。
上述的序列圖如下所示：
總結(jié)：從上述的代碼中可以看到侯繁，我們每調(diào)用一次getConnection()方法，都會通過DriverManager.getConnection()返回新的java.sql.Connection實例丸边。
8.5 為什么要使用連接池叠必？##
- 創(chuàng)建一個java.sql.Connection實例對象的代價
首先讓我們來看一下創(chuàng)建一個java.sql.Connection對象的資源消耗荚孵。我們通過連接Oracle數(shù)據(jù)庫，創(chuàng)建創(chuàng)建Connection對象纬朝，來看創(chuàng)建一個Connection對象收叶、執(zhí)行SQL語句各消耗多長時間。代碼如下：
public static void main(String[] args) throws Exception
{
String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";
PreparedStatement st = null;
ResultSet rs = null;
long beforeTimeOffset = -1L; //創(chuàng)建Connection對象前時間
long afterTimeOffset = -1L; //創(chuàng)建Connection對象后時間
long executeTimeOffset = -1L; //執(zhí)行Connection對象后時間
Connection con = null;
Class.forName("oracle.jdbc.driver.OracleDriver");
beforeTimeOffset = new Date().getTime();
System.out.println("before:\t" + beforeTimeOffset);
con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
afterTimeOffset = new Date().getTime();
System.out.println("after:\t\t" + afterTimeOffset);
System.out.println("Create Costs:\t\t" + (afterTimeOffset - beforeTimeOffset) + " ms");
st = con.prepareStatement(sql);
//設(shè)置參數(shù)
st.setInt(1, 101);
st.setInt(2, 0);
//查詢共苛，得出結(jié)果集
rs = st.executeQuery();
executeTimeOffset = new Date().getTime();
System.out.println("Exec Costs:\t\t" + (executeTimeOffset - afterTimeOffset) + " ms");
}
從此結(jié)果可以清楚地看出判没，創(chuàng)建一個Connection對象，用了250 毫秒隅茎；而執(zhí)行SQL的時間用了170毫秒澄峰。
創(chuàng)建一個Connection對象用了250毫秒！這個時間對計算機來說可以說是一個非常奢侈的辟犀！
這僅僅是一個Connection對象就有這么大的代價俏竞，設(shè)想一下另外一種情況：如果我們在Web應(yīng)用程序中，為用戶的每一個請求就操作一次數(shù)據(jù)庫堂竟，當有10000個在線用戶并發(fā)操作的話魂毁，對計算機而言，僅僅創(chuàng)建Connection對象不包括做業(yè)務(wù)的時間就要損耗10000×250ms= 250 0000 ms = 2500 s = 41.6667 min,竟然要41分鐘３鲟凇Ｏ！如果對高用戶群體使用這樣的系統(tǒng)税稼，簡直就是開玩笑烦秩！
- 問題分析：
創(chuàng)建一個java.sql.Connection對象的代價是如此巨大，是因為創(chuàng)建一個Connection對象的過程郎仆，在底層就相當于和數(shù)據(jù)庫建立的通信連接只祠，在建立通信連接的過程，消耗了這么多的時間丸升，而往往我們建立連接后（即創(chuàng)建Connection對象后）铆农，就執(zhí)行一個簡單的SQL語句，然后就要拋棄掉狡耻，這是一個非常大的資源浪費墩剖！
- 解決方案：
對于需要頻繁地跟數(shù)據(jù)庫交互的應(yīng)用程序，可以在創(chuàng)建了Connection對象夷狰，并操作完數(shù)據(jù)庫后岭皂，可以不釋放掉資源，而是將它放到內(nèi)存中沼头，當下次需要操作數(shù)據(jù)庫時爷绘，可以直接從內(nèi)存中取出Connection對象书劝，不需要再創(chuàng)建了，這樣就極大地節(jié)省了創(chuàng)建Connection對象的資源消耗土至。由于內(nèi)存也是有限和寶貴的购对，這又對我們對內(nèi)存中的Connection對象怎么有效地維護提出了很高的要求。我們將在內(nèi)存中存放Connection對象的容器稱之為連接池（Connection Pool）陶因。下面讓我們來看一下MyBatis的連接池是怎樣實現(xiàn)的骡苞。
8.6 使用了連接池的PooledDataSource##
同樣地，我們也是使用PooledDataSource的getConnection()方法來返回Connection對象】铮現(xiàn)在讓我們看一下它的基本原理：
PooledDataSource將java.sql.Connection對象包裹成PooledConnection對象放到了PoolState類型的容器中維護解幽。 MyBatis將連接池中的PooledConnection分為兩種狀態(tài)：空閑狀態(tài)（idle）和活動狀態(tài)(active)，這兩種狀態(tài)的PooledConnection對象分別被存儲到PoolState容器內(nèi)的idleConnections和activeConnections兩個List集合中：
idleConnections：空閑(idle)狀態(tài)PooledConnection對象被放置到此集合中烘苹，表示當前閑置的沒有被使用的PooledConnection集合躲株，調(diào)用PooledDataSource的getConnection()方法時，會優(yōu)先從此集合中取PooledConnection對象镣衡。當用完一個java.sql.Connection對象時霜定，MyBatis會將其包裹成PooledConnection對象放到此集合中。
activeConnections：活動(active)狀態(tài)的PooledConnection對象被放置到名為activeConnections的ArrayList中捆探，表示當前正在被使用的PooledConnection集合然爆，調(diào)用PooledDataSource的getConnection()方法時，會優(yōu)先從idleConnections集合中取PooledConnection對象,如果沒有黍图，則看此集合是否已滿曾雕，如果未滿，PooledDataSource會創(chuàng)建出一個PooledConnection助被，添加到此集合中剖张，并返回。
PoolState連接池的大致結(jié)構(gòu)如下所示：
- 獲取java.sql.Connection對象的過程
下面讓我們看一下PooledDataSource 的getConnection()方法獲取Connection對象的實現(xiàn)：
public Connection getConnection() throws SQLException {
return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();
}
public Connection getConnection(String username, String password) throws SQLException {
return popConnection(username, password).getProxyConnection();
}
上述的popConnection()方法揩环，會從連接池中返回一個可用的PooledConnection對象搔弄，然后再調(diào)用getProxyConnection()方法最終返回Conection對象。（至于為什么會有g(shù)etProxyConnection()丰滑，請關(guān)注下一節(jié)）顾犹。
現(xiàn)在讓我們看一下popConnection()方法到底做了什么：
先看是否有空閑(idle)狀態(tài)下的PooledConnection對象，如果有褒墨，就直接返回一個可用的PooledConnection對象炫刷；否則進行第2步。
查看活動狀態(tài)的PooledConnection池activeConnections是否已滿郁妈；如果沒有滿浑玛，則創(chuàng)建一個新的PooledConnection對象，然后放到activeConnections池中噩咪，然后返回此PooledConnection對象顾彰；否則進行第三步极阅；
看最先進入activeConnections池中的PooledConnection對象是否已經(jīng)過期：如果已經(jīng)過期，從activeConnections池中移除此對象涨享，然后創(chuàng)建一個新的PooledConnection對象筋搏，添加到activeConnections中，然后將此對象返回灰伟；否則進行第4步拆又。
線程等待，循環(huán)至第1步
/*
* 傳遞一個用戶名和密碼栏账，從連接池中返回可用的PooledConnection
*/
private PooledConnection popConnection(String username, String password) throws SQLException
{
boolean countedWait = false;
PooledConnection conn = null;
long t = System.currentTimeMillis();
int localBadConnectionCount = 0;
while (conn == null)
{
synchronized (state)
{
if (state.idleConnections.size() > 0)
{
// 連接池中有空閑連接，取出第一個
conn = state.idleConnections.remove(0);
if (log.isDebugEnabled())
{
log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
}
}
else
{
// 連接池中沒有空閑連接栈源，則取當前正在使用的連接數(shù)小于最大限定值挡爵，
if (state.activeConnections.size() < poolMaximumActiveConnections)
{
// 創(chuàng)建一個新的connection對象
conn = new PooledConnection(dataSource.getConnection(), this);
@SuppressWarnings("unused")
//used in logging, if enabled
Connection realConn = conn.getRealConnection();
if (log.isDebugEnabled())
{
log.debug("Created connection " + conn.getRealHashCode() + ".");
}
}
else
{
// Cannot create new connection 當活動連接池已滿，不能創(chuàng)建時甚垦，取出活動連接池的第一個茶鹃，即最先進入連接池的PooledConnection對象
// 計算它的校驗時間，如果校驗時間大于連接池規(guī)定的最大校驗時間艰亮，則認為它已經(jīng)過期了闭翩，利用這個PoolConnection內(nèi)部的realConnection重新生成一個PooledConnection
//
PooledConnection oldestActiveConnection = state.activeConnections.get(0);
long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
if (longestCheckoutTime > poolMaximumCheckoutTime)
{
// Can claim overdue connection
state.claimedOverdueConnectionCount++;
state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
state.accumulatedCheckoutTime += longestCheckoutTime;
state.activeConnections.remove(oldestActiveConnection);
if (!oldestActiveConnection.getRealConnection().getAutoCommit())
{
oldestActiveConnection.getRealConnection().rollback();
}
conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
oldestActiveConnection.invalidate();
if (log.isDebugEnabled())
{
log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
}
}
else
{
//如果不能釋放，則必須等待有
// Must wait
try
{
if (!countedWait)
{
state.hadToWaitCount++;
countedWait = true;
}
if (log.isDebugEnabled())
{
log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
}
long wt = System.currentTimeMillis();
state.wait(poolTimeToWait);
state.accumulatedWaitTime += System.currentTimeMillis() - wt;
}
catch (InterruptedException e)
{
break;
}
}
}
}
//如果獲取PooledConnection成功迄埃，則更新其信息
if (conn != null)
{
if (conn.isValid())
{
if (!conn.getRealConnection().getAutoCommit())
{
conn.getRealConnection().rollback();
}
conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
conn.setCheckoutTimestamp(System.currentTimeMillis());
conn.setLastUsedTimestamp(System.currentTimeMillis());
state.activeConnections.add(conn);
state.requestCount++;
state.accumulatedRequestTime += System.currentTimeMillis() - t;
}
else
{
if (log.isDebugEnabled())
{
log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
}
state.badConnectionCount++;
localBadConnectionCount++;
conn = null;
if (localBadConnectionCount > (poolMaximumIdleConnections + 3))
{
if (log.isDebugEnabled())
{
log.debug("PooledDataSource: Could not get a good connection to the database.");
}
throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
}
}
}
}
}
if (conn == null)
{
if (log.isDebugEnabled())
{
log.debug("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection.");
}
throw new SQLException("PooledDataSource: Unknown severe error condition. The connection pool returned a null connection.");
}
return conn;
}
對應(yīng)的處理流程圖如下所示：
如上所示,對于PooledDataSource的getConnection()方法內(nèi)疗韵，先是調(diào)用類PooledDataSource的popConnection()方法返回了一個PooledConnection對象，然后調(diào)用了PooledConnection的getProxyConnection()來返回Connection對象侄非。
- java.sql.Connection對象的回收
當我們的程序中使用完Connection對象時蕉汪，如果不使用數(shù)據(jù)庫連接池，我們一般會調(diào)用 connection.close()方法逞怨，關(guān)閉connection連接者疤，釋放資源。如下所示：
private void test() throws ClassNotFoundException, SQLException
{
String sql = "select * from hr.employees where employee_id < ? and employee_id >= ?";
PreparedStatement st = null;
ResultSet rs = null;
Connection con = null;
Class.forName("oracle.jdbc.driver.OracleDriver");
try
{
con = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:xe", "louluan", "123456");
st = con.prepareStatement(sql);
//設(shè)置參數(shù)
st.setInt(1, 101);
st.setInt(2, 0);
//查詢叠赦，得出結(jié)果集
rs = st.executeQuery();
//取數(shù)據(jù)驹马，省略
//關(guān)閉，釋放資源
con.close();
}
catch (SQLException e)
{
con.close();
e.printStackTrace();
}
}
調(diào)用過close()方法的Connection對象所持有的資源會被全部釋放掉除秀，Connection對象也就不能再使用糯累。
那么，如果我們使用了連接池鳞仙，我們在用完了Connection對象時寇蚊，需要將它放在連接池中，該怎樣做呢棍好？
為了和一般的使用Conneciton對象的方式保持一致仗岸，我們希望當Connection使用完后允耿，調(diào)用.close()方法，而實際上Connection資源并沒有被釋放扒怖，而實際上被添加到了連接池中较锡。這樣可以做到嗎？答案是可以盗痒。上述的要求從另外一個角度來描述就是：能否提供一種機制蚂蕴，讓我們知道Connection對象調(diào)用了什么方法，從而根據(jù)不同的方法自定義相應(yīng)的處理機制俯邓。恰好代理機制就可以完成上述要求.
怎樣實現(xiàn)Connection對象調(diào)用了close()方法骡楼，而實際是將其添加到連接池中：
這是要使用代理模式，為真正的Connection對象創(chuàng)建一個代理對象稽鞭，代理對象所有的方法都是調(diào)用相應(yīng)的真正Connection對象的方法實現(xiàn)鸟整。當代理對象執(zhí)行close()方法時，要特殊處理朦蕴，不調(diào)用真正Connection對象的close()方法篮条，而是將Connection對象添加到連接池中。
MyBatis的PooledDataSource的PoolState內(nèi)部維護的對象是PooledConnection類型的對象吩抓，而PooledConnection則是對真正的數(shù)據(jù)庫連接java.sql.Connection實例對象的包裹器涉茧。
PooledConnection對象內(nèi)持有一個真正的數(shù)據(jù)庫連接java.sql.Connection實例對象和一個java.sql.Connection的代理，其部分定義如下：
class PooledConnection implements InvocationHandler {
//......
//所創(chuàng)建它的datasource引用
private PooledDataSource dataSource;
//真正的Connection對象
private Connection realConnection;
//代理自己的代理Connection
private Connection proxyConnection;
//......
}
PooledConenction實現(xiàn)了InvocationHandler接口疹娶，并且伴栓，proxyConnection對象也是根據(jù)這個它來生成的代理對象：
public PooledConnection(Connection connection, PooledDataSource dataSource) {
this.hashCode = connection.hashCode();
this.realConnection = connection;
this.dataSource = dataSource;
this.createdTimestamp = System.currentTimeMillis();
this.lastUsedTimestamp = System.currentTimeMillis();
this.valid = true;
this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}
實際上，我們調(diào)用PooledDataSource的getConnection()方法返回的就是這個proxyConnection對象蚓胸。當我們調(diào)用此proxyConnection對象上的任何方法時挣饥，都會調(diào)用PooledConnection對象內(nèi)invoke()方法。
讓我們看一下PooledConnection類中的invoke()方法定義：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
//當調(diào)用關(guān)閉的時候沛膳，回收此Connection到PooledDataSource中
if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
dataSource.pushConnection(this);
return null;
} else {
try {
if (!Object.class.equals(method.getDeclaringClass())) {
checkConnection();
}
return method.invoke(realConnection, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
}
從上述代碼可以看到扔枫，當我們使用了pooledDataSource.getConnection()返回的Connection對象的close()方法時，不會調(diào)用真正Connection的close()方法锹安，而是將此Connection對象放到連接池中短荐。
8.7 JNDI類型的數(shù)據(jù)源DataSource##
對于JNDI類型的數(shù)據(jù)源DataSource的獲取就比較簡單，MyBatis定義了一個JndiDataSourceFactory工廠來創(chuàng)建通過JNDI形式生成的DataSource叹哭。下面讓我們看一下JndiDataSourceFactory的關(guān)鍵代碼：
if (properties.containsKey(INITIAL_CONTEXT) && properties.containsKey(DATA_SOURCE))
{
//從JNDI上下文中找到DataSource并返回
Context ctx = (Context) initCtx.lookup(properties.getProperty(INITIAL_CONTEXT));
dataSource = (DataSource) ctx.lookup(properties.getProperty(DATA_SOURCE));
}
else if (properties.containsKey(DATA_SOURCE))
{
//從JNDI上下文中找到DataSource并返回
dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE));
}
9 MyBatis事務(wù)管理機制#
9.1 概述##
對數(shù)據(jù)庫的事務(wù)而言忍宋，應(yīng)該具有以下幾點：創(chuàng)建（create）、提交（commit）风罩、回滾（rollback）糠排、關(guān)閉（close）。對應(yīng)地超升，MyBatis將事務(wù)抽象成了Transaction接口：
MyBatis的事務(wù)管理分為兩種形式：
- 使用JDBC的事務(wù)管理機制：即利用java.sql.Connection對象完成對事務(wù)的提交（commit()）入宦、回滾（rollback()）哺徊、關(guān)閉（close()）等。
- 使用MANAGED的事務(wù)管理機制：這種機制MyBatis自身不會去實現(xiàn)事務(wù)管理乾闰，而是讓程序的容器如（JBOSS落追，Weblogic）來實現(xiàn)對事務(wù)的管理。
這兩者的類圖如下所示：
9.2 事務(wù)的配置涯肩、創(chuàng)建和使用##
- 事務(wù)的配置
我們在使用MyBatis時轿钠，一般會在MyBatisXML配置文件中定義類似如下的信息：
<environment>節(jié)點定義了連接某個數(shù)據(jù)庫的信息，其子節(jié)點<transactionManager> 的type會決定我們用什么類型的事務(wù)管理機制病苗。
- 事務(wù)工廠的創(chuàng)建
MyBatis事務(wù)的創(chuàng)建是交給TransactionFactory 事務(wù)工廠來創(chuàng)建的疗垛，如果我們將<transactionManager>的type 配置為"JDBC",那么，在MyBatis初始化解析<environment>節(jié)點時铅乡，會根據(jù)type="JDBC"創(chuàng)建一個JdbcTransactionFactory工廠继谚，其源碼如下：
/**
* 解析<transactionManager>節(jié)點，創(chuàng)建對應(yīng)的TransactionFactory
* @param context
* @return
* @throws Exception
*/
private TransactionFactory transactionManagerElement(XNode context) throws Exception {
if (context != null) {
String type = context.getStringAttribute("type");
Properties props = context.getChildrenAsProperties();
/*
* 在Configuration初始化的時候阵幸，會通過以下語句，給JDBC和MANAGED對應(yīng)的工廠類
* typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
* typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
* 下述的resolveClass(type).newInstance()會創(chuàng)建對應(yīng)的工廠實例
*/
TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
factory.setProperties(props);
return factory;
}
throw new BuilderException("Environment declaration requires a TransactionFactory.");
}
如上述代碼所示芽世，如果type = "JDBC",則MyBatis會創(chuàng)建一個JdbcTransactionFactory.class 實例挚赊；如果type="MANAGED"，則MyBatis會創(chuàng)建一個MangedTransactionFactory.class實例济瓢。
MyBatis對<transactionManager>節(jié)點的解析會生成TransactionFactory實例荠割；而對<dataSource>解析會生成datasouce實例，作為<environment>節(jié)點旺矾，會根據(jù)TransactionFactory和DataSource實例創(chuàng)建一個Environment對象蔑鹦，代碼如下所示：
private void environmentsElement(XNode context) throws Exception {
if (context != null) {
if (environment == null) {
environment = context.getStringAttribute("default");
}
for (XNode child : context.getChildren()) {
String id = child.getStringAttribute("id");
//是和默認的環(huán)境相同時，解析之
if (isSpecifiedEnvironment(id)) {
//1.解析<transactionManager>節(jié)點箕宙，決定創(chuàng)建什么類型的TransactionFactory
TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
//2. 創(chuàng)建dataSource
DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
DataSource dataSource = dsFactory.getDataSource();
//3. 使用了Environment內(nèi)置的構(gòu)造器Builder，傳遞id 事務(wù)工廠TransactionFactory和數(shù)據(jù)源DataSource
Environment.Builder environmentBuilder = new Environment.Builder(id)
.transactionFactory(txFactory)
.dataSource(dataSource);
configuration.setEnvironment(environmentBuilder.build());
}
}
}
}
Environment表示著一個數(shù)據(jù)庫的連接柬帕，生成后的Environment對象會被設(shè)置到Configuration實例中哟忍，以供后續(xù)的使用。
上述一直在講事務(wù)工廠TransactionFactory來創(chuàng)建的Transaction陷寝，現(xiàn)在讓我們看一下MyBatis中的TransactionFactory的定義吧锅很。
- 事務(wù)工廠TransactionFactory
事務(wù)工廠Transaction定義了創(chuàng)建Transaction的兩個方法：一個是通過指定的Connection對象創(chuàng)建Transaction，另外是通過數(shù)據(jù)源DataSource來創(chuàng)建Transaction凤跑。與JDBC 和MANAGED兩種Transaction相對應(yīng)爆安，TransactionFactory有兩個對應(yīng)的實現(xiàn)的子類：
- 事務(wù)Transaction的創(chuàng)建
通過事務(wù)工廠TransactionFactory很容易獲取到Transaction對象實例。我們以JdbcTransaction為例仔引，看一下JdbcTransactionFactory是怎樣生成JdbcTransaction的扔仓，代碼如下：
public class JdbcTransactionFactory implements TransactionFactory {
public void setProperties(Properties props) {
}
/**
* 根據(jù)給定的數(shù)據(jù)庫連接Connection創(chuàng)建Transaction
* @param conn Existing database connection
* @return
*/
public Transaction newTransaction(Connection conn) {
return new JdbcTransaction(conn);
}
/**
* 根據(jù)DataSource褐奥、隔離級別和是否自動提交創(chuàng)建Transacion
*
* @param ds
* @param level Desired isolation level
* @param autoCommit Desired autocommit
* @return
*/
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
return new JdbcTransaction(ds, level, autoCommit);
}
}
如上說是，JdbcTransactionFactory會創(chuàng)建JDBC類型的Transaction当辐，即JdbcTransaction抖僵。類似地，ManagedTransactionFactory也會創(chuàng)建ManagedTransaction缘揪。下面我們會分別深入JdbcTranaction 和ManagedTransaction耍群，看它們到底是怎樣實現(xiàn)事務(wù)管理的。
- JdbcTransaction
JdbcTransaction直接使用JDBC的提交和回滾事務(wù)管理機制找筝。它依賴與從dataSource中取得的連接connection 來管理transaction 的作用域蹈垢，connection對象的獲取被延遲到調(diào)用getConnection()方法。如果autocommit設(shè)置為on袖裕，開啟狀態(tài)的話曹抬，它會忽略commit和rollback。
直觀地講急鳄，就是JdbcTransaction是使用的java.sql.Connection 上的commit和rollback功能谤民，JdbcTransaction只是相當于對java.sql.Connection事務(wù)處理進行了一次包裝（wrapper），Transaction的事務(wù)管理都是通過java.sql.Connection實現(xiàn)的疾宏。JdbcTransaction的代碼實現(xiàn)如下：
public class JdbcTransaction implements Transaction {
private static final Log log = LogFactory.getLog(JdbcTransaction.class);
//數(shù)據(jù)庫連接
protected Connection connection;
//數(shù)據(jù)源
protected DataSource dataSource;
//隔離級別
protected TransactionIsolationLevel level;
//是否為自動提交
protected boolean autoCommmit;
public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
dataSource = ds;
level = desiredLevel;
autoCommmit = desiredAutoCommit;
}
public JdbcTransaction(Connection connection) {
this.connection = connection;
}
public Connection getConnection() throws SQLException {
if (connection == null) {
openConnection();
}
return connection;
}
/**
* commit()功能 使用connection的commit()
* @throws SQLException
*/
public void commit() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}
/**
* rollback()功能 使用connection的rollback()
* @throws SQLException
*/
public void rollback() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Rolling back JDBC Connection [" + connection + "]");
}
connection.rollback();
}
}
/**
* close()功能 使用connection的close()
* @throws SQLException
*/
public void close() throws SQLException {
if (connection != null) {
resetAutoCommit();
if (log.isDebugEnabled()) {
log.debug("Closing JDBC Connection [" + connection + "]");
}
connection.close();
}
}
protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
try {
if (connection.getAutoCommit() != desiredAutoCommit) {
if (log.isDebugEnabled()) {
log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(desiredAutoCommit);
}
} catch (SQLException e) {
// Only a very poorly implemented driver would fail here,
// and there's not much we can do about that.
throw new TransactionException("Error configuring AutoCommit. "
+ "Your driver may not support getAutoCommit() or setAutoCommit(). "
+ "Requested setting: " + desiredAutoCommit + ". Cause: " + e, e);
}
}
protected void resetAutoCommit() {
try {
if (!connection.getAutoCommit()) {
// MyBatis does not call commit/rollback on a connection if just selects were performed.
// Some databases start transactions with select statements
// and they mandate a commit/rollback before closing the connection.
// A workaround is setting the autocommit to true before closing the connection.
// Sybase throws an exception here.
if (log.isDebugEnabled()) {
log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(true);
}
} catch (SQLException e) {
log.debug("Error resetting autocommit to true "
+ "before closing the connection. Cause: " + e);
}
}
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
}
setDesiredAutoCommit(autoCommmit);
}
}
- ManagedTransaction
ManagedTransaction讓容器來管理事務(wù)Transaction的整個生命周期张足，意思就是說，使用ManagedTransaction的commit和rollback功能不會對事務(wù)有任何的影響坎藐，它什么都不會做为牍，它將事務(wù)管理的權(quán)利移交給了容器來實現(xiàn)⊙意桑看如下Managed的實現(xiàn)代碼大家就會一目了然：
/**
*
* 讓容器管理事務(wù)transaction的整個生命周期
* connection的獲取延遲到getConnection()方法的調(diào)用
* 忽略所有的commit和rollback操作
* 默認情況下碉咆，可以關(guān)閉一個連接connection，也可以配置它不可以關(guān)閉一個連接
* 讓容器來管理transaction的整個生命周期
* @see ManagedTransactionFactory
*/
public class ManagedTransaction implements Transaction {
private static final Log log = LogFactory.getLog(ManagedTransaction.class);
private DataSource dataSource;
private TransactionIsolationLevel level;
private Connection connection;
private boolean closeConnection;
public ManagedTransaction(Connection connection, boolean closeConnection) {
this.connection = connection;
this.closeConnection = closeConnection;
}
public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
this.dataSource = ds;
this.level = level;
this.closeConnection = closeConnection;
}
public Connection getConnection() throws SQLException {
if (this.connection == null) {
openConnection();
}
return this.connection;
}
public void commit() throws SQLException {
// Does nothing
}
public void rollback() throws SQLException {
// Does nothing
}
public void close() throws SQLException {
if (this.closeConnection && this.connection != null) {
if (log.isDebugEnabled()) {
log.debug("Closing JDBC Connection [" + this.connection + "]");
}
this.connection.close();
}
}
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
this.connection = this.dataSource.getConnection();
if (this.level != null) {
this.connection.setTransactionIsolation(this.level.getLevel());
}
}
}
注意：如果我們使用MyBatis構(gòu)建本地程序蛀恩，即不是WEB程序疫铜，若將type設(shè)置成"MANAGED"，那么赦肋，我們執(zhí)行的任何update操作块攒，即使我們最后執(zhí)行了commit操作，數(shù)據(jù)也不會保留佃乘，不會對數(shù)據(jù)庫造成任何影響囱井。因為我們將MyBatis配置成了“MANAGED”，即MyBatis自己不管理事務(wù)趣避，而我們又是運行的本地程序庞呕，沒有事務(wù)管理功能，所以對數(shù)據(jù)庫的update操作都是無效的。
10 MyBatis關(guān)聯(lián)查詢#
MyBatis 提供了高級的關(guān)聯(lián)查詢功能住练，可以很方便地將數(shù)據(jù)庫獲取的結(jié)果集映射到定義的Java Bean中地啰。下面通過一個實例，來展示一下Mybatis對于常見的一對多和多對一關(guān)系復(fù)雜映射是怎樣處理的讲逛。
設(shè)計一個簡單的博客系統(tǒng)亏吝，一個用戶可以開多個博客，在博客中可以發(fā)表文章盏混，允許發(fā)表評論蔚鸥，可以為文章加標簽。博客系統(tǒng)主要有以下幾張表構(gòu)成：
Author表：作者信息表许赃，記錄作者的信息止喷，用戶名和密碼，郵箱等混聊。
Blog表：博客表弹谁，一個作者可以開多個博客，即Author和Blog的關(guān)系是一對多句喜。
Post表：文章記錄表预愤，記錄文章發(fā)表時間，標題咳胃，正文等信息鳖粟；一個博客下可以有很多篇文章，Blog 和Post的關(guān)系是一對多拙绊。
Comments表：文章評論表，記錄文章的評論泳秀，一篇文章可以有很多個評論：Post和Comments的對應(yīng)關(guān)系是一對多标沪。
Tag表：標簽表，表示文章的標簽分類嗜傅，一篇文章可以有多個標簽金句，而一個標簽可以應(yīng)用到不同的文章上，所以Tag和Post的關(guān)系是多對多的關(guān)系吕嘀；（Tag和Post的多對多關(guān)系通過Post_Tag表體現(xiàn)）
Post_Tag表：記錄 文章和標簽的對應(yīng)關(guān)系违寞。
一般情況下，我們會根據(jù)每一張表的結(jié)構(gòu)創(chuàng)建與此相對應(yīng)的JavaBean（或者Pojo）偶房，來完成對表的基本CRUD操作趁曼。
上述對單個表的JavaBean定義有時候不能滿足業(yè)務(wù)上的需求。在業(yè)務(wù)上棕洋，一個Blog對象應(yīng)該有其作者的信息和一個文章列表挡闰，如下圖所示：
如果想得到這樣的類的實例，則最起碼要有一下幾步：
通過Blog 的id 到Blog表里查詢Blog信息，將查詢到的blogId 和title 賦到Blog對象內(nèi)摄悯；
根據(jù)查詢到到blog信息中的authorId 去 Author表獲取對應(yīng)的author信息赞季，獲取Author對象，然后賦到Blog對象內(nèi)奢驯；
根據(jù) blogId 去 Post表里查詢 對應(yīng)的 Post文章列表申钩，將List<Post>對象賦到Blog對象中；
這樣的話瘪阁，在底層最起碼調(diào)用三次查詢語句撒遣，請看下列的代碼：
/*
* 通過blogId獲取BlogInfo對象
*/
public static BlogInfo ordinaryQueryOnTest(String blogId)
{
BigDecimal id = new BigDecimal(blogId);
SqlSession session = sqlSessionFactory.openSession();
BlogInfo blogInfo = new BlogInfo();
//1.根據(jù)blogid 查詢Blog對象，將值設(shè)置到blogInfo中
Blog blog = (Blog)session.selectOne("com.foo.bean.BlogMapper.selectByPrimaryKey",id);
blogInfo.setBlogId(blog.getBlogId());
blogInfo.setTitle(blog.getTitle());
//2.根據(jù)Blog中的authorId罗洗，進入數(shù)據(jù)庫查詢Author信息愉舔，將結(jié)果設(shè)置到blogInfo對象中
Author author = (Author)session.selectOne("com.foo.bean.AuthorMapper.selectByPrimaryKey",blog.getAuthorId());
blogInfo.setAuthor(author);
//3.查詢posts對象，設(shè)置進blogInfo中
List posts = session.selectList("com.foo.bean.PostMapper.selectByBlogId",blog.getBlogId());
blogInfo.setPosts(posts);
//以JSON字符串的形式將對象打印出來
JSONObject object = new JSONObject(blogInfo);
System.out.println(object.toString());
return blogInfo;
}
從上面的代碼可以看出伙菜，想獲取一個BlogInfo對象比較麻煩轩缤，總共要調(diào)用三次數(shù)據(jù)庫查詢，得到需要的信息贩绕，然后再組裝BlogInfo對象火的。
10.1 嵌套語句查詢##
mybatis提供了一種機制，叫做嵌套語句查詢淑倾，可以大大簡化上述的操作馏鹤，加入配置及代碼如下：
<resultMap type="com.foo.bean.BlogInfo" id="BlogInfo">
<id column="blog_id" property="blogId" />
<result column="title" property="title" />
<association property="author" column="blog_author_id"
javaType="com.foo.bean.Author" select="com.foo.bean.AuthorMapper.selectByPrimaryKey">
</association>
<collection property="posts" column="blog_id" ofType="com.foo.bean.Post"
select="com.foo.bean.PostMapper.selectByBlogId">
</collection>
</resultMap>
<select id="queryBlogInfoById" resultMap="BlogInfo" parameterType="java.math.BigDecimal">
SELECT
B.BLOG_ID,
B.TITLE,
B.AUTHOR_ID AS BLOG_AUTHOR_ID
FROM LOULUAN.BLOG B
where B.BLOG_ID = #{blogId,jdbcType=DECIMAL}
</select>
/*
* 通過blogId獲取BlogInfo對象
*/
public static BlogInfo nestedQueryOnTest(String blogId)
{
BigDecimal id = new BigDecimal(blogId);
SqlSession session = sqlSessionFactory.openSession();
BlogInfo blogInfo = new BlogInfo();
blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryBlogInfoById",id);
JSONObject object = new JSONObject(blogInfo);
System.out.println(object.toString());
return blogInfo;
}
通過上述的代碼完全可以實現(xiàn)前面的那個查詢。這里我們在代碼里只需要 blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryBlogInfoById",id);一句即可獲取到復(fù)雜的blogInfo對象娇哆。
嵌套語句查詢的原理：
在上面的代碼中湃累，Mybatis會執(zhí)行以下流程：
先執(zhí)行 queryBlogInfoById 對應(yīng)的語句從Blog表里獲取到ResultSet結(jié)果集；
取出ResultSet下一條有效記錄碍讨，然后根據(jù)resultMap定義的映射規(guī)格治力，通過這條記錄的數(shù)據(jù)來構(gòu)建對應(yīng)的一個BlogInfo 對象。
當要對BlogInfo中的author屬性進行賦值的時候勃黍，發(fā)現(xiàn)有一個關(guān)聯(lián)的查詢宵统，此時Mybatis會先執(zhí)行這個select查詢語句，得到返回的結(jié)果覆获，將結(jié)果設(shè)置到BlogInfo的author屬性上马澈；
對BlogInfo的posts進行賦值時，也有上述類似的過程弄息。
重復(fù)2步驟痊班，直至ResultSet. next () == false；
以下是blogInfo對象構(gòu)造賦值過程示意圖：
這種關(guān)聯(lián)的嵌套查詢疑枯，有一個非常好的作用就是：可以重用select語句辩块，通過簡單的select語句之間的組合來構(gòu)造復(fù)雜的對象。上面嵌套的兩個select語句com.foo.bean.AuthorMapper.selectByPrimaryKey和com.foo.bean.PostMapper.selectByBlogId完全可以獨立使用。
N+1問題：
它的弊端也比較明顯：即所謂的N+1問題废亭。關(guān)聯(lián)的嵌套查詢顯示得到一個結(jié)果集国章，然后根據(jù)這個結(jié)果集的每一條記錄進行關(guān)聯(lián)查詢。
現(xiàn)在假設(shè)嵌套查詢就一個（即resultMap 內(nèi)部就一個association標簽）豆村，現(xiàn)查詢的結(jié)果集返回條數(shù)為N液兽，那么關(guān)聯(lián)查詢語句將會被執(zhí)行N次，加上自身返回結(jié)果集查詢1次掌动，共需要訪問數(shù)據(jù)庫N+1次四啰。如果N比較大的話，這樣的數(shù)據(jù)庫訪問消耗是非常大的粗恢！所以使用這種嵌套語句查詢的使用者一定要考慮慎重考慮柑晒，確保N值不會很大。
以上面的例子為例眷射，select 語句本身會返回com.foo.bean.BlogMapper.queryBlogInfoById 條數(shù)為1 的結(jié)果集匙赞，由于它有兩條關(guān)聯(lián)的語句查詢，它需要共訪問數(shù)據(jù)庫 1*（1+1）=3次數(shù)據(jù)庫妖碉。
10.2 嵌套結(jié)果查詢##
嵌套語句的查詢會導(dǎo)致數(shù)據(jù)庫訪問次數(shù)不定涌庭，進而有可能影響到性能。Mybatis還支持一種嵌套結(jié)果的查詢：即對于一對多欧宜，多對多坐榆，多對一的情況的查詢，Mybatis通過聯(lián)合查詢冗茸，將結(jié)果從數(shù)據(jù)庫內(nèi)一次性查出來席镀，然后根據(jù)其一對多，多對一夏漱，多對多的關(guān)系和ResultMap中的配置愉昆，進行結(jié)果的轉(zhuǎn)換，構(gòu)建需要的對象麻蹋。
重新定義BlogInfo的結(jié)果映射 resultMap：
<resultMap type="com.foo.bean.BlogInfo" id="BlogInfo">
<id column="blog_id" property="blogId"/>
<result column="title" property="title"/>
<association property="author" column="blog_author_id" javaType="com.foo.bean.Author">
<id column="author_id" property="authorId"/>
<result column="user_name" property="userName"/>
<result column="password" property="password"/>
<result column="email" property="email"/>
<result column="biography" property="biography"/>
</association>
<collection property="posts" column="blog_post_id" ofType="com.foo.bean.Post">
<id column="post_id" property="postId"/>
<result column="blog_id" property="blogId"/>
<result column="create_time" property="createTime"/>
<result column="subject" property="subject"/>
<result column="body" property="body"/>
<result column="draft" property="draft"/>
</collection>
</resultMap>
對應(yīng)的sql語句如下：
<select id="queryAllBlogInfo" resultMap="BlogInfo">
SELECT
B.BLOG_ID,
B.TITLE,
B.AUTHOR_ID AS BLOG_AUTHOR_ID,
A.AUTHOR_ID,
A.USER_NAME,
A.PASSWORD,
A.EMAIL,
A.BIOGRAPHY,
P.POST_ID,
P.BLOG_ID AS BLOG_POST_ID ,
P.CREATE_TIME,
P.SUBJECT,
P.BODY,
P.DRAFT
FROM BLOG B
LEFT OUTER JOIN AUTHOR A
ON B.AUTHOR_ID = A.AUTHOR_ID
LEFT OUTER JOIN POST P
ON P.BLOG_ID = B.BLOG_ID
</select>
/*
* 獲取所有Blog的所有信息
*/
public static BlogInfo nestedResultOnTest()
{
SqlSession session = sqlSessionFactory.openSession();
BlogInfo blogInfo = new BlogInfo();
blogInfo = (BlogInfo)session.selectOne("com.foo.bean.BlogMapper.queryAllBlogInfo");
JSONObject object = new JSONObject(blogInfo);
System.out.println(object.toString());
return blogInfo;
}
嵌套結(jié)果查詢的執(zhí)行步驟：
根據(jù)表的對應(yīng)關(guān)系，進行join操作焊切，獲取到結(jié)果集扮授；
根據(jù)結(jié)果集的信息和BlogInfo 的resultMap定義信息，對返回的結(jié)果集在內(nèi)存中進行組裝专肪、賦值刹勃，構(gòu)造BlogInfo；
返回構(gòu)造出來的結(jié)果List<BlogInfo> 結(jié)果嚎尤。
對于關(guān)聯(lián)的結(jié)果查詢荔仁，如果是多對一的關(guān)系，則通過形如 <association property="author" column="blog_author_id" javaType="com.foo.bean.Author"> 進行配置，Mybatis會通過column屬性對應(yīng)的author_id 值去從內(nèi)存中取數(shù)據(jù)乏梁，并且封裝成Author對象次洼；
如果是一對多的關(guān)系，就如Blog和Post之間的關(guān)系遇骑，通過形如 <collection property="posts" column="blog_post_id" ofType="com.foo.bean.Post">進行配置卖毁，MyBatis通過 blog_Id去內(nèi)存中取Post對象，封裝成List<Post>落萎；
對于關(guān)聯(lián)結(jié)果的查詢亥啦，只需要查詢數(shù)據(jù)庫一次，然后對結(jié)果的整合和組裝全部放在了內(nèi)存中练链。
