一个最简单的RPC框架实现包含暴露服务、引用服务、Socket通讯三部分。

RPC框架简易实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
public class RpcFramework {
    public static void exportService(final Object service, int port) throws Exception {
        ServerSocket serverSocket = new ServerSocket(port);
        while (true) {
            final Socket socket = serverSocket.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    ObjectInputStream reader = null;
                    ObjectOutputStream writer = null;
                    try {
                        reader = new ObjectInputStream(socket.getInputStream());
                        String methodName = reader.readUTF();
                        Class[] argumentsType = (Class[]) reader.readObject();
                        Object[] arguments = (Object[]) reader.readObject();
                        Method method = service.getClass().getMethod(methodName, argumentsType);
                        Object result = method.invoke(service, arguments);
                        writer = new ObjectOutputStream(socket.getOutputStream());
                        writer.writeObject(result);
                    } catch (Exception e) {
                        if (null != writer) {
                            try {
                                writer.writeObject(e);
                            } catch (IOException e1) {
                                e1.printStackTrace();
                            }
                        }
                    } finally {
                        if (null != writer) {
                            try {
                                writer.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                        if (null != reader) {
                            try {
                                reader.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }).start();
        }
    }
    public static <T> T referenceService(Class<T> interfaceClass, final String host, final int port) {
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket socket = new Socket(host, port);
                ObjectOutputStream writer = null;
                ObjectInputStream reader = null;
                try {
                    writer = new ObjectOutputStream(socket.getOutputStream());
                    writer.writeUTF(method.getName());
                    writer.writeObject(method.getParameterTypes());
                    writer.writeObject(args);
                    reader = new ObjectInputStream(socket.getInputStream());
                    return reader.readObject();
                } finally {
                    if (null != writer) {
                        writer.close();
                    }
                    if (null != reader) {
                        reader.close();
                    }
                }
            }
        });
    }
}

接口

1
2
3
4
5
6
7
public interface HelloService {
    String sayHello(String name);
}
public interface ByeService {
    String sayBye(String name);
}

接口实现

1
2
3
4
5
6
7
8
9
10
11
12
13
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return name + " say hello";
    }
}
public class ByeServiceImpl implements ByeService {
    @Override
    public String sayBye(String name) {
        return name +" bye bye";
    }
}

服务提供方

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Provider {
    public static void main(String[] args) throws Exception {
        final HelloService helloService = new HelloServiceImpl();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    RpcFramework.exportService(helloService, 20880);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        final ByeService byeService = new ByeServiceImpl();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    RpcFramework.exportService(byeService, 20881);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

服务消费方

1
2
3
4
5
6
7
8
9
public class Consumer {
    public static void main(String[] args) {
        HelloService helloService = RpcFramework.referenceService(HelloService.class, "127.0.0.1", 20880);
        System.out.println(helloService.sayHello("tom"));
        ByeService byeService = RpcFramework.referenceService(ByeService.class, "127.0.0.1", 20881);
        System.out.println(byeService.sayBye("jack"));
    }
}

输出

1
2
tom say hello
jack bye bye