yangchong211/YCServerLib: gRPC学习案例，使用gRPC作为网络方案可以带来高效性、跨平台和语言、可靠性、易于使用和可扩展性等收益。同时可以减少手动编写代码的工作量，提高开发效率。 · GitHub

2023-05-09 09:31:49.699 23442-23442/com.yc.appgrpc E/Test效率测试：: Gson 序列化耗时：14
2023-05-09 09:31:49.699 23442-23442/com.yc.appgrpc E/Test效率测试：: Gson 序列化数据大小：188
2023-05-09 09:31:49.701 23442-23442/com.yc.appgrpc E/Test效率测试：: Gson 反序列化耗时：2
2023-05-09 09:31:49.701 23442-23442/com.yc.appgrpc E/Test效率测试：: Gson 数据：{"persons":[{"id":1,"name":"张三","phones":[{"number":"110","type":"HOME"}]},{"id":2,"name":"李四","phones":[{"number":"130","type":"MOBILE"}]},{"id":3,"name":"王五","phones":[{}]}]}
2023-05-09 09:31:49.720 23442-23442/com.yc.appgrpc E/Test效率测试：: protobuf 序列化耗时：4
2023-05-09 09:31:49.720 23442-23442/com.yc.appgrpc E/Test效率测试：: protobuf 序列化数据大小：59
2023-05-09 09:31:49.722 23442-23442/com.yc.appgrpc E/Test效率测试：: protobuf 反序列化耗时：2
2023-05-09 09:31:49.725 23442-23442/com.yc.appgrpc E/Test效率测试：: protobuf 数据：# com.yc.appgrpc.AddressBookProto$AddressBook@83d0213a
    people {
      id: 1
      name: "\345\274\240\344\270\211"
      phones {
        number: "110"
        type: HOME
        type_value: 1
      }
    }
    people {
      id: 2
      name: "\346\235\216\345\233\233"
      phones {
        number: "120"
      }
    }
    people {
      id: 3
      name: "\347\216\213\344\272\224"
      phones {
        number: "130"
      }
    }

message SearchRequest {
  string query = 1;
  int32 page_number = 2;
  int32 result_per_page = 3;
}

 AddressBookProto.AddressBook addressBook = AddressBookProto.AddressBook.newBuilder()
    .addPeople(zs)
    .addPeople(ls)
    .addPeople(ys)
    .build();
//序列化
byte[] bytes = addressBook.toByteArray();
//反序列化
AddressBookProto.AddressBook book = AddressBookProto.AddressBook.parseFrom(bytes);

// 创建消息对象并设置字段值
MyMessage.Builder builder = MyMessage.newBuilder();
builder.setId(1);
builder.setName("John Doe");
MyMessage message = builder.build();

// 将消息对象转换为 JSON
String json = new Gson().toJson(message);

service Greeter {
  // 简单一元模式
  rpc simpleHello (Request) returns (Reply) {}
  // 客户端流模式
  rpc clientStream (stream Request) returns (Reply) {}
  // 服务端流模式
  rpc serverStream (Request) returns (stream Reply) {}
  // 双向流模式
  rpc bothFlowStream (stream Request) returns (stream Reply) {}
}

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}
message HelloReply {
  string message = 1;
}

//构建Channel
channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
//构建服务请求API代理
GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
//构建请求实体，HelloRequest是自动生成的实体类
HelloRequest request = HelloRequest.newBuilder().setName(message).build();
//进行请求并且得到响应数据
HelloReply reply = stub.sayHello(request);
//得到请求响应的数据
String replyMessage = reply.getMessage();

//同步阻塞
GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
//异步调用
GreeterGrpc.GreeterStub stub = GreeterGrpc.newStub(channel);

blockingStub.withDeadlineAfter(3, TimeUnit.SECONDS)

//构建Channel。一般host和port格式为：127.0.0.1:8080
ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
//构建Channel。一般target格式为：googleapis.com:8080
ManagedChannel channel = ManagedChannelBuilder.forTarget(target).usePlaintext().build();

message CommonParams {
  string userId = 1;
  int64 timestamp = 2;
}

message MyRequest {
  CommonParams commonParams = 1;
  // 其他请求参数...
}

CommonParams commonParams = CommonParams.newBuilder()
    .setUserId("user123")
    .setTimestamp(System.currentTimeMillis())
    .build();

MyRequest request = MyRequest.newBuilder()
    .setCommonParams(commonParams)
    // 设置其他请求参数...
    .build();

// 创建请求消息对象
MyRequest request = MyRequest.newBuilder()
    .setName("打工充")
    .setAge(30)
    .build();

// 调用Stub对象的方法发送请求并获取响应
MyResponse response = stub.myMethod(request);

@Override
public void myMethod(MyRequest request, StreamObserver<MyResponse> responseObserver) {
    // 从请求消息中读取字段的值
    String name = request.getName();
    int age = request.getAge();

    // 创建响应消息对象
    MyResponse response = MyResponse.newBuilder()
        .setMessage("Hello, " + name + "! You are " + age + " years old.")
        .build();

    // 发送响应消息给客户端
    responseObserver.onNext(response);
    responseObserver.onCompleted();
}

//构建Channel中，添加拦截器
channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext()
        //添加拦截器
        .intercept(new LoggingInterceptor())
        .build();


//创建拦截器
public class LoggingInterceptor implements ServerInterceptor, ClientInterceptor {

    private static final String TAG = "gRPC-yc";

    @Override
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
        // 在请求发送前记录日志
        Log.d(TAG,"Sending request: " + method.getFullMethodName());
        // 调用下一个拦截器或服务实现
        return next.newCall(method,callOptions);
    }

    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
        // 在请求接收前记录日志
        Log.d(TAG,"Received request: " + call.getMethodDescriptor().getFullMethodName());
        // 调用下一个拦截器或服务实现
        return next.startCall(call,headers);
    }
}

“dns:///foo.googleapis.com:8080”
“dns:///foo.googleapis.com”
“dns:///%5B2001:db8:85a3:8d3:1319:8a2e:370:7348%5D:443”
“dns://8.8.8.8/foo.googleapis.com:8080”
“dns://8.8.8.8/foo.googleapis.com”
“zookeeper://zk.example.com:9900/example_service”

try {
    MyResponse response = stub.myMethod(MyRequest.newBuilder().build());
    // 处理正常的响应
} catch (StatusRuntimeException e) {
    // 处理 gRPC 调用过程中的错误
    Status status = Status.fromThrowable(e);
    if (status.getCode() == Status.Code.NOT_FOUND) {
        // 处理特定的错误码
    } else if (status.getCode() == Status.Code.INVALID_ARGUMENT) {
        // 处理其他错误码
    } else {
        // 处理其他未知错误
    }
}

// 创建 SSLContext
SSLContext sc = SSLContext.getInstance("TLSv1.2");
sc.init(null, getTrustManagers(isCa), null);
// 创建 SSLSocketFactory
Tls12SocketFactory socketFactory = new Tls12SocketFactory(sc.getSocketFactory());
// 通过 channel 设置 sslSocketFactory做ssl安全处理
((OkHttpChannelBuilder) channelBuilder).sslSocketFactory(socketFactory);

message MyMessage {
  int32 id = 1;
  string name = 2;
}

Type: 1
Length: 4
Value: <binary representation of id>

Type: 2
Length: <length of name>
Value: <binary representation of name>

public abstract class ManagedChannelBuilder<T extends ManagedChannelBuilder<T>> {
    public static ManagedChannelBuilder<?> forAddress(String name, int port) {
        return ManagedChannelProvider.provider().builderForAddress(name, port);
    }
    public static ManagedChannelBuilder<?> forTarget(String target) {
        return ManagedChannelProvider.provider().builderForTarget(target);
    }
}