This article explains the stateless nature of HTTP, compares session‑based and token‑based authentication, describes JWT structure and security considerations, and provides Java code examples for implementing login, token generation, verification, and extraction in a backend application.
This comprehensive guide introduces Java's CompletableFuture, explains its advantages over the traditional Future API, demonstrates how to create and compose asynchronous tasks, manage thread pools, handle timeouts and cancellations, and apply robust exception handling techniques for reliable concurrent programming.
This article deep‑dives into Spring Boot’s inner workings, explaining why dependency versions are omitted, how the spring‑boot‑starter‑parent and spring‑boot‑dependencies manage libraries, and how the composite @SpringBootApplication annotation orchestrates @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan to achieve seamless auto‑configuration and rapid application startup.
FastExcel is a Java library that builds on EasyExcel to provide higher performance, low‑memory streaming, and additional features such as PDF conversion, offering simple APIs, full compatibility, and detailed code examples for creating entity classes, listeners, and read/write operations.
This article walks you through configuring Spring Cloud for dynamic property updates, covering dependency setup, enabling bootstrap, defining configuration properties, exposing a refresh endpoint, and listening to EnvironmentChangeEvent, all illustrated with complete code snippets and screenshots.
This guide presents a comprehensive set of practical strategies—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction sizing, program refactoring, pagination, SQL tuning, and lock granularity—to dramatically reduce API latency in Java backend services.
This article explains how to improve backend performance by fetching independent report data concurrently using Java's Future, Callable, CompletableFuture, and FutureTask classes, provides code examples for each approach, and compares their principles, usage patterns, and cancellation capabilities.
This article demonstrates how to add Apache Tika dependencies to a Spring Boot project, configure tika-config.xml, create a Java configuration class, and use the injected Tika bean to detect, translate, and parse various document formats such as PDF, PPT, and XLS.
This article compares Java's built‑in synchronized keyword with the explicit ReentrantLock class, covering their underlying implementations, performance differences across JDK versions, feature sets such as fairness and interruptibility, lock release mechanisms, and best‑fit scenarios for each approach.
This article explores common overselling problems in high‑concurrency flash‑sale scenarios and presents seven practical solutions—including lock timing adjustments, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—each illustrated with SpringBoot code and performance test results.
This chapter explains how to build a Java-based performance testing engine by dissecting common testing requirements, illustrating queue and throttling models through a supermarket analogy, and presenting thread‑based and TPS‑based designs with code examples and future extensions.
The article explains the DDD rich (or active) model, its core characteristics, compares it with the anemic model, and shows how to apply it in a shared‑rental billing domain using Java, DDD layers, domain events, and a lightweight framework.
This article presents a comprehensive design for securing third‑party API calls by generating unique Access Key/Secret Key pairs, defining permission granularity, implementing signature generation with timestamps and nonces, handling token lifecycle, and providing concrete Java and SQL code examples for practical deployment.
This article explains the concept of plugin mechanisms in Java and Spring Boot, covering benefits, common implementation approaches such as ServiceLoader and custom configuration, detailed code examples, and practical guidance for building extensible backend systems.
This article explains three backend solutions—database polling with scheduled tasks, JDK DelayQueue, and Netty's HashedWheelTimer—for automatically cancelling unpaid orders after a timeout in a monolithic architecture, detailing their implementation steps, pros, cons, and optimization tips with Java code examples.
This article documents a step‑by‑step investigation of a Java 11 application that suffered OS‑level OOM despite a 4 GB heap, revealing that multiple Netty PooledByteBufAllocator instances loaded by different class loaders consumed far more native memory than expected.
This article demonstrates how to integrate the open‑source Sensitive‑Word Java library via Maven, showcases core find/replace methods, explains advanced detection features such as email, URL, IP and numeric filtering, and provides a custom replacement strategy with complete code examples.
The article analyzes the role of Spring MVC Controllers, identifies issues with traditional implementations, and demonstrates how to create a unified response structure, automatically wrap results using ResponseBodyAdvice, resolve String conversion problems, and apply JSR‑303 validation with custom rules and global exception handling.
A recent migration exposed severe latency on certain Kubernetes pods, traced to Redis connection‑pool misconfigurations and validation locks, with detailed packet captures, ARMS code‑hotspot analysis, and step‑by‑step fixes that restored performance across the cloud‑native environment.
This tutorial demonstrates how to build a Spring Boot application that extracts ID numbers and business license information from images by preprocessing them with OpenCV and recognizing text with Tesseract OCR, covering the full workflow from image handling to regex-based data extraction.
The article introduces DynamicTp, a SpringBoot-based dynamic thread‑pool framework that enables real‑time adjustment, monitoring, and alerting of ThreadPoolExecutor parameters via various configuration centers, outlines its architecture, modules, features, and integration with third‑party components, and provides usage guidance for Java backend developers.
This guide explains how to configure Alipay sandbox credentials, expose a local Java Spring Boot service via a tunneling tool, add the Alipay SDK dependency, set up configuration files, implement payment and notification endpoints, and handle common initialization errors for seamless backend payment integration.
This article explains what unfair locks are, why they can improve throughput compared to fair locks, provides a Java ReentrantLock example with code, describes the internal acquisition process, and outlines typical high‑concurrency scenarios where unfair locks are advantageous.
This article introduces a concise and elegant Java TimeTracker utility class that leverages AutoCloseable, try‑with‑resources, and functional interfaces to provide flexible performance monitoring, automatic duration calculation, and configurable exception handling while reducing repetitive timing code.
The author recounts a two‑day investigation of a widespread FastJson failure caused by a Kotlin lambda mistakenly assigned to an Object field, detailing the mixed‑language project background, the puzzling symptoms, step‑by‑step debugging, the root‑cause analysis, and the final resolution.
This article introduces LiteFlow, a lightweight Java component‑based rule engine that decouples complex business logic, explains its workbench design, demonstrates usage in both non‑Spring and SpringBoot environments with Maven setup and XML configuration, and details its core components, parsing, chain execution, and node processing.
This article explains the fundamental differences between stack and heap memory, covering their structures, allocation strategies, performance characteristics, language-specific examples in Java, C++, and Python, and provides guidance on when to use each type for efficient programming.
This article recounts a production incident where Spring Boot services consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, offers practical remediation steps, and also contains promotional material for AI community services and related offers.
This article clarifies the differences among Java’s thread interruption methods—interrupt(), Thread.interrupted(), and isInterrupted()—explaining how each affects a thread’s interrupt status, when exceptions are thrown, and how to properly monitor and handle interruptions in concurrent applications.
This guide announces the release of mica-mqtt 2.4.x, details the Maven groupId and package name changes, provides a full changelog, migration steps with code examples, and links to documentation and open‑source repositories, helping developers upgrade their MQTT solutions efficiently.
ThreadLocal provides a simple yet powerful way to give each thread its own independent variable, eliminating shared-state conflicts; this guide explains its underlying mechanism, creation methods, basic get/set operations, a complete example with console output, and important usage considerations such as potential memory leaks.
This article explains how to correctly declare Java thread pools using ThreadPoolExecutor, monitor their runtime status, configure parameters for CPU‑bound and I/O‑bound workloads, assign meaningful names, avoid common pitfalls such as unbounded queues and thread‑local leakage, and leverage dynamic pool frameworks.
This guide explains how to implement location‑based job search in a WeChat mini‑program using Solr’s spatial capabilities, covering schema setup, index building, query syntax, performance considerations, and practical code examples, while also comparing Solr with Elasticsearch for similar use cases.
FastExcel is a Java library that builds on EasyExcel to provide high‑performance, low‑memory Excel read/write, stream processing, PDF conversion and a simple API, with detailed usage examples, code snippets, and a comparison of its advantages over EasyExcel.
The author recounts a late‑night incident where a newly launched marketing tool malfunctioned due to a boolean logic error in Java code, describes the chaotic debugging process, presents the faulty and corrected implementations, and confirms the logical equivalence of the final solution.
This article examines Java reflection's advantages and drawbacks, analyzes its core API methods, benchmarks its performance against regular calls, explains why it is slower, and demonstrates how using Hutool's ReflectUtil can dramatically improve execution speed.
This article explains how to replace Spring Boot's default embedded Tomcat container with Undertow, detailing Undertow's features, providing Maven dependency changes, and comparing performance and memory usage through test results, concluding that Undertow offers superior efficiency for high‑concurrency Java web applications.
Java’s String.intern() method adds a string to the constant pool, enabling memory sharing and faster reference comparisons; this article explains its behavior, demonstrates usage with code examples, and discusses performance benefits and cautions for optimal use in real‑world applications.
This article explains how to prepare the environment, configure GraalVM, use Maven plugins, and apply Spring Boot 3.0 AOT and RuntimeHints to compile a Spring Boot application into a fast‑starting native executable, including Docker packaging and underlying AOT principles.
This article shares hard‑won lessons from production incidents and provides practical guidelines—graceful shutdown, proper startup timing, suitable business scenarios, reliability patterns, and idempotent handling—to use Spring Event safely and effectively in Java backend systems.
During a Redis version upgrade of the internal R2M cache service, a Biz thread‑pool exhaustion error was traced to JSF threads blocked on a read lock held by a topology‑updater task, revealing a deadlock caused by shared ForkJoinPool usage and missing lock timeouts.
This article analyzes a thread‑pool exhaustion issue in JD's JSF framework during a Redis cache upgrade, detailing log evidence, stack‑trace analysis, lock contention caused by read/write locks and ForkJoinPool usage, and the steps taken to diagnose and resolve the problem.
This article explains the Chain of Responsibility design pattern, its core concepts, characteristics, and problems it solves, then demonstrates how to combine it with the Strategy pattern in Java using Spring, complete with detailed code examples and execution flow.
Reentrant locks are thread‑safe synchronization tools that let the same thread acquire the same lock multiple times without deadlocking, tracking acquisition counts, and offering advantages over traditional synchronized blocks, with Java’s ReentrantLock providing flexible features such as interruptible and timed locking, illustrated by a complete code example.
This guide explains why standard Java collections are not thread‑safe, introduces their concurrent counterparts such as Vector, ConcurrentHashMap, and various BlockingQueue implementations, and provides concrete code examples and usage patterns for safe multi‑threaded programming.
This guide tackles the problem of oversized Spring Boot JARs by showing how to separate library JARs and configuration files from the main artifact, presenting three Maven‑based solutions—spring‑boot‑maven‑plugin, maven‑jar‑plugin, and maven‑assembly‑plugin—complete with configuration snippets, build commands, and deployment tips.
This article introduces the XXL‑JOB open‑source distributed scheduler, compares it with Quartz and other solutions, and provides a step‑by‑step tutorial for server deployment, executor configuration, task development, execution, logging, and the underlying Netty‑based communication design, complete with code examples.
This article describes how to dramatically speed up the import of 60,000+ XML records into MySQL by analyzing the original environment, measuring baseline performance, and applying a series of backend optimizations—including MySQL batch mode, rewriteBatchedStatements, multithreaded asynchronous writes with Disruptor, and XML parsing improvements—ultimately cutting the total runtime from five minutes to just a few seconds.
Through benchmark tests, memory analysis, and code examples, this article presents ten compelling reasons why using a traditional for loop to traverse Java Lists often outperforms Stream.forEach in terms of performance, memory usage, control flow, exception handling, mutability, debugging, readability, and state management.
This article explains why Maven dependency analysis is essential for Java backend projects, demonstrates how to run the analysis with Maven and IntelliJ IDEA, interprets the warnings about used undeclared and unused declared dependencies, and provides best‑practice timing, risks, and shortcuts for maintaining clean dependency trees.
This article explains how Java's ThreadLocal provides thread‑specific storage, enabling safe context management across thread pools, web request handling, database connections, logging, and global data propagation, thereby preventing interference and improving concurrency performance.
This article explains Java 21's virtual threads, their lightweight and auto‑managed nature, demonstrates basic usage and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance tips for high‑concurrency applications.
Byteman is a powerful Java bytecode manipulation tool that lets developers inject custom code at runtime without recompiling, using an event‑condition‑action rule language to trace, modify execution flow, coordinate threads, and collect statistics, with detailed examples of rule syntax, binding, and built‑in actions.
This article explains how to build a multi‑level office approval workflow using the Activiti engine, covering BPMN diagram design, deployment, Java code for process creation, task handling, gateway logic, database schema, API overview, framework comparisons, and further learning directions.
This technical guide breaks down Alibaba's Druid JDBC connection pool, detailing its initialization process, how connections are fetched and returned, the internal threads and condition‑signal coordination, execution handling, recommended configurations, and monitoring integration, all illustrated with code snippets and diagrams.
This article demonstrates how Java 8’s functional interfaces, especially Function and SFunction, can refactor repetitive data‑validation logic into a generic, reusable method, reducing boilerplate, improving readability, and enabling flexible validation scenarios such as checking column values, matching expected values, and verifying values against allowed lists.
The article investigates a MyBatis batch‑insert job that consumes excessive CPU and takes 14 minutes, explains why the foreach‑generated giant INSERT statement is inefficient, and demonstrates how switching to ExecutorType.BATCH or MyBatis dynamic‑SQL batch support reduces the runtime to under two seconds.
This article demonstrates how Lombok’s advanced annotations such as @RequiredArgsConstructor(onConstructor=@__(@Autowired)), @Delegate, @Cleanup, and the combination of @Builder with @Singular can automatically generate Spring‑compatible constructors, delegate methods, manage resources, and build immutable objects, thereby reducing boilerplate and improving code readability in Java backend development.
This tutorial walks you through creating a Spring Boot project, defining a REST controller, running the application, testing the endpoint, expanding CRUD methods, configuring properties, and optionally adding service and repository layers, all with clear code examples.
This guide presents a curated list of 30 essential IntelliJ IDEA plugins, covering code assistance, UI enhancements, project management, and productivity tools, with installation tips and screenshots, helping Java developers transform their IDE into a powerful one‑stop development environment.
This article explains how to improve PostgreSQL IN‑query performance in Spring Boot applications by splitting large IN parameter lists into smaller batches, executing them concurrently with a custom AOP annotation, and merging the results, providing a reusable annotation‑driven solution for high‑throughput backend services.
This article walks through diagnosing slow API responses, using Pfinder for tracing, refactoring Java collection handling with Sets, and applying JSF asynchronous calls to dramatically cut latency, offering a step‑by‑step guide to backend performance optimization.
This article explains the four standard Java ThreadPoolExecutor rejection policies—AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, and DiscardPolicy—detailing their behavior, suitable scenarios, and providing full code examples, plus guidance on creating custom policies.
LiteFlow is a lightweight Java rule engine that lets developers orchestrate serial and parallel business workflows using XML, JSON or YAML rule files stored in back‑ends like SQL or Zookeeper, offering NodeComponent, NodeSwitchComponent and NodeIfComponent types, EL syntax, Spring Boot integration, and high‑performance execution monitoring.
This article explains the Chain of Responsibility design pattern, its core concepts, characteristics, and problems it solves, then demonstrates how to combine it with the Strategy pattern through detailed Java code examples that illustrate a product‑up‑shelf validation workflow and a generic request‑handling scenario.
This guide walks you through installing Spring Boot CLI, explains its Groovy‑based features, demonstrates creating and running a Hello World web app, shows how to use @Grab for dependencies, test with spring test, package into executable JARs, and explore init and shell commands.
This guide explains Apache RocketMQ’s ordinary message concept, its full lifecycle, how to create topics, Java code for sending and receiving messages, key configuration tips, and real‑world scenarios such as asynchronous decoupling and traffic‑shaping for micro‑service architectures.
This article explains how to track online users by storing their identifiers in a Redis sorted set, using expiration timestamps as scores, and demonstrates adding, querying, and cleaning up entries with ZADD, ZRANGEBYSCORE, ZREMRANGEBYSCORE, and ZREM commands in both Java and JavaScript.
This article investigates the detailed steps and time consumption of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and code examples to demonstrate why connection pooling is essential for high‑traffic services.
This article explains Java's ThreadLocal mechanism, detailing its internal ThreadLocalMap structure, core set/get/remove operations with full code examples, and demonstrates how multiple ThreadLocal variables are stored per thread, providing a clear understanding of thread‑local storage in backend development.
This article explains how to build a flexible, scalable permission control system in Java using custom annotations and Spring AOP, covering basic concepts, system requirements analysis, database schema design, annotation definitions, aspect implementation, and business logic services for comprehensive access management.
DynamicTp is a Java‑based dynamic thread‑pool framework that extends ThreadPoolExecutor to enable runtime parameter tuning, real‑time monitoring, and multi‑channel alerting, addressing common pain points of thread‑pool configuration in microservice environments.
The article first shares a personal anecdote about job background checks and then presents a detailed explanation of LeetCode problem 5 – Longest Palindromic Substring – including problem description, dynamic‑programming analysis, recurrence formula, and complete Java and C++ code examples.
This article presents a comprehensive collection of written‑test and interview questions covering Java basics, Spring MVC annotations, JVM memory, garbage collection, database design, transaction management, distributed systems, version control, and development workflow, aimed at helping candidates prepare for small‑company technical interviews.
This article presents LiteFlow, a lightweight yet powerful rule engine built on Spring Boot, explains its architecture, component types, EL rule file syntax, data context handling, configuration options, and demonstrates a practical e‑commerce workflow example with full code snippets and deployment tips.
This tutorial explains how to create a traffic sign recognition application using Spring Boot and Java Deeplearning4j, covering CNN selection, dataset organization, Maven dependencies, data loading, model construction, training, prediction, unit testing, and expected results.
This article explains the background, challenges, and recursive algorithmic solution JD Logistics uses to merge purchase orders, detailing the merging rules, code implementation, deduplication strategy, performance gains, and the resulting operational benefits such as increased merchant satisfaction and faster processing.
This article introduces the URule rule engine, explains its core concepts and library types, shows how to install and configure it within a Spring Boot project, demonstrates rule set and decision‑table creation, and provides complete Java code examples for practical usage.
This guide shows how to integrate the Drools rule engine into a Spring Boot application to calculate e‑commerce discounts dynamically, covering Maven dependencies, configuration, model definitions, DRL rule creation, service and controller layers, and a simple test scenario demonstrating rule‑driven discount computation.
This article explains the core concepts of Java’s AbstractQueuedSynchronizer (AQS), its exclusive and shared modes, the template‑method design it uses, and walks through the actual source code showing how ReentrantLock implements both fair and non‑fair locking, complete with diagrams and code snippets for interview preparation.
This article introduces a Spring Boot 3 case collection and details five practical methods—URL path, request parameter, request header, Accept header, and custom annotation—to implement API version control, complete with code examples and guidance for maintaining compatibility across multiple API versions.
This article explains how Java's volatile keyword provides visibility guarantees and prevents instruction reordering through memory barriers, illustrates its behavior with code examples, discusses its limitations regarding atomicity, and outlines appropriate usage scenarios such as state flags and double‑checked locking.
This article explains Java’s java.util.concurrent.Phaser class, compares it with CountDownLatch, details its core methods, demonstrates practical usage with code examples, and shows how to build a custom lightweight synchronization utility for performance testing scenarios.
This article walks through a real‑world case of importing over 60,000 XML rows into MySQL, profiling the initial 300‑second runtime, and applying a series of optimizations—including JDBC batch processing, rewriteBatchedStatements, multithreaded asynchronous writes with Disruptor, and MySQL tuning—to achieve a final import time of around 4 seconds while managing memory usage.
This article demonstrates a practical approach to protect sensitive Spring Boot applications by encrypting the JAR with AES, storing the key in a secure vault, and using a custom ClassLoader to decrypt and load classes at runtime, while highlighting key management, performance, and additional hardening considerations.
This article introduces magic-api, a Java‑based rapid development framework that lets developers create HTTP APIs without writing traditional Controllers, Services, or DAOs, and provides a UI for designing endpoints, extensive database support, clustering, Swagger integration, and a quick‑start guide with Maven and configuration examples.
This article explains the step‑by‑step decision process a Java thread pool follows when execute() adds a task, covering core and maximum pool sizes, queue handling, thread creation, rejection policies, and idle thread termination.
This article introduces the Liteflow rule engine, explains its architecture and supported file formats, demonstrates how to configure and use it with Spring Boot, details component types and EL rule files, and showcases a practical e‑commerce workflow example with code snippets.
This article explains how Redisson leverages Redis, Lua scripts, and Pub/Sub to implement a robust distributed lock in Java, covering lock characteristics, client creation, acquisition, renewal, and release mechanisms with code examples.
The article explains the true purpose of the Linux kill command, compares signals like SIGTERM and SIGKILL, warns about the dangers of force‑killing processes, and provides practical Java shutdown‑hook examples and a shell script for safe, graceful termination.
This article breaks down the seven parameters of Java's ThreadPoolExecutor constructor, explaining corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, and handler, and provides practical tips on thread creation and rejection policies.
The article presents a step‑by‑step guide to refactor Spring MVC controller code by unifying response formats, applying a global response wrapper, enforcing parameter validation with JSR‑303, and handling custom exceptions through a centralized advice, all illustrated with complete Java examples.
This article explains how to protect time‑consuming business operations and critical data by designing a Redis‑based distributed lock using custom annotations, Spring AOP, and a ScheduledExecutorService that automatically extends the lock’s expiration to avoid premature release.
This article reviews the most popular programming languages that can serve as alternatives to PHP for web development, evaluating each option’s performance, ecosystem, and suitability for server‑side projects, and offers guidance on selecting the best replacement based on project requirements.
The article reviews a Java veteran's 20‑year experience to identify backend technologies such as JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC and XML that are now outdated or less essential, and recommends focusing on Spring MVC, MyBatis and a deep understanding of Servlets for modern development.
CountDownLatch and CyclicBarrier are two essential Java synchronization tools from java.util.concurrent, enabling threads to coordinate tasks; this guide explains their concepts, usage with code examples, advantages, disadvantages, and key differences, helping developers choose the right tool for thread coordination.
Learn how to integrate Go and Java by compiling Go code into a shared library, exposing functions via cgo and JNI, and invoking them from Java with detailed setup, code examples, handling of primitive and complex data types, and full build‑and‑run instructions.
This article provides a comprehensive technical walkthrough of the Druid database connection pool, covering its architecture, initialization flow, connection acquisition and release mechanisms, execution and exception handling, as well as recommended configurations and monitoring practices for optimal performance.
This article provides a step‑by‑step tutorial for Java engineers on using the LangChain4j framework to implement Retrieval‑Augmented Generation (RAG) with large language models, covering concepts, environment setup, code integration, document splitting, embedding, vector‑store operations, and prompt engineering.
This article walks Java developers through the fundamentals of Retrieval‑Augmented Generation (RAG), explains the LangChain4j framework, compares large‑model development with traditional Java coding, and provides step‑by‑step code examples for environment setup, document splitting, embedding, vector‑store operations, and LLM interaction.
