转自：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，不如直接使用现成的。