title: io.grpc.StatusRuntimeException: UNIMPLEMENTED: Method not found
body: <p>Using Springboot starter app.  Everything working. Then I moved the client and server to new packages. Everything compiles, but at runtime when I run the client I get an error:  UNIMPLEMENTED Method not found.   </p>
  
  <p>I checked that the method is in fact implemented. When I start the Springboot app where do I confirm that the bean itself was loaded? I just see confirmation that the application is up and running but no list of loaded beans in log.</p>
  
  <p>Here is my Springboot application.  All I did was move the client and server bean into a new package called example.client and example.server.   before they were in same package as spring boot com.test.MyApplication</p>
  
  <pre><code>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);
  }
  }
  </code></pre>
  
  <p>GreetingService.proto:</p>
  
  <pre><code>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);
  </code></pre>
  
  <p>}</p>
  
  <pre><code>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&lt;GreetingServiceOuterClass.HelloResponse&gt; 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&lt;GreetingServiceOuterClass.HelloResponse&gt; 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&lt;GreetingServiceOuterClass.HelloRequest&gt;  greetingWithRequestStream(StreamObserver&lt;GreetingServiceOuterClass.HelloResponse&gt; responseObserver) {
      return new StreamObserver&lt;GreetingServiceOuterClass.HelloRequest&gt;() {
          private List&lt;String&gt; nameList = new ArrayList&lt;&gt;();
  
          @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&lt;GreetingServiceOuterClass.HelloRequest&gt; greetingWithRequestResponseStream(StreamObserver&lt;GreetingServiceOuterClass.HelloResponse&gt; responseObserver) {
      return new StreamObserver&lt;GreetingServiceOuterClass.HelloRequest&gt;() {
          private List&lt;String&gt; nameList = new ArrayList&lt;&gt;();
  
          @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 -&gt;  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(() -&gt; {
  
              ManagedChannel channel = ManagedChannelBuilder.forTarget("localhost:8081")
                      .usePlaintext()
                      .build();
  
              GreetingServiceGrpc.GreetingServiceStub stub = GreetingServiceGrpc.newStub(channel);
  
              StreamObserver&lt;GreetingServiceOuterClass.HelloRequest&gt; requestStream =
                      stub.greetingWithRequestStream(new StreamObserver&lt;GreetingServiceOuterClass.HelloResponse&gt;() {
                          @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 -&gt; GreetingServiceOuterClass.HelloRequest.newBuilder().setName(name).build())
                      .forEach(requestStream::onNext);
              requestStream.onCompleted();
  
  
  
          }).start();
  
          Thread.sleep(10000);
  
  
      }
  
    }
  }
  </code></pre>