Venus: 简单、高性能、高并发 java开源remoting框架

Venus 是一个简单的、高性能、高并发能力的java 开源Remoting框架
wiki地址：http://wiki.hexnova.com/display/Venus/HOME

性能测试：http://wiki.hexnova.com/pages/viewpage.action?pageId=1507358

产品发布日志： http://wiki.hexnova.com/pages/viewrecentblogposts.action?key=Venus

1. 如何服务化
采用接口与实现分离，服务接口是一种契约，他与我们开发web Service类似。

java开发语言：采用对程序员友好的接口申明形式，开发人员不需要关心客户端与服务端之间的传输协议。
其他语言：可以通过该框架提供自定义协议进行交互
2. 服务接口定制
定义服务接口
接口参数命名
定义参数校验规则
Java语言服务接口尽量不要依赖其他项目. 接口层面只需要接口相关的参数对象类与服务类
异常定义
3. 接口参数校验
4. 提供3种交互方式
请求应答模式：普通的request、response，一般用于接口有返回值
异步请求模式：通常用于接口无返回值，客户端并不关心服务器的处理结果，也不用关心服务器处理多少时间
异步回调模式：接口无返回值，处理通常消化大量时间，需要服务端通知处理结果的业务接口

下面是一个例子：

1、简单的接口例子：HelloService.java

package com.meidusa.venus.hello.api;

import com.meidusa.venus.annotations.Endpoint;
import com.meidusa.venus.annotations.Param;
import com.meidusa.venus.annotations.Service;
import com.meidusa.venus.notify.InvocationListener;

/**
 * Service framework的 HelloService 接口例子.</p>
 * 支持3种调用方式：</p>
 * <li> 请求应答模式：普通的request、response，一般用于接口有返回值</li>
 * <li> 异步请求模式：通常用于接口无返回值，客户端并不关心服务器的处理结果，也不用关心服务器处理多少时间</li>
 * <li> 异步回调模式：接口无返回值，处理通常消化大量时间，需要服务端通知处理结果的业务接口</li>
 *
 * @author Struct
 *
 */
@Service(name="HelloService",version=1)
public interface HelloService {

	/**
	 * 无返回结果的服务调用，支持回调方式，该服务在通讯层面上为异步调用
	 * @param name
	 * @param invocationListener 客户端的回调接口
	 */
	@Endpoint(name="sayHelloWithCallbak")
	public abstract void sayHello(@Param(name="name") String name,
				      @Param(name="callback") InvocationListener<Hello> invocationListener);
	/**
	 * 无返回结果的服务调用，支持同步或者异步调用,
	 * 该接口申明：同步，并且接口申明异常
	 * @param name
	 */
	@Endpoint(name="sayHello",async=false)
	public abstract void sayHello(@Param(name="name") String name) throws HelloNotFoundException;

	/**
	 * 无返回结果的服务调用，支持同步或者异步调用，无异常申明
	 * @param name
	 */
	@Endpoint(name="sayAsyncHello",async=true)
	public abstract void sayAsyncHello(@Param(name="name") String name);


	/**
	 * 有返回结果的服务调用，该接口只能支持同步调用
	 * @param name
	 * @return
	 */
	@Endpoint(name="getHello")
	public abstract Hello getHello(@Param(name="name") String name);
}

2、客户端TestCase编写

package com.meidusa.venus.hello.client;

import java.util.concurrent.CountDownLatch;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.meidusa.venus.exception.CodedException;
import com.meidusa.venus.hello.api.Hello;
import com.meidusa.venus.hello.api.HelloNotFoundException;
import com.meidusa.venus.hello.api.HelloService;
import com.meidusa.venus.notify.InvocationListener;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:/applicationContext-helloworld-client.xml")
public class TestHelloService {

	@Autowired
	private HelloService helloService;

	@Test
	public void saySync(){
		System.out.println(helloService.getHello("jack"));
	}

	@Test
	public void testSyncWithException(){
		try {
			helloService.sayHello("jack");
		} catch (HelloNotFoundException e) {
			System.out.println("throw an user defined HelloNotFoundException");
		}
	}

	@Test
	public void testAsync(){
		helloService.sayAsyncHello("jack");
	}

	@Test
	public void testCallback() throws Exception{
		//为了让回调完成，采用countDownLatch计数器方式，避免testcase主线程运行完成而回调未结束的问题
		final CountDownLatch latch = new CountDownLatch(1);

                  //在正常的使用的代码中这个类需要单实例，避免过多的callback listener导致内存问题
                      InvocationListener<Hello> listener = new InvocationListener<Hello>() {
			public void callback(Hello myobject) {
				System.out.println(" async call back result="+myobject);
				latch.countDown();
			}

			@Override
			public void onException(Exception e) {
				if(e instanceof CodedException){
				    CodedException exception = (CodedException) e;
				    System.out.println(" async call back error:"+exception.getErrorCode()+",message="+exception.getMessage());
				}else{
				    System.out.println(" async call back message="+e.getMessage());
				}
				latch.countDown();

			}
		};

		helloService.sayHello("jack",listener);
		latch.await();
	}

}

3、服务端的实现

package com.meidusa.venus.hello.impl;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;

import com.meidusa.venus.hello.api.Hello;
import com.meidusa.venus.hello.api.HelloNotFoundException;
import com.meidusa.venus.hello.api.HelloService;
import com.meidusa.venus.notify.InvocationListener;

public class DefaultHelloService implements HelloService {
	private String greeting;
	public String getGreeting() {
		return greeting;
	}

	public void setGreeting(String greeting) {
		this.greeting = greeting;
	}
	public Hello getHello(String name) {
		Hello hello = new Hello();
		hello.setName(name);
		hello.setGreeting(greeting);
		Map<String,Object> map = new HashMap<String,Object>();
		hello.setMap(map);
		map.put("1", 1);
		map.put("2", new Long(2));
		map.put("3", new Integer(3));
		hello.setBigDecimal(new BigDecimal("1.341241233412"));
		return hello;
	}

	public void sayHello(String name)  throws HelloNotFoundException {
		throw new HelloNotFoundException(name +" not found");
	}

	@Override
	public void sayAsyncHello(String name) {
		System.out.println("method sayAsyncHello invoked");
	}

	public void sayHello(String name,
			InvocationListener<Hello> invocationListener) {
		Hello hello = new Hello();
		hello.setName(name);
		hello.setGreeting(greeting);
		Map<String,Object> map = new HashMap<String,Object>();
		hello.setMap(map);
		map.put("1", 1);
		map.put("2", new Long(2));
		map.put("3", new Integer(3));

		if(invocationListener != null){
			invocationListener.callback(hello);
		}

	}
}

WIKI 地址 http://wiki.hexnova.com/display/Venus/HOME

 

标题加上盛大看的人估计就多了

感谢楼上提醒，标题增加敏感字...

主要还是一个远程调用的框架，目前来说面向java的开发人员还是非常合适的

预览才过60，加了盛。大人气也就这样！

哈哈，说明大伙都不太关注这块技术
因为有 netty、mima等远程框架、包括spring jboss等remoting框架

主要是和阿里的dubbo相比, 没有亮点... dubbo都要出2.0.9了. 监控系统界面都出来了..重要是dubbo是SOA的思想, 而且提供了很多自治的一些功能. 还在阿里内部大范围使用(久经考验, 最近的阿里社区网站也是用dubbo做的)(http://code.alibabatech.com/wiki/display/dubbo/Home)

不过...还是给予支持, 走出第一步很重要, 希望盛大拿出更重量级的东西.

现在SOA很流行啊，上次有阿里的Dubbo，这次又出了盛大的Venus，真是你方唱罢我登场。作为普通开发人员，非常欢迎各个各大互联网厂商都开源自己的框架，是骡子是马拉出来遛遛，良性竞争是最好的结果。

应该加一些横向比较。
不知道数据传输通过什么格式，速度如何

  其实对于Java的rpc框架，最重要的就是：适用性和效率。
  适用性体现在框架设计者良好的设计思路(包括对各种类型的数据的支持，各种传输模式的支持，以及以后的可扩展性)。
  效率体现框架设计者的技术功底，可以简单的对http的包装；也可以是在tcp层自己玩。

我只能说 非常一般...