This guide shows how to create a Spring Boot and MyBatis interceptor that captures SQL execution, builds a hierarchical call tree, and visualizes it with D3.js, providing performance monitoring, statistics, and thread‑safe management for complex query debugging.
This article explains why developers should first grasp the seven SOLID principles before diving into design patterns, illustrating each principle with clear Java examples, before‑and‑after code, and practical benefits such as reduced risk, easier testing, looser coupling, and greater extensibility.
This article explains how to implement secure, time‑limited file access in Spring Boot 3 by generating signed URLs, covering the underlying mechanism, configuration properties, utility classes, REST endpoints, and testing procedures with full code examples.
This article introduces JDFrame/SDFrame, a JVM‑level DataFrame library that provides a more semantic and concise API for Java 8 stream processing, showcases quick start steps, detailed API categories such as filtering, aggregation, grouping, sorting, joining, and explains the differences between SDFrame and JDFrame with practical code examples.
When an HSF service receives a parameter created with Java 9's immutable collection factories such as Set.of(), the default Hessian2 serializer drops the collection elements, causing a NullArray InvalidObjectException and resulting in a SERVER_SERIALIZE_ERROR on the server side, which can be avoided by using mutable collections or a compatible serializer.
This article explains how to automate the handling of common entity fields such as creation time, update time, and user identifiers in Java backend services by using MyBatis-Plus automatic filling, custom AOP aspects, multi‑data‑source configuration, distributed ID generation, and auditing techniques, dramatically reducing boiler‑plate code and bugs.
This article shares practical strategies for optimizing MyBatis‑Plus CRUD operations in massive‑data scenarios, covering query, insert, update, delete, batch processing, and database‑level tuning to keep performance stable when tables exceed ten million rows.
This article provides a comprehensive interview‑style analysis of Server‑Sent Events (SSE), covering its definition, 20‑year history, core features, data format, Java Spring Boot implementation, client‑side EventSource usage, detailed comparison with WebSocket and other polling techniques, and a decision guide for choosing the right real‑time communication protocol in modern AI‑driven applications.
This article explains how to replace repetitive try‑catch blocks in Java backend development by using Spring's @ControllerAdvice for centralized exception handling, leveraging Assert assertions and custom enum‑based error codes to create clean, maintainable code and consistent API responses.
This article introduces Spring Integration, explains its core concepts such as messages, channels, endpoints, adapters, filters, and transformers, compares it with traditional middleware, and provides detailed XML and Java configuration examples for channels, endpoints, adapters, transformers, routers, integration patterns, interceptors, and a practical order‑processing workflow.
Feat is a high‑performance Java web service framework that offers a SpringBoot‑like development experience while delivering faster startup, lower memory usage, higher request throughput, and built‑in AI‑native and cloud‑native capabilities, making it a compelling alternative for modern backend development.
The article walks through replacing MyBatis with MyBatis‑Plus in a legacy project, explains the LocalDateTime conversion errors caused by version changes in MyBatis and mysql‑connector‑java, shows how upgrading the JDBC driver resolves the issue, and shares lessons on cautious component upgrades and testing.
This article concludes the "From Zero Hand‑write Mini Netty" series, walking through the evolution from a simple single‑thread NIO program to a multi‑threaded, pluggable Mini‑Netty framework with heartbeat, decoding, and responsibility‑chain processing, and outlines future plans for a full‑featured Netty chat application.
This article introduces MyBatis-Plus, explains its core zero‑invasion features such as effortless single‑table CRUD, powerful Lambda condition builders, and a rich plugin system, then provides practical guidelines and code examples for building secure, high‑performance DAO layers in microservice back‑ends.
This comprehensive guide explores Tomcat’s mature architecture, detailing its connector and container components, the underlying design patterns such as composite, observer, and template method, and the custom class‑loading mechanisms that enable modularity, hot‑reloading, and isolation for Java web applications.
This article compares MyBatis’s fully‑annotation mode and the mixed interface‑plus‑XML mode, outlining their implementation examples, advantages, disadvantages, and providing guidance on selecting the appropriate approach based on project size, query complexity, and team collaboration needs.
Discover how to dramatically speed up Java Maven multi‑module project creation by using a custom IntelliJ plugin that generates full module structures, configures dependencies, and applies best‑practice settings in seconds, complete with installation methods, usage tips, and troubleshooting advice.
This tutorial walks you through creating a reusable BaseController in Spring Boot using MyBatis‑Plus, introducing a utility class for dynamic query building, configuring pagination support, and extending the controller for any entity to instantly gain full CRUD, list, pagination, sorting, and count operations.
This article introduces UniHttp, a declarative HTTP‑client framework for Java that replaces traditional HttpClient/OkHttp code with annotation‑driven interfaces, shows quick‑start setup, explains all supported annotations, lifecycle hooks, custom client configuration, and a real‑world enterprise integration example.
This article explains how improper use of ThreadLocal in Java can lead to memory leaks and OutOfMemoryError, outlines common scenarios that trigger OOM, and provides best‑practice solutions such as proper removal and alternative ThreadLocal types.
This article shares five practical techniques for using Wenxin Code's Zulu and Chat agents—covering context provision, automatic command execution, rule constraints, inline chat, and Git commit shortcuts—to make AI‑generated Java code more reliable, maintainable, and aligned with project standards.
This article explains the fundamentals of distributed tracing in microservice architectures, details the OpenTracing standard, examines SkyWalking’s design, sampling strategies, context propagation, and plugin development, and shares practical implementation experiences and performance comparisons, helping engineers choose and integrate effective tracing solutions.
An in‑depth comparison of Oracle JDK and OpenJDK covers their origins, licensing, feature sets, release cycles, performance benchmarks, security updates, and practical migration guides, helping developers choose the right JDK for production environments and avoid costly legal or stability pitfalls.
This article explains how to handle downstream API rate limits that differ per platform by interleaving requests with a weighted round‑robin algorithm, shows the pitfalls of simple sleep‑based throttling, and provides complete Java code for a practical implementation.
This article explains how to design server‑side read/write idle detection and heartbeat mechanisms in a Mini‑Netty framework, covering the theory of heartbeats, idle event handling, a priority‑queue scheduler, and complete starter code with Java NIO examples.
This article explores the execution rules of Java's finally block, showing when it may be skipped, how it interacts with return statements, and how return values are affected, illustrated with multiple code examples and detailed analysis.
This article explains the Chain of Responsibility design pattern, outlines its typical application scenarios, and demonstrates two practical implementations—a multi‑step product creation validation and an expense‑approval workflow—showing how to configure, assemble, and execute handler chains dynamically in Java.
This article walks through JDK 17’s most impactful language upgrades—including records, sealed classes, pattern matching, text blocks, var inference, enhanced switch, and new APIs—explaining their syntax, practical use cases, and how they simplify Java code while improving performance and maintainability.
This article introduces the Liteflow rule engine, explains its architecture, component types, EL rule syntax, data context handling, Spring Boot configuration, and demonstrates a real‑world e‑commerce order processing scenario with code examples and diagrams.
This article introduces a custom IntelliJ IDEA plugin that automates the creation of Maven multi‑module projects, allowing developers to generate full directory structures, pom dependencies, and configuration files with a single command, dramatically reducing setup time from minutes to seconds.
This article presents ten practical techniques—including lazy loading, lazy database initialization, selective auto‑configuration, log level tuning, JVM flags, dependency trimming, bean optimization, JIT tweaks, classpath scanning reduction, and DevTools restart—to dramatically reduce Spring Boot application startup time.
This article explains Java's reverse domain naming convention, shows a typical Maven project layout, and outlines how using reversed domain prefixes in package names prevents naming conflicts, ensures global uniqueness, enhances readability, and supports logical layering of code modules.
This article walks through building a simple Calculator interface, creating a dual‑mode implementation, and then dynamically loading, registering, and unloading user‑supplied JAR files at runtime using reflection or Spring annotation processing, complete with utility methods and a test harness.
This article presents a free, continuously updated PDF collection of 161 Spring Boot 3 practical cases that demonstrate core utility classes, complete code snippets, and expected outputs, helping backend developers quickly master common Spring tools and patterns.
This article explains ThreadLocal's role in Java concurrency, the memory‑leak risk when its remove() method is omitted, introduces the new ScopedValue feature in JDK 20 as a safer alternative, and demonstrates practical Spring and StructuredTaskScope examples with complete code snippets.
This article deeply analyzes ShardingSphere-JDBC 5.3.0 source code, explaining its JDBC‑compatible sharding design, modular architecture, adapter pattern implementation, SQL parsing and routing, distributed transaction support, elastic scaling, performance optimizations, and extensibility via SPI.
This article walks through creating a reusable MyBatisPlus‑based controller framework for Spring Boot, covering dependency setup, utility methods for query building and reflection, a generic BaseController with full CRUD endpoints, pagination configuration, and concrete controller extensions, enabling rapid development of RESTful APIs.
The article critiques absurd interview questions, then presents a practical Java solution for compressing strings by replacing consecutive characters with their counts, explains the algorithm’s O(n) time and O(1) extra space, discusses edge cases like multi‑digit counts and Unicode handling, and offers implementation tips.
This article explains why controllers are essential yet often over‑engineered, identifies common problems such as tangled validation and inconsistent responses, and demonstrates how to unify return structures, handle String conversion, apply JSR‑303 validation, create custom validators, and centralize exception handling using Spring Boot features.
The article explains the Copy‑On‑Write (COW) technique, its read‑write separation design, step‑by‑step flow, practical demos, Java's CopyOnWriteArrayList implementation, and MySQL InnoDB MVCC usage, while also discussing its performance benefits and inherent limitations.
This article explains how to redesign a Java NIO server by introducing a Netty‑style pipeline that separates decoding, logging, authentication, and business handling into independent handlers, improving extensibility, maintainability, and performance while providing complete sample code and initialization steps.
This article explains how Java’s native serialization can expose plain‑text passwords, illustrates real‑world breaches, and shows how using the transient keyword together with encryption, library replacement, security frameworks, and penetration testing creates a five‑layer defense against serialization attacks.
This article examines common default configuration issues in SpringBoot—such as Tomcat connection limits, HikariCP pool size, JPA lazy loading, Jackson timezone handling, logging, caching, file upload limits, async execution, and transaction timeouts—and provides practical adjustments to improve performance and reliability in production environments.
A recent global survey of 500 IT asset managers reveals that 73% of enterprises faced Oracle Java compliance audits, with many spending over $500,000 annually on licensing issues, prompting a massive shift toward open‑source Java alternatives like OpenJDK.
MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement offering zero third‑party dependencies, flexible QueryWrapper support, superior CRUD speed, advanced relational mappings, built‑in data masking, caching, multi‑datasource handling, and customizable SQL auditing, making it a compelling alternative to MyBatis‑Plus for modern Java backend development.
This article explains traditional session mechanisms, the challenges of session handling in clustered environments, explores session sharing strategies, introduces single sign‑on concepts, compares CAS and OAuth2, and provides complete Java code examples for implementing SSO with Redis.
This article explains why a Java application using the Kingbase JDBC driver may encounter SocketTimeoutException during reads, analyzes the underlying socket timeout settings in both the driver and Druid connection pool, and provides a step‑by‑step solution to correctly configure timeouts and avoid repeated failures.
This article combines a look at big‑tech work intensity with a comprehensive interview guide covering website request flow, DNS resolution, HTTP status codes, TCP four‑way handshake, Java abstract classes vs interfaces, HashMap vs ConcurrentHashMap, HashSet internals, MySQL functions, and SpringBoot startup steps.
This article explains why duplicate code harms maintainability and demonstrates three practical techniques—factory/template method patterns, annotation‑driven reflection, and bean‑mapping utilities—to refactor Java backend services and dramatically reduce redundant implementations.
This guide explains how Spring Boot starters simplify dependency management, how the Spring Boot starter parent centralizes version control, and how to use the built‑in Maven plugin and DevTools for automatic restarts, including step‑by‑step Maven and IntelliJ configurations with code examples.
This article introduces MyBatis-Plus as a zero‑intrusion enhancement to MyBatis, explains its core values of convenience, safety, and compatibility, details CRUD methods, condition builders, plugin mechanisms, and best‑practice guidelines for building efficient, secure backend services.
This article introduces MyBatis-Flex, a lightweight yet powerful MyBatis enhancement framework that boosts development efficiency with type‑safe QueryWrapper, extensive features like multi‑tenant and data encryption, supports dozens of databases, and delivers 5‑10× performance gains over MyBatis‑Plus, complete with a step‑by‑step quick‑start guide.
Jeandle, the new open‑source JVM JIT compiler from Ant Group, uses LLVM to bring advanced optimization and code generation to Java, promising dramatic performance gains and a roadmap that includes full bytecode support and cutting‑edge Java‑specific optimizations.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to integrate LLVM’s high‑performance optimizations into the JVM, offering faster execution, future roadmap details, and insights into JIT and LLVM fundamentals for Java developers.
This article evaluates the efficiency of inserting massive data into MySQL using Java, comparing three strategies—MyBatis without transactions, plain JDBC with and without transactions, and JDBC batch processing—showing that batch processing combined with transactions yields the fastest insertion speed for hundreds of millions of rows.
This article explains how to design a standardized JSON response format for Java back‑end APIs, introduces a Result wrapper class, and shows how to automate response wrapping using a custom @ResponseResult annotation, interceptors, and Spring's ResponseBodyAdvice for cleaner, more maintainable code.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to boost Java performance by integrating LLVM’s optimization capabilities into the JVM, explaining JIT and LLVM fundamentals, its architecture, and an ambitious roadmap toward full bytecode support and advanced optimizations.
This article deeply explores the sequential consumption mechanisms of RocketMQ and its derivative DDMQ, comparing their source‑code implementations, detailing producer ordering, broker locking, consumer locking, and the architectural differences that allow DDMQ to achieve ordered processing with only proxy‑side locks.
This tutorial demonstrates how to validate incoming JSON payloads in Spring Boot 3 by generating JSON Schemas, creating a custom filter that checks request bodies before they reach business logic, and registering the filter, complete with code examples and test screenshots.
This tutorial walks you through adding optical character recognition to a Java SpringBoot project using the Tess4j library, covering prerequisites, dependency setup, engine initialization, RESTful API creation, and tips for improving accuracy with custom training data or third‑party services.
The article reviews decades of Java evolution, evaluates JSP, Struts, Hibernate, Servlet and other legacy tools against real‑world usefulness, interview relevance, and learning value, and advises developers on which technologies to drop and which fundamentals to master.
This guide shows how to use IntelliJ IDEA's diagram feature to visualize, clean up, and explore Java Servlet inheritance hierarchies, including removing irrelevant classes, viewing method details, zooming, adding related classes, and jumping directly to source code.
This article walks through the ten most useful Spring extension points—including global exception handling, custom interceptors, bean access, @Import usage, startup runners, BeanDefinition modification, initialization callbacks, BeanPostProcessor hooks, destroy callbacks, and custom scopes—providing clear explanations and ready‑to‑use code examples for each.
This article explains the purpose, responsibilities, and typical pitfalls of six common Java objects—PO, DAO, BO, DTO, VO, and POJO—illustrates their flow in different architectural models, and recommends tools and best‑practice patterns for efficient conversion and clean layer separation.
This article explains how to use SpringBoot, AOP, and a custom annotation to dynamically switch between MySQL master and slave databases, automatically falling back to the master when a slave fails, and covers configuration, code implementation, and multi‑source extensions.
This article explains why JVM stack overflow is a critical issue, illustrates common causes such as uncontrolled recursion and massive thread creation, provides practical stack‑size tuning guidelines, special‑scenario adjustments for SpringBoot and cloud‑native deployments, and outlines diagnostic tools and monitoring metrics to detect and avoid crashes.
This tutorial walks you through adding Spring Security to a Spring Boot project, from adding the starter dependency and creating a simple controller to observing the default login page, understanding the auto‑generated password mechanism, and customizing usernames and passwords for production use.
This article introduces MyBatis-Plus, explains its core zero‑injection CRUD capabilities, demonstrates powerful condition builders, plugin extensions, and best practices for secure, efficient data access, including custom query objects, micro‑service integration, and advanced mapper customization, helping developers boost backend productivity.
During the Double‑11 shopping festival, a leading e‑commerce platform suffered a P0 outage when its Eureka service‑discovery cluster overloaded, triggering a full‑chain failure that lasted 2 hours 42 minutes and caused losses exceeding 1.2 billion yuan; the article dissects the timeline, root causes, capacity mis‑planning, monitoring gaps, and remediation strategies.
This article explains how to create a Spring Boot starter that lets you toggle between the native @Scheduled scheduler and XXL‑JOB at runtime via a configuration property, automatically scanning annotated methods, disabling Spring's tasks, and registering them as XXL‑JOB jobs with proper logging.
This article walks through a systematic, interview‑style guide for sizing and configuring JVM heap, young generation, GC choice, and related parameters to reliably support a platform that processes one million login requests per day on an 8 GB memory node.
This article explains how the volatile keyword guarantees visibility of shared variables and prevents instruction reordering in Java, covering the Java Memory Model, memory barriers, practical code examples, and the Happens‑Before principle for reliable multithreaded programming.
Learn how to perform comprehensive Excel CRUD operations in Spring Boot 3 using the Fillo library, covering environment setup, Maven dependency, SELECT, INSERT, UPDATE, DELETE, fuzzy search, distinct queries, and row/column configuration, complete with code snippets and result screenshots.
This article introduces the lightweight Jackson‑jr library for Java, demonstrates how to create JSON objects and arrays, use the Composer API, customize serialization with annotations, and presents JMH performance comparisons showing Jackson‑jr’s superior speed over Jackson‑databind and Gson in Spring Boot 3.4.2 environments.
This article analyzes why MyBatis foreach batch inserts become extremely slow with thousands of rows, explains the underlying parsing and PreparedStatement overhead, and presents faster alternatives such as ExecutorType.BATCH, Java‑side loops, and MyBatis Dynamic SQL batch support.
Spring Boot 4, built on Spring Framework 7, introduces elegant API versioning, streamlined Bean registration, null‑safety annotations, simplified HTTP proxy creation, upgraded SPEL, GraalVM native support, Jackson 3.x, newer Servlet/WebSocket versions, and numerous other enhancements, offering developers more powerful and convenient tools.
This tutorial walks through using Jakarta JSON Processing and Binding APIs in a standalone Java application, demonstrating how to create, serialize, and deserialize JSON with JBang, complete with code samples and required dependencies.
Upgrading a Kubernetes cluster from CentOS 7.9 to Ubuntu 22.04 caused Java pods to crash with OOMKilled errors; increasing memory limits only hid the issue, and the root cause was cgroup v2 making the JVM misinterpret its resource limits, resulting in excessive threads and heap sizes. The article advises upgrading to a JVM that supports cgroup v2 or reverting the node to cgroup v1.
This article introduces JDFrame/SDFrame, a JVM‑level DataFrame‑style library that provides a more semantic and concise API for Java 8 Stream processing, covering dependency setup, quick start, filtering, aggregation, distinct, grouping, sorting, joining, and advanced features such as percent conversion, partitioning, ranking, and missing‑data replenishment.
This article walks through the fundamentals of Java's AbstractQueuedSynchronizer, covering lock‑queue relationships, CLH lock internals, dummy head nodes, state management, and step‑by‑step implementations of acquire, addWaiter, acquireQueued, shouldParkAfterFailedAcquire, and release methods, complete with runnable example code.
This article introduces JDFrame/SDFrame, a JVM‑level DataFrame‑style library that offers a more semantic and concise API for Java 8 streams, provides quick‑start instructions, detailed code examples, and a comprehensive overview of its SQL‑like operations such as filtering, aggregation, distinct, grouping, joining, and pagination.
This comprehensive guide walks Java beginners through installing IDEA and JDK, explains Spring Boot 3 fundamentals, demonstrates project creation with Spring Initializr, shows Maven standard layout, configures a simple Hello World REST controller, and covers essential topics such as POM files, GAV coordinates, Maven Wrapper, static resources, templates and unit testing.
This article explains how to overcome the single‑threaded bottleneck of Java NIO by introducing a Boss‑Worker architecture, detailing the design of multiple Selectors, thread binding, client implementation, performance considerations, and provides complete open‑source code examples.
This article explores the fundamentals of token renewal, analyzes common pitfalls, and presents five practical schemes—including single‑token, blacklist, double‑token, automatic renewal, and distributed‑environment solutions—while offering a comparison matrix, selection guidance, and best‑practice recommendations for secure, high‑performance authentication systems.
This article explains how overly broad try‑catch blocks dramatically degrade Java backend performance, demonstrates the hidden cost of throwing exceptions with benchmark data, and provides a three‑step precise‑catch strategy that can boost throughput by up to ten times.
This comprehensive tutorial explains database sharding concepts, types, strategies, and implementation in Spring Boot using ShardingSphere, covering configuration, entity and repository code, service and controller layers, integration with pagination, Swagger, ActiveMQ, security, batch processing, FreeMarker, WebSockets, AOP, performance testing, FAQs, real‑world cases, and future trends.
This article provides a step‑by‑step tutorial on configuring Spring Boot to work with MinIO, covering YAML settings, property binding, utility classes for file upload/download, controller and service implementations, key technical points, and best‑practice recommendations for scalable backend file storage.
Sa-Token is a lightweight, open‑source Java permission framework that offers zero‑configuration login, role and permission checks, session management, SSO, token customization and distributed support, providing developers with a simple yet powerful solution for securing backend applications.
This article explores the JVM bytecode instructions behind Java’s synchronized keyword and CAS mechanism, detailing monitorenter/monitorexit, ACC_SYNCHRONIZED flags, static synchronization, and the underlying Unsafe.compareAndSetInt implementation with example code and analysis.
This article examines the core differences between Java's synchronized keyword and the Lock interface, covering their principles, performance, flexibility, visibility guarantees, reentrancy, interruption handling, and practical selection guidelines with code examples, tables, and real‑world scenarios to help developers choose the appropriate locking mechanism.
This article explains why traditional if‑else logic hampers complex business rule maintenance and demonstrates how to create a flexible Spring Boot 3 rule engine using strategy and registry patterns, complete with interfaces, implementations, a registry, an engine, and a REST controller for testing.
This comprehensive guide explains how to design high‑quality Spring Boot controller layers, covering architecture planning, RESTful API conventions, parameter validation, unified response structures, exception handling, logging, security, testing, asynchronous processing, and performance optimization with practical code examples and clear best‑practice recommendations.
This article walks through a real‑world scenario where replacing MyBatis with MyBatis‑Plus caused a LocalDateTime conversion exception due to changes in MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, demonstrates how to pinpoint the root cause via stack traces, and provides step‑by‑step fixes including driver upgrades and version considerations, while also sharing lessons learned from related validation bugs.
This article dissects the MySQL connection process in Java, measuring each handshake and authentication step with Wireshark to reveal why establishing a single database connection can consume around 200 ms, and why connection pooling is essential for high‑traffic applications.
This article introduces JDFrame, a JVM‑level DataFrame‑style library that provides a more expressive, SQL‑like API for Java 8 streams, shows how to add the Maven dependency, demonstrates common operations such as filtering, grouping, sorting, joining, and explains the differences between SDFrame and JDFrame with practical code examples.
This article explains what network programming is, why it matters beyond HTTP, compares BIO and NIO models, dives into Java NIO's design with selectors, channels, and ByteBuffer methods, provides full server/client code examples, and shows how Netty simplifies high‑performance networking.
The article explains the purpose, configuration, and core implementation of StarRocks' TabletChecker component, detailing how it periodically scans OlapTable tablets, evaluates their health through multiple checks, and hands unhealthy tablets to the TabletScheduler for repair.
The article explains how inconsistent API return types, missing error handling, irrelevant or complex parameters, and lack of proper result objects lead to maintenance headaches, and demonstrates a disciplined approach using a generic ResultBean, standardized controller conventions, and Spring AOP for logging and exception handling.
This article deeply explores the ordered consumption mechanisms of RocketMQ and its derivative DDMQ, explaining the implementation differences, source‑code details of sequential sending, broker locking, client‑side processing, and compares the two systems' approaches to guarantee message order.
The article presents a step‑by‑step analysis of how to shrink a 11‑second API response to 170 ms by applying batch database writes, Redis pipeline, asynchronous processing, thread‑pool design, local‑memory buffering, MQ integration, and other performance‑tuning patterns, backed by real‑world benchmarks and code samples.
