Tagged articles
Java 21
52 articles · Page 1 of 1
The article details a real-world migration from a fixed 200-thread pool to Java 21 virtual threads, showing how serial calls to three 1-second external services caused 50-second tail latencies under load, and how virtual threads eliminated queuing by decoupling waiting from expensive OS threads, while covering pinning risks, ThreadLocal pitfalls, and migration steps.
ConcurrencyJava 21Project Loom
0 likes · 21 min read

This article analyzes why Quarkus is gaining adoption over Spring Boot for cloud-native Java, detailing its build-time processing architecture that eliminates runtime reflection, delivering 2.7x higher throughput, 2.3x faster startup, and 2.2x lower memory usage, with benchmarks, code examples, and migration trade-offs.
ArCBuild-Time ProcessingGraalVM
0 likes · 19 min read

This article analyzes how GraalVM Native Image 23.0 and Spring Boot 3.5 enable millisecond cold starts, 80% smaller containers, and production-ready serverless Java across AWS, Alibaba Cloud, Tencent Cloud, and Azure — with benchmarks, migration steps, and pitfall solutions.
AOT CompilationDockerGraalVM
0 likes · 19 min read

This article details the development of an AI-powered contract review system using RAG and Spring AI, covering the tech stack (Java 21, Spring Boot 3.x, MySQL, Redis, MinIO), document parsing with Apache Tika and PaddleOCR, user roles, and features like clause-level risk detection, version control, and knowledge base management.
AI contract reviewJava 21PaddleOCR
0 likes · 6 min read

With Java 21’s virtual threads making threads cheap, the article examines whether the traditional CompletableFuture async style can be dropped, showing that simple IO can now be written synchronously, while complex task orchestration, fallback, and timeout still benefit from CompletableFuture’s richer API.
Async ProgrammingCompletableFutureConcurrency
0 likes · 10 min read

This tutorial walks through creating a simple Java module, packaging it into a JMOD file, and using jlink to build a custom runtime image that shrinks the size from roughly 400 MB to 28 MB, then demonstrates compiling, inspecting, and running the application.
JLinkJMODJava
0 likes · 8 min read

This article introduces the open‑source spring‑response‑envelope library for Spring Boot 3, showing how a single @ResponseEnvelope annotation can automatically wrap controller results in a standard JSON structure, add metadata, handle errors, expose metrics, and reduce boilerplate code by about 30%.
JavaJava 21Micrometer
0 likes · 11 min read

Spring AI 2.0 RC1 is now on Maven Central, bringing a rebuilt architecture on Spring Boot 4, Java 21 baseline, tool‑calling overhaul, native MCP support, structured‑output enhancements, migration steps, pros and cons, and a detailed comparison with LangChain4j.
Java 21LangChain4jMCP
0 likes · 19 min read

The article examines whether Java 21’s cheap virtual threads can replace traditional thread pools, explaining the original purpose of pools, their role as natural throttlers, scenarios where virtual threads excel or fail, and practical guidelines to avoid pitfalls like pinning.
ConcurrencyJavaJava 21
0 likes · 7 min read

The article examines why many projects still cling to Java 8 and demonstrates eight transformative Java 21 features—including records, sealed classes, pattern‑matching for instanceof, switch expressions, text blocks, virtual threads, structured concurrency, and enhanced APIs—showing code examples and the benefits they bring to performance, readability, and maintainability.
JavaJava 21Records
0 likes · 11 min read

Java 21, the latest LTS release, adds fifteen JEPs but only five—virtual threads, record patterns, switch pattern matching, string templates, and sequenced collections—significantly alter coding style, offering lightweight concurrency, concise data deconstruction, modern switch syntax, powerful string interpolation, and enhanced collection APIs.
Java 21Record PatternsSequenced Collections
0 likes · 8 min read

Spring Boot 4.1 makes virtual threads the default, dramatically increasing I/O concurrency, yet the unchanged HikariCP maximumPoolSize can exhaust connections; the article explains this incompatibility, shows how to adjust pool settings, enable lazy connections, and outlines a step‑by‑step migration path from 3.x to 4.1.
HikariCPJava 21LazyConnection
0 likes · 19 min read

The article critiques the classic interface‑plus‑N‑implementations Strategy Pattern for causing class explosion, then demonstrates how Java 17’s sealed interfaces and records together with Java 21’s pattern‑matching switch provide a more concise, type‑safe, and maintainable modern implementation.
JavaJava 21Sealed Interfaces
0 likes · 7 min read

This article explains why staying on old Java and Spring Boot versions is risky, introduces a dual‑axis model for the upgrade, details Java 21‑to‑25 language and JVM improvements, outlines Spring Boot 3.5‑to‑4.0 structural changes, and provides a step‑by‑step manual and OpenRewrite migration workflow with verification guidelines.
BackendJava 21Java 25
0 likes · 11 min read

The Eclipse Foundation announced Jakarta EE 11, highlighting streamlined data access via the new Jakarta Data spec, support for Java 21 including virtual threads, modernized testing tools, deprecation of Managed Beans, and early certification of several enterprise servers, marking a major step toward cloud‑native Java development.
Jakarta DataJakarta EEJava
0 likes · 6 min read

The article walks through the evolution from Java 8 to Java 21, comparing preview and standard features such as pattern‑matching instanceof, switch expressions, text blocks, the new HttpClient API, var type inference, virtual threads, records, immutable collections, improved try‑with‑resources, sequenced collections, and garbage‑collector enhancements, illustrating each with concrete code examples and practical recommendations.
JavaJava 21Text Blocks
0 likes · 16 min read

This article provides a detailed comparison of Java 17 and Java 21 APIs, listing deprecated and removed features, suggested replacements, new I/O and serialization capabilities, enhanced reflection, Unicode emoji support, the preview foreign memory API, and the Generational ZGC, illustrated with real‑world code examples and usage scenarios.
API changesJavaJava 21
0 likes · 15 min read

This article introduces Java 21 virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed creation, shows how to enable them in Spring Boot with minimal configuration, compares performance against traditional threads, and provides additional Java performance optimization tips.
ConcurrencyJavaJava 21
0 likes · 6 min read

This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, compares performance against traditional threads, and offers additional Java performance‑tuning techniques.
ConcurrencyJavaJava 21
0 likes · 7 min read

This article explains Java 21 virtual threads, demonstrates how to create and use them in plain Java and Spring Boot, compares their performance against traditional threads in large‑scale and HTTP workloads, and offers additional Java performance optimization tips.
ConcurrencyJavaJava 21
0 likes · 6 min read

This article walks readers through upgrading from Java 11 to the Java 21 LTS by explaining the six‑month release cadence, JEP process, and SDKman setup, then demonstrates practical code examples for twelve new features—including preview Unnamed Classes, String Templates, Scoped Values, Structured Concurrency, Vector API, Virtual Threads, and Generational ZGC—highlighting their motivations, benefits, and production considerations.
JDK LTSJVMJava 21
0 likes · 16 min read

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.
ConcurrencyJavaJava 21
0 likes · 7 min read

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.
ConcurrencyJavaJava 21
0 likes · 7 min read

Learn how to enable and test Java 21 virtual threads in Spring Boot 3.2.5, compare their throughput against platform threads with JMeter, and explore performance limits through sample code and benchmarks, revealing when virtual threads excel and their constraints for CPU‑bound tasks.
Java 21Spring Bootbackend development
0 likes · 8 min read

IntelliJ IDEA 2023.3 introduces a production‑ready AI Assistant, full Java 21 support with virtual threads and pattern‑matching switch, a Run‑to‑Cursor debugging feature, a floating toolbar with quick edit actions, out‑of‑the‑box Kubernetes tooling, and numerous UI enhancements for a smoother developer experience.
AI assistantIDE FeaturesIntelliJ IDEA
0 likes · 8 min read

This article evaluates the performance of Spring Boot 3.2's virtual threads versus traditional platform threads when serving static files, using a MacBook Pro M2, Bombardier load testing, and detailed latency and throughput metrics across multiple concurrency levels.
ConcurrencyJava 21Spring Boot
0 likes · 10 min read

Celebrating the Lunar New Year, this roundup shares essential Java 21 updates, Spring Boot 3.2 enhancements, domestic open‑source innovations, and other hand‑picked tools and articles, providing developers with quick links to explore new APIs, performance improvements, and cutting‑edge Java ecosystem resources.
Java 21NacosSpring Boot
0 likes · 5 min read

This article compares Spring Boot 3.2's virtual‑thread support with traditional Tomcat thread pools and reactive WebFlux, showing configuration steps, code examples, JMeter load‑test results, and database access benchmarks to illustrate throughput, CPU and memory impacts.
Java 21Spring BootWebFlux
0 likes · 9 min read

This article evaluates the performance of Spring Boot 3.2's virtual threads when serving static files, comparing them with traditional platform threads across various concurrency levels, and concludes that platform threads slightly outperform virtual threads in this I/O‑bound scenario while suggesting better use cases for database‑driven workloads.
Java 21Spring BootStatic File Server
0 likes · 12 min read

Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.
GraalVMJava 21Native Image
0 likes · 9 min read

This article demonstrates how to use Spring Boot 3.2 with Java 21, enabling virtual threads and GraalVM native images, providing step‑by‑step setup, configuration, and sample code for controllers, async tasks, and scheduled jobs, and discusses performance benefits and considerations.
GraalVMJava 21Native Image
0 likes · 8 min read

The IntelliJ IDEA 2023.3 update introduces the fully launched AI Assistant, complete Java 21 support, enhanced debugging tools, a floating toolbar, out‑of‑the‑box Kubernetes integration, numerous UI improvements, faster Gradle and Maven imports, and a host of new framework and technology features.
AI assistantDeveloper ProductivityIDE
0 likes · 7 min read

JetBrains' IntelliJ IDEA 2023.3 release brings full Java 21 support, a new Run‑to‑Cursor debugging option, floating editing toolbars, color‑coded editor tabs, refreshed macOS icons, enhanced Speed Search shortcuts, and integrates Lets‑Plot for no‑code data visualization, though the AI Assistant remains unavailable in mainland China.
DebuggingIDE FeaturesIntelliJ IDEA
0 likes · 5 min read

This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.
GraalVMJava 21Native Image
0 likes · 8 min read

This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, guiding you through installation, configuration, sample code, and performance benefits of running a Spring application on virtual threads and native compilation.
GraalVMJava 21Native Image
0 likes · 9 min read

This article demonstrates how to use Spring Boot 3.2 together with Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step setup, configuration, and code examples for controllers, async tasks, scheduled jobs, and native compilation.
GraalVMJava 21native-image
0 likes · 8 min read

Spring Boot 3.2, released shortly after Java 21, brings a host of enhancements such as virtual thread support, CRaC checkpoint restore, SSL bundle reloading, improved observability, new RestClient and JdbcClient, Jetty 12, Pulsar, Kafka and RabbitMQ SSL, redesigned nested JAR handling, Docker image build upgrades, and a comprehensive video walkthrough by Josh Long.
DockerJava 21Kafka
0 likes · 7 min read


21CTONov 13, 2023 · Backend Development
Spring Boot 3.2 introduces Java 21 virtual thread support, SSL hot‑reload for embedded servers, GraalVM native image improvements, and a preview of Spring AI, marking a major evolution for Java backend development and performance optimization.
Java 21SSL Hot ReloadSpring AI
0 likes · 4 min read

This article introduces Java 21’s major enhancements—including lightweight virtual threads and generational ZGC—provides code samples for creating virtual threads and enabling ZGC, demonstrates a Spring Boot 3.x application using record patterns, and explains how to monitor Java 21 services with Alibaba Cloud ARMS on ACK.
ARMS MonitoringGenerational ZGCJava 21
0 likes · 12 min read

This guide explains how to enable Java 21 preview features in IntelliJ IDEA 2023.2 by configuring compiler and runtime options, allowing developers to experiment with upcoming language capabilities such as unnamed classes, patterns, and virtual threads.
ConfigurationIDEAJava
0 likes · 3 min read

This guide explains why Java preview features are disabled by default, and provides step‑by‑step instructions with screenshots for configuring IntelliJ IDEA 2023.2 to enable the --enable-preview flag so you can run and test Java 21 preview language features.
IDE configurationIntelliJ IDEAJava
0 likes · 3 min read

Java 21 introduces unnamed classes and a new launch protocol (JEP 445) that dramatically reduce boilerplate, allowing a Hello World program to be written without public, static, or parameter declarations, making the language more beginner‑friendly.
JEP 445JavaJava 21
0 likes · 3 min read

This article explains Java 21's virtual threads, their lightweight nature, and provides step‑by‑step code examples for creating and managing them via static builders, ExecutorService, and thread factories, helping developers improve concurrency and scalability in Java applications.
ConcurrencyJavaJava 21
0 likes · 6 min read

Java 21 introduces repeat() overloads for StringBuilder and StringBuffer, allowing you to duplicate characters or CharSequence efficiently; the article demonstrates usage with sample code, explains the Unicode codePoint variant, and invites readers to explore creative applications of this new API.
Code ExampleJavaJava 21
0 likes · 2 min read

This tutorial shows how to activate Java 21 virtual threads in Spring Boot 3.1 (and earlier versions), provides full configuration code for Tomcat, Undertow and Spring async, and demonstrates a performance test where concurrency gains reduce total execution time by over five times.
ConcurrencyJava 21Spring Boot
0 likes · 5 min read


21CTOSep 24, 2023 · Backend Development
Oracle's Java 21 release introduces virtual threads, record patterns, ordered collections and a preview FFM API, while Eclipse survey data shows rising Spring and Spring Boot usage and accelerating cloud‑native adoption among Java developers.
Java 21Spring Bootbackend development
0 likes · 5 min read

Spring Boot 3.1.4 is now available on Maven Central, adding Java 21 support, a new JavaVersion enum entry, dozens of bug fixes, documentation improvements, and a long list of dependency upgrades for developers building modern backend applications.
Dependency UpgradesJava 21Spring Boot
0 likes · 6 min read

Java 21, the latest LTS release, introduces virtual threads, sequenced collections, record patterns, and other enhancements; the article explains these new features, guides developers on configuring IDEs and runtimes with Azul Zulu and IntelliJ IDEA, and resolves Lombok incompatibility by updating to version 1.18.30.
Java 21LombokSpring Boot
0 likes · 4 min read

This article demonstrates how Java 21's switch pattern matching and record deconstruction let you replace verbose instanceof checks with concise two‑line snippets, even for nested records, dramatically simplifying code that extracts fields from complex objects.
JavaJava 21Record Patterns
0 likes · 4 min read


21CTOSep 20, 2023 · Backend Development
Java 21, the latest long‑term support release, brings 15 JEPs—including string templates, record patterns, virtual threads, and a foreign function API—along with extensive performance, security, and maintenance updates, while extending Java 11 support through 2032.
JEPJavaJava 21
0 likes · 12 min read

This article introduces Java 21’s newly finalized switch pattern matching and record patterns, explains their evolution from earlier JDK releases, and provides side‑by‑side code examples that show how these features dramatically reduce boilerplate and improve readability in Java applications.
JavaJava 21Record Patterns
0 likes · 6 min read

This article introduces Java 21's new Template Expressions, explains how STR and FMT processors enable safe, efficient string interpolation and formatting—including multi‑line strings, arithmetic, method calls, and object fields—while providing practical code examples and best‑practice guidance.
JavaJava 21String Interpolation
0 likes · 8 min read
