Java Spring Boot 4 for Protobuf & gRPC Microservice

Before writing a single line of code, this lecture walks you through everything you need to have in place. You'll learn which Java version is required (Java 21 or newer), how to install Amazon Corretto JDK, how to set up Visual Studio Code and its key extensions, and how to install the protobuf compiler (protoc) and the buf toolchain. By the end, your development environment will be fully ready for the course.

All course source code, scripts, AI prompts, and slides are available for download — and this lecture tells you where to find them. You'll learn where the Resources & References section is located, why minor version differences between videos and downloadable files are normal, and how to use the provided code as a reliable reference. This ensures you always have a complete fallback when you get stuck.

This lecture introduces the folder and file structure used throughout the course for all Java Spring Boot and Protocol Buffers projects. You'll see how Maven, Java source files, proto definitions, Spring configuration, and generated code are organized in a clean, predictable layout. Understanding this structure from the start helps you navigate the project confidently as it grows across the course.

Discover what Protocol Buffers (Protobuf) are and why they've become a cornerstone of modern distributed systems. This lecture explains the core elements of protobuf — the schema definition language, the proto compiler, runtime libraries, and the binary serialized data format. You'll also explore the key advantages over JSON: smaller message sizes, strict typing, automatic code generation, and built-in support for schema evolution.

Writing consistent protobuf definitions is just as important as writing clean code. This lecture walks through the official protobuf style guide, covering file naming conventions, indentation rules, the difference between proto3 and the newer editions syntax, and naming conventions for messages, fields, enums, and services. Following these conventions from day one keeps your schemas readable and maintainable as the project grows.

This course uses a proven four-step learning methodology to help you build real hands-on skills: Theory, Task, Guided Challenge, and Full Solution. This lecture explains how each step works and why following this structure — rather than jumping straight to the solution — accelerates your learning. You'll also understand when it's appropriate to use a custom solution versus the course's reference solution.

The course includes interactive browser-based practice labs for many lessons, so you can run and modify Java code without any local setup. This lecture introduces the lab environment, explains how to navigate its interface, how to use the task and reference code sections, and the important 60-minute session time limit. Whether you use the lab or your own machine, you'll gain the same full course knowledge.

This lecture introduces your first complete Protocol Buffers workflow using Java and Spring Boot 4. You'll learn how to write a basic `.proto` file, use the `java_package` option to control generated code placement, understand the role of the proto compiler within a Spring Boot Maven project, and use the generated Java classes in your application code. It's the essential first step to working with protobuf in a real Java project.

Here's your first protobuf challenge: create a working Spring Boot project that defines a simple protobuf message and uses the generated Java class in a `CommandLineRunner`. The task is concise and focused, designed to confirm that your toolchain is set up correctly and that you understand the basics of the protobuf-to-Java code generation pipeline.

Watch a complete walkthrough of building your first Spring Boot protobuf project from scratch. You'll see how to initialize the project, write the `hello.proto` file with a `HelloMessage`, generate the Java source code via Maven, and use the generated builder API in a Spring `CommandLineRunner`. This solution gives you a clear, working reference for all future protobuf work in the course.

Protobuf supports a rich set of scalar data types — and choosing the right one matters for both correctness and performance. This lecture covers all four scalar groups: numbers (including signed, unsigned, and fixed-length integer variants), booleans, strings, and bytes. You'll learn the practical rules for when to use `int32` vs `sint32` vs `fixed32`, and how each scalar maps to its corresponding Java type.

Put scalar types into practice by defining a `User` protobuf message with a variety of field types including `uint32`, `string`, `bool`, and `bytes`. This task reinforces your understanding of how field types are declared and numbered in a `.proto` file.

A step-by-step solution showing the `User` proto definition with `uint32` for ID, `string` for username, `bool` for active status, and `bytes` for password. You'll also see how to write the matching Java demo class that builds and logs a `User` instance using the generated builder, including how to convert a `String` to `ByteString` for the password field.

Learn how to model list-type data and predefined value sets in your proto schemas. This lecture covers the `repeated` keyword for defining multi-value fields (the protobuf equivalent of a Java `List`), how to declare and use `enum` types for fields like gender or status, and how to add comments to your proto files. These three features dramatically expand the expressiveness of your data models.

Watch the full solution as the `User` message is extended with a `Gender` enum, a `repeated string emails` field, and proto comments. You'll also see the Java demo updated to call `.setGender()` and `.addEmails()` using the generated builder, and verify the output includes the new fields.

JSON and protobuf can coexist — and this lecture shows you how to convert between them using the `protobuf-java-util` library. You'll learn why standard Java JSON libraries like Jackson are not suitable for protobuf, how to use `JsonFormat.Printer` to serialize a protobuf message to a JSON string, and how to use `JsonFormat.Parser` to deserialize JSON back into a protobuf object. Field name mapping between snake_case and camelCase is also covered.

The complete solution demonstrates bidirectional protobuf-JSON conversion in Java. You'll see how the password field is Base64-encoded in JSON, how `isActive` maps to camelCase in JSON and back to snake_case in protobuf, and how to construct a JSON string with the correct structure (including Base64 password and enum values) for round-trip parsing.

Protobuf messages can reference other messages as field types, enabling you to build rich, nested data structures. This lecture explains how to use one message as a data type within another — for example, using an `Address` message as a field inside a `User` message — and confirms that the writing order of messages in a file does not matter.

The solution walks through defining the `Address` message and adding it as a field in `User`. You'll see the Java demo updated to build an address with city, country, and street, attach it to a `User`, and display the result both as protobuf binary and as a JSON string with the address as a nested object.

As your schema grows, splitting proto definitions across multiple files becomes essential for maintainability and team collaboration. This lecture covers when and why to separate messages into multiple `.proto` files, how to use the `import` statement to reference messages across files (with alphabetical ordering convention), and how this reduces Git merge conflicts in team projects.

Watch the complete implementation of `user_group.proto` with proper imports, `repeated User users`, and JSON field name customization. The Java demo creates multiple `User` instances and adds them to a `UserGroup`, then outputs both the protobuf representation and a human-readable JSON version showing users as a nested array.