Il y a des moments où la dernière ne suffit pas dans le monde. Par exemple, IE, IE, IE. C'est pourquoi j'espère que ce sera une référence pour ceux qui doivent travailler dur pour se développer dans un vieil environnement. D'autres ont écrit l'explication de gRPC lui-même en détail, alors cherchez-le.
À peu près cet environnement. Divers vieux.
Tout en faisant référence à ce qui suit. https://grpc.io/docs/tutorials/basic/java/ https://github.com/grpc/grpc-java/blob/master/examples/README.md
Si vous ne pouvez pas vous le permettre, veuillez sauter ici.
Créons rapidement un environnement avec Docker comme d'habitude.
$ docker run --rm -it --name grpc-java -p 50051:50051 ubuntu
root@e7b3b2c13c0b:/# apt-get update
root@e7b3b2c13c0b:/# apt-get install -y git openjdk-8-jdk maven
root@e7b3b2c13c0b:/# git clone -b v1.22.1 https://github.com/grpc/grpc-java
root@e7b3b2c13c0b:/# cd grpc-java/examples
root@e7b3b2c13c0b:/grpc-java/examples# ./gradlew installDist
Au fait, tools.jar est utilisé, vous ne pouvez donc pas utiliser jre.
Si vous le faites avec jre, l'erreur suivante se produira.
> Task :compileJava FAILED
FAILURE: Build failed with an exception.
* What went wrong:
Execution failed for task ':compileJava'.
> Could not find tools.jar. Please check that /usr/lib/jvm/java-8-openjdk-amd64 contains a valid JDK installation.
* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
* Get more help at https://help.gradle.org
BUILD FAILED in 43s
À ce stade, l'environnement est prêt. Un échantillon de HelloWorld se trouve ci-dessous.
/grpc-java/examples/src/main/proto/helloworld.proto /grpc-java/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java /grpc-java/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
Construisons et exécutons-le sous / grpc-java / examples.
root@e7b3b2c13c0b:~# cd /grpc-java/examples
root@e7b3b2c13c0b:/grpc-java/examples# mvn clean compile
root@e7b3b2c13c0b:/grpc-java/examples# mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldServer &
[1] 5817
root@e7b3b2c13c0b:/grpc-java/examples#
root@e7b3b2c13c0b:/grpc-java/examples# mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldClient
Si vous voyez "Salutation: Bonjour tout le monde", vous avez terminé.
Cette fois, le serveur et le client fonctionnent sur le même terminal.
Si vous souhaitez arrêter le serveur, suivez les étapes ci-dessous. (fg-> Ctrl + C)
root@e7b3b2c13c0b:/grpc-java/examples# fg
mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldServer
^C*** shutting down gRPC server since JVM is shutting down
*** server shut down
root@e7b3b2c13c0b:/grpc-java/examples#
Si vous avez modifié le fichier proto, exécutez ./gradlew install Dist pour générer le code Java.
Si vous souhaitez modifier les options d'exécution Java, vous pouvez définir MAVEN_OPTS.
MAVEN_OPTS="-server -Xmx1024m -Xms1024m -Xloggc:/grpc-java/examples/GC.log -XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xverify:none -Djava.security.egd=file:/dev/./urandom -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+CMSClassUnloadingEnabled -XX:+DisableExplicitGC -XX:+PrintTenuringDistribution -XX:-Inline"
export MAVEN_OPTS
Eh bien, c'est finalement le sujet principal. C'est un jeu lié qui interdit l'utilisation de Docker et Gradle sous Windows. Pure gRPC est Java 7 ou supérieur, mais l'exemple utilise Gradle et Maven 3 ou supérieur est requis (pour utiliser le plug-in).
Commençons par créer un projet Maven. Les dépendances requises cette fois sont les suivantes. (Le journal est votre choix)
pom.xml
<dependencies>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-all</artifactId>
<version>1.22.1</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.9.0</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
</dependencies>
Créez un dossier proto directement sous le projet et créez un fichier proto.
grpc.proto
syntax = "proto3";
option java_multiple_files = true;
option java_package = "org.mygrpc.helloworld";
option java_outer_classname = "GrpcProto";
service Greeter {
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
message HelloRequest {
string name = 1;
}
message HelloReply {
string message = 1;
}
Générez la source Java à partir du fichier proto. Téléchargez le fichier pour Windows sur protobuf. https://github.com/protocolbuffers/protobuf/releases/download/v3.9.0/protoc-3.9.0-win64.zip
Décompressez-le et placez protoc.exe sous le dossier bin à un emplacement qui se trouve dans votre chemin. Vous pouvez le remettre quelque part et le passer à travers le col.
Si vous exécutez avec le chemin complet à l'avenir, vous n'avez pas à passer le chemin séparément.
À l'invite de commande, exécutez ce qui suit dans le dossier contenant grpc.proto créé précédemment.
protoc --java_out=..\src\main\java grpc.proto
La source a été générée sous ʻorg.mygrpc.helloworld`.
.
│ pom.xml
│
├─proto
│ grpc.proto
│
└─src
├─main
│ ├─java
│ │ └─org
│ │ └─mygrpc
│ │ └─helloworld
│ │ GrpcProto.java
│ │ HelloReply.java
│ │ HelloReplyOrBuilder.java
│ │ HelloRequest.java
│ │ HelloRequestOrBuilder.java
│ │
│ └─resources
│ log4j.dtd
│ log4j.xml
│
└─test
├─java
└─resources
En fait, cela ne suffit pas. Téléchargez l'outil pour en générer un autre. https://search.maven.org/search?q=g:io.grpc%20a:protoc-gen-grpc-java
Placez l'exe téléchargé dans n'importe quel dossier et exécutez ce qui suit (changez le chemin vers le dossier où l'exe ci-dessus est placé)
protoc --plugin=protoc-gen-grpc-java=C:\protoc\protoc-gen-grpc-java-1.22.1-windows-x86_64.exe --grpc-java_out=..\src\main\java grpc.proto
Je pense que vous avez créé GreeterGrpc.java.
Créez les processus serveur et client en vous référant à l'exemple.
HelloWorldServer.java
package org.mygrpc.helloworld;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;
import java.io.IOException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class HelloWorldServer {
/** Log. */
protected static Log log = LogFactory.getLog(HelloWorldServer.class);
private Server server;
private void start() throws IOException {
int port = 50051;
server = ServerBuilder.forPort(port)
.addService(new GreeterImpl())
.build()
.start();
log.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();
}
}
}
HelloWorldClient.java
package org.mygrpc.helloworld;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;
import java.util.concurrent.TimeUnit;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class HelloWorldClient {
/** Log. */
protected static Log log = LogFactory.getLog(HelloWorldClient.class);
public static void main(String[] args) throws Exception {
ManagedChannel channel = ManagedChannelBuilder
.forAddress("localhost", 50051).usePlaintext().build();
GreeterGrpc.GreeterBlockingStub blockingStub = GreeterGrpc
.newBlockingStub(channel);
try {
HelloRequest request = HelloRequest.newBuilder().setName("World").build();
try {
HelloReply resp = blockingStub.sayHello(request);
log.info(resp.getMessage());
} catch (StatusRuntimeException e) {
log.warn("RPC failed: " + e.getStatus());
return;
}
} finally {
channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
}
}
}
Si vous exécutez respectivement le serveur et le client et que vous affichez «Hello World», c'est OK. Maintenant, vous pouvez enfin développer.
À propos, il semble y avoir ce qui suit en tant que plug-in pour l'édition de fichiers proto, mais j'ai abandonné car la version 2.3.0 ou supérieure nécessite Eclipse 4.6 Neon ou supérieure. https://github.com/google/protobuf-dt
Recommended Posts