首页 > 代码库 > Venus 是一个简单的、高性能、高并发能力的java 开源Remoting框架

Venus 是一个简单的、高性能、高并发能力的java 开源Remoting框架

2024-07-07 20:34:27   230人阅读

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

Java代码  收藏代码
  1. package com.meidusa.venus.hello.api;  
  2.   
  3. import com.meidusa.venus.annotations.Endpoint;  
  4. import com.meidusa.venus.annotations.Param;  
  5. import com.meidusa.venus.annotations.Service;  
  6. import com.meidusa.venus.notify.InvocationListener;  
  7.   
  8. /** 
  9.  * Service framework的 HelloService 接口例子.</p> 
  10.  * 支持3种调用方式：</p> 
  11.  * <li> 请求应答模式：普通的request、response，一般用于接口有返回值</li> 
  12.  * <li> 异步请求模式：通常用于接口无返回值，客户端并不关心服务器的处理结果，也不用关心服务器处理多少时间</li> 
  13.  * <li> 异步回调模式：接口无返回值，处理通常消化大量时间，需要服务端通知处理结果的业务接口</li> 
  14.  * 
  15.  * @author Struct 
  16.  * 
  17.  */  
  18. @Service(name="HelloService",version=1)  
  19. public interface HelloService {  
  20.   
  21.     /** 
  22.      * 无返回结果的服务调用，支持回调方式，该服务在通讯层面上为异步调用 
  23.      * @param name 
  24.      * @param invocationListener 客户端的回调接口 
  25.      */  
  26.     @Endpoint(name="sayHelloWithCallbak")  
  27.     public abstract void sayHello(@Param(name="name") String name,  
  28.                       @Param(name="callback") InvocationListener<Hello> invocationListener);  
  29.     /** 
  30.      * 无返回结果的服务调用，支持同步或者异步调用, 
  31.      * 该接口申明：同步，并且接口申明异常 
  32.      * @param name 
  33.      */  
  34.     @Endpoint(name="sayHello",async=false)  
  35.     public abstract void sayHello(@Param(name="name") String name) throws HelloNotFoundException;  
  36.   
  37.     /** 
  38.      * 无返回结果的服务调用，支持同步或者异步调用，无异常申明 
  39.      * @param name 
  40.      */  
  41.     @Endpoint(name="sayAsyncHello",async=true)  
  42.     public abstract void sayAsyncHello(@Param(name="name") String name);  
  43.   
  44.   
  45.     /** 
  46.      * 有返回结果的服务调用，该接口只能支持同步调用 
  47.      * @param name 
  48.      * @return 
  49.      */  
  50.     @Endpoint(name="getHello")  
  51.     public abstract Hello getHello(@Param(name="name") String name);  
  52. }  



2、客户端TestCase编写

Java代码  收藏代码
  1. package com.meidusa.venus.hello.client;  
  2.   
  3. import java.util.concurrent.CountDownLatch;  
  4.   
  5. import org.junit.Test;  
  6. import org.junit.runner.RunWith;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.test.context.ContextConfiguration;  
  9. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  10.   
  11. import com.meidusa.venus.exception.CodedException;  
  12. import com.meidusa.venus.hello.api.Hello;  
  13. import com.meidusa.venus.hello.api.HelloNotFoundException;  
  14. import com.meidusa.venus.hello.api.HelloService;  
  15. import com.meidusa.venus.notify.InvocationListener;  
  16.   
  17. @RunWith(SpringJUnit4ClassRunner.class)  
  18. @ContextConfiguration(locations="classpath:/applicationContext-helloworld-client.xml")  
  19. public class TestHelloService {  
  20.   
  21.     @Autowired  
  22.     private HelloService helloService;  
  23.   
  24.     @Test  
  25.     public void saySync(){  
  26.         System.out.println(helloService.getHello("jack"));  
  27.     }  
  28.   
  29.     @Test  
  30.     public void testSyncWithException(){  
  31.         try {  
  32.             helloService.sayHello("jack");  
  33.         } catch (HelloNotFoundException e) {  
  34.             System.out.println("throw an user defined HelloNotFoundException");  
  35.         }  
  36.     }  
  37.   
  38.     @Test  
  39.     public void testAsync(){  
  40.         helloService.sayAsyncHello("jack");  
  41.     }  
  42.   
  43.     @Test  
  44.     public void testCallback() throws Exception{  
  45.         //为了让回调完成，采用countDownLatch计数器方式，避免testcase主线程运行完成而回调未结束的问题  
  46.         final CountDownLatch latch = new CountDownLatch(1);  
  47.   
  48.                   //在正常的使用的代码中这个类需要单实例，避免过多的callback listener导致内存问题  
  49.                       InvocationListener<Hello> listener = new InvocationListener<Hello>() {  
  50.             public void callback(Hello myobject) {  
  51.                 System.out.println(" async call back result="+myobject);  
  52.                 latch.countDown();  
  53.             }  
  54.   
  55.             @Override  
  56.             public void onException(Exception e) {  
  57.                 if(e instanceof CodedException){  
  58.                     CodedException exception = (CodedException) e;  
  59.                     System.out.println(" async call back error:"+exception.getErrorCode()+",message="+exception.getMessage());  
  60.                 }else{  
  61.                     System.out.println(" async call back message="+e.getMessage());  
  62.                 }  
  63.                 latch.countDown();  
  64.   
  65.             }  
  66.         };  
  67.   
  68.         helloService.sayHello("jack",listener);  
  69.         latch.await();  
  70.     }  
  71.   
  72. }  



3、服务端的实现

Java代码  收藏代码
    1. package com.meidusa.venus.hello.impl;  
    2.   
    3. import java.math.BigDecimal;  
    4. import java.util.HashMap;  
    5. import java.util.Map;  
    6.   
    7. import com.meidusa.venus.hello.api.Hello;  
    8. import com.meidusa.venus.hello.api.HelloNotFoundException;  
    9. import com.meidusa.venus.hello.api.HelloService;  
    10. import com.meidusa.venus.notify.InvocationListener;  
    11.   
    12. public class DefaultHelloService implements HelloService {  
    13.     private String greeting;  
    14.     public String getGreeting() {  
    15.         return greeting;  
    16.     }  
    17.   
    18.     public void setGreeting(String greeting) {  
    19.         this.greeting = greeting;  
    20.     }  
    21.     public Hello getHello(String name) {  
    22.         Hello hello = new Hello();  
    23.         hello.setName(name);  
    24.         hello.setGreeting(greeting);  
    25.         Map<String,Object> map = new HashMap<String,Object>();  
    26.         hello.setMap(map);  
    27.         map.put("1", 1);  
    28.         map.put("2", new Long(2));  
    29.         map.put("3", new Integer(3));  
    30.         hello.setBigDecimal(new BigDecimal("1.341241233412"));  
    31.         return hello;  
    32.     }  
    33.   
    34.     public void sayHello(String name)  throws HelloNotFoundException {  
    35.         throw new HelloNotFoundException(name +" not found");  
    36.     }  
    37.   
    38.     @Override  
    39.     public void sayAsyncHello(String name) {  
    40.         System.out.println("method sayAsyncHello invoked");  
    41.     }  
    42.   
    43.     public void sayHello(String name,  
    44.             InvocationListener<Hello> invocationListener) {  
    45.         Hello hello = new Hello();  
    46.         hello.setName(name);  
    47.         hello.setGreeting(greeting);  
    48.         Map<String,Object> map = new HashMap<String,Object>();  
    49.         hello.setMap(map);  
    50.         map.put("1", 1);  
    51.         map.put("2", new Long(2));  
    52.         map.put("3", new Integer(3));  
    53.   
    54.         if(invocationListener != null){  
    55.             invocationListener.callback(hello);  
    56.         }  
    57.   
    58.     }  
    59. }  


联系
我们