java rmi 与 spring mvc rest 性能简单对比

场景描述：

服务端用rest和rmi发布两个接口，两个接口提供同样的功能，获取同一个bean；

服务端用httpclient和rmi分别起十个线程调用，打印时间；

废话少说，程序猿用代码说话： 

首先定义一个Bean:

package net.tt.rest.domain;

import java.io.Serializable;

import lombok.Data;

/**
 *
 * @author tbc 
 * @version 1.0 {2016年6月13日 上午11:29:56}
 */
@Data
public class MyBean implements Serializable {
	private static final long serialVersionUID = -3442523325988510637L;
	private String uuid;
	private String name;
	private String value;

	public static MyBeanBuilder builder() {
		return new MyBeanBuilder();
	}

	public static class MyBeanBuilder {
		private String uuid;
		private String name;
		private String value;

		public MyBeanBuilder uuid(String uuid) {
			this.uuid = uuid;
			return this;
		}

		public MyBeanBuilder name(String name) {
			this.name = name;
			return this;
		}

		public MyBeanBuilder value(String value) {
			this.value = value;
			return this;
		}

		public MyBean build() {
			MyBean b = new MyBean();
			b.setName(name);
			b.setUuid(uuid);
			b.setValue(value);
			return b;
		}

	}

}

要发布的接口：

package net.tt.rest.service;

import java.rmi.Remote;
import java.rmi.RemoteException;

import net.tt.rest.domain.MyBean;

/**
 *
 * @author tbc 
 * @version 1.0 {2016年6月13日 上午10:14:43}
 */
public interface RmiRest extends Remote {

	MyBean getBean() throws RemoteException;

}

接口实现：

package net.tt.rest.service.impl;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import net.tt.rest.domain.MyBean;
import net.tt.rest.service.RmiRest;

/**
 * UnicastRemoteObject用于导出的远程对象和获得与该远程对象通信的存根。
 * 
 * @author tbc 
 * @version 1.0 {2016年6月13日 上午10:39:26}
 */
@Service("rmiRestImpl")
public class RmiRestImpl extends UnicastRemoteObject implements RmiRest {
	private static final long serialVersionUID = 1L;
	private Logger log = LoggerFactory.getLogger(RmiRestImpl.class);

	public RmiRestImpl() throws RemoteException {
	}

	@Override
	public MyBean getBean() throws RemoteException {
		MyBean bean = MyBean.builder()//
				.uuid(UUID.randomUUID().toString())//
				.name("MyName")//
				.value("thid is a test!")//
				.build();
		return bean;
	}

}

spring mvc controller -> 

package net.tt.rest.controller;

import java.rmi.RemoteException;
import java.util.Map;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.google.common.collect.Maps;

import net.tt.rest.domain.MyBean;
import net.tt.rest.service.RmiRest;

/**
 *
 * @author tbc 
 * @version 1.0 {2016年6月13日 上午10:57:03}
 */
@RestController
public class MyRestController {
	private Logger log = LoggerFactory.getLogger(MyRestController.class);

	@Resource(name = "rmiRestImpl")
	RmiRest rmiRest;

	@RequestMapping(value = "bean", method = { RequestMethod.GET })
	public MyBean getBean() throws RemoteException {
		return rmiRest.getBean();
	}

}

监听器，发布RMI ：

package net.tt.rest.listener;

import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.tt.rest.service.RmiRest;
import net.tt.rest.service.impl.RmiRestImpl;

/**
 *
 * @author tbc
 * @version 1.0 {2016年6月13日 上午10:44:13}
 */
@WebListener("rmi")
public class MyServletContextListener implements ServletContextListener {
	private Logger log = LoggerFactory.getLogger(MyServletContextListener.class);

	@Override
	public void contextInitialized(ServletContextEvent sce) {
		log.info("启动监听，启动rmi服务...");
		try {
			RmiRest rr = new RmiRestImpl();
			LocateRegistry.createRegistry(8888);

			Naming.bind("rmi://localhost:8888/rr", rr);

			log.info("远程RmiRest对象绑定成功--->");
		} catch (RemoteException e) {
			log.error("创建远程对象发生异常");
			e.printStackTrace();
		} catch (MalformedURLException e) {
			log.error("发生重复绑定对象异常！");
			e.printStackTrace();
		} catch (AlreadyBoundException e) {
			log.error("发生URL畸形异常！");
			e.printStackTrace();
		}

	}

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		log.info("销毁监听器...");
	}

}

 OK，到此服务端代码就完成了，至于spring及监听的相关配置，不是本文重点，不再赘述，启动jetty，OK，成功！

下面写客户端代码进行测试： 

package net.tt.mytest.rmirest;

import java.io.IOException;
import java.rmi.Naming;
import java.util.concurrent.TimeUnit;

import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.fluent.Request;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.tt.rest.domain.MyBean;
import net.tt.rest.service.RmiRest;

/**
 *
 * @author tbc 
 * @version 1.0 {2016年6月13日 上午11:15:05}
 */
public class RmiRestTest {
	private static Logger log = LoggerFactory.getLogger(RmiRestTest.class);

	public static void main(String[] args) throws ClientProtocolException, IOException, InterruptedException {
		log.info("springMvcRest testing ...");
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				long restStart = System.currentTimeMillis();
				String restContent = "";
				try {
					restContent = Request.Get("http://localhost:8080/spring/bean")//
							.execute()//
							.returnContent()//
							.asString();
					log.info("rest return -> {}", restContent);
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// log.info("exec result : {}", restCode);
				log.info("本次耗时：{}", (System.currentTimeMillis() - restStart));
			}).start();
		}

		TimeUnit.SECONDS.sleep(3);
		System.out.println("--------------------------------->");
		log.info("rmi testing ...");
		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				long rmiStart = System.currentTimeMillis();
				int restCode = 0;
				try {
					RmiRest rr = (RmiRest) Naming.lookup("rmi://localhost:8888/rr");
					MyBean b = rr.getBean();
					log.info("rmi return -> {}", b);
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				log.info("本次耗时：{}", (System.currentTimeMillis() - rmiStart));
			}).start();
		}

	}

}

OK，一段简单的代码，进行一下简单的对比测试，全程裸奔，那么看一下结果：

程序猿能用代码说明的问题咱就用图片说明。。。

注：本文不讨论rest和RMI 甚至 RPC方案的优劣，不涉及跨平台等等属性，仅仅是在纯JAVA方案的前提下，测试rest与rmi两种方案的性能问题，本测试也不是十分严谨，事实上，这种测试是很不公平的，可以说拿RMI的优势来对比REST的劣势，非常偏，但在纯JAVA系统中，只关心性能的情况下，应该还是有一定的参考意义的；

另外，据说jersey的实现方案性能要比spring mvc强，下次做一下这方面的相关测试；