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.
This article explains how Spring Batch’s core concepts, chunk processing, metadata management, virtual‑thread integration, partitioning, and multi‑threaded step configurations can dramatically increase throughput and resource efficiency when handling large, I/O‑intensive data sets.
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.
A senior Java developer at Eaton Corporation sabotaged the company's global production system with malicious code before his dismissal, causing a massive outage, data loss, and a four‑year prison sentence, highlighting the severe risk of insider threats and the need for robust access controls and monitoring.
An unexpected NullPointerException occurs when adding a simple log line to a Java DTO, revealing that FastJSON’s serialization process invokes methods like isChinaName(), getXxx(), and isXxx() via ASM-generated serializers, and the article explains the underlying mechanism, common pitfalls, and best‑practice annotations to avoid such bugs.
This article explains how the Model Context Protocol (MCP) bridges large language models and external services by converting OpenAPI specifications into callable tools, covering generation with openapi‑generator, mapping rules, three runtime modes (stdio, streamable, SSE), and implementation details in Java, Python, and Go.
During a gray‑release a single server reported that the Spring container was closed while the Netty server still accepted HTTP requests, leading to an IllegalStateException; the article analyzes the root cause in Dubbo startup, explains the event flow, and proposes a reliable fix using ApplicationReadyEvent.
By merging similar or duplicate requests upstream before sending them downstream, you can dramatically reduce downstream load and boost overall throughput; this article compares Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset, detailing their implementations, configurations, and ideal use cases.
This article explains why Redisson's RMapCache.size() includes expired entries, demonstrates how to obtain the exact number of currently valid key‑value pairs using keySet().size() or readAllEntrySet().size(), and provides performance tips and a real‑world e‑commerce use case.
This guide explains how to replace Spring Boot's default Logback with Log4j2, covering Maven dependency changes, XML/YAML configuration, Java usage examples, advanced options like environment-specific files and asynchronous logging, and common troubleshooting tips.
This article explains why asynchronous execution is essential for reducing latency in Java applications and walks through eight practical implementations—including threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava—complete with code examples and usage tips.
Spring Boot AOP simplifies cross‑cutting concerns such as logging, transaction management, and monitoring by using proxy‑based aspect‑oriented programming; this guide walks through adding dependencies, core concepts, proxy mechanisms, configuration, defining aspects with various advice types, custom annotations, real‑world scenarios, best practices, and troubleshooting tips.
This guide walks you through installing RabbitMQ, configuring Spring Boot, building basic producers and consumers, exploring work, fanout, direct and topic patterns, and applying advanced features like confirmations, manual ACKs, TTL, dead‑letter, delayed and priority queues, plus clustering, monitoring and troubleshooting tips.
This guide explains how to integrate Alibaba's EasyExcel library into a Spring Boot project to perform low‑memory, high‑performance Excel import and export using annotation‑based entity mapping, listener mode, dynamic headers, async processing, validation, templates, and encryption.
This article explains the differences and relationships between processes, threads, coroutines, and virtual threads, provides detailed Java code examples, compares their characteristics and performance, and offers practical guidance on choosing the right concurrency model for various scenarios.
This article combines practical advice for negotiating offers at Tonghuashun with a comprehensive Java interview cheat‑sheet covering method overloading vs overriding, final vs finally, sleep vs wait, HashMap insertion and resizing, reference types, HTTP request structure, status codes, thread‑pool parameters, and garbage‑collection algorithms.
This article explains how Java's BigDecimal class maintains exact decimal precision by scaling numbers to integers, detailing its internal fields, the add method implementation, and a concrete example that demonstrates the underlying computation steps.
Discover how treating the literal string "null" as a legitimate username can cause hidden bugs across frontend validation, backend logic, database integrity, and security, and learn practical code snippets and defensive strategies to detect and prevent these pitfalls.
Redis implements an approximate LRU using random sampling and timestamps, while classic LRU relies on exact access order; the article explains both LRU and LFU fundamentals, their Java implementations, Redis-specific variants, trade‑offs, use‑case recommendations, and configuration tips for selecting the optimal eviction policy.
This article explains the fundamental differences between processes, threads, coroutines, and virtual threads, shows how they are implemented in Java with code examples, compares their performance, and provides practical guidance on choosing the right concurrency model for various workloads.
This article introduces the Java Diff Utils library, explains its core features such as computing differences, applying patches, and generating unified diffs, and provides step‑by‑step Spring Boot 3 examples—including dependency setup, string list comparison, patch generation, application, side‑by‑side view creation, and HTML rendering—for efficient text version control.
This article explains how to simplify Spring MVC controller code by introducing a unified response format, leveraging ResponseBodyAdvice for automatic wrapping, applying JSR‑303 validation for request parameters, creating custom validators, and handling exceptions globally to keep business logic clean and maintainable.
This article explains why thread pools are essential for performance, explores the JDK ThreadPoolExecutor’s internal architecture, parameters, lifecycle states, common pitfalls, and provides practical best‑practice guidelines—including handling invokeAll timeouts, submit exceptions, rejection policies, and pool isolation techniques—to help developers use thread pools safely and efficiently.
This step‑by‑step tutorial shows Java beginners how to create a Spring Boot 3.5.5 application that generates a math‑expression image captcha, stores the answer in session or an in‑memory map, provides REST endpoints, handles CORS, and includes a complete front‑end page with refresh and validation logic.
This guide compiles high‑frequency Java interview questions—from core language concepts and collections to JVM tuning, MySQL indexing, Redis caching, Spring frameworks, micro‑services, and MQ reliability—providing a comprehensive reference for candidates targeting small‑to‑mid‑size companies.
This guide walks you through adding MQTT dependencies, configuring connection parameters, creating a unified MqttConfig class, defining a messaging gateway, implementing service and controller layers, and applying advanced production settings such as SSL/TLS, multi‑topic subscriptions, QoS choices, clustering, health checks, and performance tuning for Spring Boot applications.
This guide explains how Spring Boot 3.x uses Logback by default, shows basic property‑based setup, advanced logback‑spring.xml configurations, profile‑specific logging, SQL tracing with Hibernate, MyBatis, p6spy and datasource‑proxy, plus MDC tracing, async logging, alerting and production best practices.
This guide walks you through creating a SpringBoot parent project, adding common, business, and API‑gateway submodules, configuring dependency management, structuring the repository, isolating logs, and building or running individual modules, while highlighting common pitfalls and best‑practice layouts.
This article provides a comprehensive, step‑by‑step breakdown of Spring Boot's auto‑configuration system, covering its core SPI‑based design, execution flow, conditional annotations, the evolution from spring.factories to the new .imports file in version 3.x, practical examples, custom configuration creation, and debugging techniques.
This guide walks through two approaches for configuring multiple databases in a Spring Boot and MyBatis project—native multi‑data‑source beans and the dynamic‑datasource‑spring‑boot‑starter—covering project structure, Maven dependencies, Java configuration, mapper setup, usage examples, common pitfalls, and a concise summary of when to choose each method.
This article explains how xxl‑job uses Netty HTTP, dynamic proxies, and fully asynchronous processing to implement a high‑throughput RPC mechanism, detailing the communication layer, overall workflow, and the clever design that wraps async calls into synchronous‑looking code.
The article introduces a self‑built utility that automatically generates Java backend code—including entity classes, DAO interfaces, service implementations, and controllers—based on database table definitions, dramatically reducing the manual effort of creating dozens of tables and their associated CRUD logic.
This article explains why traditional database search struggles with large data sets, introduces Lucene as a high‑performance full‑text engine, and shows step‑by‑step how to integrate it into Spring Boot 3 using Hibernate Search, custom analyzers, entity mapping, repository extensions, and test cases.
This guide explains why adding the javacv‑platform dependency inflates a Java project's JAR to hundreds of megabytes and shows how to configure Maven to include only the needed native libraries, dramatically reducing size, build time, and deployment overhead.
This guide lists the 15 most common MyBatis pitfalls—from SQL injection and mismatched field mappings to N+1 queries and improper pagination—paired with concrete best‑practice solutions, code snippets, and configuration tips to make your persistence layer safer, more efficient, and easier to maintain.
This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.
This tutorial walks through using Zhihu's open‑source FUST microservice framework together with DeepSeek's language model API to design, implement, and deploy a scalable, high‑performance intelligent Q&A system, covering architecture, data models, service layers, and deployment scripts.
This article examines common token‑renewal pitfalls and presents five practical solutions—including single‑token, blacklist, double‑token with triple validation, automatic renewal, and distributed‑environment techniques—while offering best‑practice guidelines to enhance security, user experience, and system scalability.
This tutorial walks you through setting up a Spring Boot project with Tess4J, adding required dependencies, configuring language data, implementing an OCR service and REST controller, and testing both local file and remote URL image recognition, all with complete code examples.
Brian Goetz, Java language architect, outlines his vision for a more growable Java by introducing the “witness” concept, discussing underlying philosophy, potential new features like numeric types, operator overloading, collection expressions, and how these ideas fit into the Valhalla project and Java’s future roadmap.
This article explains how to handle JSON objects with unknown or dynamic fields in Java using Jackson's @JsonAnySetter to collect extra properties into a Map and @JsonAnyGetter to serialize them back as regular fields, complete with practical code examples and common pitfalls.
This tutorial walks through integrating SpringDoc into a Spring Boot project, covering why it replaces SpringFox, how to configure it with minimal settings, add API annotations, set up grouped documentation, and handle static resources and Spring Security for full Swagger UI access.
This article explains how to migrate a Java application from JPA 2.x to Jakarta Persistence 3.0 by updating Maven dependencies, replacing javax.persistence imports with jakarta.persistence, adjusting XML namespace URLs, and renaming configuration properties, all illustrated with concrete code snippets.
This article explains how timeless design patterns—from Singleton to Builder—continue to enhance code reuse, maintainability, and team collaboration in cloud‑native and microservice systems, while also highlighting practical applications, performance trade‑offs, and common pitfalls.
This tutorial walks through adding the required Maven dependencies, configuring application.yml, creating SwaggerConfig, implementing sample controllers, accessing the enhanced Knife4j UI and Swagger UI, troubleshooting common issues, and comparing SpringDoc OpenAPI with Knife4j OpenAPI3 to help developers choose the right solution for Spring Boot 3.x projects.
This article provides a comprehensive comparison of JWT and Token‑Redis authentication schemes, covering their underlying principles, Java implementations, advantages and disadvantages, performance and security trade‑offs, suitable use‑cases, and practical guidance for choosing the optimal solution in modern web and mobile applications.
Tree-sitter is a high‑performance incremental parsing library that supports over 50 languages; the article explains its core features, typical use cases such as editor syntax highlighting and static analysis, and walks through a concrete multi‑language SQL extraction implementation in Java, Python, and XML.
This article introduces four of Spring Boot’s expression engines—Groovy, MVEL, JEXL, and JSP EL—showing how to add their Maven dependencies, run concrete code examples, and provides practical guidance on selecting the right engine based on performance, feature richness, and integration ease.
Password reset security relies on the server storing only salted hash values, not the original passwords; this article explains why plain‑text storage is unsafe, outlines hash algorithm types, demonstrates MD5’s shortcomings, and provides Java code for generating SHA‑256 + salt hashes.
This guide outlines the mandatory code changes required when moving from JDK 8 to JDK 17—such as removed modules, internal API restrictions, and compiler flag updates—and highlights optional optimizations like var inference, collection factories, switch expressions, records, text blocks, enhanced Stream and Random APIs, with practical examples and migration steps.
This article explains Java generics, their benefits such as type safety, readability, code reuse and performance, and shows how type erasure works by demonstrating that two differently typed ArrayLists compare equal at runtime, revealing the underlying implementation details.
This article examines script injection threats in Java applications and compares static, dynamic, and interactive security testing tools—SAST, DAST, and IAST—highlighting their strengths, weaknesses, and popular options to help developers select the most suitable solution.
This article explains how using a bitmap can reduce the memory needed to store billions of integers from about 15 GB to under 500 MB, describes the bitmap concept, introduces Bloom filters, outlines their principles, advantages, common use cases, and provides Java and Redis code examples for implementation.
This article explains Java reflection—a powerful feature used by frameworks like Spring and MyBatis—covering its core concepts and demonstrating five practical ways to invoke methods, access fields, handle static and private methods, and work with superclass methods using concise code examples.
This article provides a comprehensive guide to Spring Batch, covering its purpose, supported business scenarios, core components and interfaces, Maven setup, sample job definitions, parallel execution, decision flows, nested jobs, data reading and writing, validation processing, and REST‑based job scheduling, all illustrated with complete code examples.
This article compiles essential Spring and Java utility methods—including assertion checks, object and collection handling, file I/O, resource management, and reflection/AOP tools—providing concise code examples and usage guidelines to help developers avoid redundant code and write cleaner, more reliable applications.
Explore 11 practical Spring Boot bean registration methods—from simple @Component scanning to advanced ImportSelector, FactoryBean, and runtime dynamic registration—detailing code examples, use cases, and configuration steps, enabling developers to choose the optimal approach for flexible, modular applications.
Oracle’s latest LTS release, JDK 25, introduces compact source files, streamlined module imports, enhanced constructors, memory‑efficient compact object headers, AI‑friendly features like pattern matching and the Vector API, plus performance and security improvements, while aiming to make Java more approachable for beginners.
Explore eight practical techniques for achieving asynchronous execution in Java—from low‑level threads and Futures to Spring’s @Async, ApplicationEvent, message queues, and Guava ListenableFuture—complete with code samples, performance insights, and best‑practice recommendations for building responsive backend services.
