RPC 远程过程调用

RPC框架是分布式服务的基础，

RPC远程过程调用（RPC）是一种协议，程序可以使用这个协议请求网络中另一台计算机上某程序的服务而不需要知道网络细节；

调用非本机的方法，不了解底层通信，想本地方法一样调用

RPC框架设计

封装网络交互，远程调用对象的代理，支持容器（Spring，jetty），尽量可配置，可扩展

实现代码

新建调用接口并实现它

public interface HelloService {
        String sayHi(String name);
}

public class HelloServiceImpl implements HelloService{

    @Override
    public String sayHi(String name) {
          return "Hi, " + name;
    }
}

新建服务中心接口，并实现
public interface Server {
    public void stop();
      
    public void start() throws IOException;
 
    public void register(Class serviceInterface, Class impl);
 
    public boolean isRunning();
 
    public int getPort();
}

//服务中心代码接口实现类
public class ServiceCenter implements Server{
    //线程池
    //用来创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小通常根据系统资源进行设置
    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    //用来存储接口的实现类的MAP；等于是注册
    private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>();
 
    private static boolean isRunning = false;
 
    private static int port;
 
    public ServiceCenter(int port) {
        this.port = port;
    }
 
    public void stop() {
        isRunning = false;
       // shutdown()方法在终止前允许执行以前提交的任务
        executor.shutdown();
    }
 
    public void start() throws IOException {
        ServerSocket server = new ServerSocket();
        //Socket监听端口
        server.bind(new InetSocketAddress(port));
        System.out.println("start server");
        try {
            while (true) {
                // 1.监听客户端的TCP连接，接到TCP连接后将其封装成task，由线程池执行
                executor.execute(new ServiceTask(server.accept()));
            }
        } finally {
            server.close();
        }
    }
 
    public void register(Class serviceInterface, Class impl) {
        serviceRegistry.put(serviceInterface.getName(), impl);
    }
 
    public boolean isRunning() {
        return isRunning;
    }
 
    public int getPort() {
        return port;
    }
 
    private static class ServiceTask implements Runnable {
        Socket clent = null;
 
        public ServiceTask(Socket client) {
            this.clent = client;
        }
 
        public void run() {
            ObjectInputStream input = null;
            ObjectOutputStream output = null;
            try {
                // 2.将客户端发送的码流反序列化成对象，反射调用服务实现者，获取执行结果
                input = new ObjectInputStream(clent.getInputStream());
                // 读取一个UTF-8 修改版格式的String
                String serviceName = input.readUTF();
                String methodName = input.readUTF();
                //读成对象
                Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                Object[] arguments = (Object[]) input.readObject();
                //获取代理的注册类
                Class serviceClass = serviceRegistry.get(serviceName);
                if (serviceClass == null) {
                    throw new ClassNotFoundException(serviceName + " not found");
                }
                Method method = serviceClass.getMethod(methodName, parameterTypes);
                //通过代理执行方法
                Object result = method.invoke(serviceClass.newInstance(), arguments);
 
                // 3.将执行结果反序列化，通过socket发送给客户端
                output = new ObjectOutputStream(clent.getOutputStream());
                output.writeObject(result);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (output != null) {
                    try {
                        output.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (input != null) {
                    try {
                        input.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (clent != null) {
                    try {
                        clent.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
 
        }
    }
}

动态代理类

public class RPCClient<T> {
     public static <T> T getRemoteProxyObj(final Class<?> serviceInterface, final InetSocketAddress addr) {
         RPCProxyClient rpc=new RPCProxyClient(addr,serviceInterface);
       /* 将本地的接口调用转换成JDK的动态代理，在动态代理中实现接口的远程调用
         原因就是在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，
                这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是T类型，所以就可以将其转化为T类型了。
                同时我们一定要记住，通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，
                 它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，
                 并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。*/
        /* ClassLoader loader
         ----指定被代理对象的类加载器
         Class[] Interfaces
         ----指定被代理对象所实现的接口
         InvocationHandler h ----指定需要调用的InvocationHandler对象 */
            return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[]{serviceInterface}, rpc);
        }

}

public class RPCProxyClient implements InvocationHandler {
    private InetSocketAddress addr;
    private Class<?> serviceInterface;
    
    public RPCProxyClient(InetSocketAddress addr,Class<?> serviceInterface){
        this.addr=addr;
        this.serviceInterface=serviceInterface;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
          Socket socket = null;
          ObjectOutputStream output = null;
          ObjectInputStream input = null;
          try {
              // 2.创建Socket客户端，根据指定地址连接远程服务提供者
              socket = new Socket();
              System.out.println(addr);
              socket.connect(addr);

              // 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
              output = new ObjectOutputStream(socket.getOutputStream());
              output.writeUTF(serviceInterface.getName());
              output.writeUTF("测试String");
              output.writeUTF(method.getName());
              output.writeObject(method.getParameterTypes());
              output.writeObject(args);

              // 4.同步阻塞等待服务器返回应答，获取应答后返回
              input = new ObjectInputStream(socket.getInputStream());
              return input.readObject();
          } finally {
              if (socket != null) socket.close();
              if (output != null) output.close();
              if (input != null) input.close();
          }
      }

}

测试调用

public class RPCTest {
     public static void main(String[] args) throws IOException {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        //启动服务器
                        Server serviceServer = (Server) new ServiceCenter(9999);
                        serviceServer.register(HelloService.class, HelloServiceImpl.class);
                        serviceServer.start();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            //客户端调用，通过传入接口，和访问的地址；直接达到访问服务的目的
            HelloService service = RPCClient.getRemoteProxyObj(HelloService.class, new InetSocketAddress("localhost", 9999));
            System.out.println(service.sayHi("test"));
        }

}