This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.
The article details how repeatedly calling FileSystem.get(uri, conf, user) created distinct UserGroupInformation objects, inflating the static FileSystem cache and causing a heap‑memory leak that triggered an Out‑Of‑Memory error, and explains that using the two‑argument get method or explicitly closing instances resolves the issue.
This tutorial demonstrates adding JsonPath to a Spring Boot project, using DSL‑style expressions to extract authors, titles, counts and filtered data from a sample JSON payload, and shows how to drive the extraction dynamically via configurable mappings with fastjson and hutool.
This article demonstrates how to use Java reflection in Spring Boot projects to automatically enforce naming conventions and coding standards, thereby enhancing code quality, maintainability, and scalability while providing practical demo steps and code examples.
The article compares redundant and normalized storage, explains their trade‑offs, and introduces an in‑memory aggregation technique implemented via a repository "fill" method in Java, showing how to replace costly SQL joins with flexible, code‑driven data merging while preserving consistency and performance.
This article provides a comprehensive guide to Spring’s essential infrastructure, covering Java and Spring resource management, environment property handling, type conversion APIs, data binding mechanisms, generic type inspection with ResolvableType, internationalization support, the BeanFactory and ApplicationContext architecture, and the built‑in event system, all illustrated with code examples and diagrams.
This article explains how the @JsonView annotation in Spring Boot lets developers define multiple JSON views to selectively expose fields based on client needs, user roles, API versions, or data aggregation requirements, providing code examples and practical usage tips.
This article walks through creating a server‑side license‑plate recognition system using Spring Boot 3.x, the open‑source Tesseract OCR library, and OpenCV for image preprocessing, covering project goals, Maven dependencies, core service implementations, special‑plate handling, and a REST API controller.
This article examines the performance impact of excessive logging in high-throughput Java services and presents three practical approaches—ThreadLocal-style wrappers, explicit flag propagation, and a decoupled component with an extensible API—to achieve cross-thread request-level log sampling while preserving traceability.
This article explains the WKB binary format, its storage advantages in MySQL and PostgreSQL, and provides step‑by‑step Java code using JTS's GeometryFactory, WKBWriter, and WKBReader to write a Point to WKB, convert it to a hex string, and read it back into a geometry object.
This article walks through how to use the Singleton pattern together with SpringBoot's ScheduledExecutorService to build a reusable asynchronous task manager, recreate Ruoyi's login‑log recording logic, and verify the non‑blocking behavior with a concrete test case.
This article presents fourteen actionable Java backend code‑optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modularization, exception handling, database query reduction, null‑avoidance, strategic use of design patterns, IDE shortcuts, and efficient collection handling—to help developers write cleaner, more maintainable, and higher‑performance code.
This article presents a comprehensive collection of over thirty IntelliJ IDEA debugging features, shortcuts, and advanced techniques—including breakpoint types, conditional breakpoints, remote debugging, and code evaluation—to help Java developers dramatically improve their debugging workflow and productivity.
This article explains Spring's bean creation process, focusing on the populateBean method and the AutowiredAnnotationBeanPostProcessor, and shows why static fields are ignored during field injection while also offering a way to inject them via a non‑static @Autowired method.
This article demonstrates how to use the JDK's built-in command-line and graphical tools—such as jps, jinfo, jvisualvm, jstat, jstack, and jcmd—to monitor JVM performance, analyze GC behavior, inspect thread stacks, and troubleshoot memory and configuration issues in Java applications.
This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, demonstrates the LocalDateTime conversion error caused by MySQL‑connector‑java version incompatibility, shows how upgrading the driver resolves the issue, and shares a cautionary tale about unintended bugs after component upgrades.
This article shows how to use SpringBoot together with the POI‑TL template engine to create Word reports that embed text, images, tables and charts, providing a step‑by‑step guide, code snippets and a reusable utility class for rapid document generation.
This article explains the two‑phase reachability analysis in Java garbage collection, detailing why the object‑graph traversal stage incurs stop‑the‑world pauses, how the tri‑color marking model reveals issues like floating garbage and object disappearance, and describes incremental update and snapshot‑at‑the‑beginning techniques that avoid STW.
The article explains how a binary message on a multilingual public‑restroom sign was decoded by identifying UTF‑8 byte patterns, extracting the first 24 bits to reveal the Chinese character “向”, and providing a Java program that parses the entire bit string into readable Chinese text.
This article provides a step‑by‑step tutorial on installing Flowable‑UI, designing BPMN diagrams, setting up a Spring Boot backend project, configuring the database tables, and using Flowable engine APIs with complete code examples and deployment instructions.
The article explains that RestTemplate is deprecated in Spring 5+, outlines WebClient’s non‑blocking I/O, functional style, streaming support and improved error handling, and provides step‑by‑step code examples for synchronous and asynchronous requests, timeout configuration, and error processing.
This article explains the underlying principles of Nacos as a service registry, covering registration flow, health‑checking, dynamic service awareness, the architecture diagram, key source‑code components, and how service discovery works in Spring Cloud micro‑service environments.
The article warns developers against swallowing exceptions in Java, explains the risks of empty catch blocks using a sample code snippet, and emphasizes the need for proper exception handling to avoid hidden errors and potential termination.
This article introduces the key SpringBoot extension interfaces—including BeanPostProcessor, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, SmartInstantiationAwareBeanPostProcessor, SmartInitializingSingleton, ApplicationContextInitializer, EnvironmentPostProcessor, and the *Runner interfaces—explaining their purposes, usage patterns, and providing concrete code examples to help developers customize and extend SpringBoot applications effectively.
Datadog’s 2024 DevSecOps report reveals that 90% of Java services contain at least one severe vulnerability—far higher than other languages—largely due to indirect dependencies, and stresses the need for comprehensive dependency scanning, prioritized remediation, and robust alert triage to manage the flood of low‑impact automated attacks.
This article presents fourteen actionable Java coding‑style and architecture tips—ranging from using configuration properties and Lombok constructors to modularizing methods, throwing exceptions, reducing DB calls, avoiding null returns, and leveraging IDE suggestions—to help developers write cleaner, more robust backend code.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously after transaction commit, illustrated with a payment‑system logging scenario and complete Java code examples.
The article walks through building a custom OpenTelemetry Java‑agent extension for Pulsar client metrics—migrating from SkyWalking, setting up a Gradle project, using ByteBuddy to instrument methods with advice, registering gauge metrics, packaging the jar, handling common class‑loader pitfalls, and configuring deployment via the OpenTelemetry operator.
This guide explains why MySQL or Java processes can consume 900% CPU, outlines step‑by‑step diagnostics using tools like top, show processlist, jstack, and provides concrete fixes such as adding indexes, disabling slow logs, using caches, and optimizing thread handling.
This article presents LeetCode problem 797, which asks for all possible paths from node 0 to node n‑1 in a directed acyclic graph, explains the DFS approach, lists constraints and examples, and provides complete implementations in Java, C++, C, and Python.
The team successfully employed eBPF dynamic tracing to obtain full Java call‑stack traces from any point in an OpenJDK 8 JVM process with microsecond‑level overhead, without requiring any JVM agents, bytecode injection, or code modifications, making it suitable for production environments.
The article presents a technique that uses a generic AggregateController, dynamic model‑name routing, and a lightweight mapping container to share CRUD logic across dozens of tables, reducing hundreds of API methods to just two controllers while keeping the codebase clean and extensible.
This article demonstrates how to use Spring's MethodReplacer to substitute arbitrary bean methods with custom implementations, covering code preparation, bean registration, handling overloaded methods, and XML configuration, all illustrated with a complete runnable example.
This article examines whether a Service layer in Java Spring projects truly requires interfaces, debunking common arguments, exploring development workflows without interfaces, discussing project structuring for single and multiple implementations, and concluding when interfaces are beneficial or unnecessary.
This article demonstrates how to protect sensitive user information in a Java backend by encrypting data before storage, decrypting and desensitizing it on retrieval, and applying these rules automatically through custom annotations, reflection, and Spring AOP aspects.
This article explains how to lower the learning curve of DDD and CQRS by using structured, standardized, and templated approaches, introduces a Maven archetype for rapid project scaffolding, and demonstrates an IntelliJ IDEA plugin that auto‑generates boilerplate code for aggregate roots, commands, queries, and related components.
This article introduces Spring 6.2’s Parallel Bean Initialization feature, explains its benefits for reducing startup time, provides step‑by‑step code examples for configuring background bean initialization and a bootstrap executor, compares traditional and concurrent initialization timings, and details the underlying implementation in the Spring container.
This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and personal information using SQL string functions, a Java library (sensitive‑plus), and the MyBatis‑Mate Sensitive Jackson plugin, providing complete code examples, configuration files, and test results for backend developers.
This article investigates how Java's java.util.concurrent.ExecutorService thread pools react to exceptions when tasks are submitted via execute versus submit, providing source‑code experiments, observed outcomes, and a detailed analysis of the underlying JDK implementation.
This article explains the theoretical and practical limits of Java String length, covering compiler restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and the JDK9 optimization that changes internal storage.
This article explains the hidden pitfalls of Lombok’s @Builder annotation, demonstrates how it deviates from the classic Builder pattern, and presents safer alternatives such as @Accessors with practical code examples and guidance for mixing required and optional parameters in Java projects.
Learn how to implement multi-version REST APIs in SpringBoot 2.7.16 using a single custom annotation, custom RequestCondition, and HandlerMapping, enabling seamless version control, client compatibility, and flexible business scenarios with clear code examples and testing screenshots.
This article introduces JMH, explains its key features, and presents microbenchmark results comparing thread‑exclusive, thread‑shared, Snowflake, UUID, and Snowflake‑algorithm GUID generation methods under various thread counts, accompanied by the full Java test code.
This article explains how to design a plug‑in architecture for a data‑governance service that can start, stop, add, or upgrade individual tasks at runtime without restarting the whole service, using a custom URLClassLoader, Spring bean registration, XXL‑Job integration, dynamic configuration updates, and a clean unload process.
This article demonstrates how to replace a costly double‑for‑loop that matches two large lists of users with a HashMap lookup, showing performance measurements, the effect of adding a break statement, and detailed Java code examples for backend developers.
This article explains how to design ranking systems for games and social apps, compares database sorting and client‑side approaches, and provides step‑by‑step Java code for implementing Redis‑based counters, leaderboards, performance optimizations, and real‑world use cases.
The article explains why long chains of if‑else are hard to maintain, proposes a rule‑engine architecture with abstract BaseRule, concrete rule classes, and a RuleService that supports AND/OR short‑circuit execution, and evaluates its advantages and drawbacks with Java code examples.
This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.
This tutorial walks through setting up a simple Spring Boot project, adding MyBatis‑Plus dependencies, configuring MybatisX in IntelliJ IDEA, generating entity, mapper, service, and controller code, and handling common connection issues, providing a complete end‑to‑end example of rapid MyBatis development.
This guide shows how to integrate the lightweight LiteFlow rule engine into a Spring Boot application, split complex business logic into reusable components, configure rule files, and use various component types—including switch, condition, and parameterized components—to achieve dynamic orchestration, hot‑reloading, and high scalability.
This article explains the Visitor design pattern, illustrates its structure, and provides a complete Java implementation that lets HR and finance departments process full‑time and part‑time employee data in an OA system without modifying existing classes.
This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using Redis caching and Redisson distributed locks, detailing the design of request lock annotations, unique key generation, and practical code examples for robust idempotent APIs.
The article shows how to replace bulky if‑else logic in Spring Boot by using the strategy pattern together with a factory that autowires all Strategy implementations into a Map, explains the @Autowired semantics for collections, and provides concrete code examples.
This article walks through using the Apache POI and POI‑TL libraries to render Word (.docx) files from custom templates, covering version compatibility, template syntax, data model definitions, and step‑by‑step code examples for text, images, tables, and charts.
This article explains three Redis‑based rate‑limiting approaches—using SETNX for simple counters, ZSET for sliding‑window limits, and a token‑bucket algorithm with List—providing Java code examples and discussing their advantages and drawbacks.
This article explains the concept of a prefix tree (Trie), demonstrates how to build and use it for prefix searches, insertions, and deletions, and provides a complete Java implementation with detailed examples and visual illustrations.
HSF (High‑speed Service Framework) is Alibaba’s high‑performance SOA solution that decouples monolithic applications via non‑blocking RPC, offering service discovery, dynamic routing, grouping, and both synchronous and asynchronous calls, configurable serialization, timeout, and thread pools, and employing patterns such as proxy, chain‑of‑responsibility, observer and decorator.
This article explains the concept, necessity, key characteristics, and step‑by‑step Java implementation of Redis‑based distributed locks, providing code examples and guidance for ensuring mutual exclusion, reliability, and performance in backend systems.
This guide explains how Spring Boot 3.1.10 discovers and loads external configuration files from classpath and filesystem locations, how to customize file names and paths with spring.config.name, spring.config.location, and spring.config.additional-location, and demonstrates merging, profile-specific files, optional prefixes, wildcards, imports, and handling missing resources.
A programmer discovers a binary message on a multilingual restroom sign, deduces it uses UTF‑8 encoding, explains the encoding rules, and provides a Java program that converts the binary sequence into the Chinese character "向", demonstrating practical UTF‑8 decoding.
This guide walks you through setting up Spring AI, configuring model providers and vector stores, initializing a Spring Boot project, adding OpenAI credentials, and running a complete RAG (Retrieval‑Augmented Generation) demo with code snippets and sample API calls.
This article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that automatically extracts SpringBoot controllers, simplifies HTTP request debugging, supports multiple request bodies, pre‑ and post‑scripts, reflection calls, cURL import, Apifox export, global API search, and even provides a static resource server.
This article provides a comprehensive overview of Netty's core layers, protocol support, transport services, logical architecture, various I/O models, packet framing techniques, custom protocol design, write‑and‑flush behavior, off‑heap memory management, and high‑performance data structures such as FastThreadLocal and HashedTimerWheel.
When converting Date parameters in OpenFeign calls, the client serializes them to strings using the local CST timezone, causing a 14‑hour discrepancy that can be resolved by using timestamps, @DateTimeFormat, or custom formatters on both client and server sides.
This article demonstrates how to integrate JWT token authentication and role‑based access control (RBAC) into a Spring Boot backend using Spring Security, covering model classification, dependency setup, user details implementation, token utilities, filters, configuration, and login handling with code examples.
Bloom filters are space‑efficient probabilistic structures that answer “definitely not” or “maybe” membership queries, with a controllable false‑positive rate derived from bit array size, element count, and hash functions, and can be implemented via Guava’s Java library, Redisson’s Redis wrapper, native Redis modules, or custom bitmap code, dramatically reducing memory usage and latency in large‑scale systems such as URL deduplication or user‑product checks.
The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.
This article explains how to analyze and optimize Spring Boot Docker images by using the new layer‑building feature in Spring Boot 2.3, restructuring Dockerfiles, and employing multi‑stage builds to eliminate duplicate layers, dramatically shrink image size, and speed up image pushes.
This article explains the concept of Service Provider Interface (SPI), demonstrates how Java's ServiceLoader, Spring's SpringFactoriesLoader, and Dubbo's ExtensionLoader implement SPI, compares their configurations and capabilities, and discusses advanced features such as adaptive extensions, IOC/AOP integration, wrappers, and auto‑activation.
This article explains why Caffeine’s default scheduler (disabledScheduler) does not trigger RemovalListener on expired entries, details the three cache cleanup strategies, compares the four built‑in schedulers, and shows how to configure a functional scheduler with code examples.
This article explains Spring's Resource abstraction, its key methods, built‑in implementations, and how to use ResourceLoader, ResourcePatternResolver, and ResourceLoaderAware for flexible resource access in Spring Boot 2.7 applications.
This article describes a Java data isolation solution that adds an 'env' field to tables, uses a MyBatis interceptor to rewrite SQL for environment‑aware queries, and introduces custom annotations with AOP to selectively skip environment checks, detailing implementation, challenges, and best practices.
This article explains the challenges of synchronizing billions of order records to Elasticsearch, outlines the design of the ECP service that automates heterogeneous data integration, and details its implementation including multi‑source reading, SQL parsing, dynamic rate limiting, retry mechanisms, SPI‑based extensibility, environment isolation, health‑check, smooth migration, and logging.
IntelliJ IDEA 2024.1 introduces full‑line code completion powered by a local deep‑learning model, Java 22 language support, a revamped terminal, sticky lines in the editor, enhanced Maven handling, improved debugging, richer Spring assistance, advanced HTTP client features, and new database tools, all aimed at boosting developer productivity and safety.
This article shares a detailed ByteDance backend interview experience covering three rounds, summarizing essential topics such as Java HashMap internals, Spring circular dependencies, MySQL indexing, OS process/thread concepts, networking protocols, TLS handshake, HTTP/2 features, and common design patterns, providing concise explanations and practical tips.
This article explains the purpose, usage patterns, JVM-level object header and monitor mechanisms, lock state transitions, and lock‑upgrade strategies of Java's synchronized keyword, providing code examples and visual diagrams to illustrate how thread synchronization is achieved internally.
This article explains the Chain of Responsibility design pattern, demonstrates its use for multi‑step product validation and a reimbursement workflow in Java with Spring, provides UML diagrams, configuration handling, concrete handler implementations, client execution code, and discusses the pattern’s advantages and drawbacks.
Spring supports constructor, setter, and field injection, but field injection is discouraged; @Autowired (Spring‑specific, by‑type) and @Resource (standard, by‑name) differ in defaults and IDE warnings, so prefer constructor injection for required beans, setter injection for optional ones, and only use @Resource for unavoidable field injection to lessen container coupling.
Java 22 introduces twelve enhancements—including seven preview and one incubator features—spanning language syntax, APIs, performance, and tooling, with detailed explanations of each JEP’s purpose, value, and impact on developer productivity and code readability.
This guide walks through setting up Flink CDC with MySQL on SpringBoot 2.7, covering binlog configuration, Maven dependencies, Java implementation for real‑time change capture, startup options, a custom Redis sink, and a web UI for monitoring the streaming pipeline.
This guide explains why batch processing is essential for API tuning and provides step‑by‑step techniques—including bulk database operations, request merging, pagination, parallel execution, caching, and monitoring—backed by concrete Java code samples and SQL queries to help engineers dramatically improve throughput and latency.
By replacing ZooKeeper’s default WatchManager hash‑set tables with concurrent maps and bitmap‑based structures, the authors cut watch‑related heap usage from several gigabytes to under 12 MB, lowered lock contention, and achieved 5‑6× latency gains, delivering up to 91 % memory reduction and ten‑fold SLA improvement in production clusters.
IntelliJ IDEA 2024.1 introduces full line code completion, enhanced Java 22 support, a revamped terminal with visual enhancements, sticky lines in the editor, improved indexing for Java and Kotlin, scalable UI, language injection in string templates, upgraded logging workflow, and a redesigned Conflicts Detected dialog.
This article introduces a Java library that simplifies file and resource download handling in Spring MVC and WebFlux by using annotations, reactive programming, customizable handlers, source factories, concurrent loading, compression, response writing, and event‑driven logging to support a wide range of download scenarios.
This article explores solutions for managing multiple data sources in a Spring application, covering dynamic routing with AbstractRoutingDataSource, configuration‑file and database‑table approaches, AOP‑based source switching, and custom multi‑transaction handling to ensure consistency across heterogeneous databases.
This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.
This guide explains how to implement a robust, re‑entrant distributed lock using Redisson in a Spring Boot 2.7 application, covering basic and asynchronous APIs, Maven dependency setup, YAML configuration, custom annotation, AspectJ implementation, and comprehensive test cases.
This article introduces IntelliJ IDEA’s advanced debugging features, such as conditional breakpoints and the Evaluate Expression tool, demonstrating how to set up and use them with Java code examples to quickly locate and fix runtime errors.
This article compares JWT and session authentication, explains their differences, advantages, and drawbacks, and provides a complete Java implementation with Redis integration, token generation, validation, renewal, and related interceptor configuration for a robust backend authentication system.
This article explains the challenges of using WebSocket in a microservice environment, introduces a load‑balancing library that forwards messages between service instances, shows how to enable it with Spring annotations, and details the underlying connection, subscription, and selector mechanisms for reliable message routing.
This article explains why globally unique identifiers are needed in performance testing, compares several common solutions such as Java UUID, Redis/Zookeeper distributed ID generators, the Snowflake algorithm, and thread‑local or shared counters, and provides complete Java code examples for each approach.
Learn how Cross-Origin Resource Sharing (CORS) works, when it’s needed, the role of preflight requests, essential HTTP headers, and step-by-step Spring Boot solutions—including @CrossOrigin annotations, global configuration, and custom filters—to securely enable cross-domain calls in your applications.
This guide explains why Tomcat’s default settings are unsuitable for production, then walks through JVM memory tuning, thread‑pool adjustments, connector optimizations, and security hardening to dramatically improve stability and throughput on various server configurations.
The article presents a Huawei OD interview problem where numbered basketballs are inserted into a linear bucket and can be removed from either end, describes the input and output formats, provides a simulation-based solution using double‑ended queues, and includes reference implementations in C++ and Java.
The article shows how to efficiently load 300,000 MySQL rows in Java by comparing MyBatis and plain-JDBC batch inserts, demonstrating that batching 1,000‑5,000 records per transaction with proper transaction control, connection pooling, and MySQL tuning reduces insertion time from hours to seconds.
This article introduces Spring Data JPA's Query by Example (QBE) feature, explains its benefits and limitations, and provides step‑by‑step code examples—including entity definition, repository setup, and various query scenarios—illustrated with SQL output and screenshots.
This article provides a comprehensive guide on using Jenkins Pipeline to automate the deployment of Java backend projects, covering pipeline concepts, parameterized builds, code checkout, Maven compilation, JAR packaging, remote uploading, backup, update, and service restart procedures.
This article describes the challenges and technical solutions for synchronizing billions of order records from a relational database to Elasticsearch, including multi‑source data reading, dynamic rate limiting, retry strategies, SPI‑based service integration, environment isolation, health‑checking, smooth migration, and structured logging, all implemented in a backend service called ECP.
This article introduces WeBlog, a Spring Boot + Vue 3.2 based front‑and‑back end blog, details its core features, module structure, technology stack, provides repository links and demo credentials, and showcases screenshots of the admin dashboard and user interface.
