gRPC [Java] Master Class: Build Modern API & Micro services

Learn how protocol buffers power gRPC by defining messages and services, enabling code generation, and delivering smaller, binary payloads with faster, cross-language communication.

Understand how http/2 replaces many per-request connections with a single long-lived, multiplexed channel. See server push, header compression to binary data, and ssl security boosting gRPC performance with protocol buffers.

Discover the four types of gRPC APIs—unary, server streaming, client streaming, and bidirectional streaming—and how to implement them with protocol buffers, including the stream keyword.

Explore how gRPC scales by keeping the main thread unblocked with asynchronous server operations, and choose synchronous or asynchronous client calls based on response criticality.

Explore how gRPC secures data with binary schema-based serialization, SSL encryption, TLS connections, and interceptors for authentication.

Compare gRPC and REST, weigh protocol buffers versus JSON, and highlight HTTP/2, streaming, and bidirectional communication, showing how gRPC can replace REST with stronger schemas, security, and performance.

Explore how gRPC generates code from Protocol Buffers, secures data with binary serialization and TLS, supports client, server, and bidirectional streaming, and uses interceptors for authentication when REST falls short.

Download and install the JDK and IntelliJ community, create a new Gradle Java project with SDK 17, configure protobuf and gRPC plugins, and load Gradle changes to generate code.

Create dummy.proto with proto3 syntax and java_package, enable java_multiple_files, and run Gradle generate proto to produce java and gRPC stubs from the protobuf.

Write the server boilerplate to listen on localhost 551 and gracefully shut down with a shutdown hook, using IntelliJ and Gradle for setup and testing.

Set up a java gRPC client by creating a greeting.client package, building a plaintext managed channel to localhost:551, and running then shutting down the client to validate the boilerplate.

Define a greeting proto with greeting request and response messages and a unary greet endpoint, generate Java code with Gradle, and prepare server-side implementation.

Implement a unary gRPC server in Java by extending GreetingServiceImplBase, overriding greet with a stream observer to send a hello response, and registering the service on the server.

Implement a Java gRPC unary API client that calls the grid endpoint with a blocking stub, handles arguments, and prints the server's greeting response.

Implement a gRPC sum API in Java by defining proto files, generating code, and building server and client to perform a sum of two numbers on port 5052.

Learn to implement a server streaming gRPC endpoint in Java by defining greetManyTimes in the greeting proto, returning ten greeting responses, and regenerating code with Gradle.

Implement server-side streaming in the gRPC Java greeting service by overriding greetManyTimes, constructing a hello response from the request's first name. Send ten responses via onNext and complete with onCompleted.

Demonstrates implementing a server streaming client in Java: call the greeting service with a blocking stub, process each streamed result, and verify ten hello Clement outputs.

Implement a server streaming primes api in gRPC by defining prime request and prime response in protobuf. Generate code, implement the server and client, and stream prime factors to client.

Define a client streaming rpc long greet in the proto, generating code with Gradle, and review the generated greeting service that uses stream observers for requests and a single response.

Implement long read server endpoint for the greeting service by returning a stream observer for requests and responses, concatenating 'hello' with each first name and delivering the result on completion.

Refactor the client to implement a Java gRPC client streaming call using an asynchronous stub, a stream observer for responses, and a countdown latch to coordinate completion.

Define a client-streaming avg API in java gRPC, implement protobuf messages, server streaming logic, and a client that streams numbers 1–10 to obtain the average.

Define a bidirectional gRPC endpoint greet everyone in the greeting service, using streams of greeting requests and greeting responses, and generate proto with Gradle before implementing the server.

Implement a gRPC bidirectional streaming server in Java, returning a stream observer for greeting requests and sending a greeting response on each request, while handling errors and completion.

Implement a bi-directional streaming gRPC client in Java by wiring a greeting service stub, creating a stream observer, sending multiple greet requests, and handling responses with onNext and onCompleted.

Build a bidirectional max API with a gRPC Java server and client, defining max request and max response messages, implementing a stream observer, and testing via Gradle generated code.

Build a unary gRPC square root endpoint in Java, using calculator.proto and SCR.proto, and handle negative inputs with status invalid argument on server and client.

Implement a unary gRPC API greet with deadline, simulate a 300 ms server delay, and verify client-side deadlines of 3 seconds and 100 ms, including cancellation handling and deadline exceeded.

Generate ssl certificates and configure a secure gRPC java setup with a server tls and a tls client using a cert chain and ca trust.

Explore gRPC reflection setup for a calculator server using Evans CLI to discover services, messages, and RPCs, and test client and server streaming interactions.

Install docker and docker compose to set up a crude blog api with create, read, update, and delete operations, and prepare the IntelliJ environment for the database setup.

Set up a MongoDB database with docker-compose, include the Mongo Express UI, map ports 27017 and 8081, and run via IntelliJ to prepare the next lecture’s Java dependencies.

Set up a Java gRPC blog service by adding the MongoDB driver 4.50 and creating a blog.proto with blog and blog ID messages and RPCs: create, read, update, delete, list.

Implement the create blog API on the server by wiring a blog service to a Mongo database, store the blog document, and return the new blog id.

Develop a Java gRPC blog client that calls the create blog endpoint, builds a blog request with author, title, and content, and verifies the entry in MongoDB.

Implement the read blog API on the server by validating the blog id, querying MongoDB by id, handling not found, and returning the blog with author, title, and content.

Implement a gRPC client read blog call with a blocking stub, handle errors via try catch, and run MongoDB, server, and client to create and read the blog.

Implement the update blog api endpoint on the server, validate the id, perform find one and update on the Mongo collection for author, title, and content, and handle not found.

Call the update blog API from the client by building a new blog with the given id, author, title, and content, and handle errors with a try-catch.

List all blog entries from a Mongo collection in a gRPC java service, iterating documents to build and stream each blog response with onNext, then complete the stream with onCompleted.

Explore building a gRPC Java list blogs client that uses a blocking stub to fetch and print all entries, with MongoDB verification and CRUD setup including delete.

Implement the delete blog API on the server by validating the id, calling Mongo delete one, and returning appropriate statuses for internal or not found errors.

Develop a Java gRPC client that calls the delete blog endpoint using a blocking stub, handles a status runtime exception, and verifies deletion in MongoDB.