Java简单的RPC实现（一）

RPC使用java最基本的，传输层使用Socket，序列化使用Serializable，java 动态代理模式，但是未实现消息注册等相关信息

大道至简

server端

  

package com.rpc.entity;

import java.io.Serializable;

public class RpcObject implements Serializable{
    
    private static final long serialVersionUID = 1L;
    private Class<?> c;
    private String methodName;
    private Object[] args;
    
    public RpcObject() {
        
    }
    
    public RpcObject(Class<?> c, String methodName, Object[] args) {
        this.c = c;
        this.methodName = methodName;
        this.args = args;
    }
    
    public Class<?> getC() {
        return c;
    }
    
    public void setC(Class<?> c) {
        this.c = c;
    }
    
    public String getMethodName() {
        return methodName;
    }
    
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
    
    public Object[] getArgs() {
        return args;
    }
    
    public void setArgs(Object[] args) {
        this.args = args;
    }
}

ConfMonitor

package com.rpc.server;

import java.util.HashMap;
import java.util.Map;

import com.rpc.service.impl.HelloImpl;

/**
 * 模拟配置，实际的框架中大部分都是使用xml进行配置的，比如Hessian是配置在web.xml的servlet属性里的
 * @author cdwangzijian
 *
 */
public class ConfMonitor {
    @SuppressWarnings("rawtypes")
    public static Map<String, Class> conf = new HashMap<String, Class>();
    
    static {
        conf.put("com.rpc.service.IHello", HelloImpl.class);
    }
}

RpcThread

package com.rpc.server;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.Socket;

import com.rpc.entity.RpcObject;

public class RpcThread extends Thread {
    
    private Socket s;
    
    public RpcThread(Socket s) {
        this.s = s;
    }
    
    @Override
    public void run() {
        
        ObjectInputStream is = null;
        ObjectOutputStream os = null;
        
        try {
            
            is = new ObjectInputStream(s.getInputStream());
            
            // 得到远程调用参数，包含了接口名，调用方法，方法参数
            RpcObject rpcObject = (RpcObject) is.readObject();
            
            System.out.println("Method:"+rpcObject.getMethodName());
            
            // 构建接口的实现类，然后通过反射调用方法
            Object o = getObject(rpcObject.getC());
            System.out.println("class:"+rpcObject.getC());
            
            
            Object reO = executeMethod(o, rpcObject.getMethodName(), rpcObject.getArgs());
            
            // 输出返回值
            os = new ObjectOutputStream(s.getOutputStream());
            os.writeObject(reO);
            os.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if(is!=null){
                    is.close();
                }
                
                if(os!=null){
                    os.close();
                }                
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 通过反射技术执行方法，并返回返回值
     * @param o
     * @param methodName
     * @param args
     * @return
     */
    private Object executeMethod(Object o, String methodName, Object[] args) {
        Object objR = null;
        Class<?>[] cs = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            cs[i] = arg.getClass();
        }
        try {
            Method m = o.getClass().getMethod(methodName, cs);
            objR = m.invoke(o, args);
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return objR;
    }
    
    /**
     * 根据接口名得到实例
     * @param c
     * @return
     */
    private Object getObject(Class<?> c) {
        Object o = null;
        try {
            
            System.out.println("c.getName:"+c.getName());
            
            o = ConfMonitor.conf.get(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return o;
    }
}

StartUp

package com.rpc.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * RPC服务器启动
 * @author cdwangzijian
 *
 */
public class StartUp {
    
    public static final int port = 9001;
    
    public static void main(String[] args) {
            exportRpc();
    }
    
    /**
     * 导出RPC接口
     */
    private static void exportRpc() {
        try {
            ServerSocket ss = new ServerSocket(port);
            while(true){
                Socket s = ss.accept();
                if(s!=null){
                    new RpcThread(s).start();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HelloImpl

package com.rpc.service.impl;

import com.rpc.service.IHello;

public class HelloImpl implements IHello {
    @Override
    public String sayHello(String name) {
        return "hello:" + name;
    }
}

IHello

package com.rpc.service;

public interface IHello {
    String sayHello(String name);
}

客户端实现：

 ProxyFactory

package com.zhy.proxy;

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

public class ProxyFactory {

    @SuppressWarnings("unchecked")
    public static <T> T create(Class<T> c, String ip, int port) {
         
        InvocationHandler handler = new RpcProxy(ip, port, c);
        
        return (T) Proxy.newProxyInstance(c.getClassLoader(),new Class[] {c},handler);
    }
}

RpcProxy

package com.zhy.proxy;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.Socket;

import com.rpc.entity.RpcObject;

/**
 * 客户端接口代理
 * 当客户端接口方法被调用的时候，把方法名，方法参数作为参数。
 * 传送给远程服务执行，然后获取返回值
 * @author cdwangzijian
 *
 */
public class RpcProxy implements InvocationHandler, Serializable{
    
    private String ip;
    private int port;
    private Class<?> c;
    
    private static final long serialVersionUID = 1L;

    public RpcProxy(String ip, int port, Class<?> c) {
        this.ip = ip;
        this.port = port;
        this.c = c;
    }
    
    /**
     * 动态代理类，当调用接口方法的时候转为调用此方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
        
        // 用作返回值
        Object o = null;        
        // 通过socket调用远程服务
        Socket s = new Socket(ip, port);
        
        // 组装为一个保留了要调用的类，方法名及参数的对象，然后序列化之后传给远程
        RpcObject rpcObject = new RpcObject(c, method.getName(), args);
        
        ObjectOutputStream os = null;
        ObjectInputStream is = null;
        
        try{
            os = new ObjectOutputStream(s.getOutputStream());
            os.writeObject(rpcObject);
            os.flush();
            
            // 从远程得到返回结果
            is = new ObjectInputStream(s.getInputStream());
            o = is.readObject();
            
        } catch (Exception e) {
            e.printStackTrace();
            
        } finally{
            
            if(os!=null){
                os.close();
            }
            
            if(is!=null){
                is.close();
            }
            
        }
        
        return o;
    }
    
}

RpcClient

package com.zhy;

import com.rpc.service.IHello;
import com.zhy.proxy.ProxyFactory;

public class RpcClient {
    public static void main(String[] args) {
        
        String ip = "localhost";
        int port = 9001;
        
        IHello hello = ProxyFactory.create(IHello.class, ip, port);
        
        System.out.println(hello.sayHello("小明"));
        
    }
}

输出结果：