Engineering With Java: Digest #52
Handpicked and Curated: The Best Java and Spring Blogs.
Introduction 📝
In this edition, we explore key innovations and practices within the Java ecosystem.
Netflix's migration to Java 17 and Spring Boot 3 is highlighted, showcasing its use of open-source tools to bridge compatibility gaps.
Other topics include AI in Java, optimizing API pagination with Spring Data, and building semantic search applications.
Plus, you'll find insights on using Java Streams, enhancing CLI applications with JLine 3, and integrating the Facebook Graph API with RestFB.
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 ⭐
How Netflix Uses Java
Netflix has fully migrated to Java 17 and Spring Boot 3, embracing modern Java features and enabling the broader community to progress.
A significant challenge during this upgrade was the shift from
javax.*tojakarta.*namespaces, which breaks compatibility for libraries between Spring Boot 2 and 3.To address this, Netflix built an open-source Gradle plugin that rewrites bytecode at dependency resolution time, allowing older libraries to work seamlessly with the new Jakarta-based APIs.
In the GraphQL space, Netflix developed the DGS framework on top of GraphQL Java to simplify backend development with an annotation-based model and built-in testing, later collaborating with the Spring team to integrate and align with Spring for GraphQL.
For inter-service communication, Netflix prefers GraphQL for frontend-backend APIs due to its flexible, schema-driven design, and gRPC for backend-to-backend RPC because of its performance and strong typing via Protobuf.
REST, while still usable for quick setups, is largely discouraged as it lacks schema awareness and flexibility needed for modern applications.
Foojay Webinar Live Stream: Java’s Place in the AI Revolution
The discussion focused on the use of AI in Java, particularly for predictive analysis and classifiers, with insights into the difference between deep learning and generative AI.
It explained how deep nets, a Java-based library, helps with model training and evaluation, emphasizing its simplicity for developers transitioning into machine learning.
It highlighted that while Python is dominant in AI for quick development and prototyping, Java excels in production environments due to its strong infrastructure.
The conversation also touched on the challenges of using Java for AI, with potential bottlenecks in adopting Java-based AI libraries in the face of Python's dominance.
What Happens When Threads Compete for Resources in Java Applications
This article explains how thread contention in Java occurs when multiple threads compete for shared resources, like variables or files.
It covers how Java manages this through synchronization and locks to prevent race conditions and ensure thread safety.
Deadlocks, where threads are stuck waiting on each other, are also discussed, along with how the JVM handles them through thread dumps.
The role of monitors in managing thread access and the potential performance impact of thread contention are key points.
Latest 🔥
Strings Just Got Faster
This article highlights a performance improvement in JDK 25 that makes the
String::hashCodemethod mostly constant foldable by marking the internalhashfield with the@Stableannotation.This allows the JVM to treat the hash code as a constant after its first computation, leading to significant speedups—especially when strings are used as keys in immutable maps.
Benchmarks show hash code operations dropping from ~4.6 ns in JDK 24 to ~0.57 ns in JDK 25.
However, strings with a hash code of zero (e.g., the empty string) don't benefit yet, though future fixes are planned.
Paginating API Results with Spring Boot and Spring Data
This article explains how pagination works in Spring Boot with Spring Data JPA.
It covers how the
Pageableinterface helps manage large result sets, how Spring handles query parameters likepage,size, andsort, and how it translates them intoPageRequestobjects.It also discusses sorting and how Spring constructs the corresponding SQL query with
LIMITandOFFSET.It explains the different return types (
Page,Slice,List) and provides a guide on creating a clean response structure with metadata likehasNextandhasPrevious.
Building an AI Chatbot in Java With Langchain4j and MongoDB Atlas
This tutorial demonstrates building an AI-powered chatbot using Langchain4j and MongoDB Atlas.
The chatbot uses vector search for semantic understanding, retrieving relevant information based on meaning rather than keywords.
The system loads document data, generates vector embeddings using OpenAI’s embedding model, and stores them in MongoDB.
When a user queries the chatbot, it performs a similarity search in MongoDB, retrieves relevant content, and uses it to generate a context-aware response through a language model.
The setup includes creating beans for embedding storage, content retrieval, and response generation, with a REST API for user interaction.
Semantic Search with Spring Boot & Redis
This article outlines how to build a semantic search app using Spring Boot and Redis, utilizing vector similarity search (VSS) to find movies based on meaning rather than exact word matches.
The app turns movie synopses into vectors using embedding models and stores them in Redis, a database now enhanced for vector storage in Redis 8. The implementation leverages Redis OM Spring for efficient querying and embedding generation.
It covers the process of creating a movie entity, defining search services for semantic and hybrid searches, and providing a RESTful search controller for querying movies based on vector similarity, genres, cast, and other metadata.
How Fast Are Streams Really?
This article explores the performance trade-offs of using Java Streams compared to traditional loops.
While Streams offer readability, conciseness, and safety, especially for complex transformations, the performance concerns arise in simpler, more basic use cases.
The author questions whether Streams' elegance comes at a performance cost and whether they are fast enough for tasks that don't require complex transformations.
The article emphasizes the importance of measuring performance in real-world scenarios rather than focusing on micro-optimizations, urging developers to make the right decision based on the actual needs of their tasks.
Streams Are Cool, Maps Are Cooler, toMap() Is a Trap
This article discusses the nuances of using Java Streams and the pitfalls of using
toMapin particular.It highlights how
toMapcan introduce bugs and inefficiencies when improperly applied, particularly when handling duplicates or missing values.The author emphasizes that while Streams provide an elegant approach to processing data, developers should be cautious with certain operations and focus on practical solutions
Getting Started with JLine 3
JLine 3 is a Java library that enhances CLI applications by adding features like command history, auto-completion, line editing, and terminal abstraction.
It supports multiple platforms and is useful for building interactive command-line tools, similar to Bash shells.
The article includes a Java example that demonstrates integrating JLine 3 for user input handling, with features like tab completion and command history. JLine 3 is widely used in projects like Apache Karaf and Apache Cassandra.
A Guide to RestFB
This guide on RestFB provides an introduction to using the RestFB library for working with the Facebook Graph API in Java.
It covers setting up RestFB, authenticating users, fetching data such as user profiles and posts, and handling API requests with the library.
The guide also explains handling Facebook's OAuth flow and integrating the Graph API with your Java applications.