1. syntax = "proto3";
3. option java_multiple_files = true;
4. option java_package = "io.grpc.examples.getstuno";
5. option java_outer_classname = "GetStuNoProto";
6. option objc_class_prefix = "GSN";
8. package getstuno;
10. service GetStuNoService {
11. rpc getMsg (StuNoRequest) returns (StuNoResponse){}
12. }
14. message StuNoRequest {
15. string name = 1;
16. }
18. message StuNoResponse {
19. string number = 1;
20. }

syntax = "proto3";

option java_multiple_files = true;
option java_package = "io.grpc.examples.getstuno";
option java_outer_classname = "GetStuNoProto";
option objc_class_prefix = "GSN";

package getstuno;

service GetStuNoService {
    rpc getMsg (StuNoRequest) returns (StuNoResponse){}
}

message StuNoRequest {
    string name = 1;
}

message StuNoResponse {
    string number = 1;
}

1. package getstuno;
3. import io.grpc.Server;
4. import io.grpc.ServerBuilder;
5. import io.grpc.examples.getstuno.GetStuNoServiceGrpc;
6. import io.grpc.examples.getstuno.StuNoResponse;
7. import io.grpc.examples.getstuno.StuNoRequest;
8. import io.grpc.stub.StreamObserver;
9. import java.io.IOException;
10. import java.util.logging.Logger;
12. /**
13. * Server that manages startup/shutdown of a {@code Greeter} server.
14. */
15. public class GetStuNoServer {
16. private static final Logger logger = Logger.getLogger(GetStuNoServer.class.getName());
18. private Server server;
20. private void start() throws IOException {
21. /* The port on which the server should run */
22. int port = 50051;
23. server = ServerBuilder.forPort(port)
24. .addService(new GetStuNoServiceImpl())
25. .build()
26. .start();
27. logger.info("Server started, listening on " + port);
28. Runtime.getRuntime().addShutdownHook(new Thread() {
29. @Override
30. public void run() {
31. // Use stderr here since the logger may have been reset by its JVM shutdown hook.
32. System.err.println("*** shutting down gRPC server since JVM is shutting down");
33. GetStuNoServer.this.stop();
34. System.err.println("*** server shut down");
35. }
36. });
37. }
39. private void stop() {
40. if (server != null) {
41. server.shutdown();
42. }
43. }
45. /**
46. * Await termination on the main thread since the grpc library uses daemon threads.
47. */
48. private void blockUntilShutdown() throws InterruptedException {
49. if (server != null) {
50. server.awaitTermination();
51. }
52. }
54. /**
55. * Main launches the server from the command line.
56. */
57. public static void main(String[] args) throws IOException, InterruptedException {
58. final GetStuNoServer server = new GetStuNoServer();
59. server.start();
60. server.blockUntilShutdown();
61. }
63. static class GetStuNoServiceImpl extends GetStuNoServiceGrpc.GetStuNoServiceImplBase {
65. @Override
66. public void getMsg(StuNoRequest req, StreamObserver<StuNoResponse> responseObserver) {
67. String number = "0000";
68. logger.info("Received name: " + req.getName());
69. if (req.getName().equals("爱丽丝")) {
70. number = "1234";
71. }
72. StuNoResponse reply = StuNoResponse.newBuilder().setNumber(number).build();
73. responseObserver.onNext(reply);
74. responseObserver.onCompleted();
75. }
76. }
77. }

package getstuno;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.examples.getstuno.GetStuNoServiceGrpc;
import io.grpc.examples.getstuno.StuNoResponse;
import io.grpc.examples.getstuno.StuNoRequest;
import io.grpc.stub.StreamObserver;
import java.io.IOException;
import java.util.logging.Logger;

/**
 * Server that manages startup/shutdown of a {@code Greeter} server.
 */
public class GetStuNoServer {
    private static final Logger logger = Logger.getLogger(GetStuNoServer.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 GetStuNoServiceImpl())
                .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");
                GetStuNoServer.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 GetStuNoServer server = new GetStuNoServer();
        server.start();
        server.blockUntilShutdown();
    }

    static class GetStuNoServiceImpl extends GetStuNoServiceGrpc.GetStuNoServiceImplBase {

        @Override
        public void getMsg(StuNoRequest req, StreamObserver<StuNoResponse> responseObserver) {
            String number = "0000";
            logger.info("Received name: " + req.getName());
            if (req.getName().equals("爱丽丝")) {
                number = "1234";
            }
            StuNoResponse reply = StuNoResponse.newBuilder().setNumber(number).build();
            responseObserver.onNext(reply);
            responseObserver.onCompleted();
        }
    }
}

1. package getstuno;
3. import io.grpc.ManagedChannel;
4. import io.grpc.ManagedChannelBuilder;
5. import io.grpc.StatusRuntimeException;
6. import io.grpc.examples.getstuno.GetStuNoServiceGrpc;
7. import io.grpc.examples.getstuno.StuNoResponse;
8. import io.grpc.examples.getstuno.StuNoRequest;
10. import java.util.concurrent.TimeUnit;
11. import java.util.logging.Level;
12. import java.util.logging.Logger;
14. /**
15. * A simple client that requests a greeting from the {@link GetStuNoServer}.
16. */
17. public class GetStuNoClient {
18. private static final Logger logger = Logger.getLogger(GetStuNoClient.class.getName());
20. private final ManagedChannel channel;
21. private final GetStuNoServiceGrpc.GetStuNoServiceBlockingStub blockingStub;
23. /** Construct client connecting to GetStuNo server at {@code host:port}. */
24. public GetStuNoClient(String host, int port) {
25. this(ManagedChannelBuilder.forAddress(host, port)
26. // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
27. // needing certificates.
28. .usePlaintext()
29. .build());
30. }
32. /** Construct client for accessing HelloWorld server using the existing channel. */
33. GetStuNoClient(ManagedChannel channel) {
34. this.channel = channel;
35. blockingStub = GetStuNoServiceGrpc.newBlockingStub(channel);
36. }
38. public void shutdown() throws InterruptedException {
39. channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
40. }
42. /** Say hello to server. */
43. public void greet(String name) {
44. StuNoRequest request = StuNoRequest.newBuilder().setName(name).build();
45. StuNoResponse response;
46. try {
47. response = blockingStub.getMsg(request);
48. } catch (StatusRuntimeException e) {
49. logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
50. return;
51. }
52. logger.info("Client received: " + response.getNumber());
53. }
55. /**
56. * Greet server. If provided, the first element of {@code args} is the name to use in the
57. * greeting.
58. */
59. public static void main(String[] args) throws Exception {
60. GetStuNoClient client = new GetStuNoClient("localhost", 50051);
61. try {
62. /* Access a service running on the local machine on port 50051 */
63. String user = "爱丽丝";
64. if (args.length > 0) {
65. user = args[0]; /* Use the arg as the name to greet if provided */
66. }
67. client.greet(user);
68. } finally {
69. client.shutdown();
70. }
71. }
72. }

package getstuno;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;
import io.grpc.examples.getstuno.GetStuNoServiceGrpc;
import io.grpc.examples.getstuno.StuNoResponse;
import io.grpc.examples.getstuno.StuNoRequest;

import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A simple client that requests a greeting from the {@link GetStuNoServer}.
 */
public class GetStuNoClient {
    private static final Logger logger = Logger.getLogger(GetStuNoClient.class.getName());

    private final ManagedChannel channel;
    private final GetStuNoServiceGrpc.GetStuNoServiceBlockingStub blockingStub;

    /** Construct client connecting to GetStuNo server at {@code host:port}. */
    public GetStuNoClient(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()
                .build());
    }

    /** Construct client for accessing HelloWorld server using the existing channel. */
    GetStuNoClient(ManagedChannel channel) {
        this.channel = channel;
        blockingStub = GetStuNoServiceGrpc.newBlockingStub(channel);
    }

    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    /** Say hello to server. */
    public void greet(String name) {
        StuNoRequest request = StuNoRequest.newBuilder().setName(name).build();
        StuNoResponse response;
        try {
            response = blockingStub.getMsg(request);
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return;
        }
        logger.info("Client received: " + response.getNumber());
    }

    /**
     * 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 {
        GetStuNoClient client = new GetStuNoClient("localhost", 50051);
        try {
            /* Access a service running on the local machine on port 50051 */
            String user = "爱丽丝";
            if (args.length > 0) {
                user = args[0]; /* Use the arg as the name to greet if provided */
            }
            client.greet(user);
        } finally {
            client.shutdown();
        }
    }
}

1. syntax = "proto3";
3. package getstuno;
5. service GetStuNoService {
6. rpc getMsg (StuNoRequest) returns (StuNoResponse){}
7. }
9. message StuNoRequest {
10. string name = 1;
11. }
13. message StuNoResponse {
14. string number = 1;
15. }

syntax = "proto3";

package getstuno;
 
service GetStuNoService {
 rpc getMsg (StuNoRequest) returns (StuNoResponse){}
}
 
message StuNoRequest {
  string name = 1;
}
 
message StuNoResponse {
  string number = 1;
}

1. import grpc
2. import getStuNo_pb2
3. import getStuNo_pb2_grpc
5. from concurrent import futures
6. import time
8. _ONE_DAY_IN_SECONDS = 60 * 60 * 24
11. class GetStuNoServicer(getStuNo_pb2_grpc.GetStuNoServiceServicer):
13. def getMsg(self, request, context):
14. print("Received name: %s" % request.name)
15. if request.name == '爱丽丝':
16. number = '1234'
17. else:
18. number = '0000'
19. return getStuNo_pb2.StuNoResponse(number=number)
22. def serve():
23. server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
24. getStuNo_pb2_grpc.add_GetStuNoServiceServicer_to_server(GetStuNoServicer(), server)
25. server.add_insecure_port('[::]:50051')
26. server.start()
27. try:
28. while True:
29. time.sleep(_ONE_DAY_IN_SECONDS)
30. except KeyboardInterrupt:
31. server.stop(0)
33. if __name__ == '__main__':
34. serve()

import grpc
import getStuNo_pb2
import getStuNo_pb2_grpc
 
from concurrent import futures
import time
 
_ONE_DAY_IN_SECONDS = 60 * 60 * 24
 
 
class GetStuNoServicer(getStuNo_pb2_grpc.GetStuNoServiceServicer):
 
  def getMsg(self, request, context):
    print("Received name: %s" % request.name)
    if request.name == '爱丽丝':
      number = '1234'
    else:
      number = '0000'
    return getStuNo_pb2.StuNoResponse(number=number)
 
 
def serve():
  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
  getStuNo_pb2_grpc.add_GetStuNoServiceServicer_to_server(GetStuNoServicer(), server)
  server.add_insecure_port('[::]:50051')
  server.start()
  try:
    while True:
      time.sleep(_ONE_DAY_IN_SECONDS)
  except KeyboardInterrupt:
    server.stop(0)
 
if __name__ == '__main__':
  serve()

1. import grpc
3. import getStuNo_pb2
4. import getStuNo_pb2_grpc
6. def run():
7. # NOTE(gRPC Python Team): .close() is possible on a channel and should be
8. # used in circumstances in which the with statement does not fit the needs
9. # of the code.
10. with grpc.insecure_channel('localhost:50051') as channel:
11. stub = getStuNo_pb2_grpc.GetStuNoServiceStub(channel)
12. response = stub.getMsg(getStuNo_pb2.StuNoRequest(name='爱丽丝'))
13. print("Client received: " + response.number)
16. if __name__ == '__main__':
17. run()

import grpc
 
import getStuNo_pb2
import getStuNo_pb2_grpc
 
def run():
  # NOTE(gRPC Python Team): .close() is possible on a channel and should be
  # used in circumstances in which the with statement does not fit the needs
  # of the code.
  with grpc.insecure_channel('localhost:50051') as channel:
    stub = getStuNo_pb2_grpc.GetStuNoServiceStub(channel)
    response = stub.getMsg(getStuNo_pb2.StuNoRequest(name='爱丽丝'))
  print("Client received: " + response.number)
 
 
if __name__ == '__main__':
  run()