In this chapter, you'll transform an e-commerce codebase by using Java Records to eliminate repetitive boilerplate code. You'll also streamline complex conditional logic with Pattern Matching and Switch Expressions, making your code more readable and maintainable. Additionally, you'll learn to use Text Blocks for cleaner JSON and SQL formatting, and the `java.time` API for accurate global order tracking.

The Cost of Java Boilerplate in Our Domain

EASY

Java has long been known for its verbosity, especially when it comes to simple data structures. In the past, creating a `ProductDTO` to transfer an ID, name, and price involved more than just declaring these fields.

Developers had to manually write constructors, getters, setters, and override methods like `equals()`, `hashCode()`, and `toString()`. This transformed a straightforward task into a cumbersome 60 lines of code.

Integrated Development Environments (IDEs) and tools like Lombok offered some relief by generating this boilerplate code. However, they did not eliminate the inherent complexity in the language itself.

Modern Java, starting from Java 14 with preview features and solidified in Java 16, introduced Records, a new way to define data-carrying classes. Records automatically generate the necessary methods, reducing boilerplate and making code more readable.

This shift not only simplifies the syntax but also enhances maintainability and reduces errors. It allows developers to focus on the domain logic rather than the mechanics of class definition.

Understanding how Records work and when to use them is crucial for writing clean, efficient Java code in today's development landscape.

Java's verbosity historically led to excessive boilerplate for simple data classes.
Manual creation of constructors and methods was error-prone and time-consuming.
IDEs and Lombok helped but didn't address the language's complexity.
Modern Java Records eliminate boilerplate, focusing on domain logic.
Records improve code readability and maintainability.
Understanding Records is key to writing clean, modern Java code.


// Modern Java with Records simplifies data class creation
public record ShippingInfo(String address) {}

Java Records: Immutable Data Carriers

EASY

Introduced in Java 16, **Records** provide a modern way to define immutable data structures with minimal code. They are designed to simplify the creation of classes whose primary purpose is to hold data. When you define a `record`, you specify its components directly in the header.

The Java compiler takes care of generating a constructor, accessor methods, and implementations of `equals()`, `hashCode()`, and `toString()`. This means less boilerplate and more focus on the logic of your application.

Accessor methods in records are named after the fields, without the 'get' prefix. For instance, if you have a field named `price`, you access it with `.price()` instead of `.getPrice()`. This makes the code cleaner and more intuitive.

Records are inherently immutable; their fields are `final` by default. This immutability makes them ideal for use cases like Data Transfer Objects (DTOs) in e-commerce applications, where you want to ensure data integrity during complex processes.

Consider using records for HTTP responses or database projections. Once an `OrderSummary` record is created, its state cannot be changed, preventing accidental modifications that could lead to bugs.

Records offer a concise way to define immutable data structures.
The compiler auto-generates constructors and methods, reducing boilerplate.
Accessor methods in records are direct and do not use 'get' prefixes.
Records are perfect for DTOs, HTTP responses, and database projections.
Using records can eliminate the need for libraries like Lombok.


// Modern Java Record: One line replaces 60 lines of boilerplate
public record OrderSummary(String orderId, BigDecimal total, String status) { }

// Usage:
OrderSummary summary = new OrderSummary("ORD-123", new BigDecimal("50.00"), "SHIPPED");
System.out.println(summary.status()); // Prints: SHIPPED

Switch Expressions and Yielding Values

EASY

In the past, calculating discount rates based on a user's loyalty tier often involved cumbersome `switch` statements. These were prone to errors due to the infamous 'fall-through' behavior, where forgetting a `break;` could lead to unintended case execution and billing errors.

Java's modern approach with **Switch Expressions** eliminates these pitfalls. By using the arrow syntax `->`, each case is isolated, preventing accidental fall-through. This means you can write cleaner and safer code.

Switch Expressions also allow you to directly assign the result of the switch to a variable. This functional style of programming reduces side-effects and ensures that your variables are always initialized with a value.

Moreover, the compiler now checks for exhaustiveness, especially useful when working with enums. This ensures that every possible value is handled, reducing runtime errors.

Switch Expressions not only make your code more readable but also more robust, aligning with modern Java's emphasis on safety and clarity.

Traditional switch statements could lead to bugs due to missing 'break;' statements.
Switch Expressions use '->' to ensure only the matched branch executes.
They allow the switch to yield a result directly, promoting functional programming.
Exhaustiveness checks ensure all enum values are handled, reducing errors.
Encourages cleaner and more readable code by eliminating fall-through cases.


public enum Tier { BRONZE, SILVER, GOLD }

// Switch Expression yielding a value directly
double discount = switch (customerTier) {
    case BRONZE -> 0.05;
    case SILVER -> 0.10;
    case GOLD -> 0.20;
};

Text Blocks for Clean JSON and SQL

MID

In earlier Java versions, crafting multi-line strings was cumbersome. Developers had to rely on concatenation with `+` and manually insert `\n` for new lines, often leading to messy and hard-to-read code.

Java 15 introduced **Text Blocks**, a feature that significantly simplifies handling multi-line strings. By using triple quotes `"""`, you can now include large blocks of text, such as JSON, HTML, or SQL, directly in your code without losing readability.

Text Blocks maintain the original formatting of the text, which is particularly useful for embedding formatted JSON responses or SQL queries. The compiler smartly removes any unnecessary leading whitespace, aligning the text based on the position of the closing triple quotes.

This feature is especially beneficial when you need to hardcode default JSON responses or raw SQL queries in your data access layer. It keeps your code clean and aligned with how the text is meant to be read, making maintenance easier and reducing the chance of introducing errors.

Old Java required tedious string concatenation for multi-line strings.
Text Blocks (`"""`) allow embedding formatted text directly.
The compiler removes unnecessary leading spaces for clean output.
Ideal for embedding JSON and SQL directly in your code.
Improves readability and reduces potential for errors.
Essential for clean, maintainable code in backend development.


String rawQuery = """
    SELECT o.id, o.total, u.email 
    FROM orders o
    JOIN users u ON o.user_id = u.id
    WHERE o.status = 'PENDING'
    """;

The Modern java.time API: Instants and Timezones

MID

In the world of e-commerce, each order needs a precise timestamp for when it was created. Before Java 8, developers were stuck with `java.util.Date`, a class infamous for its mutability and lack of timezone awareness, leading to bugs and headaches.

Java 8 revolutionized date and time handling with the `java.time` package, also known as JSR-310. This package introduced `Instant`, a class that captures a specific moment in time in UTC, making it ideal for machine-level timestamps.

When you need to display time to users, you can convert an `Instant` to a `ZonedDateTime` by combining it with a `ZoneId`. This allows you to account for timezone differences and daylight saving changes, ensuring your application is both accurate and user-friendly.

The immutability of `java.time` classes means you can perform date arithmetic safely without side effects. For example, adding days to a date is straightforward and safe, as shown in the method chaining of `LocalDate.now().plusDays(3)`.

The old `Date` class is now largely obsolete, kept around only for compatibility with legacy systems. Embracing `java.time` not only modernizes your code but also enhances its reliability and clarity.

`java.util.Date` was mutable, leading to threading and timezone issues.
`java.time` classes are immutable, ensuring thread safety.
`Instant` captures a precise moment in UTC, ideal for timestamps.
`ZonedDateTime` combines `Instant` with `ZoneId` for timezone-aware display.
Immutability allows safe and chainable date arithmetic.


Instant orderPlacedAt = Instant.now();

// Estimate delivery 3 days later, adjusted to the customer's timezone
ZonedDateTime deliveryEstimate = orderPlacedAt
    .atZone(ZoneId.of("America/New_York"))
    .plusDays(3);

Sealed Classes to Restrict Hierarchies

MID

In designing a checkout system, it's crucial to model `PaymentResult` accurately. Imagine a payment outcome that can only be `Success`, `Failure`, or `Pending`. Traditionally, creating a `PaymentResult` interface would allow any developer to implement it, potentially leading to unexpected and invalid states.

Enter **Sealed Classes**, a feature introduced in Java 17. By declaring a class or interface as `sealed`, you can control exactly which classes can extend or implement it. This is done by listing the permitted subclasses explicitly.

Sealed classes align perfectly with Domain-Driven Design principles. They enforce a strict hierarchy, ensuring that only known and valid states are represented in your codebase. This structural integrity means the compiler can guarantee exhaustive checks, eliminating the risk of unforeseen states.

When combined with Records, sealed classes allow you to create clear and concise algebraic data types. This combination enhances readability and maintainability, as each possible state is explicitly defined and managed.

In practice, sealed classes help maintain domain integrity, making your application logic more predictable and robust. They prevent the accidental or malicious creation of invalid states, which is particularly valuable in complex systems where data accuracy is paramount.

Traditional interfaces allow unrestricted subclassing, which can lead to invalid states.
Sealed classes restrict subclassing to a predefined list, ensuring only valid states.
They enforce domain integrity by preventing unauthorized implementations.
Perfectly complement Records to define clear and concise data types.
Enhance code reliability by allowing exhaustive checks at compile time.


public sealed interface PaymentResult permits Success, Failure, Pending { }

public record Success(String transactionId) implements PaymentResult { }
public record Failure(String errorCode) implements PaymentResult { }
public record Pending(Instant checkAgainAt) implements PaymentResult { }

Pattern Matching with instanceof

MID

When working with a `PaymentResult`, you often need to determine its specific subclass to proceed correctly. Traditionally, this involved using `instanceof` to check the type, followed by a cumbersome cast to access the subclass's methods. This two-step process was not only verbose but also error-prone.

Java's pattern matching for `instanceof` simplifies this by combining the type check and variable declaration in one clean step. If the condition is true, the casted variable is directly available within the `if` block, eliminating redundant casting and reducing the risk of `ClassCastException`.

This enhancement significantly reduces boilerplate code, making your logic more readable and maintainable. It also enhances safety by ensuring that the variable is only accessible when the type check passes, providing a more robust way to handle different object types.

By streamlining type checks and variable declarations, pattern matching helps you write cleaner, more efficient Java code. This feature is especially useful in complex applications where multiple subclass checks are common.

Old method: Check type with `instanceof`, then cast manually.
Pattern matching merges type checking and variable declaration.
Scoped variable is accessible only if the type check passes.
Reduces boilerplate code and potential casting errors.
Improves readability and maintainability of conditional logic.


PaymentResult result = gateway.charge(cart);

if (result instanceof Success successData) {
    // Directly use 'successData' without additional casting
    System.out.println("Transaction successful! ID: " + successData.transactionId());
} else if (result instanceof Failure failData) {
    System.out.println("Transaction failed with error: " + failData.errorCode());
}

Pattern Matching in Switch Expressions

ADVANCED

In Java 21, Pattern Matching for Switch is a game-changer, especially when combined with Sealed Classes. It allows you to write cleaner, more maintainable code by eliminating the need for cumbersome `if-else` chains that rely on `instanceof` checks.

Imagine you have a sealed interface like `PaymentResult` with subclasses `Success`, `Failure`, and `Pending`. Instead of checking each type manually, you can pass `PaymentResult` into a switch expression. The switch automatically matches the subclass type and binds it for use within the case block.

This feature not only simplifies your code but also enhances safety. Since `PaymentResult` is sealed, the compiler ensures your switch is exhaustive. If you forget to handle a subclass like `Pending`, your code won't compile, preventing potential logic errors.

Switch expressions with pattern matching are particularly useful in enterprise applications where domain logic can grow complex. They help ensure that all possible states are handled explicitly, reducing the risk of unhandled cases as your application evolves.

Switch expressions now support pattern matching, simplifying type checks.
Variables are automatically bound within each case, reducing boilerplate.
Exhaustiveness is enforced for sealed interfaces, ensuring all cases are covered.
Ideal for complex domain logic, enhancing code safety and readability.
Reduces the need for `instanceof` and manual type casting.


String uiMessage = switch (result) {
    case Success s -> "Order confirmed: " + s.transactionId();
    case Failure f -> "Payment declined: " + f.errorCode();
    case Pending p -> "Awaiting confirmation at " + p.checkAgainAt();
};

Balancing Backward Compatibility with Modern Java

ADVANCED

Imagine you've just secured a role where your main task is to maintain a Java 8 codebase. This codebase is filled with old Spring configurations and traditional getter/setter methods. While it's crucial to embrace Java 21's new features, a senior developer must also honor backward compatibility.

Java's enduring strength lies in its backward compatibility. Code written two decades ago can still run on today's JVMs. This means that when upgrading from Java 11 to Java 21, you don't need to overhaul everything at once.

Modern Java features, like Records and Pattern Matching, are optional. You should refactor legacy Data Transfer Objects (DTOs) into Records during active maintenance, not arbitrarily. Similarly, incorporate Pattern Matching when you're already addressing a bug.

The goal is to modernize smoothly—enhancing the codebase one pull request at a time while ensuring the application remains stable. This is the hallmark of expert Java development in an enterprise setting.

Java's commitment to backward compatibility ensures old code runs on new JVMs.
Enterprise environments often use older Java versions; expect to see legacy syntax.
Modernization should be incremental, aligning with ongoing work rather than massive overhauls.
Senior developers must balance respect for legacy code with the push for modern practices.
Effective modernization involves understanding and refactoring legacy patterns into new ones.


// The key to modernizing Java:
// Deeply understand legacy code to effectively refactor it using modern Java features.

Chapter takeaway

By embracing modern Java features from Java 14 to Java 21, you can write more expressive, safe, and concise code, distinguishing yourself as a forward-thinking backend engineer.