This guide demonstrates how to add Apache Tika to a Spring Boot project by declaring the tika‑bom, core and parser dependencies, providing a custom tika‑config.xml, creating a @Configuration class that builds a Tika bean, and then injecting the bean to detect, parse, or translate documents.
This article explains three practical Spring Boot approaches—scheduled tasks, delayed RabbitMQ queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with ready‑to‑use Java code examples.
This article presents 18 practical code review guidelines covering comments, logging, naming, parameter validation, exception handling, modularity, concurrency, testing, formatting, compatibility, security, transaction, idempotency, middleware, code smells, and remote calls, offering concrete examples and best‑practice recommendations for Java developers.
This guide explains how to handle large file uploads in Java by using instant (秒传) upload, chunked (分片) upload, and breakpoint resume techniques, detailing the underlying Redis state tracking, server‑side file writing with RandomAccessFile or MappedByteBuffer, and practical implementation steps for both front‑end and back‑end.
This article reviews the most widely adopted Java language enhancements introduced from Java 8 through Java 20, including local‑variable type inference, switch expressions, text blocks, records, pattern‑matching instanceof, sealed classes, and improved NullPointerException messages, providing examples and reference links for each feature.
The article presents a Java Spring solution that uses a custom URLClassLoader to dynamically load, register, and unload governance task JARs as Spring beans and XXL‑Job handlers at runtime, with configuration persistence via YAML or Nacos and Maven Shade packaging for seamless updates without service restarts.
This article explains why invisible token refresh is needed, describes backend automatic token renewal using Java JWT, provides full Maven dependencies and JwtUtil implementation, shows unit‑test examples, and discusses frontend token extension strategies and edge‑case handling.
This article explores the advantages of combining Java, Spring Boot, and Vue for full‑stack web development, outlining the technology selection, step‑by‑step development workflow, best practices for code quality, testing, debugging, performance optimization, and deployment using containerization.
This article introduces Java’s origins, key characteristics, environment setup, basic syntax, object‑oriented concepts, exception handling, common libraries, and simple practice projects, providing beginners with a comprehensive foundation to start programming in Java.
The article explains how Java's annotation mechanism, including @ThreadSafe, @NotThreadSafe, @GuardedBy, and @Immutable, can be applied to clarify and manage concurrent behavior, helping developers resolve the timing uncertainties inherent in multithreaded programming.
This article introduces the String class, covering its immutable nature, essential methods such as substring, indexOf, replace, concatenation techniques, formatting, comparison, sorting, and search capabilities across languages like Java and Python, highlighting its fundamental role in text processing.
This article examines how bitmap data structures and multithreading can dramatically accelerate blacklist filtering in large‑scale marketing systems, reducing processing time from tens of minutes to milliseconds while saving memory and improving overall system performance.
This article explains how to integrate Spring Boot with Minio to enable direct client‑side file uploads by generating time‑limited presigned credentials on the backend, covering environment setup, Maven dependencies, configuration classes, REST endpoints, response fields, and complete front‑end examples including chunked and resumable uploads.
Graceful Response is a Spring Boot component that provides unified response wrapping, global exception handling, and custom error codes, helping developers reduce boilerplate, improve code readability, and accelerate API development while maintaining consistent error responses.
The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.
This article explains why JVM tuning matters, identifies scenarios that require tuning such as performance bottlenecks, memory overflows, and concurrency issues, and then details monitoring and diagnostic tools—including JDK command‑line utilities and third‑party solutions—followed by a comprehensive guide to JVM parameters, garbage‑collector selection, and practical ways to apply these settings in production environments.
This article presents a real‑world case study of optimizing massive batch‑processing tasks in an ad‑platform by applying query‑level improvements, cursor‑based pagination, shard‑aware batch updates, JVM‑tuned garbage collection, and distributed load‑balancing, ultimately reducing CPU usage from 80% to under 2% and cutting query‑per‑minute volume from millions to a few thousand.
This guide explains the five ThreadPoolExecutor rejection policies in Java—AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy, and custom handlers—detailing their behavior, use‑cases, and providing concrete code examples for each.
This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.
This tutorial walks you through creating a custom Spring Boot Starter, from Maven project setup and dependency configuration to defining auto‑configuration classes, registering them, and writing comprehensive unit tests to verify conditional behavior.
This article introduces the open‑source Disruptor library, explains its core concepts such as Ring Buffer, Sequence, Sequencer and Wait Strategy, and provides a step‑by‑step Java demo—including Maven dependency, event model, handlers, configuration, producer, and test code—to show how to build a fast in‑memory message queue.
This article introduces J2Cache, a two‑level caching framework for Spring Boot, explains its L1 (Caffeine/Ehcache) and L2 (Redis/Memcached) architecture, and provides a complete hands‑on example covering Maven dependencies, configuration, core service classes, REST controller, and testing procedures.
The article chronicles Sun Microsystems' birth, its breakthrough with workstations, the development of SPARC CPUs and Solaris OS, the rise to market dominance, and the eventual decline caused by strategic missteps and competition from Linux and Intel, offering insights into technology‑driven business management.
This tutorial explains how to integrate Elasticsearch into a Spring Boot application, covering project setup, dependency addition, configuration, entity and repository creation, service and controller implementation, and testing to enable efficient full‑text search for large data sets.
Facing rapid business expansion, Huolala’s quality assurance team tackled redundant code, high regression costs, and lack of coverage metrics by designing an intelligent automated testing framework that analyzes effective code, provides smart test case recommendations, visualizes progress, and integrates monitoring, resulting in significant coverage improvements and efficiency gains across services.
The article clarifies Java processes and threads using a game analogy, then demonstrates three thread‑creation techniques—extending Thread, implementing Runnable, and implementing Callable with FutureTask—while covering run vs start, thread control methods such as sleep, join, and daemon settings.
This article thoroughly explains OpenFeign’s core architecture, including its dynamic proxy mechanism, seven essential components, the process of building and executing HTTP calls, and how Spring Cloud integrates and configures OpenFeign through annotations, factories, and property settings.
This article explains Spring Boot’s @MatrixVariable feature, covering its RFC 3986 basis, practical usage scenarios, multiple code examples, and the underlying request‑mapping mechanism, helping developers efficiently pass multi‑dimensional parameters within URI paths.
This article analyzes typical reasons why Java backend services experience sustained 100% CPU usage—such as bulk data retrieval, Kafka auto‑acknowledgement, infinite loops, excessive multithreading, massive file synchronization, deadlocks, inefficient regular expressions, and heavy real‑time calculations—and offers practical mitigation strategies.
This guide walks you through setting up the Java environment, downloading Apache RocketMQ 5.1.4, installing its NameServer, Broker, and optional Proxy components on an Ubuntu 20.04 cloud instance, and configuring both local and cluster deployment modes with optional visual dashboard tools.
This tutorial explains how to create a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration class creation, registration via spring.factories, and comprehensive unit testing to ensure correct conditional behavior.
Learn how to set up Camunda, a flexible Java-based BPMN 2.0 workflow engine, within a Spring Boot application by generating a project, configuring dependencies, defining data models and REST endpoints, designing a simple process diagram, and testing the workflow end‑to‑end.
Discover how the low‑code Java framework Erupt enables rapid creation of full‑stack admin applications without writing front‑end code, by using annotations to generate CRUD pages, integrating with SpringBoot, configuring dependencies, and extending with modules for scheduling, code generation, monitoring, NoSQL, and magic‑API.
This article explains how to integrate Spring Retry into a Spring Boot project to gracefully handle third‑party API failures, covering annotation‑based retries, asynchronous retries, exception filtering, fallback handling, and an optional Hystrix circuit‑breaker extension for comprehensive fault tolerance.
This article introduces LiteFlow, a powerful rule‑engine framework for Spring Boot, explains its advantages, shows how to define rules in XML/JSON/YML, and provides a complete end‑to‑end example with code snippets and hot‑swap components for flexible business logic.
This article explains the differences between DTO, BO, PO, and VO in backend development, illustrates their roles with Java code examples, and shows how to configure global settings to filter null fields in DTOs, reducing the need for separate VO objects.
Spring Boot offers several ways to validate request parameters—including the @Valid and @Validated annotations and custom validation annotations—each with its own strengths, allowing developers to enforce data integrity, improve code quality, and enhance user experience across different scenarios.
This article explains how to design and implement a two‑level caching architecture in Spring Boot by combining a local Caffeine cache with a remote Redis cache, covering manual approaches, annotation‑driven management with Spring Cache, and a custom AOP solution to minimize code intrusion.
This article explains pagination rationalization in SpringBoot using MyBatis PageHelper, illustrates common unreasonable pagination scenarios, demonstrates a bug caused by page deletion, and shows how a simple two‑line configuration or per‑query setting resolves the issue while detailing the underlying implementation.
This article examines eight common reasons why Java backend services experience 100% CPU usage—such as fetching excessive data, automatic Kafka acknowledgments, infinite loops, multithreaded imports, massive file syncs, deadlocks, inefficient regular expressions, and heavy real‑time calculations—and provides practical mitigation strategies.
This guide explains how Spring Boot automatically registers Servlet, Filter, and Listener beans, how to customize their mappings with registration beans, configure the embedded servlet container, and handle JSP limitations, providing code examples and practical tips for backend developers.
This guide walks through systematic troubleshooting of Java applications by checking CPU, disk, memory, and network layers, using tools like jstack, jmap, vmstat, iostat, and tcpdump to pinpoint and resolve performance and stability problems.
This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.
The article humorously discusses Huawei cafeteria competition before presenting LeetCode problem 102, which requires a breadth‑first level order traversal of a binary tree, and provides complete Java, C++, C, and Python implementations that use a queue to process each tree level.
This article explains how Spring's @ConfigurationProperties and @PropertySources annotations work, compares their purposes, and provides step‑by‑step examples for binding external configuration to Java beans and loading multiple property files in a Spring Boot application.
This article explores how to create and use custom authorization annotations in Spring Security to achieve more flexible, expressive, and maintainable permission checks, covering the basics of Spring Security, advantages of custom annotations, step‑by‑step implementation, and additional use‑case scenarios.
This article explains how to use SLF4J's MDC to tag logs with a request ID, why the ID is lost in asynchronous threads, and how to apply a decorator pattern (MDCRunnable) so that the request ID is correctly propagated and searchable across all threads and thread pools.
This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts such as pointcuts, advice, aspects, join points and weaving, and provides multiple Spring Boot examples—including simple @GetMapping logging, custom permission annotations, and the use of various AOP annotations—complete with full source code snippets.
This article demonstrates how to build a dynamically configurable thread pool in a Spring Cloud backend by using Nacos as a configuration center, covering dependency setup, YAML files, Java implementation, controller exposure, testing steps, and practical tips for runtime adjustments.
This article explains how to use Spring Boot's @EnableScheduling and @Scheduled annotations to create cron, fixed‑delay, and fixed‑rate tasks, and demonstrates a lightweight approach for dynamically updating or disabling cron expressions at runtime without external schedulers.
This article explains how MyBatis implements first‑level (session) and second‑level (namespace) caches, details their activation conditions, common pitfalls—especially when integrated with SpringBoot—and provides step‑by‑step configuration, code examples, and best‑practice recommendations to ensure cache effectiveness while avoiding hidden hazards.
This article explains how to improve a high‑traffic Java service by reusing a singleton HttpClient, enabling keep‑alive, configuring a pooling connection manager, and adding an idle‑connection monitor, which reduces average request latency from 250 ms to about 80 ms.
This article explains the seven Spring transaction propagation levels, shows how nested @Transactional methods interact under each level, and provides concrete code‑level examples that illustrate when transactions are merged, suspended, started anew, or rolled back, helping developers choose the right strategy for reliable enterprise applications.
This article explains how to use static analysis tools like IDEA and PMD together with dynamic coverage tools such as JaCoCo to identify, clean up, and refactor unused, duplicated, or dead Java code in large backend projects, improving maintainability and stability.
This article provides a comprehensive overview of distributed locks, detailing their four essential conditions, three implementation methods—including a Redis-based solution with Java code examples—and explains how to acquire and release locks safely in high‑concurrency distributed systems.
This article presents several approaches for generating unique, scalable order numbers in Spring Boot, including UUIDs, database sequences or auto‑increment IDs, timestamp‑based strings with random components, and distributed Snowflake IDs, each accompanied by Java code examples and discussion of their advantages and drawbacks.
This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.
When converting arrays to lists in Java, Arrays.asList cannot handle primitive arrays (treating them as a single element), returns a fixed‑size view that disallows add or remove operations, and shares its backing array so modifications affect both structures, so developers should use boxed streams or copy into a new ArrayList.
This article walks through an interview question about the maximum concurrent requests a default SpringBoot application can process, builds a minimal demo, examines Tomcat and Undertow thread‑pool configurations, and shows how container defaults and parameters like core size, max size, and queue length determine the real limit.
This article explains how different Java JSON libraries handle boolean getter naming, shows code examples of serialization results with fastjson, Gson, and Jackson, and recommends using a plain "success" field with an isSuccess() getter to avoid runtime bugs.
This article documents the step‑by‑step migration of a Java campus‑blog project from JDK 8 + Spring Boot 2.6 to JDK 17 and Spring Boot 3.2, explaining why the upgrade is worthwhile, detailing code and configuration changes, and sharing solutions to the numerous compatibility issues encountered.
This article shares hard‑won production lessons on using Spring Event, explaining why graceful service shutdown, proper startup timing, consistency requirements, and retry mechanisms are essential for reliable event publishing in Java backend systems.
This article demonstrates various Spring dependency‑injection techniques—including Optional, ObjectProvider, Provider, arrays, collections, maps, @Value literals and SpEL expressions, as well as @Lazy proxies—showing the code and resulting bean representations for each approach.
This article introduces Java 8's Stream API, explains its pipeline concept similar to SQL and Linux pipes, and demonstrates common operations such as filter, map, sorted, forEach, collect, statistics and parallelStream using a UserPo class with complete runnable code examples.
This article explains the JVM memory model, detailing the five runtime data areas—heap, method area, JVM stack, native method stack, and program counter—along with their structures, configuration parameters, and roles in Java execution and performance tuning.
The article introduces LangChain as a framework that unifies LLM providers through model I/O, connects external data via retrievers, composes workflows with chains, maintains context with memory, and enables tool use through agents, and demonstrates Java examples for TongYi embeddings, a ChatGLM‑6B RetrievalQA chain, and discusses agent registration and micro‑service‑based agent factories.
This article presents a systematic approach to distinguish effective from ineffective diff failures in traffic replay by designing a JSON similarity model based on value, key, and structural comparisons, implementing the algorithm in Java, and demonstrating its superior accuracy over traditional system diff through extensive experiments.
This article demonstrates advanced Lombok annotations such as @RequiredArgsConstructor, @Delegate, @Cleanup, @Builder, and @Singular, showing how they can be combined with Spring to reduce boilerplate, manage resources, and create fluent builders in Java backend projects.
This article explains a real‑world scenario of extending trial‑user eligibility rules, introduces a refactored Java rule‑engine architecture that separates data, abstract rule templates, concrete rule implementations, and a service supporting AND/OR short‑circuit logic, and evaluates its advantages and drawbacks.
A week‑long API freeze in a sandbox environment was traced to Redis connection pool misconfiguration, where threads waited indefinitely for a Jedis resource, leading to Tomcat request threads blocking and 500 errors, and the issue was resolved by adjusting pool settings and using proper connection release patterns.
This article demonstrates how to prevent API abuse in a Java Spring application by using a custom HandlerInterceptor combined with Redis to track request counts per IP and URI, covering basic implementation, configuration, custom annotations, reflection for flexible limits, and discusses potential pitfalls and improvements.
This article explains how to configure Spring Boot's built‑in ThreadPoolTaskExecutor, customize its core parameters, and use it together with Java 8 CompletableFuture to run asynchronous tasks, including a performance comparison with a synchronous implementation.
This guide walks through XXL‑JOB’s core features, shows how to download and set up the admin console, configure a SpringBoot executor, and implement various job types—including simple, sharding, command‑line, HTTP, and lifecycle tasks—complete with code samples and UI screenshots.
This guide shows how to add a retry mechanism to Spring Boot applications using Spring Retry, covering dependency setup, enabling @EnableRetry, defining @Retryable with custom back‑off settings, handling failures with @Recover, writing unit tests, and observing behavior with different retry counts and exception filters.
This guide shows how to configure Spring Boot, MyBatis‑Plus and the dynamic‑datasource starter to connect to MySQL, SQL Server and PostgreSQL, add and remove data sources at runtime, verify their availability, and perform manual switching using a utility class and functional interfaces.
This guide walks through integrating Spring Data Elasticsearch into a Spring Boot application, covering entity mapping annotations, repository creation, service layer implementation, and unit tests to perform create, read, update, delete, and fuzzy search operations on Elasticsearch indices.
Over a month of systematic JVM tuning, the author reduced FullGC frequency from 40 times per day to once every ten days, halved YoungGC time, identified and fixed a memory leak caused by anonymous inner‑class listeners, and documented the step‑by‑step optimization process with configuration changes and performance results.
This article humorously references recent layoff memes before presenting a detailed tutorial on solving LeetCode problem 392—checking whether string s is a subsequence of t—using a two‑pointer algorithm, complete with step‑by‑step explanation, complexity analysis, visual illustrations, and reference implementations in C++, Java, and Python.
Learn how to set up and integrate the Camunda BPMN 2.0 workflow engine into a Spring Boot application, covering project initialization, Maven dependencies, configuration files, creating a simple user task process, and testing the workflow via Camunda’s web interface.
This article explains how to manage the throughput of Java 21 virtual threads by using Executors to create them and applying java.util.concurrent.Semaphore to limit concurrent execution, ensuring efficient and safe concurrency without pooling virtual threads.
This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and its divide‑and‑conquer algorithm, demonstrates custom RecursiveTask implementations with full source code, analyzes ForkJoinPool construction, task submission, work‑stealing, monitoring APIs, commonPool pitfalls, and performance evaluation, providing practical guidance for Java developers.
This article explains Spring's @Lookup method injection, shows how to define the annotation, register beans, run examples, and dives into the underlying CGLIB proxy mechanism and bean creation process for dynamic bean lookup.
This article explains Java concurrency issues such as deadlock, livelock, and thread starvation, demonstrates deadlock examples, discusses prevention techniques like timeouts and lock ordering, and provides an overview of the java.util.concurrent package including executors, locks, semaphores, latches, barriers, and concurrent collections.
This article walks through the fundamentals of HTTP session handling, the challenges of session sharing in clustered environments, and presents a step‑by‑step design of a Single Sign‑On solution using CAS, including concrete code examples, Redis‑based session storage, and a comparison with OAuth2.
This article presents a developer‑centric guide to designing a Java code‑optimization tool that automatically replaces trivial getter/setter methods with Lombok’s @Data annotation, detailing the scanning, filtering, modification steps, JavaParser usage, Maven integration, and practical usage instructions.
This article explains three common pitfalls of using Java's Arrays.asList—its incompatibility with primitive arrays, the immutability of the returned list, and the shared backing array that causes side‑effects—along with practical solutions such as using wrapper types, Streams, or creating a new ArrayList.
This article introduces eight common Java asynchronous implementation techniques—including raw threads, thread pools, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—explains their use cases, advantages, and limitations, and provides concrete code examples for each method.
This article walks through setting up a SpringBoot project with the Modbus4j library to communicate with Modbus TCP devices, covering repository configuration, Maven dependencies, utility class implementation, single and batch reads, scheduled tasks, and troubleshooting common function‑code errors.
This guide explains how to implement a searchable user‑story interface using PostgreSQL tables with btree and gin indexes, Java record models, Spring Boot data access, and REST controllers to support range and full‑text queries efficiently.
This tutorial walks you through adding OpenAI's generative capabilities to a Spring Boot application with Spring AI, covering project setup, API key configuration, controller creation, simple and advanced prompt usage, and how to test the resulting AI-powered endpoints.
This article explains how to design a standardized JSON response format, implement a unified result class and enum, handle global exceptions with @ControllerAdvice, and configure comprehensive Logback logging for Spring Boot applications, providing complete code examples and best‑practice guidelines.
This article explains Spring's seven transaction propagation behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how nested transactional methods interact, when new transactions are created or suspended, and how exceptions influence commit and rollback across different propagation settings.
This article explains why MyBatis' default SqlSession implementation is not thread‑safe, how Spring‑MyBatis integration introduces SqlSessionTemplate and its dynamic proxy, and how transaction‑bound ThreadLocal management ensures safe SqlSession usage across multiple threads.
An in‑depth guide to Spring Expression Language (SpEL) covering its core features, evaluation contexts, parser configuration, collection handling, operators, variables, bean references, and a practical AOP case study, all illustrated with concise Java code examples.
This article explains why distributed locks are needed, outlines Redisson's lock properties, walks through its Lua‑based acquisition, renewal, and release processes, examines master‑slave pitfalls, compares RedLock with Zookeeper, and provides practical code examples for Java developers.
This article explains the concepts behind SpringBoot Starters, walks through the creation of a custom starter that provides global request/response encryption and decryption using SM2, shows the project structure, key configuration files, core code, testing steps, and subsequent optimizations.
This article showcases the correct "Hello World" syntax for twelve widely used programming languages, providing clear code snippets and brief explanations to help beginners understand the fundamental first program across Java, C, Python, C++, C#, Visual Basic .NET, JavaScript, PHP, Objective‑C, SQL, Ruby, and MATLAB.
Industrial and Commercial Bank of China received patent CN112905176B for a SpringBoot‑based web system backend method that extracts operation data, maps business IDs to configuration, builds conditional expressions, and processes data, thereby reducing development changes, cutting costs, and enhancing system stability.
This article explains what CSRF attacks are, how they exploit authenticated browsers through forged requests, outlines the three essential conditions for a successful attack, and presents practical defense measures such as token validation, cookie handling, secondary authentication, and code examples in Java and JSP.
