枫林的小窝

为什么必须是final的呢？

JDK8之前，匿名内部类访问的局部变量为什么必须要用final修饰

1.Hello

syntax = "proto3";

option java_multiple_files = true;

package hello;

service Hello {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

2.gRPCService

import hello.HelloGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;

public class gRPCService {
    private static final String gRPC_HOST = "isilent.me";
    private static final int gRPC_PORT = 80;
    private static gRPCService instance;
    private ManagedChannel mChannel;

    public static gRPCService getInstance() {
        if (instance == null) {
            instance = new gRPCService();
        }
        return instance;
    }

    private gRPCService() {

    }

    /**
     * 获取Channel
     *
     * @return
     */
    private ManagedChannel getChannel() {
        if (mChannel == null || mChannel.isShutdown()) {
            // 设置最大接收消息大小为20M
            mChannel = ManagedChannelBuilder.forAddress(gRPC_HOST, gRPC_PORT).usePlaintext().maxInboundMessageSize(20 * 1024 * 1024).build();
        }
        return mChannel;
    }

    /**
     * 获取Hello存根
     *
     * @return
     */
    public HelloGrpc.HelloStub getHelloStub() {
        return HelloGrpc.newStub(getChannel());
    }
}

3.SimpleStreamObserver

import android.os.Handler;
import android.os.Looper;

import io.grpc.stub.StreamObserver;

public abstract class SimpleStreamObserver<T> implements StreamObserver<T> {
    private static Handler handler = new Handler(Looper.getMainLooper());

    @Override
    public void onCompleted() {

    }

    @Override
    public void onNext(final T value) {
        // 返回主线程
        handler.post(new Runnable() {
            @Override
            public void run() {
                onSuccess(value);
            }
        });
    }

    /**
     * 请求成功的回调
     *
     * @param value
     */
    protected abstract void onSuccess(T value);
}

4.Main

public static void Main() {
    HelloRequest request = HelloRequest.newBuilder().setName("hello").build();
    gRPCService.getInstance().getHelloStub().sayHello(request, new SimpleStreamObserver<HelloReply>() {
        @Override
        protected void onSuccess(HelloReply value) {
            System.out.println(value.getMessage());
        }

        @Override
        public void onError(Throwable t) {

        }
    });
}

JAVA使用的是一种名为值传递的求值策略，这种策略在传值过程中会复制实参的引用，并将这份拷贝传入到方法形参中，所以对形参的任何重赋值操作都不会对实参产生影响。

参考链接：

Java的值传递和引用传递，你真的搞清楚了吗？

1.下载安装Protobuf Support插件，如图所示：

2.在项目根目录的 build.gradle 的 buildscript 中加入 protobuf-gradle-plugin 插件：

buildscript {
    ...
    dependencies {
        ...
        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.12"
    }
}

3.在应用Module的 build.gradle 中进行如下配置

apply plugin: 'com.android.application'
apply plugin: 'com.google.protobuf'

protobuf {
    protoc { artifact = 'com.google.protobuf:protoc:3.11.0' }
    plugins {
        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.29.0' }
    }
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                java { option 'lite' }
            }
            task.plugins {
                grpc { option 'lite' }
            }
        }
    }
}

dependencies {
    // gRPC
    implementation 'io.grpc:grpc-okhttp:1.29.0'
    implementation 'io.grpc:grpc-protobuf-lite:1.29.0'
    implementation 'io.grpc:grpc-stub:1.29.0'
    implementation 'javax.annotation:javax.annotation-api:1.2'
}

4.最后将 .proto 协议文件放在 src/main/proto/ 文件夹下，点击build进行编译，如果出现如下图，则证明环境配置成功！

参考链接：

教你如何使用ProtoBuf，通过gRPC服务在android上进行网络请求。

gRPC快速入门

GRPC原理解析

官方示例

df

参考链接：

Linux df命令

du [-sh][目录或文件]

-s或–summarize 仅显示总计。

-h或–human-readable 以K，M，G为单位，提高信息的可读性。

参考链接：

Linux du命令