# Step-3: Implement a server.
This step extends the generated server skeleton code to write a simple server
that provides the hello service. This introduces two new classes:
- a service implementation [GreetingsImpl.java ](src/main/java/ex/grpc/GreetingsImpl.java ).
- a server that hosts the service implementation and allows access over the network: [GreetingsServer.java ](src/main/java/ex/grpc/GreetingsServer.java ).
## Service implementation
[GreetingsImpl.java ](src/main/java/ex/grpc/GreetingsImpl.java )
implements the behaviour we require of our GreetingService. There are a
number of important features of gRPC being used here:
```
public void hello(Helloworld.HelloRequest req,
StreamObserver< Helloworld.HelloReply > responseObserver) {
Helloworld.HelloReply reply = Helloworld.HelloReply.newBuilder().setMessage(
"Hello " + req.getName()).build();
responseObserver.onValue(reply);
responseObserver.onCompleted();
}
```
- it provides a class `GreetingsImpl` that implements a generated interface `GreetingsGrpc.Greetings`
- `GreetingsGrpc.Greetings` declares the method `hello` that was declared in the proto [IDL ](src/main/proto/helloworld.proto )
- `hello's` signature is typesafe:
hello(Helloworld.HelloRequest req, StreamObserver< Helloworld.HelloReply > responseObserver)
- `hello` takes two parameters:
`Helloworld.HelloRequest` : the request
`StreamObserver<Helloworld.HelloReply>` : a response observer, an interface to be called with the response value
- to complete the call
- the return value is constructed
- the responseObserver.onValue() is called with the response
- responseObserver.onCompleted() is called to indicate that no more work will done on the RPC.
## Server implementation
[GreetingsServer.java ](src/main/java/ex/grpc/GreetingsServer.java ) shows the
other main feature required to provde the gRPC service; how to allow a service
implementation to be accessed from the network.
```
private void start() throws Exception {
server = NettyServerBuilder.forPort(port)
.addService(GreetingsGrpc.bindService(new GreetingsImpl()))
.build();
server.startAsync();
server.awaitRunning(5, TimeUnit.SECONDS);
}
```
- it provides a class `GreetingsServer` that holds a `ServerImpl` that will run the server
- in the `start` method, `GreetingServer` binds the `GreetingsService` implementation to a port and begins running it
- there is also a `stop` method that takes care of shutting down the service and cleaning up when the program exits
## Build it
This is the same as before: our client and server are part of the same maven
package so the same command builds both.
```
$ mvn package
```
## Try them out
We've added simple shell scripts to simplifying running the examples. Now
that they are built, you can run the server with:
```
$ ./run_greetings_server.sh
```
and in another terminal window confirm that it receives a message.
```
$ ./run_greetings_client.sh
```
