gRPC初探

最新推荐文章于 2024-09-28 11:38:42 发布

NullPointerExcept

最新推荐文章于 2024-09-28 11:38:42 发布

阅读量5k

点赞数

分类专栏： Thrift RPC开发文章标签： thrift

Thrift RPC开发专栏收录该内容

23 篇文章 0 订阅

订阅专栏

gRPC是google新开源的一个基于protobuf的rpc框架，使用通信协议为HTTP2，网络通信层基于netty实现；

它首先提供移动客户端的rpc功能，同时也是一个通用的rpc框架。

下面是我做的一个简单的gRPC的demo。

通过IDL定义服务接口和消息格式

如下IDL文件，定义了服务接口和消息格式，

SearchService.proto文件

syntax = "proto3";
package search;
option Java_multiple_files = true;
option java_package = "com.usoft.grpc.example.search";
option java_outer_classname = "SearchProto";
service SearchService {
   // 四种rpc method
   rpc SearchWithSimpleRpc (SearchRequest) returns (SearchResponse) {};
   rpc SearchWithServerSideStreamRpc (SearchRequest) returns (stream SearchResponse) {};
   rpc SearchWithClientSideStreamRpc (stream SearchRequest) returns (SearchResponse) {};
   rpc SearchWithBidirectionalStreamRpc(stream SearchRequest) returns (stream SearchResponse) {};
}
message SearchRequest {
  string query = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
}
message SearchResponse {
  message Result {
    string url = 1;
    string title = 2;
    repeated string snippets = 3;
  }
  repeated Result result = 1;
}

使用service 和 message 关键字分别定义了服务接口和基于该服务接口的消息格式。

message可以嵌套定义。

这里是基于protobuf 3 定义的服务接口和消息格式，在protobuf 3 中不再使用 required 和 optional 关键字，只保留了repeated 关键字。

使用protobuf 3 定义的消息格式比protobuf 2 显得更干净和整洁。

由IDL文件生成服务器端和客户端代码

这里使用的构建工具时gradle，使用gRPC的gradle插件，

apply plugin: 'com.google.protobuf'

运行插件的generate任务

编写服务器端和客户端业务逻辑实现

服务器端只需要实现SearchServiceGrpc.SearchService这个接口就可以，其实这个接口就是我们在proto文件中用service关键字定义的接口。

在上边的proto文件中，我们定义了四种rpc method，分别是

rpc SearchWithSimpleRpc (SearchRequest) returns (SearchResponse) {};
rpc SearchWithServerSideStreamRpc (SearchRequest) returns (stream SearchResponse) {};
rpc SearchWithClientSideStreamRpc (stream SearchRequest) returns (SearchResponse) {};
rpc SearchWithBidirectionalStreamRpc(stream SearchRequest) returns (stream SearchResponse) {};

这四种rpc method 对应着客户端和服务器端的实现是不同的，即表现在发送消息的方式，有stream关键词意味着是否是以stream（流式）的方式发送消息。

第一种 rpc SearchWithSimpleRpc (SearchRequest) returns (SearchResponse) {};

这种方式是最简单的一种rpc 方式，客户端通过一个stub 阻塞式的调用远程服务器方法，阻塞式表现在客户端调用后等待服务器端的返回消息。

j2ee里面的stub是这样说的..为屏蔽客户调用远程主机上的对象，必须提供某种方式来模拟本地对象,这种本地对象称为存根(stub),存根负责接收本地方法调用,并将它们委派给各自的具体实现对象

stub 在gRPC中也是这个意思。通过stub调用远程服务接口。

在客户端定义两种阻塞式的stub 和异步方式的stub，如下，

blockingStub 和 asyncStub

private final ManagedChannel channel;
private final SearchServiceGrpc.SearchServiceBlockingStub blockingStub;
private final SearchServiceGrpc.SearchServiceStub asyncStub;
/**
 * Construct client connecting to HelloWorld server at {@code host:port}.
 */
public SearchClient(String host, int port) {
    channel = ManagedChannelBuilder.forAddress(host, port)
        .usePlaintext(true).build();
    blockingStub = SearchServiceGrpc.newBlockingStub(channel);
    asyncStub = SearchServiceGrpc.newStub(channel);
}

客户端的实现

/**
 * simple rpc
 * 
 * @param pageNo
 * @param pageSize
 */
public void searchWithSimpleRpc(int pageNo, int pageSize) {
    try {
        logger.info(
            "search param pageNo=" + pageNo + ",pageSize=" + pageSize);
        SearchRequest request = SearchRequest.newBuilder()
            .setPageNumber(pageNo).setResultPerPage(pageSize).build();
        SearchResponse response = blockingStub.searchWithSimpleRpc(request);
        logger.info("search result: " + response.toString());
    } catch (RuntimeException e) {
        logger.log(Level.WARNING, "RPC failed", e);
        return;
    }
}

在客户端通过这行代码调用远程服务器方法

SearchResponse response = blockingStub.searchWithSimpleRpc(request);

直到一个消息返回

服务器端方法实现

/**
 * Simple RPC
 * A simple RPC where the client sends a request to the server using the
 * stub and waits for a response to come back, just like a normal function
 * call.
 * 
 * @param request
 * @param responseObserver
 */
@Override
public void searchWithSimpleRpc(SearchRequest request,
        StreamObserver<SearchResponse> responseObserver) {
    system.out.println("pageNo=" + request.getPageNumber());
    System.out.println("query string=" + request.getQuery());
    System.out.println("pageSize=" + request.getResultPerPage());
    List<SearchResponse.Result> results = new ArrayList<SearchResponse.Result>(
        10);
    for (int i = 0; i < request.getResultPerPage(); i++) {
        SearchResponse.Result result = SearchResponse.Result.newBuilder()
            .setTitle("title" + i).setUrl("dev.usoft.com")
            .addSnippets("snippets" + i).build();
        results.add(result);
    }
    SearchResponse response = SearchResponse.newBuilder()
        .addAllResult(results).build();
    responseObserver.onNext(response);
    //We use the response observer's onCompleted() method to specify that we've finished dealing with the RPC.
    responseObserver.onCompleted();
}

第二种 rpc SearchWithServerSideStreamRpc (SearchRequest) returns (stream SearchResponse) {};

服务器端的 rpc 方法的stream 方式实现。这种方式下客户端和服务器端主要交互方式表现为当客户端发送一个消息后，服务器可以连续多次返回消息，而客户端回连续读取消息，直到服务器发送完毕。

客户端实现

/**
 * server side stream rpc
 * 
 * @param pageNo
 * @param pageSize
 */
public void searchWithSeverSideStreamRpc(int pageNo, int pageSize) {
    try {
        logger.info(
            "search param pageNo=" + pageNo + ",pageSize=" + pageSize);
        SearchRequest request = SearchRequest.newBuilder()
            .setPageNumber(pageNo).setResultPerPage(pageSize).build();
        Iterator<SearchResponse> responseIterator = blockingStub
            .searchWithServerSideStreamRpc(request);
        while (responseIterator.hasNext()) {
            SearchResponse r = responseIterator.next();
            if (r.getResult(0).getSnippets(0).equals("the last")) {
                logger.info("the end: \n" + r.toString());
                break;
            }
            logger.info("search result:\n " + r.toString());
        }
    } catch (RuntimeException e) {
        logger.log(Level.WARNING, "RPC failed", e);
        return;
    }
}

关键代码

Iterator<SearchResponse> responseIterator = blockingStub
            .searchWithServerSideStreamRpc(request);

客户端通过一个阻塞式的stub调用一个远程服务器的方法后，会返回一个消息的 iterator ，通过iterator 遍历返回的所有消息，读取一个消息的序列。

服务器端实现

/**
 * Server-side streaming RPC
 * A server-side streaming RPC where the client sends a request to the
 * server and gets a stream to read a sequence of messages back. The client
 * reads from the returned stream until there are no more messages. As you
 * can see in our example, you specify a server-side streaming method by
 * placing the stream keyword before the response type.
 * 
 * @param request
 * @param responseObserver
 */
@Override
public void searchWithServerSideStreamRpc(SearchRequest request,
        StreamObserver<SearchResponse> responseObserver) {
    System.out.println("pageNo=" + request.getPageNumber());
    System.out.println("query string=" + request.getQuery());
    System.out.println("pageSize=" + request.getResultPerPage());
    List<SearchResponse.Result> results = new ArrayList<SearchResponse.Result>(
        10);
    for (int i = 0; i < request.getResultPerPage(); i++) {
        SearchResponse.Result result = SearchResponse.Result.newBuilder()
            .setTitle("title" + i).setUrl("dev.usoft.com")
            .addSnippets("snippets" + i).build();
        results.add(result);
    }
    SearchResponse response = SearchResponse.newBuilder()
        .addAllResult(results).build();
    responseObserver.onNext(response);
    SearchResponse.Result result = SearchResponse.Result.newBuilder()
        .setTitle("title").setUrl("dev.usoft.com").addSnippets("the last")
        .build();
    SearchResponse theNext = SearchResponse.newBuilder().addResult(result)
        .build();
    responseObserver.onNext(theNext);
    responseObserver.onCompleted();
}

服务器端连续发送了两次消息，

responseObserver.onNext(response);

responseObserver.onNext(theNext);

这就表现为服务器端rpc 方法的流式实现，返回消息的序列。

第三种 rpc SearchWithClientSideStreamRpc (stream SearchRequest) returns (SearchResponse) {};

这种rpc 方法和第二种正好相反，这种是客户端的rpc方法的流式实现，也就是说客户端可以发送连续的消息给服务器端。

客户端实现

/**
 * client side stream rpc
 * 
 * @param pageNo
 * @param pageSize
 * @throws Exception
 */
public void searchWithClientSideStreamRpc(int pageNo, int pageSize)
        throws Exception {
    final SettableFuture<Void> finishFuture = SettableFuture.create();
    StreamObserver<SearchResponse> responseObserver = new StreamObserver<SearchResponse>() {
        @Override
        public void onNext(SearchResponse searchResponse) {
            logger.info(
                "response with result=\n" + searchResponse.toString());
        }
        @Override
        public void onError(Throwable throwable) {
            finishFuture.setException(throwable);
        }
        @Override
        public void onCompleted() {
            finishFuture.set(null);
        }
    };
    StreamObserver<SearchRequest> requestObserver = asyncStub
        .searchWithClientSideStreamRpc(responseObserver);
    try {
        // 发送三次search request
        for (int i = 1; i <= 3; i++) {
            SearchRequest request = SearchRequest.newBuilder()
                .setPageNumber(pageNo).setResultPerPage(pageSize + i)
                .build();
            requestObserver.onNext(request);
            if (finishFuture.isDone()) {
                logger.log(Level.WARNING, "finish future is done");
                break;
            }
        }
        requestObserver.onCompleted();
        finishFuture.get();
        logger.log(Level.INFO, "finished");
    } catch (Exception e) {
        requestObserver.onError(e);
        logger.log(Level.WARNING, "Client Side Stream Rpc Failed", e);
        throw e;
    }
}

这种方式客户端实现比较复杂了，简单来说就是通过StreamObserver 的匿名类来处理消息的返回，关键代码，

StreamObserver<SearchResponse> responseObserver = new StreamObserver<SearchResponse>() {
        @Override
        public void onNext(SearchResponse searchResponse) {
            logger.info(
                "response with result=\n" + searchResponse.toString());
        }
        @Override
        public void onError(Throwable throwable) {
            finishFuture.setException(throwable);
        }
        @Override
        public void onCompleted() {
            finishFuture.set(null);
        }
    };

服务器端实现

/**
 * Client-side streaming RPC
 * A client-side streaming RPC where the client writes a sequence of
 * messages and sends them to the server, again using a provided stream.
 * Once the client has finished writing the messages, it waits for the
 * server to read them all and return its response. You specify a
 * server-side streaming method by placing the stream keyword before the
 * request type.
 * 
 * @param responseObserver
 * @return
 */
@Override
public StreamObserver<SearchRequest> searchWithClientSideStreamRpc(
        final StreamObserver<SearchResponse> responseObserver) {
    return new StreamObserver<SearchRequest>() {
        int searchCount;
        SearchRequest previous;
        long startTime = System.nanoTime();
        @Override
        public void onNext(SearchRequest searchRequest) {
            searchCount++;
            if (previous != null
                && previous.getResultPerPage() == searchRequest
                    .getResultPerPage()
                && previous.getPageNumber() == searchRequest
                    .getPageNumber()) {
                logger.info("do nothing");
                return;
            }
            previous = searchRequest;
        }
        @Override
        public void onError(Throwable throwable) {
            System.out.println("error");
        }
        @Override
        public void onCompleted() {
            logger.info("search count = " + searchCount);
            List<SearchResponse.Result> results = new ArrayList<SearchResponse.Result>(
                10);
            for (int i = 0; i < previous.getResultPerPage(); i++) {
                SearchResponse.Result result = SearchResponse.Result
                    .newBuilder().setTitle("title" + i)
                    .setUrl("dev.usoft.com").addSnippets("snippets" + i)
                    .build();
                results.add(result);
            }
            SearchResponse response = SearchResponse.newBuilder()
                .addAllResult(results).build();
            responseObserver.onNext(response);
            responseObserver.onCompleted();
            logger.info("spend time = "
                + String.valueOf(System.nanoTime() - startTime));
        }
    };
}

服务器端的实现也是比较复杂的，但是思路还是很清晰的。

onNext 方法一个一个的处理客户端连续发送的消息，对应着客户端的一次onNext 调用。

onCompleted方法表示客户端发送消息结束，对应着客户端的一次onCompleted 调用。

第四种 rpc SearchWithBidirectionalStreamRpc(stream SearchRequest) returns (stream SearchResponse) {};

这种方式实现的rpc 是双向流式实现。主要表现是客户端和服务器端都可以连续的发送消息。

先看客户端的实现

/**
 * bidirectional stream rpc
 * 
 * @param pageNo
 * @param pageSize
 */
public void searchWithBidirectionalStreamRpc(int pageNo, int pageSize)
        throws Exception {
    final SettableFuture<Void> finishFuture = SettableFuture.create();
    StreamObserver<SearchRequest> requestObserver = asyncStub
        .searchWithBidirectionalStreamRpc(
            new StreamObserver<SearchResponse>() {
                @Override
                public void onNext(SearchResponse searchResponse) {
                    logger.info("response with result = \n"
                        + searchResponse.toString());
                }
                @Override
                public void onError(Throwable throwable) {
                    finishFuture.setException(throwable);
                }
                @Override
                public void onCompleted() {
                    finishFuture.set(null);
                }
            });
    try {
        // 发送三次search request
        for (int i = 1; i <= 3; i++) {
            SearchRequest request = SearchRequest.newBuilder()
                .setPageNumber(pageNo).setResultPerPage(pageSize + i)
                .build();
            requestObserver.onNext(request);
        }
        requestObserver.onCompleted();
        finishFuture.get();
        logger.log(Level.INFO, "finished");
    } catch (Exception e) {
        requestObserver.onError(e);
        logger.log(Level.WARNING, "Bidirectional Stream Rpc Failed", e);
        throw e;
    }
}

代码看起来很多，但还是清晰的。就是表现在 onNext 方法和 onCompleted方法分别处理不同的消息发送。onNext 表示一次消息的发送，onCompleted表示消息发送完毕。

服务器端的实现

/**
 * Bidirectional streaming RPC
 * A bidirectional(双向的) streaming RPC where both sides send a sequence of
 * messages using a read-write stream. The two streams operate
 * independently, so clients and servers can read and write in whatever
 * order they like: for example, the server could wait to receive all the
 * client messages before writing its responses, or it could alternately
 * read a message then write a message, or some other combination of reads
 * and writes. The order of messages in each stream is preserved. You
 * specify this type of method by placing the stream keyword before both the
 * request and the response.
 * 
 * @param responseObserver
 * @return
 */
@Override
public StreamObserver<SearchRequest> searchWithBidirectionalStreamRpc(
        final StreamObserver<SearchResponse> responseObserver) {
    return new StreamObserver<SearchRequest>() {
        int searchCount;
        SearchRequest previous;
        long startTime = System.nanoTime();
        @Override
        public void onNext(SearchRequest searchRequest) {
            searchCount++;
            if (previous != null
                && previous.getResultPerPage() == searchRequest
                    .getResultPerPage()
                && previous.getPageNumber() == searchRequest
                    .getPageNumber()) {
                logger.info("do nothing");
                return;
            }
            previous = searchRequest;
            logger.info("search count = " + searchCount);
            List<SearchResponse.Result> results = new ArrayList<SearchResponse.Result>(
                10);
            for (int i = 0; i < searchRequest.getResultPerPage(); i++) {
                SearchResponse.Result result = SearchResponse.Result
                    .newBuilder().setTitle("title" + i)
                    .setUrl("dev.usoft.com").addSnippets("snippets" + i)
                    .build();
                results.add(result);
            }
            SearchResponse response = SearchResponse.newBuilder()
                .addAllResult(results).build();
            responseObserver.onNext(response);
            logger.info("spend time = "
                + String.valueOf(System.nanoTime() - startTime));
        }
        @Override
        public void onError(Throwable throwable) {
            System.out.println("error");
        }
        @Override
        public void onCompleted() {
            responseObserver.onCompleted();
        }
    };
}

好的，代码也很清晰，onNext 处理 rpc客户端的每次消息发送，同时服务器端处理客户端发送消息然后返回消息结果。这是一个客户端和服务器端多次交互的过程。

完整的客户端代码，省略代码实现，

package com.usoft.example.search;
import com.google.common.util.concurrent.SettableFuture;
import com.usoft.grpc.example.search.SearchRequest;
import com.usoft.grpc.example.search.SearchResponse;
import com.usoft.grpc.example.search.SearchServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;
import java.util.Iterator;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 * Created by xinxingegeya on 15/9/25.
 */
public class SearchClient {
    private static final Logger logger = Logger
        .getLogger(SearchClient.class.getName());
    private final ManagedChannel channel;
    private final SearchServiceGrpc.SearchServiceBlockingStub blockingStub;
    private final SearchServiceGrpc.SearchServiceStub asyncStub;
    /**
     * Construct client connecting to HelloWorld server at {@code host:port}.
     */
    public SearchClient(String host, int port) {
        channel = ManagedChannelBuilder.forAddress(host, port)
            .usePlaintext(true).build();
        blockingStub = SearchServiceGrpc.newBlockingStub(channel);
        asyncStub = SearchServiceGrpc.newStub(channel);
    }
    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }
    /**
     * simple rpc
     * 
     * @param pageNo
     * @param pageSize
     */
    public void searchWithSimpleRpc(int pageNo, int pageSize) {
       
    }
    /**
     * server side stream rpc
     * 
     * @param pageNo
     * @param pageSize
     */
    public void searchWithSeverSideStreamRpc(int pageNo, int pageSize) {
       
    }
    /**
     * client side stream rpc
     * 
     * @param pageNo
     * @param pageSize
     * @throws Exception
     */
    public void searchWithClientSideStreamRpc(int pageNo, int pageSize)
            throws Exception {
       
    }
    /**
     * bidirectional stream rpc
     * 
     * @param pageNo
     * @param pageSize
     */
    public void searchWithBidirectionalStreamRpc(int pageNo, int pageSize)
            throws Exception {
      
    }
    /**
     * client
     */
    public static void main(String[] args) throws Exception {
        SearchClient client = new SearchClient("localhost", 50051);
        try {
//            client.searchWithSimpleRpc(1, 13);
//            client.searchWithSeverSideStreamRpc(1, 2);
//            client.searchWithClientSideStreamRpc(1, 3);
            client.searchWithBidirectionalStreamRpc(1, 3);
        } finally {
            client.shutdown();
        }
    }
}

完整的服务器端实现

package com.usoft.example.search;
import com.usoft.grpc.example.search.SearchServiceGrpc;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import java.util.logging.Logger;
/**
 * Created by xinxingegeya on 15/9/25.
 */
public class SearchServer {
    private static final Logger logger = Logger
        .getLogger(SearchServer.class.getName());
    /* The port on which the server should run */
    private int port = 50051;
    private Server server;
    private void start() throws Exception {
        server = ServerBuilder.forPort(port)
            .addService(SearchServiceGrpc.bindService(new SearchServiceImpl()))
            .build().start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                // Use stderr here since the logger may have been reset by its JVM shutdown hook.
                System.err.println(
                    "*** shutting down gRPC server since JVM is shutting down");
                SearchServer.this.stop();
                System.err.println("*** server shut down");
            }
        });
    }
    private void stop() {
        if (server != null) {
            server.shutdown();
        }
    }
    /**
     * Await termination on the main thread since the grpc library uses daemon
     * threads.
     */
    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }
    /**
     * Main launches the server from the command line.
     */
    public static void main(String[] args) throws Exception {
        final SearchServer searchServer = new SearchServer();
        searchServer.start();
        searchServer.blockUntilShutdown();
    }
}

总结：

1.gRPC使用protobuf定义消息格式，使消息的序列化和反序列高效，并且序列化后数据小，占用带宽小。

2.服务间通信的接口和消息格式通过IDL文件明确定义。

3.在上面服务器端实现中，当启动服务器时，可以实现服务注册，或者说加入服务注册的逻辑，比如在zk上注册服务，从而做到客户端的服务发现。

4.在客户端中，可以加入服务发现的逻辑，从而实现服务的高可用。

5.gRPC基于netty实现的HTTP2 通信协议，对于后端的分布式微服务化，可以脱离具体的Servlet容器或Java EE服务器，更加轻便，同时可以嵌入jetty等嵌入式的Servlet容器。

6.通过zk实现服务注册和服务发现，实现服务的治理中心。

7.相对于spring mvc实现的后端的服务化接口，省略了controller层实现，客户端直接通过stub调用服务器端的逻辑。

=========END=========