Java io.grpc.StatusRuntimeException:未实现：未找到方法_Java_Spring_Spring Boot_Grpc_Grpc Java

Java io.grpc.StatusRuntimeException:未实现：未找到方法

java spring spring-boot

Java io.grpc.StatusRuntimeException:未实现：未找到方法,java,spring,spring-boot,grpc,grpc-java,Java,Spring,Spring Boot,Grpc,Grpc Java,使用Springboot入门应用程序。一切正常。然后我将客户机和服务器移动到新的包中。一切都会编译，但在运行时，当我运行客户端时，会出现一个错误：未实现的方法未找到我检查了该方法是否已实际实现。当我启动Springboot应用程序时，我在哪里确认bean本身已加载？我只看到应用程序已启动并正在运行，但日志中没有加载bean的列表这是我的Springboot应用程序。我所做的只是将客户机和服务器bean移动到一个名为example.client和example.server的新包中。之前，它们

使用Springboot入门应用程序。一切正常。然后我将客户机和服务器移动到新的包中。一切都会编译，但在运行时，当我运行客户端时，会出现一个错误：未实现的方法未找到

我检查了该方法是否已实际实现。当我启动Springboot应用程序时，我在哪里确认bean本身已加载？我只看到应用程序已启动并正在运行，但日志中没有加载bean的列表

这是我的Springboot应用程序。我所做的只是将客户机和服务器bean移动到一个名为example.client和example.server的新包中。之前，它们与spring boot com.test.MyApplication位于同一个包中

io.grpc.StatusRuntimeException: UNIMPLEMENTED: Method not found:  example.GreetingService/greetingWithResponseStream
at io.grpc.Status.asRuntimeException(Status.java:526)
at  io.grpc.stub.ClientCalls$StreamObserverToCallListenerAdapter.onClose(ClientCalls.java:434)
at  io.grpc.PartialForwardingClientCallListener.onClose(PartialForwardingClientCallListener.java:39)



package com.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
}
}

GreetingService.proto：

syntax = "proto3";
package example;

message HelloRequest {
    string name = 1;
}


message HelloResponse {
    string greeting = 1;
}


service GreetingService {
    rpc greeting (HelloRequest) returns (HelloResponse);
    rpc greetingWithResponseStream (HelloRequest) returns (stream  HelloResponse);
  rpc greetingWithRequestStream (stream HelloRequest) returns  (HelloResponse);
rpc greetingWithRequestResponseStream (stream HelloRequest) returns  (stream HelloResponse);

}

import-example.GreetingServiceOuterClass；
导入io.grpc.stub.StreamObserver；
导入java.util.ArrayList；
导入java.util.List；
@GrpcService
公共类GreetingServiceImpl扩展了GreetingServiceGrpc.GreetingServiceImplBase{
@凌驾
公共无效问候语（GreetingServiceOuterClass.HelloreRequest请求、StreamObserver响应Observer）{
GreetingServiceOuterClass.HelloResponse响应=GreetingServiceOuterClass.HelloResponse.newBuilder（）
.setGreeting（“你好，”+request.getName（））
.build（）；
responseObserver.onNext（响应）；
responseObserver.onCompleted（）；
}
@凌驾
public void greetingWithResponseStream（GreetingServiceOuterClass.HelloRequest请求，StreamObserver responseObserver）{
GreetingServiceOuterClass.HelloResponse响应=GreetingServiceOuterClass.HelloResponse.newBuilder（）
.setGreeting（“（流响应）您好，”+request.getName（）
.build（）；
responseObserver.onNext（响应）；
responseObserver.onNext（响应）；
responseObserver.onNext（响应）；
responseObserver.onCompleted（）；
}
@凌驾
公共StreamObserver与RequestStream的会面（StreamObserver响应Observer）{
返回新的StreamObserver（）{
私有列表名称列表=新的ArrayList（）；
@凌驾
public void onNext（GreetingServiceOuterClass.HelloreRequest请求）{
nameList.add（request.getName（））；
}
@凌驾
公共作废登记员（可丢弃的t）{
t、 printStackTrace（）；
}
@凌驾
未完成的公共无效（）{
GreetingServiceOuterClass.HelloResponse响应=GreetingServiceOuterClass.HelloResponse.newBuilder（）
.setGreeting（“（流请求）您好，”+String.join（“，名称列表））
.build（）；
responseObserver.onNext（响应）；
responseObserver.onCompleted（）；
}
};
}
@凌驾
公共StreamObserver与RequestResponseStream（StreamObserver responseObserver）会面{
返回新的StreamObserver（）{
私有列表名称列表=新的ArrayList（）；
@凌驾
public void onNext（GreetingServiceOuterClass.HelloreRequest请求）{
nameList.add（request.getName（））；
}
@凌驾
公共作废登记员（可丢弃的t）{
t、 printStackTrace（）；
}
@凌驾
未完成的公共无效（）{
nameList.stream（）
.map（name->GreetingServiceOuterClass.helloreresponse.newBuilder（）.setGreeting（（流请求/响应）您好，“+name.build（））
.forEach（responseObserver:：onNext）；
responseObserver.onCompleted（）；
}
};
}
}
包示例.client；
导入示例.GreetingServiceGrpc；
导入示例.GreetingServiceOuterClass；
导入io.grpc.ManagedChannel；
导入io.grpc.ManagedChannel Builder；
导入io.grpc.stub.StreamObserver；
导入java.util.stream.stream；
公共类客户端{
公共静态void main（字符串[]args）{
ManagedChannel=ManagedChannel Builder.forTarget（“本地主机：8081”）
.usePlaintext（）
.build（）；
GreetingServiceGrpc.GreetingServiceBlockingStub=GreetingServiceGrpc.newBlockingStub（频道）；
GreetingServiceOuterClass.HelloRequest请求=GreetingServiceOuterClass.HelloRequest.newBuilder（）.setName（“Steve”）.build（）；
GreetingServiceOuterClass.Hello响应=存根。问候语（请求）；
System.out.println（响应）；
}
公共静态类RequestStreamClient{
公共静态void main（字符串[]args）引发InterruptedException{
新线程（（）->{
ManagedChannel=ManagedChannel Builder.forTarget（“本地主机：8081”）
.usePlaintext（）
.build（）；
GreetingServiceGrpc.GreetingServiceStub存根=GreetingServiceGrpc.newStub（频道）；
StreamObserver请求流=
stub.greetingWithRequestStream（新的StreamObserver（））{
@凌驾
public void onNext（GreetingServiceOuterClass.Hello响应）{
System.out.println（响应）；
}
@凌驾
公共作废登记员（可丢弃的t）{
t、 printStackTrace（）；
}
@凌驾
未完成的公共无效（）{
}
});
“史蒂文1”、“史蒂文2”、“史蒂文3”流
.map（名称->GreetingServiceOuterClass.HelloRequest.newBuilder（）.setName（名称）.build（））
.forEach（请求流：：onNext）；
requestStream.onCompleted（）；
}).start（）；
睡眠（10000）；
}
}
}

@springboot应用程序状态：

这是一个方便的注释，相当于声明 @配置、@EnableAutoConfiguration和@ComponentScan

和@ComponentScan状态：

如果未定义特定的包，将从该类的包

import example.GreetingServiceOuterClass;

import io.grpc.stub.StreamObserver;
import java.util.ArrayList;
import java.util.List;

@GrpcService
public class GreetingServiceImpl extends    GreetingServiceGrpc.GreetingServiceImplBase{

@Override
public void greeting(GreetingServiceOuterClass.HelloRequest request,   StreamObserver<GreetingServiceOuterClass.HelloResponse> responseObserver) {
    GreetingServiceOuterClass.HelloResponse response =    GreetingServiceOuterClass.HelloResponse.newBuilder()
            .setGreeting("HELLO, THERE, " + request.getName())
            .build();
    responseObserver.onNext(response);
    responseObserver.onCompleted();

}

@Override
public void  greetingWithResponseStream(GreetingServiceOuterClass.HelloRequest request, StreamObserver<GreetingServiceOuterClass.HelloResponse> responseObserver) {
    GreetingServiceOuterClass.HelloResponse response =  GreetingServiceOuterClass.HelloResponse.newBuilder()
            .setGreeting("(Stream Response) Hello there, " + request.getName())
            .build();
    responseObserver.onNext(response);
    responseObserver.onNext(response);
    responseObserver.onNext(response);
    responseObserver.onCompleted();
}

@Override
public StreamObserver<GreetingServiceOuterClass.HelloRequest>  greetingWithRequestStream(StreamObserver<GreetingServiceOuterClass.HelloResponse> responseObserver) {
    return new StreamObserver<GreetingServiceOuterClass.HelloRequest>() {
        private List<String> nameList = new ArrayList<>();

        @Override
        public void onNext(GreetingServiceOuterClass.HelloRequest request) {
            nameList.add(request.getName());
        }

        @Override
        public void onError(Throwable t) {
            t.printStackTrace();
        }

        @Override
        public void onCompleted() {
            GreetingServiceOuterClass.HelloResponse response = GreetingServiceOuterClass.HelloResponse.newBuilder()
                    .setGreeting("(Stream Request) Hello there, " + String.join(" ", nameList))
                    .build();
            responseObserver.onNext(response);
            responseObserver.onCompleted();
        }
    };
}

@Override
public StreamObserver<GreetingServiceOuterClass.HelloRequest> greetingWithRequestResponseStream(StreamObserver<GreetingServiceOuterClass.HelloResponse> responseObserver) {
    return new StreamObserver<GreetingServiceOuterClass.HelloRequest>() {
        private List<String> nameList = new ArrayList<>();

        @Override
        public void onNext(GreetingServiceOuterClass.HelloRequest request) {
            nameList.add(request.getName());
        }

        @Override
        public void onError(Throwable t) {
            t.printStackTrace();
        }

        @Override
        public void onCompleted() {
            nameList.stream()
                    .map(name ->  GreetingServiceOuterClass.HelloResponse.newBuilder().setGreeting("(Stream Request/Response) Hello there, " + name).build())
                    .forEach(responseObserver::onNext);
            responseObserver.onCompleted();
        }
    };
}
}


package example.client;

import example.GreetingServiceGrpc;
import example.GreetingServiceOuterClass;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;

import java.util.stream.Stream;

public class Client {
public static void main(String[] args) {
    ManagedChannel channel =   ManagedChannelBuilder.forTarget("localhost:8081")
            .usePlaintext()
            .build();

        GreetingServiceGrpc.GreetingServiceBlockingStub stub =    GreetingServiceGrpc.newBlockingStub(channel);
    GreetingServiceOuterClass.HelloRequest request = GreetingServiceOuterClass.HelloRequest.newBuilder().setName("Steve").build();
    GreetingServiceOuterClass.HelloResponse response = stub.greeting(request);
    System.out.println(response);
}


public static class RequestStreamClient {


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

        new Thread(() -> {

            ManagedChannel channel = ManagedChannelBuilder.forTarget("localhost:8081")
                    .usePlaintext()
                    .build();

            GreetingServiceGrpc.GreetingServiceStub stub = GreetingServiceGrpc.newStub(channel);

            StreamObserver<GreetingServiceOuterClass.HelloRequest> requestStream =
                    stub.greetingWithRequestStream(new StreamObserver<GreetingServiceOuterClass.HelloResponse>() {
                        @Override
                        public void onNext(GreetingServiceOuterClass.HelloResponse response) {
                            System.out.println(response);
                        }

                        @Override
                        public void onError(Throwable t) {
                            t.printStackTrace();
                        }

                        @Override
                        public void onCompleted() {
                        }
                    });

            Stream.of("Steve1", "Steve2", "Steve3")
                    .map(name -> GreetingServiceOuterClass.HelloRequest.newBuilder().setName(name).build())
                    .forEach(requestStream::onNext);
            requestStream.onCompleted();



        }).start();

        Thread.sleep(10000);


    }

  }
}

@SpringBootApplication
@ComponentScan({"example.client","example.server"})
@Import(GreetingServiceImpl.class)
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}