Engineering With Java: Digest #48
Handpicked and Curated: The Best Java and Spring Blogs.
Introduction 📝
This week’s edition discusses various Java and Spring Boot topics, including Java 24's performance improvements (e.g., AOT class loading), garbage collection, and local AI-driven applications using Quarkus.
It covers event-driven architecture, Spring Batch's CompositeItemReader, and the use of DTOs in API responses for better security and maintainability.
Additionally, it explains Spring Boot's file streaming and rate-limiting techniques. Also highlighted is the introduction of scoped values in Java 24 and how they enhance thread-local data management.
At the end, we share an interesting open-source project and some resources for your next Java and spring boot interview questions.
Top Picks ⭐
Java 24 - Better Language, Better APIs, Better Runtime
Nikolai Poock, a Java Developer Advocate at Oracle, introduced key features from Java 22 to 24. He highlighted improvements like AOT (Ahead-of-Time) class loading and linking, which reduces startup and warm-up times by caching runtime decisions. This can lead to significant speedups (e.g., 40% faster boot for Spring Pet Clinic) while ensuring correctness even if optimizations fail.
He discussed enhancements to virtual threads, fixing issues like object monitor pinning, and making them more efficient for blocking workloads. Stream API got more flexible with stream gatherers, unlocking complex intermediate operations like sliding windows and fixed groups.
The session balanced runtime optimizations and developer-facing features, emphasizing how Java keeps evolving to meet modern app performance demands. For more, he recommended checking JEPs and Oracle's Java YouTube channel.
Java Garbage Collection Explained: How the JVM Keeps Your Code Clean
This article dives deep into Java garbage collection, explaining how the JVM automatically manages memory to prevent leaks and improve performance.
It covers the generational model, where objects are divided into young, old, and metaspace regions, and explores various GC algorithms like G1, ZGC, and Shenandoah — each suited for different workloads. The author shares practical tips on JVM tuning, monitoring with tools like VisualVM and Java Flight Recorder, and using references like SoftReference and WeakReference for finer control.
It emphasizes best practices to write GC-friendly code, like minimizing object creation and avoiding memory leaks. The piece concludes by encouraging developers to experiment with settings, analyze GC logs, and continuously refine their applications for optimal efficiency.
Building local LLM AI-Powered Applications with Quarkus, Ollama and Testcontainers
The article explores how to develop AI-driven applications using local large language models (LLMs). It introduces the PingPong-AI project, which integrates Quarkus—a modern Java framework optimized for cloud-native applications—with Ollama, a platform for running AI models locally.
This combination allows for reduced latency and enhanced data privacy by eliminating reliance on external AI services. Additionally, the article discusses utilizing Testcontainers to facilitate integration testing by simulating the Ollama environment, ensuring robust and reliable application performance.
The piece also highlights the use of Quarkus Dev Services to streamline development workflows, simplifying the setup and management of necessary services during development.
Latest 🔥
Spring Cloud Stream: Demystifying Event-Driven Architecture
This article " explains how event-driven systems enhance modern applications by handling high-throughput, low-latency data streams. Using relatable analogies like restaurant orders and bank transactions, it illustrates the shift from synchronous to asynchronous communication, boosting scalability and responsiveness. It covers key components—producers, consumers, and processors—and highlights tools like Apache Kafka and RabbitMQ.
The piece also explores concepts like loose coupling, fault tolerance, CAP theorem trade-offs, and real-time stream processing with libraries like Apache Flink. Ultimately, it underscores that adopting event-driven architecture is essential for modern, resilient software systems.
Composite Item Reader in Spring Batch
This article discusses how to combine multiple data sources into a single reader using Spring Batch's
CompositeItemReader. This approach allows for efficient and flexible data processing by aggregating data from various sources, such as CSV files and databases, into a unified stream for batch jobs.It also provides a detailed guide on configuring and implementing the
CompositeItemReader, including setting up individual readers for each data source and combining them.Additionally, it emphasizes the importance of testing the composite reader to ensure accurate data reading and processing.
Java Pattern Matching in switch: Write Cleaner and Safer Code
This article discusses the evolution and benefits of incorporating pattern matching into Java's switch statements. Traditionally, Java's switch was limited to primitive types and enums, but recent enhancements allow for more expressive and concise code.
Pattern matching enables developers to directly inspect the type and structure of objects within switch cases, reducing boilerplate code and potential errors associated with explicit casting.
This feature not only streamlines code but also enhances its safety by ensuring that all possible cases are handled appropriately.
The article provides examples demonstrating how pattern matching in switch statements leads to more readable and maintainable code, marking a significant improvement in Java's type-checking capabilities.
Spring Boot Best Practices: Use DTOs Instead of Entities in API Responses
The article emphasizes the importance of using Data Transfer Objects (DTOs) instead of entities in Spring Boot API responses. DTOs are design patterns that facilitate the transfer of data between different parts of an application, ensuring that only necessary information is exposed.
This practice enhances security by preventing the exposure of sensitive data and promotes loose coupling between the API and the underlying data models. By decoupling the internal data structures from the API responses, developers can modify the database schema without impacting the API consumers.
Additionally, using DTOs can improve performance by allowing the selection of specific fields to be included in the response, reducing payload size. Implementing DTOs aligns with best practices in Spring Boot development, leading to more maintainable and secure applications.
How Spring Boot Implements Rate Limiting for APIs
This article explains how Spring Boot handles rate limiting to protect APIs from abuse and ensure fair usage.
It covers various strategies like token bucket and leaky bucket algorithms to control request flow. Tools like Bucket4j and Resilience4j can help implement rate limiting in Spring Boot, allowing developers to set limits based on IP address, user ID, or API key.
Proper rate limiting prevents DDoS attacks, optimizes resource usage, and improves API reliability.
It also emphasizes using proper error handling (like HTTP 429 Too Many Requests) to inform clients when limits are reached.
Scoped Values in Java 24 - Inside Java Newscast #86
In the Inside Java Newscast, Nicolai Parlog explores scoped values, a new API in JDK 24 that offers a safe, scalable way to manage thread-local data without relying on method arguments or mutable static fields.
Scoped values are bound to a thread, accessible only within a defined lambda, and automatically cleaned up after execution — preventing memory leaks and simplifying reasoning about data flow.
They contrast with
ThreadLocal, which can lead to memory bloat in high-thread environments, especially with virtual threads. WhileThreadLocalremains useful for bidirectional data flow or unscoped lifetimes, scoped values should be the default choice for most use cases.They also integrate seamlessly with structured concurrency, inheriting data across child threads. With JDK 24’s release approaching, scoped values may soon become a finalized feature, marking a step forward in modern Java concurrency management.
Constructing a Lexical Analyzer in Java
Lexical analysis is the initial phase of the compilation process, where the source code is transformed into tokens, which are the basic building blocks for syntax analysis.
In Java, this involves reading a stream of characters and organizing them into units called lexemes. A lexeme is a raw sequence of characters that matches a pattern for a token.
This process is essential for structuring raw input into clearly defined tokens, thereby improving a compiler's efficiency and maintainability.
Understanding lexical analysis is cr ucial for developers interested in the inner workings of compilers and the Java compilation process.
How Spring Boot Implements File Streaming for Large Files
Streaming large files efficiently in Spring Boot can be achieved by leveraging Spring WebFlux, which provides reactive programming support for handling such scenarios. WebFlux enables non-blocking I/O operations, allowing the application to handle large file streams without consuming excessive memory or blocking threads.
This approach is particularly beneficial when dealing with high-concurrency environments or large datasets, as it enhances performance and scalability. Implementing file streaming in this manner ensures that the application remains responsive and can handle multiple simultaneous file transfers effectively.
Open Source 🛠️
Reddisson
Redisson is a Java client for Redis, offering a simple and feature-rich API to interact with Redis in a distributed environment. It provides a wide range of Redis-based services like distributed locks, maps, sets, lists, queues, and more, enabling scalable and fault-tolerant applications.
Redisson supports synchronous, asynchronous, and reactive programming models, making it highly versatile for different Java applications. It integrates seamlessly with Spring Boot and other Java frameworks, making it ideal for building distributed systems, caching solutions, and message-driven architectures.
Key features include distributed data structures, distributed objects, pub/sub, and more, allowing developers to leverage Redis effectively in Java applications.
Career Devlopment 📚
Checkout this linkedin post about cracking system design interview.
Capgemini Java, Spring Boot, Microservices Interview Questions and Answers