public class HelloWorldServer {

  private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());

  private Server server;

  private void start() throws IOException {

    /* The port on which the server should run */

    int port = 50051;

    server = ServerBuilder.forPort(port)

        .addService(new GreeterImpl())

        .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");

        HelloWorldServer.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 IOException, InterruptedException {

    final HelloWorldServer server = new HelloWorldServer();

    server.start();

    server.blockUntilShutdown();

  }

  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {

    @Override

    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {

      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();

      responseObserver.onNext(reply);

      responseObserver.onCompleted();

    }

  }

}

public class HelloWorldClient {

  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());

  private final ManagedChannel channel;

  private final GreeterGrpc.GreeterBlockingStub blockingStub;

  /** Construct client connecting to HelloWorld server at {@code host:port}. */

  public HelloWorldClient(String host, int port) {

    this(ManagedChannelBuilder.forAddress(host, port)

        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid

        // needing certificates.

        .usePlaintext(true));

  }

  /** Construct client for accessing RouteGuide server using the existing channel. */

  HelloWorldClient(ManagedChannelBuilder<?> channelBuilder) {

    channel = channelBuilder.build();

    blockingStub = GreeterGrpc.newBlockingStub(channel);

  }

  public void shutdown() throws InterruptedException {

    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);

  }

  /** Say hello to server. */

  public void greet(String name) {

    logger.info("Will try to greet " + name + " ...");

    HelloRequest request = HelloRequest.newBuilder().setName(name).build();

    HelloReply response;

    try {

      response = blockingStub.sayHello(request);

    } catch (StatusRuntimeException e) {

      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());

      return;

    }

    logger.info("Greeting: " + response.getMessage());

  }

  /**

   * Greet server. If provided, the first element of {@code args} is the name to use in the

   * greeting.

   */

  public static void main(String[] args) throws Exception {

    HelloWorldClient client = new HelloWorldClient("localhost", 50051);

    try {

      /* Access a service running on the local machine on port 50051 */

      String user = "world";

      if (args.length > 0) {

        user = args[0]; /* Use the arg as the name to greet if provided */

      }

      client.greet(user);

    } finally {

      client.shutdown();

    }

  }

}