Engineering With Java: Digest #53
Handpicked and Curated: The Best Java and Spring Blogs.
Introduction 📝
In this week’s edition, we spotlight the latest and greatest in Java development! From powerful AI-driven tools like Brokk, designed to help manage large Java codebases with transparency and precision, to innovative improvements in Java Streams with the new Stream.Gatherer API—these picks highlight practical solutions and fresh ideas to elevate your coding experience.
Whether you’re modernizing legacy monoliths with Spring Boot sidecars or diving into clean architecture patterns with functional interfaces, this curated collection is packed with insightful articles and tutorials to keep you ahead in the Java ecosystem.
Explore these insights in detail with the full articles linked below.
🚀 Java + Spring Boot + SQL Interview + Certification Prep 🚀
🎯 Perfect for aspiring developers, job switchers & interview prep warriors!🔥 What’s Inside (PDF format):
Grokking the Java Interview (Vol 1 & 2)
Grokking the Spring Boot Interview
Grokking the SQL Interview
Java SE 17 Developer Certification (1Z0-829) Guide
250+ Spring Framework Certification Practice Questions
Top Picks ⭐
Brokk: AI for Large (Java) Codebases
The article introduces Brokk, a standalone AI-powered tool designed to help Java developers manage large codebases more effectively by providing clear insights into the AI’s reasoning and decisions, unlike typical IDE plugins. Brokk’s interface includes areas for issuing instructions, viewing AI outputs, tracking activity with undo capabilities, managing workspace files and code fragments, and integrating Git for version control.
Central to Brokk is its workspace, which organizes diverse context—like code snippets, documentation, and external resources—to ensure the AI operates with full understanding, reducing errors like API hallucinations and technical debt.
This structured approach aims to improve the accuracy and reliability of AI-assisted coding in complex Java projects.
Using Java Stream Gatherers To Improve Stateful Operations
This article highlights the capabilities of the new
Stream.GathererAPI in Java 24, which simplifies the implementation of stateful operations within Java Streams.Traditionally, handling state (like comparing current and previous elements) required awkward workarounds using external mutable structures, but gatherers encapsulate this behavior in a clean, modular way.
A gatherer consists of an initializer (for setting up state), an integrator (for processing each element), a combiner (for merging state in parallel streams), and a finisher (for final output).
The article demonstrates a practical use case—computing percentage changes between consecutive stock quotes—where a custom gatherer maintains the previous quote and emits the calculated change.
This approach eliminates boilerplate code, improves readability, and promotes reusability, making gatherers a powerful tool for building expressive and maintainable stream transformations in Java.
Monoliths, REST, and Spring Boot Sidecars: A Real Modernization Playbook
This article discusses how to modernize legacy enterprise Java applications without a complete rewrite. It emphasizes that true modernization often involves incremental changes, such as integrating REST APIs into SOAP-based systems and adding sidecar components to existing monolithic applications.
This approach allows organizations to introduce modern features like JSON interfaces and cloud integrations while maintaining the stability and compliance of their legacy systems.
It also highlights that in regulated environments, modernization is more about strategic adaptation than radical transformation. By leveraging sidecar patterns and other techniques, teams can evolve their applications to meet contemporary requirements without disrupting core business logic.
Latest 🔥
Setting Up Read Replication with Spring Boot Using JPA
This article provides a practical guide for configuring read replicas in a Spring Boot application to enhance performance and scalability. The author emphasizes the importance of routing read operations to a replica database while directing write operations to the primary database.
This approach reduces the load on the primary database and improves read performance, especially under high traffic conditions. The article outlines the steps to configure separate
DataSourcebeans for the primary and replica databases, and to implement a customRoutingDataSourcethat determines the appropriate data source based on the type of operation.Additionally, the author discusses the use of
@Transactional(readOnly = true)annotations to ensure that read operations are directed to the replica database. By following these guidelines, developers can effectively set up read replication in their Spring Boot applications, leading to improved performance and scalability
Building Multi-Tenant Applications With Spring Boot
This article provides a comprehensive guide to implementing a database-per-tenant architecture using Spring Boot. This approach ensures clear data isolation by assigning each tenant its own database, facilitating independent migrations, backups, and data management.
To determine the appropriate tenant for each request, the application utilizes a custom HTTP header (e.g.,
X-Tenant-ID) and stores the tenant ID in aThreadLocalvariable, ensuring thread-safe access throughout the request lifecycle.Database routing is achieved by extending Spring's
AbstractRoutingDataSourceand overriding thedetermineCurrentLookupKey()method to return the current tenant ID.A configuration class maps each tenant to its respective data source, allowing Spring to select the correct connection pool for each request. This setup provides robust data isolation and scalability for multi-tenant applications
Clean Java Architecture with Supplier, Function, and Consumer Interfaces
This article demonstrates how to implement a clean architecture in Java by leveraging functional interfaces—
Supplier,Function, andConsumer—to create a modular and decoupled message processing pipeline.In this architecture, the
Supplierinterface handles input retrieval, theFunctioninterface manages business logic transformations, and theConsumerinterface processes the output, such as logging or storing the result.This approach promotes separation of concerns, enhances testability, and facilitates easy maintenance by isolating different stages of the processing flow.
The article emphasizes that by using these functional interfaces, developers can achieve a clean and scalable architecture that adheres to best practices in software design.
End-to-End Audit Logging in Java: Capturing Who Did What and When
This article explains how to implement comprehensive audit logging in Java applications to improve security, compliance, and troubleshooting.
It highlights using Aspect-Oriented Programming (AOP) and Spring Events to intercept and log key actions without altering business logic.
Essential audit details include the actor, operation, timestamp, affected data, and contextual info like IP address.
This approach helps build scalable, maintainable audit systems that provide detailed records of user activities for monitoring, reporting, and analysis.
Secure Inter-Service Communication in Java Microservices with mTLS
This article provides a practical guide to implementing mutual TLS (mTLS) to secure communication between microservices in a Java environment.
It emphasizes the importance of mTLS in establishing trust and encrypting data in transit, ensuring that both client and server authenticate each other.
The guide outlines the necessary steps to configure mTLS using Spring Cloud Gateway and Kubernetes, including generating and managing certificates, configuring Spring Boot applications for mTLS, and deploying the setup in a Kubernetes cluster.
By following this approach, developers can enhance the security of their microservices architecture, protect sensitive data, and comply with regulatory requirements
Spring I/O 2025
Spring I/O 2025, held in Barcelona from May 21 to 23, was a significant event for the Spring developer community. The conference featured over 1,200 professionals and enthusiasts, with a diverse program that included workshops, keynotes, and technical sessions across multiple tracks.
Notably, the event showcased the latest advancements in the Spring ecosystem, such as Spring Framework 7, Spring Boot 4, and the general availability of Spring AI 1.0.
Attendees had the opportunity to engage with cutting-edge topics and tools, enhancing their skills and knowledge in modern application development. The conference also fostered a strong sense of community, providing a platform for networking and collaboration among developers, speakers, and industry leaders.
Overall, Spring I/O 2025 reinforced its position as a premier conference for those involved in the Spring and Java ecosystems.
Spring Team on AOT Cache Handling, Null Safety with JSpecify, and Support Durations
The article discusses recent advancements in the Spring ecosystem, focusing on Ahead-of-Time (AOT) compilation, null safety improvements, and support durations. Spring Framework 6.2 introduced AOT compilation to optimize applications for native environments, enhancing startup times and reducing memory consumption.
The Spring team is working on refining AOT cache handling to improve performance further. Regarding null safety, Spring is adopting JSpecify annotations to standardize nullability annotations across the Java ecosystem, aiming to reduce NullPointerExceptions and improve code reliability.
Additionally, the article touches on the Spring team's approach to support durations, ensuring that Spring projects maintain compatibility and receive updates in alignment with the broader Java ecosystem's lifecycle
A Guide to OpenAI Text-to-Speech (TTS) in Spring AI
The Baeldung article provides a comprehensive tutorial on integrating OpenAI's TTS capabilities into a Spring Boot application using Spring AI. It outlines the necessary dependencies, configuration settings, and code examples to enable text-to-speech functionality.
Key features include selecting different voices (e.g., Alloy, Echo, Fable, Onyx, Nova, Shimmer), adjusting speech speed, and choosing output formats such as MP3, WAV, or Opus.
The guide also demonstrates how to implement both standard and streaming audio responses, allowing for real-time audio playback. By following this guide, developers can easily add voice synthesis capabilities to their Spring Boot applications, enhancing user interaction through audio output.