一、服务远程简单调用

image.png
服务远程调用，可以利用http+传统的servlet服务实现。（关于通信服务，也可使用其他，例如：netty等框架）

  1. 服务消费者通过httpClient，使用ip+port。调用远程服务。

  2. 服务提供者，接受入参，（通过接口信息获取实现类信息）通过反射方式，执行业务处理逻辑，序列化处理结果返回。

    缺陷

    服务消费者，在调用远程服务时，每次都需要进行参数组装（Invocattion参数）、HttpClient数据发送等远程调用逻辑实现。重复的调用逻辑严重影响正常业务逻辑。
    image.png

    消费端实现

    1. public class OriginalConsumer {
    3.  public static void main(String[] args) throws IOException {
    5.      //组装Invocation参数
    6.      RpcInvocation invocation = new RpcInvocation();
    7.      invocation.setServiceName(DemoServiceImpl.class.getName());
    8.      invocation.setMethodName("sayHello");
    9.      invocation.setParameterTypes(new Class[]{String.class});
    10.      invocation.setArguments(new Object[]{"masterlu"});
    12.      //发送数据
    13.      Socket socket = new Socket("127.0.0.1", 8080);
    14.      ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
    15.      oos.writeObject(invocation);
    17.      //接收数据
    18.      InputStream inputStream = socket.getInputStream();
    19.      byte[] bytes = new byte[1024];
    20.      int read = inputStream.read(bytes);
    21.      System.out.println(new String(bytes,0,read));
    23.  }
    24. }

    服务端实现

    ```java /**

    • 原始服务提供 */ public class OriginalService {
  1. public static void main(String[] args) throws IOException {
  2.     // 1. 注册服务
  3.     // 2. 本地注册
  4.     // 3. 启动tomcat
  5.     // 注册服务
  7.     ServerSocket serverSocket = new ServerSocket(8080);
  8.     while (true) {
  9.         Socket accept = serverSocket.accept();
  10.         new Thread(() -> {
  11.             try {
  12.                 InputStream inputStream = accept.getInputStream();
  13.                 // 获取接口调用信息
  14.                 ObjectInputStream ois = new ObjectInputStream(accept.getInputStream());
  15.                 Invocation invocation = (Invocation) ois.readObject();
  16.                 Class implClass = Class.forName(invocation.getServiceName());//接口
  18.                 //反射调用方法
  19.                 Class[] parameterTypes = new Class[invocation.getArguments().length];
  20.                 for (int i = 0; i < invocation.getArguments().length; i++) {
  21.                     parameterTypes[i] = invocation.getArguments()[i].getClass();
  22.                 }
  23.                 Method method = implClass.getMethod(invocation.getMethodName(), new Class[]{String.class});
  24.                 String result = (String) method.invoke(implClass.newInstance(), invocation.getArguments());
  26.                 System.out.println("socket:" + result);
  28.                 IOUtils.write(result, accept.getOutputStream());
  29.             } catch (Exception e) {
  30.                 System.out.println(e);
  31.             }
  32.         }).start();
  33.     }
  35. }

}

  1. <a name="kMsqd"></a>
  2. # 二、动态代理优化服务远程调用
  3. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/13013491/1666612005954-824e53a0-6099-4cb1-b623-ae1655fd44cd.png#averageHue=%23f1f1f1&clientId=uf4921a63-9744-4&from=paste&height=209&id=u55925192&originHeight=314&originWidth=1407&originalType=binary&ratio=1&rotation=0&showTitle=false&size=80023&status=done&style=none&taskId=u662e767c-14cc-45c6-a2ca-64107097204&title=&width=938)
  4. <a name="Hs5uo"></a>
  5. ## 缺陷
  6. 服务消费者，在代码中写死服务提供者IP。提供者下线、扩容，对服务消费者，影响很大。
  7. <a name="Pwk1A"></a>
  8. ## 优化消费端实现
  9. ```java
  10.     public static void main(String[] args) throws IOException {
  12.         //将远程调用逻辑进行封装，减少对业务逻辑的影响
  13.         DemoService demoService = getProxy(DemoServiceImpl.class);
  14.         String result = demoService.sayHello("masterlu");
  15.         System.out.println(result);
  18.     }
  20.     public static <T> T getProxy(final Class interfaceClass) {
  21.         return (T)Proxy.newProxyInstance(
  22.                 interfaceClass.getClassLoader(),
  23.                 interfaceClass.getInterfaces(),
  24.                 (proxy, method, args) -> {
  26.                     //组装Invocation参数
  27.                     RpcInvocation invocation = new RpcInvocation();
  28.                     invocation.setServiceName(interfaceClass.getName());
  29.                     invocation.setMethodName(method.getName());
  30.                     invocation.setParameterTypes(method.getParameterTypes());
  31.                     invocation.setArguments(args);
  33.                     //发送数据
  34.                     Socket socket = new Socket("127.0.0.1", 8080);
  35.                     ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  36.                     oos.writeObject(invocation);
  38.                     //接收数据
  39.                     InputStream inputStream = socket.getInputStream();
  40.                     byte[] bytes = new byte[1024];
  41.                     int read = inputStream.read(bytes);
  42.                     return new String(bytes,0,read);
  43.                 });
  44.     }
  45. }

三、引入注册中心优化服务远程调用

image.png

引入注册中心，服务提供者，将信息存储在注册中；消费者实时感知可用服务。
注册中心数据缓存
服务消费者，获取注册中心数据后，缓存在本地。注册中心临时短时间故障，不影响服务使用。
失败重试
服务消费获取远程服务列表后，可实现服务的调用策略（随机、轮询、最少活跃、一致性哈希【根据参数计算hash，决定调用服务，参数一致会调用同一台】）

注册中心作用

监控服务提供者
可以利用zk的临时节点，或利用redis的定时节点（定时延期），实时感知服务提供者的服务可用性，监控服务提供者的服务。
发现服务消费者
利用zk的wacth机制（注册到提供的创建的临时节点上）、redis的发布订阅模式，及时感知服务提供者增、减的情况

四、增加监控中心

image.png