This article explores the powerful new features introduced in JDK 17—including records, sealed classes, pattern matching, enhanced switch expressions, text blocks, and the ZGC garbage collector—showing how they simplify code, improve readability, and boost performance for modern Java development.
This article walks through integrating the open‑source Flowable BPM engine into a Spring Boot 3 application, covering Maven dependencies, YAML datasource and Flowable settings, thread‑pool configuration, process modeling with the Flowable UI, deployment, and APIs for starting, querying, completing, and rejecting workflow instances, all illustrated with code snippets and screenshots.
This guide presents fifteen practical Spring Boot performance techniques—from lazy initialization and context indexing to JVM tuning, connection‑pool tweaks, caching strategies, JSON serialization, and native image compilation—providing concrete configurations, code snippets, and best‑practice advice for faster startup, lower memory usage, and higher throughput.
This article explains how to replace repetitive try‑catch blocks in Spring applications by using @ControllerAdvice, custom Assert utilities, and enum‑based exception definitions, providing a clean, unified error‑handling mechanism with consistent response structures and environment‑aware messaging.
This article describes the design and implementation of a high‑performance log‑analysis system for massive MyBatis logs, covering problem analysis, technology selection, architecture, multithreaded parsing, flexible regex templates, performance monitoring, pitfalls, optimization practices, results, and future plans.
This tutorial walks through integrating the Retrofit HTTP client into Spring Boot using the retrofit‑spring‑boot‑starter, covering dependency setup, interface definition, token handling, global interceptors, and essential configuration such as logging, timeouts, and retry policies.
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.
This article explains six common and dangerous pitfalls when using Spring's @Transactional annotation, illustrates each with problematic code examples, and provides concrete best‑practice solutions to ensure correct transaction propagation, self‑invocation handling, exception rollback, data source consistency, transaction scope, and method visibility.
This article introduces Liteflow, a lightweight yet powerful Java rule engine that enables developers to orchestrate complex serial and parallel business flows using concise XML/JSON/YAML definitions, supports hot‑deployment, multiple scripting languages, and provides detailed usage examples, component types, configuration, and a real‑world e‑commerce scenario.
The article walks through swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL driver, shows how upgrading mysql‑connector‑java resolves the issue, and warns that component upgrades can trigger cascading bugs that require thorough testing.
This article explains the challenges of moving AI agents from demo to production, compares native framework and non‑intrusive observability solutions, and provides a step‑by‑step guide to integrate Spring AI Alibaba with LoongSuite's Java agent for OpenTelemetry‑based monitoring.
This article explores the most impactful Java 17 enhancements—including records, sealed classes, pattern matching, text blocks, var, improved switch expressions, stream API upgrades, enhanced NullPointerException, new garbage collectors, and the foreign memory access API—showing how they simplify code, boost performance, and modernize Java development.
This article walks through various Java retry mechanisms—including manual loops, static and dynamic proxies, AOP, Spring Retry annotations, and Guava‑retry—explaining their implementations, advantages, drawbacks, and when to choose each approach for robust remote service calls.
This article explains why read‑write separation is essential for high‑concurrency applications, discusses its limitations, and provides a step‑by‑step Spring Boot implementation—including datasource configuration, routing logic, context management, custom annotations, AOP handling, and usage examples—complete with code snippets and diagrams.
During a Double‑11 promotion, a massive request timeout caused order success rates to plunge, but by using Arthas, jstack, and targeted code analysis, the team identified a non‑thread‑safe HashBiMap in a global cache, halted the outage, and implemented fixes to prevent future failures.
This article explains how enterprise architects can integrate ONNX‑based machine‑learning inference directly into Java applications, covering tokenizer integration, GPU acceleration, deployment patterns, and lifecycle management to achieve secure, scalable, and observable AI services without relying on Python runtimes.
This guide explains why Java struggles with high‑performance or data‑intensive workloads, introduces GPU acceleration with CUDA, compares integration options such as JCuda, JNI, and JNA, walks through a practical encryption use case with performance benchmarks, and provides production‑grade best practices for memory, threading, testing, security, and deployment.
This article explores the most impactful Java 17 enhancements—including records, sealed classes, pattern matching, text blocks, var, enhanced switch, and new APIs—showing how they simplify code, improve readability, boost performance, and modernize Java development for both beginners and seasoned programmers.
Learn how to prevent message loss in RabbitMQ by addressing three critical failure points—producer‑to‑broker, broker storage, and broker‑to‑consumer—using publisher confirms, durable queues with persistent messages, cluster mirroring, and manual consumer acknowledgments, complete with Java code examples.
This article introduces LatchUtils, a lightweight Java utility that streamlines asynchronous task registration and waiting, compares it with manual CountDownLatch and CompletableFuture approaches, and demonstrates how it reduces boilerplate while keeping business logic clear and maintainable.
This article explains LeetCode problem 1749, which asks for the subarray with the maximum absolute sum, and shows how prefix sums reduce the task to tracking minimum and maximum prefix values, providing full reference implementations in Java, C++, Python, and TypeScript.
This article explains why JSON field mismatches cause backend failures in microservice architectures and presents three robust Spring Boot solutions—using a Map, Jackson's JsonNode, and @JsonAnySetter/@JsonAnyGetter—to flexibly and safely adapt dynamic JSON structures.
Discover how Java 17’s new features—record classes, sealed classes, pattern matching, text blocks, enhanced switch expressions, var type inference, improved Stream API, and better NullPointerException messages—streamline code, boost readability, and increase performance, with practical examples and tips for modern Java development.
The article explains what a GC spike (Garbage Collection Spike) is, analyzes its typical causes such as large short‑lived objects, memory leaks, and heap configuration, presents a real‑world high‑concurrency case study, and details step‑by‑step JVM tuning and architectural strategies that reduced latency spikes and raised service availability from 95% to over 99.99%.
Sa-Token is a lightweight, open‑source Java authentication framework that offers zero‑configuration login, permission checks, session handling, single sign‑on, and extensive features, with simple one‑line APIs and high extensibility for backend and security development.
Explore the hidden power‑ups of Spring Boot—including @Conditional, @ConfigurationProperties, Actuator, DevTools, Retry, Cache, testing strategies, custom starters, Admin UI, and CLI—through concise explanations and complete code examples that demonstrate how to boost development efficiency and build production‑ready applications.
This article walks through the design and implementation of a simplified TikTok‑style recommendation system using Spring Cloud microservices, covering business requirements, service decomposition, Eureka registration, Feign clients, Redis and Kafka integration, circuit‑breaker fallback, and end‑to‑end testing.
Learn how to generate various QR codes in Java—including login tokens, promotional URLs, and temporary visitor codes—by analyzing use cases, selecting the ZXing library, and following step‑by‑step code examples with best‑practice tips and common pitfalls.
This article explains how oversized database query results can cause JVM memory spikes and OOM errors, and shows how to use MyBatis interceptors to monitor, limit, and protect memory consumption with non‑intrusive code, Prometheus metrics, and configurable thresholds, ultimately improving system stability and performance.
This article provides a comprehensive technical guide covering Java bytecode structure, the seven-stage class lifecycle, JIT compilation, memory layout, garbage‑collection algorithms, execution engine details, and both static and dynamic bytecode enhancement techniques such as ASM, Javassist, and Java agents.
This guide shows how to integrate springdoc‑openapi 2.7.0 with Spring Boot 3.5.6 to generate an online Swagger UI, covering Maven dependencies, configuration class, annotation usage, response wrapper, version compatibility notes, and the URL to access the generated documentation.
This guide walks backend engineers through the fundamentals of object storage, showing how to perform quick OSS uploads, implement multipart uploads for large files, prevent duplicate uploads with MD5 checks, and secure files against malicious content using header validation, content scanning, and bucket isolation.
This article explains how to solve interleaved log lines in multi‑threaded pods by using a TraceId stored in SLF4J MDC, propagating it via HTTP headers, adapting thread pools and Spring task decorators, and integrating SkyWalking to enrich Logback patterns for end‑to‑end request tracing.
This article dives into advanced Jackson capabilities for Spring Boot 3, covering file, stream, byte array, URL, typed Map, JsonNode, ObjectNode, and streaming JsonParser techniques, each illustrated with concise code examples to help developers build robust, flexible JSON handling in backend services.
This article explains why storing plain‑text sensitive fields such as phone numbers is unsafe, then demonstrates how to use a custom MyBatis TypeHandler to automatically encrypt data on insert and decrypt it on query, complete with code samples, configuration steps, and test results.
This guide walks you through installing Nacos, configuring a Spring Boot 3.x application for dev, test, and prod environments, using namespaces, Data ID conventions, @RefreshScope for hot updates, and validates the setup with sample code and runtime checks.
This guide walks through building a WeChat mini‑program login system using Java backend services, covering the retrieval of openId and phone number via WeChat APIs, database design, token generation, and request interception for secure authentication.
This article explains why authentication loops occur when external user tokens and internal service tokens are handled together in Spring Security, and provides a step‑by‑step solution using distinct headers, custom filters, and Feign interceptors to break the cycle.
This tutorial demonstrates how to integrate multiple large language models from different providers into a Spring Boot application using Spring AI, configure primary, secondary, and tertiary models, and implement a fallback mechanism with Spring Retry to ensure high availability of the chatbot.
This comprehensive guide explains the fundamentals and practical implementations of task scheduling in Java, covering Linux crontab, JDK Timer, ScheduledExecutorService, Quartz, Spring Schedule, and popular distributed schedulers like SchedulerX, elastic‑job, XXL‑Job and LTS, with code examples and configuration details.
Spring announced that RestTemplate will be deprecated in Spring Framework 7.0 and removed later, outlining a migration path to the newer RestClient for synchronous use and WebClient for reactive scenarios, while providing a timeline and practical guidance for developers.
This article explains how to use Spring Boot's @Sql annotation for integration testing, covering script execution, statement injection, execution phases, grouping, merge modes, and configuration with clear code examples and screenshots.
This guide walks you through configuring Spring Boot for full‑stack internationalization, covering dependency setup, message resource files, application properties, locale resolver and interceptor, controller and service usage, Thymeleaf templates, custom resolvers, testing, and handling static content.
This guide walks through enabling Spring Boot 3.x scheduling, creating simple and complex @Scheduled jobs, configuring thread pools, externalizing cron expressions, conditional execution, exception handling, and provides a complete runnable example with best‑practice tips.
This guide shows how to use the OpenTelemetry Java Agent to instantly add observability—metrics, traces, and error reporting—to long‑standing legacy Java applications without modifying a single line of code, covering setup, environment configuration, health monitoring, performance tracing, and visualizing data in Grafana.
This article explains how Lombok’s automatic getter/setter generation can cause MyBatis to store enum fields as null, details the underlying JavaBeans naming conflict, and also reveals why EasyExcel fails with @Accessor(chain=true) annotations, offering practical solutions for both problems.
This article explains how Java 11‑plus string methods like isBlank(), lines(), repeat(), strip(), indent(), transform(), formatted(), stripIndent() and translateEscapes() simplify prompt construction, AI output cleaning, and data‑processing tasks, offering concise, performant, and AI‑friendly code examples.
This article introduces CompletableFuture, explains its core features and ideal use cases, and provides 50 practical Spring Boot 3 examples covering simple async tasks, chaining, exception handling, timeouts, custom thread pools, HTTP requests, and advanced composition techniques.
This article explains how xxl-job employs Netty HTTP, dynamic proxy patterns, and fully asynchronous processing to achieve efficient remote procedure calls, detailing the communication layer, overall workflow, key design points, and the underlying Java code that synchronously retrieves results from asynchronous operations.
This comprehensive guide explains why reflection configuration is essential for GraalVM native compilation, details Spring Boot 3's reflection mechanisms, enumerates common pitfalls with concrete solutions, and presents best‑practice strategies and tooling to reliably build native images for Java back‑ends.
This guide explains Druid—Alibaba's Java database connection pool—covering its core concepts, Maven dependencies, property configuration, built‑in filters, SQL and slow‑SQL monitoring, Spring AOP integration, ad removal, and how to retrieve runtime statistics via DruidStatManagerFacade, all with complete code examples.
This article presents a complete Java‑based architecture for high‑throughput Doris stream loading, covering project structure, Maven dependencies, configuration properties, field‑mapping annotations, automatic mapper utilities, a robust parallel loader with retry and compression, plus performance tuning recommendations.
In high‑traffic Java applications, massive duplicate error logs hinder troubleshooting; this article introduces a Spring Boot‑based error fingerprint clustering system that generates unique MD5 fingerprints, uses LRU caching, and provides a visual dashboard to intelligently deduplicate, aggregate, and quickly locate root causes, dramatically improving debugging efficiency and reducing storage costs.
This article explains the LRU cache eviction strategy, details its O(1) get and put operations using a combined hash table and doubly linked list, and provides a complete Java implementation with step‑by‑step code examples and design rationale.
This guide walks through the complete architecture, Maven dependencies, configuration classes, annotation‑driven field mapping, utility mappers, a parallel Stream Load core, response handling, and performance tuning for integrating Apache Doris with a Spring Boot backend.
This guide explains why Tomcat may become a bottleneck under high concurrency, shows how to replace it with the lightweight Undertow server in Spring Boot 3, and provides detailed configuration snippets for thread pools, timeouts, request size limits, compression, HTTP/2, access logging, and monitoring recommendations.
JoyAgent‑JDGenie, an open‑source, product‑grade multi‑agent system from JD Cloud, offers a fully‑featured, lightweight, end‑to‑end AI platform with model, tool, memory, agent, and application layers, allowing developers to launch a customized enterprise AI application in just five minutes, deployable locally or via Docker.
Spring Framework 7 will deprecate RestTemplate, outlining a migration timeline, the shortcomings of the classic HTTP client, and introducing RestClient and WebClient as modern alternatives for synchronous and reactive applications, while providing guidance for both new and legacy projects.
This guide walks through IntelliJ IDEA's Debug feature, covering preparation, main interface, service and debug buttons, variable inspection, conditional breakpoints, expression evaluation, frame dropping, force return, multithread, Stream, and remote debugging, complete with code examples and screenshots.
This article explains how to solve interleaved log lines in multi‑threaded pods by propagating a unique TraceId via HTTP headers and SLF4J MDC, integrating the approach with Spring filters, Feign interceptors, thread‑pool adapters, and SkyWalking for end‑to‑end tracing.
This article introduces Graceful Response, a Spring Boot library that provides unified response wrapping, global exception handling, and validation support, showing how it reduces boilerplate code, improves readability, and standardizes error codes across controllers and services.
This article explains a practical method to estimate flight seat occupancy and how many wait‑list passengers can be accommodated, using historical no‑show rates, a two‑stage allocation algorithm, and a Java implementation that produces key operational metrics.
This article explains how to restrict the number of requests to a Spring Boot API within a given time window by using a custom @RequestLimit annotation, a Redis‑backed interceptor, and the necessary configuration to register the interceptor in the application.
This article explains how Java 24 and OpenJDK introduce HTTP/3 via JEP 517, describes the QUIC protocol that powers it, compares performance against HTTP/2, and provides Java benchmark code showing reduced latency and fewer TCP connections when using HTTP/3.
This guide walks through the complete implementation of WeChat Mini Program login, covering front‑end wx.login calls, back‑end code2Session exchanges, database schema design, API specifications, environment configuration, token validation via interceptors, and key security considerations, all illustrated with code snippets and diagrams.
This article explains why defensive programming is crucial for production‑grade Spring Boot 3 applications and presents eight concrete patterns—ranging from Optional‑based NPE safety and collection handling to configuration validation, async management, transaction control, testing, exception handling, circuit‑breaker integration, and reactive programming—each illustrated with real‑world code examples and best‑practice recommendations.
Learn how to efficiently handle upserts in MySQL by leveraging the native DUPLICATE KEY UPDATE feature, simplifying code with a custom MyBatis‑Plus AbstractMethod injector, complete with thread‑safe locking, SQL generation, and integration steps for seamless backend development.
This article explores why API gateways are essential in microservice architectures, outlines core design functions such as routing, load balancing, authentication, rate limiting, and protocol translation, and provides practical code examples, performance‑tuning strategies, technology comparisons, and deployment guidelines for robust backend systems.
This article walks through a complete Netty TCP client demo for IoT messaging, covering project architecture, module layout, business flow, detailed code explanations—including a local BlockingQueue replacement for RocketMQ, thread‑safe client creation with Redis locks, and testing endpoints—providing a practical reference for building robust socket‑based services.
This article explains how Java 24 and OpenJDK add HTTP/3 support, compares its speed to HTTP/2 using benchmark code, and shows why the QUIC‑based protocol delivers lower latency and fewer TCP connections for modern web applications.
This article introduces the Smart-Doc tool for Spring Boot, explains why API documentation is essential, compares common documentation solutions, and provides step‑by‑step instructions—including Maven plugin configuration, JSON settings, command‑line generation of HTML, Markdown, Word, Postman and OpenAPI formats, as well as package exclusion and additional options.
This article explains the concept of enum parameter inversion, shows how to encapsulate enums and add formatting methods in Java and TypeScript, and demonstrates how the technique reduces the number of arguments needed when calling formatting functions.
This article explains the challenges of manual JDBC transaction handling, introduces Spring's unified transaction API with PlatformTransactionManager, TransactionDefinition, and TransactionStatus, demonstrates code examples for programmatic and declarative transactions, and discusses common pitfalls such as non‑public methods, self‑invocation, and exception handling.
JetCache, an open‑source Java caching library, combines local (Caffeine) and distributed (Redis) caches into a multi‑level system, offering annotation‑driven lazy loading, automatic refresh, consistency strategies, cache pre‑warming, monitoring, and safeguards against penetration, avalanche, and memory leaks.
This article explains the powerful flatMap operator in Java streams, covering basic usage, Optional handling, replacing nested loops, API response flattening, combining with filter, reactive programming, and a comprehensive end‑to‑end example, all illustrated with Spring Boot 3 code snippets.
This article explains why upgrading from Java 8 to JDK 17 is essential, detailing new language features such as records, sealed classes, pattern matching, text blocks, var inference, enhanced switch, Stream API improvements, better NullPointerExceptions, modern garbage collectors, and the foreign memory access API, all illustrated with concise code examples.
This article explains the concept of API idempotency, when it should be applied, practical design patterns—including database checks, unique transaction IDs, and Snowflake ID generation—and the core principles for balancing reliability and cost in backend services.
The article introduces JoyAgent‑JDGenie, an open‑source, product‑grade multi‑agent system from JD Cloud, explains its mission to eliminate the last‑mile barrier for rapid multi‑agent app creation, details its layered architecture, recent DataAgent addition, and discusses deployment options and challenges.
This article explains the five SOLID principles—Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—using an order‑processing system example, showing common violations, step‑by‑step refactorings, practical guidelines, and Java code snippets to improve code modularity, maintainability, and extensibility.
This article explains how to add data‑permission filtering to MyBatis‑Plus by creating a custom annotation, implementing a global interceptor, wiring a permission‑handler, configuring the interceptor in the MyBatis‑Plus plugin, and extending the solution with role‑based scopes for advanced use cases.
JDK 17 introduces sealed classes, pattern matching, text blocks, and record types that together transform Java code into a more declarative, concise, and safe style, offering developers modern syntax, reduced boilerplate, compile‑time exhaustiveness checks, and better readability while maintaining performance and ecosystem compatibility.
This guide explains Spring and Spring Boot's highly extensible architecture by detailing nine core extension points, their injection timing, practical uses, and best‑practice recommendations, enabling developers to customize the container lifecycle from startup to runtime.
This article explores the most impactful JDK 17 enhancements—including records, sealed classes, pattern matching, text blocks, improved switch expressions, var type inference, and advanced Stream API features—showing how they simplify Java code, boost readability, and increase performance for developers transitioning from older versions.
This article introduces the open‑source Java utility library Hutool, showcasing how its concise APIs for date handling, file I/O, HTTP requests, encryption, and general utilities can dramatically reduce boiler‑plate code and boost developer efficiency.
This article details a step‑by‑step optimization of a large‑scale Excel import workflow, covering the transition from raw POI to EasyExcel, caching database lookups, batch INSERT statements, and parallel stream processing to reduce a 100k‑row import from minutes to under two minutes.
This article explains the major breaking changes introduced when Spring Boot 4.x upgrades from Jackson 2.x to Jackson 3.x, covering package renames, ObjectMapper builder usage, exception handling, API signature updates, type handling, integration impacts, and step‑by‑step migration strategies.
During a midnight promotion launch, a forgotten TODO caused thread‑pool exhaustion and frequent Full GC, bringing down an e‑commerce service; the article presents a five‑step end‑to‑end JVM tuning methodology, from data collection to root‑cause verification and code fix, showing how to diagnose and resolve such incidents.
Learn how to prevent duplicate execution of Spring Boot @Scheduled tasks in multi-instance deployments by integrating ShedLock, including Maven dependencies, H2 database setup, LockProvider configuration, and annotation usage to ensure each job runs only once across all nodes.
JD Cloud has released JoyAgent‑JDGenie, the first fully product‑grade open‑source Java multi‑agent system that bundles front‑end, back‑end, framework, engine and core agents, supports major LLMs, offers layered architecture, Docker or manual deployment, and showcases demos such as PPT generation and sales analysis.
This article explains how to protect sensitive user information such as phone numbers in a MySQL database by using MyBatis TypeHandler to automatically encrypt data on insert and decrypt it on query, complete with code examples and configuration steps.
This article introduces a custom IntelliJ IDEA plugin that automates the creation of Maven multi‑module Java projects, turning a tedious half‑hour setup into a 30‑second one‑click process, while offering smart dependency wiring, customizable templates, and detailed installation and usage instructions.
This article explains the purpose and usage of Spring Boot’s @PostConstruct and @PreDestroy annotations for bean initialization and cleanup, discusses their migration to Jakarta EE in Spring Boot 3+, and presents modern alternatives such as @EventListener with ApplicationReadyEvent, DisposableBean, and destroyMethod configurations, complete with code examples.
Spring Boot 4.0, currently in preview with a GA slated for November 2025, introduces modular architecture, API versioning, BeanRegistrar, JSpecify null‑safety, GraalVM native image support, virtual threads, and up to 800% performance gains, while outlining a detailed release timeline and migration considerations for developers.
This article explains why @Transactional fails in multi‑threaded Spring services, provides a utility for splitting large data sets, shows thread‑pool configuration, demonstrates a failing transaction scenario, and presents a solution using manual MyBatis sqlSession commit to guarantee atomic rollback across all threads.
An internal sandbox API kept hanging for a week, prompting a deep dive with top, jstack, and Arthas that revealed Redis connection pool threads stuck in wait, leading to configuration tweaks and proper connection release to restore service stability.
This article introduces nine often‑overlooked Spring Boot 3 annotations—including @ConditionalOnExpression, @ConstructorBinding, @EventListener, @Lazy, @EnableConfigurationProperties, @Profile, @Scheduled, @Scope, and @Retryable—explaining their purpose, showing practical code examples, and demonstrating how they improve configuration, immutability, event handling, circular‑dependency resolution, and fault tolerance.
This article explains why many large enterprises forbid the default Tomcat in SpringBoot projects, comparing memory usage, concurrency handling, architectural differences, and configuration flexibility of Tomcat and Undertow, and provides migration guidelines and real‑world case studies.
This article demonstrates how to replace cumbersome if‑else chains in payment processing with Java enums that encapsulate behavior, leveraging functional interfaces, the strategy pattern, and Spring integration to achieve cleaner, extensible, and testable code while adhering to the Open/Closed principle.
This guide walks you through the concepts, environment setup, step‑by‑step integration, advanced configurations, monitoring, troubleshooting, and best practices for combining Dubbo's high‑performance RPC framework with Spring Boot to build production‑grade distributed Java services.
Spring Boot Admin is an open‑source tool that provides real‑time health checks, JVM metrics, log management, environment inspection, JMX control, and customizable alerts for Spring Boot applications, and this guide explains its core features, architecture, quick setup, advanced security, notification, Actuator integration, and production best practices.
