轉自：http://www.iteye.com/topic/255397

1.那即將離我遠去的

用buffalo作為我的ajax類庫也有些歷史了,幾乎是和Spring同時開始接觸的.

按照官方的方式,Buffalo與Spring的集成是很簡單:

    在Spring中配置一個BuffaloServiceConfigure bean,把spring托管的服務在其中聲明即可,Buffalo可以通過ServletContext得到Spring的WebApplicationContext,進而得到所需的服務:

<bean name="buffaloConfigBean" 
                class="net.buffalo.service.BuffaloServiceConfigurer"> 
                <property name="services"> 
                        <map> 
                                <entry key="springSimpleService"> 
                                        <ref bean="systemService" /> 
                                </entry> 
                                <entry key="springSimpleService2"> 
                                        <ref bean="systemService2" /> 
                                </entry> 
                        </map> 
                </property> 
 </bean> 

 

     似乎很簡單,但,有沒有覺得似乎很傻?只是把Spring里已經配置好的bean再引用一次而已,

一旦面臨協作開發,和所有的全局配置文件一樣,BuffaloServiceConfigure bean下面就會囊括幾十上百個service ref,一大堆人圍著這個配置文件轉,CVS沖突就成了家常便飯了,苦惱不已.當然,按我們這么多年的開發經驗是不會出現這種低級錯誤的,早早的在項目設計階段就會按模塊劃分出多個配置文件,一人獨用,無需和別人共享配置,輕松面對沖突問題,帶來的局面就是每個包里都塞著一個buffalo.xml,一個項目里配置文件到處有,不斷得copy/paste,層層套套,那可不是碩果累累的滿足感.

     當然,Spring本身在2.5之前也因XML配置繁瑣而讓人詬病,Guice才能異軍突起,那時Spring比Buffalo的配置更多,所以Buffalo的問題也就不是問題了.但有一天,我終于要正式升級到Spring2.5.

     世界清靜了!使用annotation,看到怎么多配置文件消失,看到簡潔的Bean/MVC配置,呵呵,還真是令人心情愉悅的.

     誒,等等,怎么還有大堆XML?哦?原來是Buffalo...

     Buffalo像個刺頭,傻愣愣地杵在XML里.

 

2.于是我開始把Buffalo也Annotation化.

 

話說Spring的擴展能力還是ganggang的,一天時間,就有成果了.

先寫個注解:

package cn.tohot.common.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * buffalo擴展接口,用于表明該類是一個buffalo服務.
 * @author tedeyang
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Buffalo {
	/**
	 * @return 遠程調用時的服務名.
	 */ 
	String value();
}

 

接著再寫Spring的擴展

 

/**
 * 
 */
package cn.tohot.common.annotation;

import java.util.HashMap;

import net.buffalo.service.BuffaloServiceConfigurer;

import org.apache.log4j.Logger;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 該類作為FactoryBean可以無縫替換buffalo 2.0自帶的配置類,并使用annotation進行配置.
 * @author tedeyang
 *
 */
@SuppressWarnings("unchecked")
public class BuffaloAnnotationServiceFactoryBean implements FactoryBean, InitializingBean, DisposableBean, BeanPostProcessor {
	private static final Logger log = Logger.getLogger(BuffaloAnnotationServiceFactoryBean.class);

	private BuffaloServiceConfigurer buffaloConfigurer = null;

	public BuffaloAnnotationServiceFactoryBean() {
		buffaloConfigurer = new BuffaloServiceConfigurer();
		buffaloConfigurer.setServices(new HashMap());
	}

	private void addBuffaloBean(String buffaloServiceName,Object bean) {
		buffaloConfigurer.getServices().put(buffaloServiceName, bean);
		log.info("Add a buffalo service :"+buffaloServiceName);
	}

	public Object getObject() throws Exception {
		return this.buffaloConfigurer;
	}

	public Class getObjectType() {
		return BuffaloServiceConfigurer.class;
	}

	public boolean isSingleton() {
		return true;
	}

	public void afterPropertiesSet() throws Exception {
 	}

	public void destroy() throws Exception {
		if (buffaloConfigurer != null)
			buffaloConfigurer.setServices(null);
		buffaloConfigurer = null;
	}
 
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		log.debug("find a bean:"+beanName);
		if (bean.getClass().isAnnotationPresent(Buffalo.class)) {
			Buffalo buffalo = bean.getClass().getAnnotation(Buffalo.class);
			addBuffaloBean(buffalo.value(), bean); 
		}
		return bean;
	}

}

 

 主要思路是用FactoryBean替換原BuffaloServiceConfigurer,并掛上BeanPostProcessor的鉤子,檢測一下annotation,發現buffalo服務就添加到原BuffaloServiceConfigurer中去.

 

3.今天我這樣配置Buffalo:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

	<!-- Spring Annotation配置, 自動搜索組件 -->
	<context:component-scan base-package="cn.tohot.demo"/> 
  	<bean id="buffalo"	class="cn.tohot.common.annotation.BuffaloAnnotationServiceFactoryBean" /> 
</beans>

 

 服務端的Buffalo bean 類:

package cn.tohot.demo;

import org.springframework.stereotype.Service;

import cn.tohot.common.annotation.Buffalo;

@Service     //聲明Spring bean,
@Buffalo("testbean") //聲明一個名為"testbean"的Buffalo service
public class BuffaloBeanTestService {
	public String run() {
		System.out.println("run");
		return "run";
	}
}

 很簡潔,不是嗎?

轉自：http://www.iteye.com/topic/11738
前幾天解釋了Spring的抽象事務機制。這次講講Spring中的DataSource 事務。
DataSource事務相關的類比較多，我們一步步來撥開其中的密團。

1 如何獲得連接
看DataSourceUtils代碼

protected static Connection doGetConnection(DataSource dataSource, boolean allowSynchronization);
			throws SQLException {
		
		ConnectionHolder conHolder = (ConnectionHolder); TransactionSynchronizationManager.getResource(dataSource);;
		if (conHolder != null); {
			conHolder.requested();;
			return conHolder.getConnection();;
		}

		
		Connection con = dataSource.getConnection();;
		if (allowSynchronization && TransactionSynchronizationManager.isSynchronizationActive();); {
						conHolder = new ConnectionHolder(con);;
			TransactionSynchronizationManager.bindResource(dataSource, conHolder);;
			TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(conHolder, dataSource););;
			conHolder.requested();;
		}

		return con;
	}

原來連接是從TransactionSynchronizationManager中獲取，如果TransactionSynchronizationManager中已經有了，那么拿過來然后調用conHolder.requested()。否則從原始的DataSource這創建一個連接，放到一個ConnectionHolder，然后再調用TransactionSynchronizationManager.bindResource綁定。
好，我們又遇到兩個新的類TransactionSynchronizationManager和ConnectionHolder和。繼續跟蹤


2 TransactionSynchronizationManager
看其中的一些代碼

private static ThreadLocal resources = new ThreadLocal();;
public static Object getResource(Object key); {
		Map map = (Map); resources.get();;
		if (map == null); {
			return null;
		}
		Object value = map.get(key);;
				return value;
	}
public static void bindResource(Object key, Object value); throws IllegalStateException {
		Map map = (Map); resources.get();;
				if (map == null); {
			map = new HashMap();;
			resources.set(map);;
		}
		map.put(key, value);;
			}

原來TransactionSynchronizationManager內部建立了一個ThreadLocal的resources，這個resources又是和一個map聯系在一起的，這個map在某個線程第一次調用bindResource時生成。
聯系前面的DataSourceUtils代碼，我們可以總結出來。
某個線程使用DataSourceUtils，當第一次要求創建連接將在TransactionSynchronizationManager中創建出一個ThreadLocal的map。然后以DataSource作為鍵，ConnectionHolder為值放到map中。等這個線程下一次再請求的這個DataSource的時候，就從這個map中獲取對應的ConnectionHolder。用map是為了解決同一個線程上多個DataSource。
然后我們來看看ConnectionHolder又是什么？



3 對連接進行引用計數
看ConnectionHolder代碼，這個類很簡單，看不出個所以然，只好再去看父類代碼ResourceHolderSupport，我們感興趣的是這兩個方法

public void requested(); {
		this.referenceCount++;
	}

	public void released(); {
		this.referenceCount--;
	}

看得出這是一個引用計數的技巧。原來Spring中對Connection是竟量使用已創建的對象，而不是每次都創建一個新對象。這就是DataSourceUtils中

if (conHolder != null); {
			conHolder.requested();;
			return conHolder.getConnection();;
		}

的原因


4 釋放連接
完成事物后DataSourceTransactionManager有這樣的代碼

protected void doCleanupAfterCompletion(Object transaction); {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject); transaction;

		// Remove the connection holder from the thread.
		TransactionSynchronizationManager.unbindResource(this.dataSource);;
		txObject.getConnectionHolder();.clear();;

		//...		DataSourceUtils.closeConnectionIfNecessary(con, this.dataSource);;
	}

DataSourceUtils

protected static void doCloseConnectionIfNecessary(Connection con, DataSource dataSource); throws SQLException {
		if (con == null); {
			return;
		}

		ConnectionHolder conHolder = (ConnectionHolder); TransactionSynchronizationManager.getResource(dataSource);;
		if (conHolder != null && con == conHolder.getConnection();); {
			// It's the transactional Connection: Don't close it.
			conHolder.released();;
			return;
		}
		
		// Leave the Connection open only if the DataSource is our
		// special data source, and it wants the Connection left open.
		if (!(dataSource instanceof SmartDataSource); || ((SmartDataSource); dataSource);.shouldClose(con);); {
			logger.debug("Closing JDBC connection");;
			con.close();;
		}
	}

恍然大悟。如果事物完成，那么就
TransactionSynchronizationManager.unbindResource(this.dataSource);將當前的ConnectionHolder
從TransactionSynchronizationManager上脫離，然后doCloseConnectionIfNecessary。最后會把連接關閉掉。

5 兩個輔助類JdbcTemplate和TransactionAwareDataSourceProxy
JdbcTemplate中的execute方法的第一句和最后一句

public Object execute(PreparedStatementCreator psc, PreparedStatementCallback action);
			throws DataAccessException {

		Connection con = DataSourceUtils.getConnection(getDataSource(););;
		//其他代碼
	DataSourceUtils.closeConnectionIfNecessary(con, getDataSource(););;
		}
	}

作用不言自明了吧

從TransactionAwareDataSourceProxy中獲取的連接是這個樣子的

public Connection getConnection(); throws SQLException {
		Connection con = DataSourceUtils.doGetConnection(getTargetDataSource();, true);;
		return getTransactionAwareConnectionProxy(con, getTargetDataSource(););;
	}

萬變不離其宗，不過我們還是看看getTransactionAwareConnectionProxy

protected Connection getTransactionAwareConnectionProxy(Connection target, DataSource dataSource); {
		return (Connection); Proxy.newProxyInstance(
				ConnectionProxy.class.getClassLoader();,
				new Class[] {ConnectionProxy.class},
				new TransactionAwareInvocationHandler(target, dataSource););;
	}

原來返回的是jdk的動態代理。繼續看TransactionAwareInvocationHandler

public Object invoke(Object proxy, Method method, Object[] args); throws Throwable {
		//...			if (method.getName();.equals(CONNECTION_CLOSE_METHOD_NAME);); {
				if (this.dataSource != null); {
					DataSourceUtils.doCloseConnectionIfNecessary(this.target, this.dataSource);;
				}
				return null;
			}

					}

TransactionAwareDataSourceProxy會先從DataSourceUtils獲取連接。然后將這個連接用jdk的動態代理包一下返回。外部代碼如果調用的這個冒牌的Connection，就會先調用TransactionAwareInvocationHandler的invoke，在這個invoke 中，完成原來調用DataSourceUtils的功能。

總結上面的流程
Spring 對DataSource進行事務管理的關鍵在于ConnectionHolder和TransactionSynchronizationManager。
  0.先從TransactionSynchronizationManager中嘗試獲取連接
  1.如果前一步失敗則在每個線程上，對每個DataSouce只創建一個Connection
   2.這個Connection用ConnectionHolder包裝起來，由TransactionSynchronizationManager管理
  3.再次請求同一個連接的時候，從TransactionSynchronizationManager返回已經創建的ConnectionHolder，然后調用ConnectionHolder的request將引用計數+1
  4.釋放連接時要調用ConnectionHolder的released，將引用計數-1
  5.當事物完成后，將ConnectionHolder從TransactionSynchronizationManager中解除。當誰都不用，這個連接被close

以上所有都是可以調用DataSourceUtils化簡代碼，而JdbcTemplate又是調用DataSourceUtils的。所以在Spring文檔中要求盡量首先使用JdbcTemplate，其次是用DataSourceUtils來獲取和釋放連接。至于TransactionAwareDataSourceProxy，那是下策的下策。不過可以將Spring事務管理和遺留代碼無縫集成。

所以如某位朋友說要使用Spring的事務管理，但是又不想用JdbcTemplate，那么可以考慮TransactionAwareDataSourceProxy。這個類是原來DataSource的代理。
其次，想使用Spring事物，又不想對Spring進行依賴是不可能的。與其試圖自己模擬DataSourceUtils，不如直接使用現成的。