Best of Java — October 2025

1. 1
   Video

   CodeHead·25w

   99% Of Devs Don't Understand Spring Boot

   Spring Boot simplifies Java development by automating configuration and removing XML complexity, making it production-ready out of the box. Major companies like Netflix, Amazon, and Spotify rely on it to power massive-scale systems with billions of API calls daily. Modern versions support Kotlin, reactive programming through Spring WebFlux, and cloud-native deployments, making it more relevant than its outdated reputation suggests. The framework's strength lies in its reliability, comprehensive ecosystem, and ability to handle enterprise-scale workloads efficiently.

   175

   24
2. 2
   Article

   Javarevisited·26w

   Stop Writing Database-Dependent Tests — Mock Your Data Access Layer

   Database-dependent tests are slow, fragile, and blur the boundaries between unit and integration testing. Mocking the data access layer through interfaces and dependency injection enables fast, isolated unit tests that focus on business logic rather than infrastructure. The recommended approach is to use mocks for 90% of tests while reserving database-touching integration tests for the remaining 10%, ensuring high coverage without sacrificing development speed.

   97

   10
3. 3
   Article

   Javarevisited·26w

   What Spring Boot Taught Me About Clean Architecture

   A developer's journey from writing monolithic Spring Boot controllers to implementing Clean Architecture principles. The piece demonstrates how to refactor tightly-coupled code into layered architecture with proper separation of concerns, showing practical examples of moving business logic from controllers to service layers. It connects Clean Architecture concepts to SOLID principles and explains how proper layering improves testability and maintainability in Java applications.

   91

   3
4. 4
   Article

   Learn Python·25w

   How can I ACTUALLY start on coding?

   A beginner programmer seeks guidance on how to effectively start learning to code, specifically with Python and Java. They're struggling with confusing lessons, unclear next steps after completing tutorials, and practical implementation challenges like adding UI features to a basic calculator project.

   65

   32
5. 5
   Article

   Spring·25w

   Spring Boot 3.4.11 available now

   Spring Boot version 3.4.11 has been released and is now available for developers to download and use in their Java applications.

   39

   1
6. 6
   Article

   Quarkus·26w

   Grpc Zero

   Quarkus gRPC Zero eliminates the need for native protoc binaries by running gRPC code generation entirely within the JVM. It embeds libprotobuf compiled to WebAssembly and translated to Java bytecode using Chicory, enabling portable and consistent builds across all platforms. Developers can continue writing .proto files as usual while avoiding platform-specific toolchain maintenance, simplifying CI pipelines, and reducing dependencies. The extension is currently experimental and available as a drop-in replacement for the standard quarkus-grpc-codegen artifact.

   34
7. 7
   Article

   JetBrains·28w

   IntelliJ IDEA 2025.2.3 Is Out!

   IntelliJ IDEA 2025.2.3 is now available with bug fixes addressing Jira Task Server integration, breakpoint functionality in the Services view with ClassicUI plugin, and the ability to open multiple files from the Find Usages dialog. The update can be installed through the IDE, Toolbox App, snaps for Ubuntu, or downloaded directly from the website.

   34

   3
8. 8
   Article

   InfoWorld·27w

   Java or Python for building agents?

   Choosing between Java and Python for AI agents should depend on your team's existing expertise and technology stack, not trends. While Python dominates AI development due to its accessibility and rich ecosystem, Java developers can build equally effective agents using frameworks like Embabel. Organizations will achieve faster AI adoption by leveraging their current tools and skills rather than switching to unfamiliar technologies. By 2028, 80% of generative AI applications will be built on existing data management platforms, reinforcing the value of working with what you already have.

   33

   6
9. 9
   Article

   Javarevisited·24w

   JUnit 5 is dead, long live JUnit 6!

   JUnit 6 was officially released on September 30, 2025, marking a smooth evolution from JUnit 5 rather than a disruptive overhaul. The new version requires Java 17 as baseline, unifies version numbers across Platform, Jupiter, and Vintage modules, and adds full Kotlin 2.1+ support with suspend functions. Key improvements include inherited test ordering for nested classes, explicit nullability annotations via JSPECIFY, cleaner console output with control character handling, enhanced CSV parameterized tests with text blocks and comments, and a new fail-fast execution mode. The JUnit Vintage engine for JUnit 4 tests enters deprecation, signaling the end of legacy support after twenty years.

   32
10. 10
    Article

    The Apache Software Foundation Blog·28w

    The Apache Software Foundation Announces New Top-Level Projects

    The Apache Software Foundation has promoted Apache DevLake and Apache Grails to Top-Level Projects. DevLake is a dev data platform that ingests and visualizes data from DevOps tools to provide actionable insights. Grails is a Groovy-based web application framework for the JVM built on Spring Boot, celebrating 20 years since its initial launch and experiencing renewed momentum during its incubation period.

    30

    1
11. 11
    Article

    Just Java·27w

    Java Developer Reflection

    A developer reflects on Java development practices and poses questions about what makes a strong Java developer in the age of AI. The discussion touches on core concepts like OOP, concurrency, collections, streams, JVM internals, and design patterns as foundational skills. The author seeks community input on motivation for continuous learning and best practices in modern Java development.

    28

    2
12. 12
    Article

    JetBrains·25w

    IntelliJ IDEA 2025.2.4 Is Out!

    IntelliJ IDEA 2025.2.4 is now available with bug fixes addressing critical issues including uninstaller failures, code completion freezes caused by recursive StubIndex calls, cURL import problems in HTTP Client, line ending preservation during shelve/unshelve operations, background image display in tool windows, Maven console output for Chinese characters, AI diff view usability improvements, and module build dependency ordering.

    24
13. 13
    Video

    Awesome·26w

    Modern Java is pretty cool and you can't avoid it anymore...

    Modern Java has evolved significantly from its verbose, bloated reputation. Key improvements include records for reducing boilerplate, type inference with the var keyword, Project Loom's virtual threads for simplified concurrency, and advanced garbage collectors for better performance. New frameworks like Quarkus leverage GraalVM and ahead-of-time compilation to deliver cloud-native applications with millisecond startup times and reduced memory footprints, while maintaining familiar Java syntax and patterns. These changes make Java competitive with modern languages while preserving its enterprise stability and extensive job market.

    22

    1
14. 14
    Article

    Collections·28w

    Java Weekly: Spring Boot 4 and Jackson 3 Support

    Spring Boot 4 introduces Jackson 3 support with significant changes including the shift from mutable ObjectMapper to immutable JsonMapper and package name updates. The framework maintains backward compatibility by supporting both Jackson 2 and 3 during migration. Additional updates include reactive context improvements for ThreadLocal reliability, Spring AI versions 1.0.3 and 1.1.0-M3, Spring Cloud 2025.1.0-M3 milestone, and various tooling updates like Mandrel 25 and WildFly 38 Beta.

    19
15. 15
    Article

    Vlad Mihalcea·27w

    Troubleshooting Java

    A review of the second edition of "Troubleshooting Java" by Laurentiu Spilca, covering debugging techniques, profiling with VisualVM, memory management, and distributed systems troubleshooting. The book spans 388 pages across 13 chapters, teaching developers how to use IDE debuggers effectively, profile applications, handle deadlocks, analyze heap dumps and GC logs, and prevent cascading failures in distributed systems. Includes detailed annexes on Java Memory Model, thread lifecycle, synchronization, and common threading issues.

    16
16. 16
    Article

    InfoWorld·24w

    Will JavaFX return to Java?

    A proposal to reintegrate JavaFX into the Java Development Kit has emerged in the OpenJDK community, seven years after its removal in Java 11. The proposal argues that original separation reasons—JDK bloat, independent evolution needs, and Oracle-to-Gluon development transfer—are less relevant today due to modularization, synchronized releases, and open source availability. Oracle responded by stating they're investigating options to improve JavaFX accessibility within the JDK, though no specific plans were announced.

    13
17. 17
    Article

    Inside Java·26w

    JDK 26: HTTP/3 Support – Inside.java

    JDK 26 introduces HTTP/3 support to Java's HttpClient API, built on the QUIC protocol over UDP instead of TCP. Developers can enable HTTP/3 by setting it as the preferred version on HttpClient or HttpRequest instances. The implementation automatically downgrades to HTTP/2 or HTTP/1.1 if the server doesn't support HTTP/3. The HttpClient can discover HTTP/3 support through mechanisms like HTTP Alternative Services headers, allowing subsequent requests to use the preferred protocol. Early access builds are available for testing and feedback.

    13
18. 18
    Article

    Foojay.io·25w

    Spring Framework 7 API Versioning Explained

    Spring Framework 7 introduces native API versioning support through a new version attribute in @RequestMapping annotations. The framework provides multiple versioning strategies including request header, path segment, query parameter, and media type parameter approaches. Developers can configure versioning either through annotation-based WebMvcConfigurer implementations or property-based configuration in application.properties. The feature includes built-in components for version resolution, parsing (supporting semantic versioning), validation, and deprecation handling to maintain backward compatibility while evolving APIs.

    12
19. 19
    Article

    Just Java·24w

    JUnit 6.0.0 — What's New, Why Migrate, and How to Use

    JUnit 6.0.0 was released on September 30, 2025, introducing breaking changes and modernization. The framework now requires Java 17 as the minimum baseline (dropping support for Java 16 and lower) and Kotlin 2.2. Key improvements include unified version numbering across Platform, Jupiter, and Vintage modules, JSpecify nullability annotations for better null safety, and Java Flight Recorder integration in the junit-platform-launcher module. The release removes obsolete APIs while delivering performance enhancements and improved consistency for modern Java development.

    11
20. 20
    Article

    Foojay.io·27w

    7 habits of Highly Effective Java Coding

    Seven practical habits for Java developers using AI coding assistants effectively. Covers taking ownership of AI-generated code, providing rich context for better outputs, prioritizing maintainability over cleverness, validating dependencies for security risks, writing meaningful tests beyond coverage metrics, and conducting human-focused code reviews. Emphasizes that AI accelerates development but requires developer vigilance to ensure quality, security, and long-term maintainability.

    11
21. 21
    Article

    Baeldung·27w

    Java Serialization with Non Serializable Parts

    Explores techniques for serializing Java objects that contain non-serializable fields. Covers using transient fields to skip serialization, the readResolve() method for post-deserialization initialization, and custom writeObject()/readObject() methods for full control. Also demonstrates wrapper classes as a solution when you can't modify the original class source code.

    11
22. 22
    Article

    A Java geek·28w

    Transactions and ThreadLocal in Spring

    Deep dive into Spring's transaction management implementation, revealing how it relies on ThreadLocal to bind transaction context to threads. Explores the TransactionSynchronizationManager class that stores transaction resources per thread, and contrasts this with Spring's reactive transaction approach using immutable Context objects. Discusses the challenges Spring faces in migrating to virtual threads (Project Loom) while maintaining backward compatibility with existing ThreadLocal-based implementations.

    11