Hessian和Spring整合

标签: hessian spring | 发表时间:2014-04-01 11:48 | 作者:HarderXin
出处:http://blog.csdn.net

    上篇文章简单的介绍了Hessian以及它的一些执行原理,现在我们来看看它与强大框架spring的集成吧!

一、服务端使用spring,我们得下载Hessian支持包和Spring的相应的jar包,可以在我的资源库中进行免费下载:

1、新建web工程,我取名为HessianSpringServer,在web/WEB-INFO/BIN中导入我们相应的jar包,跟上篇文章一样,编写我们的实体类和接口类、以及接口实现类:

实体用户类:

package com.server.bean;

import java.io.Serializable;

public class User implements Serializable{
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 7175134832651443717L;
	//用户编号
	private int id;
	//用户名
	private String userName;
	//密码
	private String password;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	public User(int id, String userName, String password) {
		super();
		this.id = id;
		this.userName = userName;
		this.password = password;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result
				+ ((password == null) ? 0 : password.hashCode());
		result = prime * result
				+ ((userName == null) ? 0 : userName.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (id != other.id)
			return false;
		if (password == null) {
			if (other.password != null)
				return false;
		} else if (!password.equals(other.password))
			return false;
		if (userName == null) {
			if (other.userName != null)
				return false;
		} else if (!userName.equals(other.userName))
			return false;
		return true;
	}
}


定义我们的接口类:

package com.server.service;

import java.util.List;

import com.server.bean.User;

public interface UserService {
	
	public List<User> getUser();
	
}

定义我们的接口实现类:

package com.server.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.server.bean.User;
import com.server.service.UserService;

public class UserServiceImpl implements UserService{

	public List<User> getUser() {
		//我们可以在这个方法中与数据库打交道
		List<User> list=new ArrayList<User>();
		list.add(new User(1,"Mary","123456"));
		list.add(new User(2,"Jack","236547"));
		list.add(new User(3,"Joy","362541"));
		return list;
	}
}


2、新建spring配置文件springremoting-servlet.xml,让接口及实现类由spring容器去管理:

<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
        <!-- Hessian服务接口Impl注入 -->
        <bean id="userService" class="com.server.service.impl.UserServiceImpl"/>
        
        <!-- 使用HessianServiceExporter为服务接口Impl在网络地址中映射一个Hessian服务-->
	<!-- 完整的远程调用请求  Url:http://localhost:8080/HessianSpringServer/sr/userService,前部分在web.xml中已经进行了配置 -->
        <bean name="/userService" class="org.springframework.remoting.caucho.HessianServiceExporter">
         	<!-- Hessian服务的接口 -->
        	<property name="serviceInterface" value="com.server.service.UserService"/>
        	<!-- Hessian服务的接口Impl -->
        	<property name="service" ref="userService"></property>
        </bean>
</beans>


3、配置我们的web.xml文件,让服务器启动后能够加载到我们的springremoting-servlet.xml,以及配置访问路径

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	
	<servlet>
	    <!-- 完整的远程调用请求Url:http://localhost:8080/HessianSpringServer/sr/* -->
	    <servlet-name>springremoting</servlet-name>
	    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	    <init-param>
	        <param-name>contextConfigLocation</param-name>
	        <!-- 服务启动加载 springremoting-servlet.xml-->
	        <param-value>classpath:springremoting-servlet.xml</param-value>
	    </init-param>
	    <load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
	    <servlet-name>springremoting</servlet-name>
	    <url-pattern>/sr/*</url-pattern>
	</servlet-mapping>
  	<welcome-file-list>
    	<welcome-file>index.jsp</welcome-file>
  	</welcome-file-list>
</web-app>

好了,我们的简单的服务端搭建完成了,记得把我们的接口类(UserService)和实体类(User)打成相应的jar包(也可以在客户端复制服务端接口类的代码,这样太繁琐了),因为我们的客户端需要访问到,这是Hessian里面定义的,No Why!

将我们的项目部署到Tomcat服务器上,启动Tomcat,如果报错了,说明你的配置没有配好哦,得自己仔细检查检查,如果不报错,说明我们的服务端搭建完成,下面来编写我们的客户端吧!

二、客户端不使用Spring,新建java项目,导入我们的Hessian支持包和在服务端打包的借口类jar包

编写我们的测试类,因为我把没有spring和有spring的客户端测试类写在了一起,好做个对比:

package com.client.test;


import java.util.List;

import com.caucho.hessian.client.HessianProxyFactory;
import com.server.bean.User;
import com.server.service.UserService;

public class UserServiceTest {
	public static void main(String[] args) {
		//不使用Spring服务器访问地址
		//String url="http://localhost:8080/HessianServer/us";
		//使用spring服务器访问的地址
		String url="http://localhost:8080/HessianSpringServer/sr/userService";
		//获得HessianProxyFactory实例
		HessianProxyFactory factory=new HessianProxyFactory();
		try {
			//不使用Spring创建我们的接口对象
			//UserService userService=(UserService)factory.create(url);
			//使用Spring创建我们的接口对象
			UserService userService=(UserService)factory.create(UserService.class,url);
			//执行服务端方法
			List<User> users=userService.getUser();
			//遍历输出
			for(User user:users){
				System.out.println("id="+user.getId()+",name="+user.getUserName()+",pwd="+user.getPassword());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

其实我在做测试的时候还是有一个疑问的,就是我发现在服务端Hessian和spring整合后,客户端需要这样去调用:factory.create(UserService.class,url);需要指定相应接口的class,不能直接使用url地址传入:factory.create(url);这样会抛出一个异常:UndeclaredThrowableException,其实服务端在spring配置文件里面已经给接口类以及实现类进行了注入:

    <!-- Hessian服务接口Impl注入 -->
        <bean id="userService" class="com.server.service.impl.UserServiceImpl"/>
        
        <!-- 使用HessianServiceExporter为服务接口Impl在网络地址中映射一个Hessian服务-->
		<!-- 完整的远程调用请求Url:http://localhost:8080/HessianSpringServer/sr/userService -->
        <bean name="/userService" class="org.springframework.remoting.caucho.HessianServiceExporter">
         	<!-- Hessian服务的接口 -->
        	<property name="serviceInterface" value="com.server.service.UserService"/>
        	<!-- Hessian服务的接口Impl -->
        	<property name="service" ref="userService"></property>
        </bean>


并且,没生成一个Service,都会要重新写一个bean,所以这里我觉得直接使用地址factory.create(url);是可以访问的,跟没有使用spring时候在web.xml中配置一样,可是它不行,应该是spring里面给它做处理了吧,我们必须要factory.create(UserService.class,url);不然,里面会找不到相应的实体类吧!大家在写代码的时候注意下就是了!

运行main函数,得到的结果为:

id=1,name=Mary,pwd=123456
id=2,name=Jack,pwd=236547
id=3,name=Joy,pwd=362541

测试成功,哈哈...!

三、客户端使用Spring,我们的客户端也可以使用Spring,让factory.create(UserService.class,url);交给spring容器去处理,同样,需要导入我们的Hessian支持包和在服务端打包的借口类jar包,还需要我们的spring支持包,上面已经给出了相应的下载地址,如果你客户端需要使用JUnit进行测试,也需要junit的测试类包,我的那个包文件里面都已经包含了

1、既然我们在客户端使用了spring,当然得编写我们的配置文件,例如springremoting-client.xml,然后将我们的访问地址和接口类在里面进行注入:

<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
        <bean id="userService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
            <!-- 注入我们的接口类 -->
        	<property name="serviceInterface" value="com.server.service.UserService"/>
        	<!-- 服务器访问地址 -->
        	<property name="serviceUrl" value="http://localhost:8080/HessianSpringServer/sr/userService"/>
        </bean>
</beans>

2、编写我们的测试函数:

package com.client.test;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.server.bean.User;
import com.server.service.UserService;

public class UserServiceSpringTest {
	public static void main(String[] args) {
		//加载我们的Spring配置文件
		ApplicationContext context=new ClassPathXmlApplicationContext("springremoting-client.xml");
		//获取我们的接口类
		UserService userService=(UserService)context.getBean("userService");
		List<User> users=userService.getUser();
		//遍历输出
		for(User user:users){
			System.out.println("id="+user.getId()+",name="+user.getUserName()+",pwd="+user.getPassword());
		}
	}
}

测试输出:

id=1,name=Mary,pwd=123456
id=2,name=Jack,pwd=236547
id=3,name=Joy,pwd=362541
两种情况的不同之处在于客户端里面的Hessian工厂对象交给spring容器去管理了,各有各的好处,大家可以根据实际情况进行选择!

使用junit测试我们的客户端:

/**
 *
 * Copyright: Copyright (c) 2012 Asiainfo-Linkage
 *
 * client@date:2014-3-28
 * @ClassName: UserServiceTest.java
 * @Description: 该类的功能描述
 *
 * @version: v1.0.0上午9:01:27eleven
 * @author: elevenHessianSpringClient
 *
 * Modification History:
 * Date  Author  Version Description
 * ---------------------------------------------------------*
 * 2014-3-28 eleven v1.0.0 新建
 */
package client;


import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import service.UserServiceI;

/**
 * @Title: UserServiceTest.java
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author eleven
 * @date 2014-3-28 上午9:01:27
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:springremoting-client.xml"})
public class UserServiceTest {
	
	private UserServiceI userService;
	
	@Resource
	public void setUserService(UserServiceI userService) {
		this.userService = userService;
	}

	@Test
	public void test() {
		System.out.println(userService.queryUserList());
	}

}


好了,Hessian与Spring整合完成,希望大家一起交流学习,共同进步!Hessian与sping、struts、hibernate三大框架整合,大家可以去尝试一下哦!

作者:HarderXin 发表于2014-4-1 11:48:26 原文链接
阅读:0 评论:0 查看评论

相关 [hessian spring] 推荐:

简单Spring+hessian

- - Web前端 - ITeye博客
简单的Spring+hessian. dist\modules里面的 spring-webmvc.jar . lib\caucho 里面的hessian-3.1.3.jar. 里面有个接口interface:. 建立一个model层:(实现Serializable接口). 在WEB-INF下面创建一个remoting-servlet.xml:.

Hessian和Spring整合

- - CSDN博客推荐文章
    上篇文章简单的介绍了Hessian以及它的一些执行原理,现在我们来看看它与强大框架spring的集成吧. 一、服务端使用spring,我们得下载Hessian支持包和Spring的相应的jar包,可以在我的资源库中进行免费下载:. 1、新建web工程,我取名为HessianSpringServer,在web/WEB-INFO/BIN中导入我们相应的jar包,跟上篇文章一样,编写我们的实体类和接口类、以及接口实现类:.

Hessian, CXF, Spring httpinvoke 对比

- - Java - 编程语言 - ITeye博客
做了一个 Hessian, CXF, Spring httpinvoke 速度对比. 时间消耗  cxf > spring httpinvoke > hessian. 并发为10, 调用1W次所耗时间. 当然, 都知道 cxf 和 hessian 实现以及应用场景不太一样, 但差这么多还是很意外的.

Hessian原理

- - 互联网 - ITeye博客
Hessian 原理分析. 一.      远程通讯协议的基本原理. 二.      应用级协议 Binary-RPC. Binary-RPC 是一种和 RMI 类似的远程调用的协议,它和 RMI 的不同之处在于它以标准的二进制格式来定义请求的信息 ( 请求的对象、方法、参数等 ) ,这样的好处是什么呢,就是在跨语言通讯的时候也可以使用.

Hessian介绍及简单应用

- - Java - 编程语言 - ITeye博客
一、首先先说Hessian是什么.     Hessian:hessian是一个轻量级的remoting onhttp工具,使用简单的方法提供了RMI的功能,相比WebService,Hessian更简单、快捷. 采用的是二进制RPC协议,因为采用了二进制协议,所以它很适合于发送二进制数据,Hessian主要作面向对象的消息通信.

Android项目快速开发框架探索(Mysql + OrmLite + Hessian + Sqlite)

- - 博客园_首页
结合之前所用的ormlite和hessian,再加上SAE已经支持JAVA,把服务端切换到JAVA,也就有了本文. 使用hessian来做数据传输,ormlite来实现客户端与服务端的数据存储,极大的减少了CRUD工作. 本文为探索贴,未正式用于大型项目,欢迎大家讨论使用.   欢迎转载,但请保留文章原始出处:).

序列化框架比较:kryo & hessian & Protostuff & java

- - zzm
序列化框架性能对比(kryo、hessian、java、protostuff). 无需静态编译,但序列化前需预先传入schema. 不支持无默认构造函数的类,反序列化时需用户自己初始化序列化后的对象,其只负责将该对象进行赋值. 测试方法:(参考自 https://github.com/eishay/jvm-serializers).

基于hessian和netty的RPC框架设计和实现

- - Java - 编程语言 - ITeye博客
基于hessian和netty的RPC框架设计和实现.         对系统进行服务化改造,或者构建一个分布式系统,RPC是核心的组件,目前主流的RPC框架有hessian\thrift\ avro等,如果不考虑跨语言的话thrift\ avro使用起来稍显复杂,要写IDL序列化配置,hessian又依赖servlet容器,于是使用netty和hessian构建了一个的RPC框 架.

Spring详解

- - CSDN博客架构设计推荐文章
Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目的是简化企业开发.. PersonDaoBean 是在应用内部创建及维护的. 所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的.

Spring定时

- - 行业应用 - ITeye博客
spring的定时任务配置分为三个步骤:. . . . . .