Buffalo与Spring也能玩转annotation

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";
	}
}

 很简洁,不是吗?