netty实现简单rpc

RPC是Remote Procedure Call的简称，即远程过程调用，通过rpc，我们可以像调用本地接口一样，调用远程接口。在这个过程中，接口的实现对我们透明。实现rpc的框架很多，比如著名的dubbo框架，这里介绍通过netty来实现一个简单的rpc。

这里分为三个项目，分别是netty-rpc-api（定义接口）,netty-rpc-consumer（客户端）,netty-rpc-registry（服务端）。他们的职责这里简单说明一下：

netty-rpc-api：定义一个接口和rpc调用过程中传输的消息体InvokeMsg，无需任何依赖，被其他两个项目引用。

netty-rpc-consumer：依赖netty-rpc-api，通过proxy的方式调用接口。

netty-rpc-registry：实现netty-rpc-api项目中定义的接口，并注册服务，等待客户端调用。

三个工程结构如下：

netty-rpc-api项目

RpcService.java

package com.xxx.service;
public interface RpcService {
	String hello(String name);
	int add(int a,int b);
	int sub(int a,int b);
}

InvokeMsg.java

package com.xxx.core.msg;

import java.io.Serializable;

public class InvokeMsg implements Serializable{
	private static final long serialVersionUID = 1L;
	private String className;
	private String methodName;
	private Class<?>[] paramTypes;
	private Object[] values;
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public String getMethodName() {
		return methodName;
	}
	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}
	public Class<?>[] getParamTypes() {
		return paramTypes;
	}
	public void setParamTypes(Class<?>[] paramTypes) {
		this.paramTypes = paramTypes;
	}
	public Object[] getValues() {
		return values;
	}
	public void setValues(Object[] values) {
		this.values = values;
	}
	
}

netty-rpc-registry项目

pom.xml

<dependency>
      <groupId>com.xxx</groupId>
      <artifactId>netty-rpc-api</artifactId>
      <version>1.0</version>
</dependency>
<dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-all</artifactId>
      <version>4.1.27.Final</version>
</dependency>

RpcServiceImpl.java

package com.xxx.provider;

import com.xxx.service.RpcService;

public class RpcServiceImpl implements RpcService{

	@Override
	public String hello(String name) {
		return "hello,my name is "+name;
	}

	@Override
	public int add(int a, int b) {
		return a + b;
	}

	@Override
	public int sub(int a, int b) {
		return a - b;
	}
}

RegistryHandler.java

package com.xxx.registry;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import com.xxx.core.msg.InvokeMsg;

public class RegistryHandler extends ChannelInboundHandlerAdapter{

	public static ConcurrentHashMap<String, Object> classMap = new ConcurrentHashMap<String, Object>();
	
	private List<String> classCache = new ArrayList<String>();
	
	public RegistryHandler() {
		scannerClass("com.xxx.provider");
		doRegister();
	}
	
	private void doRegister() {
		if(classCache.size() ==0 ){return;}
		for(String name:classCache){
			try {
				Class<?> clazz = Class.forName(name);
				Class<?> interfaces = clazz.getInterfaces()[0];
				classMap.put(interfaces.getName(), clazz.newInstance());
			} catch (Exception e) {
				
			}
		}
	}
	
	private void scannerClass(String packageName) {
		URL url = this.getClass().getClassLoader().getResource(packageName.replaceAll("\\.", "/"));
		File dirFile = new File(url.getFile());
		for(File file:dirFile.listFiles()){
			if(file.isDirectory()){
				scannerClass(packageName+"."+file.getName());
			}else{
				classCache.add(packageName+"."+file.getName().replace(".class", ""));
			}
		}
	}
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		Object result = new Object();
		InvokeMsg request = (InvokeMsg)msg;
		if(classMap.containsKey(request.getClassName())){
			Object clazz = classMap.get(request.getClassName());
			Method method = clazz.getClass().getMethod(request.getMethodName(),
             request.getParamTypes());
			result = method.invoke(clazz, request.getValues());
		}
		ctx.writeAndFlush(result);
		ctx.close();
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		cause.printStackTrace();
		ctx.flush();
		ctx.close();
	}
	
}

RpcRegistry.java

package com.xxx.registry;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

public class RpcRegistry{
	
	private int port;
	
	public RpcRegistry(int port){
		this.port = port;
	}
	
	public void start(){
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workGroup = new NioEventLoopGroup();
		ServerBootstrap bootstrap = new ServerBootstrap();
		try {
			bootstrap.group(bossGroup, workGroup)
			         .channel(NioServerSocketChannel.class)
			         .childHandler(new ChannelInitializer<SocketChannel>() {

						@Override
						protected void initChannel(SocketChannel ch)
								throws Exception {
							ChannelPipeline pipeline = ch.pipeline();
							pipeline.addLast(new 
                            LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0,4,0,4));
							pipeline.addLast(new LengthFieldPrepender(4));
							pipeline.addLast("encoder",new ObjectEncoder());
							pipeline.addLast("decoder",new
                             ObjectDecoder(Integer.MAX_VALUE, 
                             ClassResolvers.cacheDisabled(null)));
							pipeline.addLast(new RegistryHandler());
						}
			        	 
					}).option(ChannelOption.SO_BACKLOG, 128)
					.childOption(ChannelOption.SO_KEEPALIVE, true);
			ChannelFuture future = bootstrap.bind(port).sync();
			System.out.println("server listener at port : "+port);
			future.channel().closeFuture().sync();
		} catch (Exception e) {
			bossGroup.shutdownGracefully();
			workGroup.shutdownGracefully();
		}
	}
	
    public static void main( String[] args ){
    	new RpcRegistry(8080).start();
    }
}

netty-rpc-consumer项目

pom.xml

<dependency>
      <groupId>com.xxx</groupId>
      <artifactId>netty-rpc-api</artifactId>
      <version>1.0</version>
</dependency>
<dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-all</artifactId>
      <version>4.1.27.Final</version>
</dependency>

RpcProxyHandler.java

package com.xxx.consumer.proxy;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class RpcProxyHandler extends ChannelInboundHandlerAdapter{

	private Object response;
	
	public Object getResponse(){
		return this.response;
	}
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		System.out.println("client receive message: "+msg);
		response = msg;
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		cause.printStackTrace();
		ctx.flush();
		ctx.close();
	}
	
}

RpcProxy.java

package com.xxx.consumer.proxy;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import com.xxx.core.msg.InvokeMsg;

public class RpcProxy {
	@SuppressWarnings("unchecked")
	public static <T> T create(Class<?> clazz){
		MethodProxy proxy = new MethodProxy(clazz);
		T result = (T)Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, proxy);
		return result;
	}
}

class MethodProxy implements InvocationHandler{
	private Class<?> clazz;
	public MethodProxy(Class<?> clazz) {
		this.clazz = clazz;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		if(Object.class.equals(method.getDeclaringClass())){
			try {
				return method.invoke(this, args);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}else{
			return rpcInvoke(proxy,method,args);
		}
		return args;
	}

	private Object rpcInvoke(Object proxy, Method method, Object[] args) {
		InvokeMsg msg = new InvokeMsg();
		msg.setClassName(this.clazz.getName());
		msg.setMethodName(method.getName());
		msg.setValues(args);
		msg.setParamTypes(method.getParameterTypes());
		final RpcProxyHandler handler = new RpcProxyHandler();
		EventLoopGroup group = new NioEventLoopGroup();
		try {
			Bootstrap bootstrap = new Bootstrap();
			bootstrap.group(group)
			         .channel(NioSocketChannel.class)
			         .option(ChannelOption.TCP_NODELAY, true)
			         .handler(new ChannelInitializer<SocketChannel>() {

						@Override
						protected void initChannel(SocketChannel ch)
								throws Exception {
							ChannelPipeline pipeline = ch.pipeline();
							pipeline.addLast("frameDecoder",new 
                            LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4,0,4));
							pipeline.addLast("frameEncoder",
                             new LengthFieldPrepender(4));
							pipeline.addLast("encoder",new ObjectEncoder());
							pipeline.addLast("decoder",new 
                             ObjectDecoder(Integer.MAX_VALUE, 
                             ClassResolvers.cacheDisabled(null)));
						    pipeline.addLast("handler",handler);
						}
			        	 
					});
			ChannelFuture future = bootstrap.connect("localhost", 8080).sync();
			future.channel().writeAndFlush(msg).sync();
			future.channel().closeFuture().sync();
			return handler.getResponse();
		} catch (Exception e) {
			group.shutdownGracefully();
		}
		return null;
	}
	
}

RpcConsumer.java

package com.xxx.consumer;

import com.xxx.consumer.proxy.RpcProxy;
import com.xxx.service.RpcService;

public class RpcConsumer {
    public static void main( String[] args ){
    	RpcService service = RpcProxy.create(RpcService.class);
    	String hello = service.hello("rpc");
    	System.out.println(hello);
    	System.out.println(service.add(5, 3));
    	System.out.println(service.sub(5, 3));
    }
}

启动netty-rpc-registry项目，然后启动客户端消费者netty-rpc-consumer，有如下打印信息。

这样一个简易的rpc框架就完成了。

整理一下整个流程的示意图：

这中间消息体invokeMsg，起到了关键的纽带作用，客户端调用时，将请求接口，请求方法，请求参数封装到一起，传递给服务端，服务端根据收到的消息，解析请求接口，请求方法，请求参数，采用反射调用本地方法，并将结果返回给客户端。客户端监听到有数据返回，将结果返回给调用者。