一、RPC 簡介

 參考：
       http://itindex.net/detail/52530-rpc-%E6%A1%86%E6%9E%B6-%E5%88%86%E6%9E%90

 簡介：

   RPC(Remote Procedure Call Protocol)——遠端過程呼叫協議。使得程式像訪問本地資源一樣，去訪問遠端系統資源。更具體的將，像呼叫本地api一樣，呼叫遠端api。
 
 RPC呼叫框架 ：
     RMI實現： 利用java.rmi包實現，基於Java遠端方法協議(Java Remote Method Protocol) 和java的原生序列化。 
     Hessian： 是一個輕量級的remoting onhttp工具，使用簡單的方法提供了RMI的功能。 基於HTTP協議，採用二進位制編解碼。 
     protobuf-rpc-pro ： 是一個Java類庫，提供了基於 Google 的 Protocol Buffers 協議的遠端方法呼叫的框架。基於 Netty 底層的 NIO 技術。支援 TCP 重用/ keep-alive、SSL加密、RPC 呼叫取消操作、嵌入式日誌等功能。 
     THRIFT： 是一種可伸縮的跨語言服務的軟體框架。它擁有功能強大的程式碼生成引擎，無縫地支援C + +，C#，Java，Python和PHP和Ruby。thrift允許你定義一個描述檔案，描述資料型別和服務介面。依據該檔案，編譯器方便地生成RPC客戶端和伺服器通訊程式碼。 底層通訊基於SOCKET。 
     AVRO：標準性的雲端計算的資料交換和 儲存的Protocol。支援HTTP，TCP兩種協議。 

   
 
二、GRPC原理
  參考：https://juejin.im/entry/59bb30f76fb9a00a616f1b73
  背景：
      基於HTTP/2之上的二進位制協議(Protobuf序列化機制)
      一個連線可以多路複用，併發處理多個請求和響應
      多語言的類庫實現
      服務定義檔案和自動程式碼生成(.proto檔案和protobuf編譯工具)
      可以對框架進行功能定製和擴充套件(例如： 對接Zookeeper，域名解析服務，SLB服務等）
  流程：
      三、GRPC例子
    原始碼：[email protected]:xiangqian19831224/grpc-example.git
1、client
 

package com.rpc.mail;

import java.util.concurrent.TimeUnit;
import com.rpc.mail.SendMailServiceGrpc.SendMailServiceBlockingStub;
import io.grpc.ManagedChannel;
import io.grpc.netty.NettyChannelBuilder;

public class GrpcClient {
   public static void main(String[] args) throws Exception {
      ManagedChannel channel = NettyChannelBuilder.forAddress
 
("127.0.0.1", 8080).usePlaintext(true).build();
      //同步呼叫(非同步呼叫的話，就是：SendMailServiceGrpc.newFutureStub(channel))
SendMailServiceBlockingStub stub = SendMailServiceGrpc.newBlockingStub(channel);

      //設定請求引數
SendMailRequest param = SendMailRequest.newBuilder().setRecipient("[email protected]").setTitle("運維郵件").setContent("SOA服務掛了").build();
      SendMailResponse resp = stub.sendMail(param);
      System.out.println(resp.getMsg() + "\t" + resp.getCode());

      //close
channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
   }
}

SendMailServiceBlockingStub

package com.rpc.mail;

import io.grpc.Server;
import io.grpc.netty.NettyServerBuilder;

public class GrpcServer {
   public static void main(String[] args) throws Exception {
      Server server = NettyServerBuilder.forPort(8080).addService(SendMailServiceGrpc.bindService(new SendMailServiceImpl())).build();
      server.start();
      System.out.println("server startup at 8080");
      server.awaitTermination();
   }
}

package com.rpc.mail;

import io.grpc.stub.StreamObserver;

public class SendMailServiceImpl implements SendMailServiceGrpc.SendMailService {
   public void sendMail(SendMailRequest request, StreamObserver<SendMailResponse> responseObserver) {
      System.out.println(request.getRecipient() + "\t" + request.getTitle() + "\t" + request.getContent());
      //這裡是具體的業務邏輯
SendMailResponse resp = SendMailResponse.newBuilder().setCode(0).setMsg("OK").build();
      //設定返回結果
responseObserver.onNext(resp);
      responseObserver.onCompleted();
   }
}

package com.ec.search;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
@EnableDiscoveryClient
public class EurekaServerApplication {

   public static void main(String[] args) {
      SpringApplication.run(EurekaServerApplication.class, args);
   }
}

package com.ec.search;

import com.ec.search.eureka.EurekaNameResolverProvider;
import com.netflix.discovery.EurekaClientConfig;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.util.RoundRobinLoadBalancerFactory;
import org.ec.search.grpc.services.Request;
import org.ec.search.grpc.services.Response;
import org.ec.search.grpc.services.SearchServiceGrpc;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

/**
 * TODO: comment here
*/
@Service
public class SearchServiceClient {
   private Logger logger = LoggerFactory.getLogger(SearchServiceClient.class);

   @Autowired
EurekaClientConfig eurekaClientConfig;

   private SearchServiceGrpc.SearchServiceBlockingStub searchServiceBlockingStub;

   public String search(String query, int pageNum, int pageSize, int type){
      Request.Builder builder = Request.newBuilder();
      builder.setQuery(query);
      builder.setPageNum(pageNum);
      builder.setPageSize(pageSize);
      Request request = builder.build();

      Response response = searchServiceBlockingStub.searchByQuery(request);
      String docs = response.getDocs();
      return docs;
   }

   @PostConstruct
private void initializeClient() {

      ManagedChannel channel = ManagedChannelBuilder
            .forTarget("eureka://grpc-server")//搜尋引擎的分片名稱
            .nameResolverFactory(new EurekaNameResolverProvider(eurekaClientConfig, "grpc.port"))//搜尋引擎分片埠
            .loadBalancerFactory(RoundRobinLoadBalancerFactory.getInstance())
            .usePlaintext(true)
            .build();

      searchServiceBlockingStub = SearchServiceGrpc.newBlockingStub(channel);
   }
}

package com.ec.search;

import io.grpc.stub.StreamObserver;
import org.ec.search.grpc.services.Request;
import org.ec.search.grpc.services.Response;
import org.ec.search.grpc.services.SearchServiceGrpc;
import org.lognet.springboot.grpc.GRpcService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * TODO: comment here
*/
@GRpcService
public class SearchGrpcService extends SearchServiceGrpc.SearchServiceImplBase {
   private Logger logger = LoggerFactory.getLogger(SearchGrpcService.class);

   @Override
public  void searchByQuery(Request request, StreamObserver<Response> responseObserver){
      logger.debug("Request: " + request);
      Response.Builder builder = Response.newBuilder();
      builder.setQuery(request.getQuery());
      builder.setDocs("[服務成功]"); //返回結果
      Response response = builder.build();

      responseObserver.onNext(response);
      responseObserver.onCompleted();
   }
}