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.
This article explains how to build a Maven‑based tool that scans a Java codebase, removes trivial getter and setter methods, adds Lombok’s @Data annotation, and rewrites the source files using JavaParser, complete with implementation steps, code examples, and usage instructions.
This article explains how to use Jenkins Pipeline to automate the deployment of a Java backend project, covering pipeline basics, parameterized builds, GitLab branch checkout, Maven compilation, JAR packaging, remote file transfer, backup, update, and service restart with Docker Swarm.
This article presents Liteflow, a lightweight yet powerful Java rule engine that supports XML/JSON/YAML rule files, multiple storage backends, and hot‑deployment, and demonstrates its components, configuration, and a real‑world e‑commerce workflow example with code snippets.
Graceful Response is a Spring Boot library that provides unified response wrapping, global exception handling, custom error codes, validation support, and configurable response styles, enabling developers to write cleaner controller code, reduce boilerplate, and improve API consistency.
This article explains how to create custom predicate and gateway filter factories in Spring Cloud Gateway, covering the underlying concepts, implementation steps, example code, and YAML configuration to tailor routing conditions and request handling for specific business needs.
This article explains the Fork/Join model and Java's ForkJoinPool, covering the divide‑and‑conquer algorithm, custom RecursiveTask implementation, core pool design, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing with code examples and practical guidelines.
A legacy Java project using MySQL, MyBatis 3.5.0, and an old mysql‑connector‑java version encounters a Conversion not supported for java.time.LocalDateTime error after switching to MyBatis‑Plus, and the article walks through root‑cause analysis, version upgrades, and practical fixes.
This article walks through the evolution of system architecture from monolithic to microservices, explains Spring Cloud Alibaba components, introduces Nacos for service registration and discovery, provides step‑by‑step installation and integration instructions, and includes code snippets for a Spring Boot project.
The article examines which Java backend technologies are considered obsolete—such as JSP, Struts, Hibernate, and others—by applying criteria like practical usage, depth of understanding, and interview relevance, and advises learners on what to drop, prioritize, or master for modern development.
This guide demonstrates how to use Spring's @Resource annotation to inject collections such as Map, List, and array, as well as single beans, and explains resolution strategies like @Priority, @Primary, BeanFactory, ApplicationContext, @Qualifier, and custom qualifiers.
This article introduces the open‑source Java library Disruptor, explains its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step demo with Maven dependency, event model, factory, handler, and a Spring‑Boot test illustrating high‑throughput producer‑consumer messaging.
This article provides an in‑depth overview of WebSocket, covering its definition, advantages and disadvantages, protocol details, connection lifecycle, message format, JavaScript and Java APIs, Spring Boot integration, performance considerations, and future development directions.
This article explains how Java's System.gc triggers full or concurrent garbage collection in NIO scenarios, detailing the JVM's handling of out‑of‑memory errors during memory‑mapped file operations and direct buffer allocations, and examines the behavior across various garbage collectors such as Serial, Parallel, G1, ZGC, and Shenandoah.
This article explains how to implement IP‑location lookup by recommending the free ip2region offline library, provides Maven dependency details, shows step‑by‑step Java code for loading the XDB file, querying an IP address, interpreting the result format, and highlights its high accuracy and cross‑region support.
This article introduces Alibaba's Druid JDBC connection pool, walks through a basic Java usage example, details essential configuration parameters, and demonstrates a multithreaded concurrency test to evaluate performance and stability in MySQL environments.
This article explains how to use Java Flight Recorder (JFR) and JProfiler for low‑overhead, production‑grade performance analysis, covering JFR advantages, process discovery, file generation commands, JProfiler features, memory and CPU profiling techniques, and includes practical code examples.
This guide explains how to define Spring AOP aspects with @Aspect, configure ProxyFactoryBean for fine‑grained proxy control, and create proxies programmatically using ProxyFactory, providing complete code examples and configuration details for Spring 6.1.2.
This article explains the main lock mechanisms used in concurrent and distributed Java applications—including pessimistic, optimistic, distributed, reentrant, spin, shared, read/write, fair, non‑fair, interruptible, segment, and lock‑upgrade techniques—along with their characteristics, usage scenarios, and sample SQL or Java code snippets.
The article guides beginners through command‑line Java execution, showing how JDK 8 requires explicit compilation and class‑path, JDK 11 introduces single‑source file launching without compilation, and JDK 22 extends this to multi‑file programs, allowing direct execution of several source files with a simple java command.
This article explains how configuration management evolves from simple local files in monolithic applications to centralized, dynamic configuration centers like Nacos for microservices, covering code examples, registration, deregistration, viewing, change subscription, and guidance on choosing a service registry.
This guide walks through reading local or network images in Java, creating a Graphics2D canvas, and applying either a red semi‑transparent text watermark or a scaled image watermark at pixel‑specified coordinates before saving the result as a PNG file.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, compares their performance and memory usage through load tests, and demonstrates why Undertow is a better choice for high‑concurrency Java web applications.
A real‑world bug caused by incorrect year‑week calculation is explained, then the ISO‑8601 week‑based year definition and Java's LocalDate/WeekFields APIs are introduced to reliably compute the correct year and week for any date.
This article explains how to dynamically manage multiple data sources and ensure transaction consistency across a master and several application databases in Spring by extending AbstractRoutingDataSource, using configuration‑file and database‑table solutions, and implementing a custom multi‑database transaction manager.
This article examines the detailed steps and performance impact of creating a MySQL connection from a Java web application, measures the latency of the handshake and authentication using Wireshark, and demonstrates why connection pooling is essential for high‑traffic services.
This article explains how to handle log files that are too large to fit into memory by reading them line‑by‑line with Java streams, using a Counter class and BitSet to track service usage and efficiently generate a top‑10 report.
This article introduces Spring's BeanWrapper, explains how to set and retrieve simple and nested properties, demonstrates indexed and key‑based access, covers automatic and custom type conversion using PropertyEditorSupport and Converter, and clarifies conversion priority and registration details for backend developers.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, uncovers the root cause of a LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, demonstrates version upgrades and code fixes, and shares a related production bug and its remediation.
This article investigates the time overhead of establishing MySQL database connections in Java web applications, detailing the TCP handshake, authentication steps, and measured latency using Wireshark, and demonstrates why connection pooling is essential to avoid hundreds of milliseconds per request.
The article analyzes high coupling problems caused by multiple controller calls and third‑party integrations in a Java settlement backend, and proposes a dedicated TPS microservice with unified Feign interfaces, enum‑based routing, and factory patterns to decouple frontend and backend logic while providing implementation examples and diagrams.
This article examines the internal read/write mechanisms of Java's FileChannel and MappedByteBuffer on Linux kernel 5.4, compares their performance through detailed source analysis and benchmarks, and explains why MappedByteBuffer often outperforms FileChannel for small I/O but can be overtaken for larger transfers due to page‑fault and dirty‑page handling.
This article introduces a Java library that simplifies file download in Spring applications by using a @Download annotation, supporting various source types, reactive and servlet environments, concurrent loading, compression, and customizable handlers, and details its architecture, code examples, and practical considerations.
This article explains how to achieve zero‑downtime releases for Java applications by using JVM shutdown hooks, Spring context events, and service‑registry tricks for both monolithic and microservice architectures, with concrete code samples, configuration details, and Kubernetes probes to ensure seamless online upgrades.
This article details a step‑by‑step investigation of a container whose memory usage spiked to 99% due to large objects being allocated to the old generation under G1GC, explains the root cause, demonstrates reproducible tests with JVM flags and monitoring tools, and provides practical mitigation strategies.
The article explains that Java database connection pools rely on blocking I/O and JDBC design rather than IO multiplexing, detailing the technical, architectural, and ecosystem reasons why multiplexed DB access is uncommon despite its potential performance benefits.
This article walks through Spring 6.1.2’s bean creation lifecycle, from the refresh entry point to property population, initialization, and disposable bean registration, illustrating each step with concise code examples and detailed explanations.
Although IO multiplexing can boost performance, most Java applications continue to use connection pools like c3p0 or Tomcat because JDBC is blocking, DB protocols require multiple sessions, and integrating NIO drivers into existing web containers adds significant complexity and ecosystem constraints.
The article describes a production OOM incident caused by downloading a 2.4 GB file, walks through GC log and heap‑dump analysis using MAT, identifies the problematic use of FileUtils.readFileToByteArray, and presents streaming and external storage solutions to prevent memory exhaustion.
This guide demonstrates how to use Spring's UriComponentsBuilder and related classes—UriBuilderFactory, ServletUriComponentsBuilder, and MvcUriComponentsBuilder—to construct, encode, and link URIs in various scenarios, providing clear code examples for each step, including handling templates, query parameters, and servlet contexts.
A tech roundup reveals Sam Altman's candid take on OpenAI’s branding, China’s sweeping ban on foreign CPUs, Apple’s AI partnership talks for iOS 18, and Oracle’s Java 22 release, highlighting how policy, funding, and new tools are reshaping the AI landscape.
This article analyses the challenges of protecting intellectual property in B2B Java applications, reviews existing obfuscation and encryption tools, and proposes a lightweight Maven‑based encryption plus javaagent decryption scheme that secures both proprietary code and third‑party dependencies while keeping performance impact below five percent.
This article explains common causes of extreme CPU usage in MySQL and Java applications, provides step‑by‑step troubleshooting methods using Linux tools and SQL commands, and presents real‑world case studies with concrete optimizations such as indexing, caching, and thread‑handling adjustments.
Java 8’s Stream API introduces a declarative, lazy-processing model for collections, and this article details multiple ways to create streams—including from collections, arrays, static factory methods, files, generators, and iterators—providing code examples and explanations to help developers harness its expressive and efficient data‑handling capabilities.
ThreadLocal in Java provides thread‑local variables by maintaining a per‑thread map, enabling data isolation, simplifying inter‑thread data transfer, and storing context information, while requiring careful handling to avoid memory leaks, thread‑pool contamination, and overuse.
This article provides a comprehensive guide to Java SE exception handling, covering the concepts and classifications of checked and unchecked exceptions, the try‑catch‑finally structure, custom exception creation, exception chaining, and best‑practice recommendations for writing robust, maintainable Java code.
This article explains how to integrate Apache Kafka into a Spring Boot project, covering dependency setup, producer and consumer configuration, code examples, and optimization tips to build a high‑throughput, reliable message processing system.
This article explains why Java's String class is immutable, detailing the benefits such as thread safety, cached hash codes, and string pooling, and describes the internal mechanisms—including a private final char array, creation of new objects on concatenation, and the intern method—that enforce this immutability.
This article recounts the end‑to‑end design, bottleneck analysis, and iterative performance tuning—including MySQL, Redis, RocketMQ, compression, sharding, and connection‑pool adjustments—that enabled a volunteer registration platform to meet demanding high‑concurrency and data‑accuracy requirements under limited resources.
This article explains how to build a high‑performance, dynamically configurable rate‑limiting utility for Java applications using Caffeine cache with a 1‑second refresh interval, covering data structures, limit‑checking logic, dynamic configuration, and sample code with test results.
This article explains how to diagnose and resolve severe CPU usage spikes—up to 900%—in MySQL and Java processes, detailing step‑by‑step identification, common causes such as missing indexes or excessive garbage collection, and practical remediation techniques including query optimization, indexing, caching, and thread analysis.
This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.
