hsf服务和spring结合的用法小结

    在spring mvc 的项目开发中，由于各个系统之间需要进行数据的传递，因此，一些公司都是通过基于服务的接口方式提供数据，在淘宝，是通过hsf服务的方式开放自己应用的接口，达到数据在各个应用间的流动和互用。

 

一：hsf服务提供的方式。

  1. 在biz层（业务逻辑层），可以写一个直接直接与数据库dao层打交道的接口和实现类：

比如：

 

 

package com.taobao.tee.hsfPrivider;
public interface RuleService4CaseCenter {

	//根据案例id获取与与其关联的规则rule的信息
	public List<Map<Integer, Object>> getRuleInfoByCaseId(long caseId);
	
	//由于案例中心那边的案例id对应的案例名称会更改，所以在更改时同步到tee这边对应的规则中
	public void updateCaseName4Rule(Map<String,String> paraMap);
}

 

 

package com.taobao.tee.hsfPrivider.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RuleService4CaseCenterImpl implements RuleService4CaseCenter {
	
	
	private RuleDAOSqlMap ruleDAOSqlMap;
	

	public RuleDAOSqlMap getRuleDAOSqlMap() {
		return ruleDAOSqlMap;
	}

	public void setRuleDAOSqlMap(RuleDAOSqlMap ruleDAOSqlMap) {
		this.ruleDAOSqlMap = ruleDAOSqlMap;
	}

	public List<Map<Integer, Object>> getRuleInfoByCaseId(long caseId){
	
		List<RuleBean> listRuleBean=ruleDAOSqlMap.getRuleInfo4CaseCenter(caseId);
		List<Map<Integer,Object>> returnResult=new ArrayList<Map<Integer,Object>>();
		
		for(RuleBean rb:listRuleBean){
			Map<Integer, Object>  tempMap=new HashMap<Integer,Object>();
			
			RuleInfo4CaseCenter tempRuleInfo=new RuleInfo4CaseCenter();
			tempRuleInfo.setRuleId(rb.getId());
			tempRuleInfo.setRuleName(rb.getName());
			
			tempMap.put(rb.getId(), tempRuleInfo);
			returnResult.add(tempMap);
		}
		return returnResult;
	}
	
	public void updateCaseName4Rule(Map<String,String> paraMap){
		List<RuleBean> listRuleBean=ruleDAOSqlMap.getRuleInfo4CaseCenter(Long.parseLong(paraMap.get("caseId")));
		Date nowDate=new Date();
		for(RuleBean rb:listRuleBean){
			rb.setCaseName(paraMap.get("caseName"));
			rb.setUpdateTime(DateUtil.formatDateYmdHms(nowDate));
			
			//这个更新语句就包括些历史库的过程
			ruleDAOSqlMap.updateRuleById(rb);	

		}
	}
	
	
}

 

这个实现类中由于引用到了数据库操作bean类ruleDAOSqlMap提供的服务，所以在spring通过set的方式将其注入进去。

ruleDAOSqlMap在xml文件中配置，其原理是在jboss启动的时候jvm就把xml中配置的所有bean都注入到spring容器，在运行的时候外部类获取相应bean的服务。

 

2. 当然为了数据安全考虑，不会把这个biz打成jar部署到maven二方库，而是通过common层暴露这个接口给外部需要服务的接口人，所以在common层中写一个RuleService4CaseCenter 接口，其包路径和内容都跟biz中一样，然后把common层通过pom.xml配置并通过package生成jar包，通过mvn deploy方式将jar部署到

maven二方库给别人使用。

 

 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<parent>
	    <groupId>com.taobao</groupId>
	    <artifactId>parent</artifactId>
	    <version>1.0.2</version>
	</parent>
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.taobao.tee</groupId>
	<artifactId>tee-common</artifactId>
	<packaging>jar</packaging>
	<name>tee-common</name>
	<version>1.0.0</version>

	<dependencies>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.1</version>
		</dependency>
	</dependencies>
</project>

 

3.提供hsf服务：

	<bean id="ruleHsfService4CaseCenter" class="com.taobao.hsf.app.spring.util.HSFSpringProviderBean" init-method="init">
	    <property name="serviceInterface">
			 <value>com.taobao.tee.hsfPrivider.RuleService4CaseCenter</value>
		</property>
		<property name="target">
			<ref bean="ruleService4CaseCenter" />
		</property>	
		<property name="serviceVersion">
			<value>${teeRuleCaller.version}</value>
		</property>
		<property name="serviceName">
			<value>ruleService4CaseCenter</value>
		</property>
		<property name="clientTimeout">
			<value>4000</value>
		</property>
	</bean>
				
   <bean id="ruleService4CaseCenter" class="com.taobao.tee.hsfPrivider.impl.RuleService4CaseCenterImpl">
	   <property name="ruleDAOSqlMap">
		   <ref bean="ruleDAOSqlMap" />
	   </property>
   </bean>

 

3. 使用方通过pom文件的依赖配置，获取common的jar包提供的RuleService4CaseCenter接口和配置的hsf服务（也就是RuleService4CaseCenter接口的实现）的消费就能得到服务。

 

二：当使用别的应用提供的接口时，一般是采用hsf服务消费的配置方式，相当是服务的消费方。

而且最好是在本地对这个服务接口做一个封装，这样的好处是解耦，一个是做一个服务方出现异常情况的一个保护操作，不至于受到提供方的接口失败影响到自己的正常业务。

 另一个好处是能在此基础上封装自己应用需要的一些方法，做到接口的自适应，满足自身业务的需求。

 

比如： 服务方通过jar包提供接口，我通过pom.xml文件配置获取这个jar包，引进这个接口到本地应用：

 

@SuppressWarnings("rawtypes")
public interface CaseService {
	/**
	 * @param data [keys]: name, flag, desc, filename, eventTime, operator, attachment
	 * @return
	 */
	public Result add(Map<String, Object> data);
	public Result update(Map<String, Object> data);
	public Result delete(long id);
	public Result<Map<String, Object>> getCaseById(long id);
	public Result<Map<String, Object>> queryCase(Map<String, Object> para);
	public Result<Map<String, Object>> queryCaseFive();
}

由于是第三方提供的hsf服务，在本地消费，需要在web层的source/main/resource目录下的配置hsf的消费配置，把他当成是bean的方式供本地其他类进行spring的注入和应用：

 

	<bean id="caseService"
       class="com.taobao.hsf.app.spring.util.HSFSpringConsumerBean" init-method="init">
      <property name="interfaceName" value="com.tcp.service.CaseService" />
      <property name="version" value="${tee.hsf.common.version}"/>     
    </bean>
	<bean id="caseService4Tee" class="com.taobao.tee.CaseService.CaseService4Tee">
		<property name="caseService">
			<ref bean="caseService" />
		</property>
	</bean>

 

然后，最好对CaseService接口bean在本地进行封装（通过依赖注入方式），以满足本地应用的特殊要求：

 

public class CaseService4Tee {
	private   CaseService caseService;

	public CaseService getCaseService() {
		return caseService;
	}

	public void setCaseService(CaseService caseService) {
		this.caseService = caseService;
	}
	
	
	//用于显示案例名称的下拉菜单
	public  List<Map<String,String>> getCaseNameByList(){
		
		Map<String ,Object> caseMap=new HashMap<String,Object>();
		caseMap.put("start", 0);
		caseMap.put("pagesize", 1000);
		List<Map<String,String>> caseList=new ArrayList<Map<String,String>>();
		try {
			Result<Map<String,Object>> caseResult =caseService.queryCase(caseMap);
			Collection<Map<String,Object>> caseCollection=caseResult.getDataList();	
	        //由于一个对象中有太多的key-value值，一些是不要的，所以只有这么循环遍历了
			
			for(Iterator<Map<String,Object>> iterator=caseCollection.iterator(); iterator.hasNext(); ){
				Map<String,Object> retMap=iterator.next();
				Map<String, String> vMap = new HashMap<String, String>();
		        vMap.put("key", retMap.get("id").toString());
		        vMap.put("display", retMap.get("name").toString());
				caseList.add(vMap);
			}
			return caseList;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return caseList;
	}
}

 

然后把这个封装的类在xml中配置成bean的方式，这样便于其他类对其进行依赖注入的方式进行使用：

 

	<bean id="caseService4Tee" class="com.taobao.tee.CaseService.CaseService4Tee">
		<property name="caseService">
			<ref bean="caseService" />
		</property>
	</bean>