RPC学习笔记初遇篇(一)

public interface HelloService {
    String sayHi(String string);
}
public class HelloServiceImpl implements  HelloService{
    @Override
    public String sayHi(String string) {
        return string;
    }
}

// 注册中心
public interface ServerCenter {
    void start() throws IOException;
    void  register(Class serverName,Class serverImpl);
    void stop();
}
package org.example.rpc;
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.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @author xingke
 * @date 2022-01-15 17:08
 */
public class ServerCenterImpl implements  ServerCenter{
    /**
     * 注册过来的服务存放到多个Map.
     * 这里不考虑服务端集群的场景。
     */
    private static Map<String,Class> serviceRegister = new ConcurrentHashMap<>();
    /**
     * 这里采用JDK内置的线程池。
     * 实际中推荐自定义线程池
     */
    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()) ;
    /**
     * 启动标志位
     */
    private static boolean isRunning = false;
    @Override
    public void start() throws IOException {
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(8080));
        isRunning = true;
        while (true){
            System.out.println("server start....");
            Socket socket = serverSocket.accept();
            executor.execute(new RemoteCallTask(socket));
        }
    }
    @Override
    public void register(Class serverName, Class serverImpl) {
        serviceRegister.put(serverName.getName(),serverImpl);
    }
    @Override
    public void stop() {
        isRunning = false;
        executor.shutdown();
    }
    public static class RemoteCallTask implements Runnable{
        private Socket socket;
        public RemoteCallTask(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                 ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream())
            ){
                String serviceName = objectInputStream.readUTF();
                String methodName = objectInputStream.readUTF();
                Class[] parameterTypes = (Class[]) objectInputStream.readObject();
                Object[] args = (Object[]) objectInputStream.readObject();
                Class serviceClass = serviceRegister.get(serviceName);
                Method method = serviceClass.getMethod(methodName, parameterTypes);
                Object result = method.invoke(serviceClass.newInstance(), args);
                objectOutputStream.writeObject(result);
            } catch (IOException | ClassNotFoundException | NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}
public class RpcClient{
    public static <T> T getRemoteProxyObj(Class serverInterface, InetSocketAddress address) {
        return (T) Proxy.newProxyInstance(serverInterface.getClassLoader(), new Class[]{serverInterface}, (proxy, method, args) -> {
                    Socket socket = new Socket();
                    ObjectInputStream objectInputStream = null;
                    ObjectOutputStream objectOutputStream = null;
                    socket.connect(address);
                    objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeUTF(serverInterface.getName());
                    objectOutputStream.writeUTF(method.getName());
                    objectOutputStream.writeObject(method.getParameterTypes());
                    objectOutputStream.writeObject(args);
                    objectInputStream = new ObjectInputStream(socket.getInputStream());
                    return objectInputStream.readObject();
                }
        );
    }
}
// 先启动服务端,要不然客户端会连接不上报异常。
public class RpcServerTest{
    public static void main(String[] args) {
        new Thread(()->{
            ServerCenter serverCenter = new ServerCenterImpl();
            serverCenter.register(HelloService.class, HelloServiceImpl.class);
            try {
                serverCenter.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
public class RpcClientTest {
    public static void main(String[] args) throws ClassNotFoundException {
        HelloService httpService = RpcClient.getRemoteProxyObj(Class.forName("org.example.rpc.server.HelloService"), new InetSocketAddress(8080));
        // 方法在执行的时候开始远程调用
        httpService.sayHi("hello world");
    }
}