After upgrading to JDK 11, a FastJSON serialization bug caused the amount field in Money objects to disappear, leading to failed refunds; this article details the investigation, from classloader quirks and ASM handling to dependency conflicts and the ultimate fix of removing a problematic jar.
This article explains why Spring transactions can become ineffective or fail to roll back, covering issues such as wrong method visibility, final methods, internal calls, missing Spring bean registration, multithreading, unsupported table engines, misconfigured propagation, exception handling, and offers practical solutions for each case.
This article explains how to implement high‑accuracy IP location lookup using the free ip2region offline database, provides Maven dependency details, demonstrates Java code for searching IP addresses, shows sample output, and highlights its support for both domestic and international IPs.
When a data platform server suddenly shows CPU utilization near 99% despite modest traffic, this guide walks through pinpointing the offending Java process, tracing the high‑load thread, uncovering a time‑conversion routine that over‑calculates seconds, and applying a lightweight fix that drops CPU load by dozens of times.
This article explains the Spring Boot startup mechanism, covering the @SpringBootApplication entry annotation, its constituent annotations, the role of SpringApplication.run, and the step‑by‑step initialization flow that powers Java backend applications.
This article provides a step‑by‑step guide to creating a Spring Boot starter for enterprise‑grade object storage services, explaining OSS concepts, Amazon S3 basics, project setup, Maven dependencies, configuration classes, template interfaces, implementation details, auto‑configuration, packaging, and testing.
This article explains how to enable hot deployment in Spring Boot using DevTools, configure automatic recompilation in IDEs, simplify Java bean code with Lombok, and add the Spring Configuration Processor for property metadata, providing Maven snippets and step‑by‑step instructions.
This guide explains how to integrate the mybatis-plus-generator-ui library into a Spring Boot project, configure database connections, launch the web UI, and use its customizable templates and naming converters to generate Entity, Mapper, Service, and Controller classes for multiple databases with a single click.
This article explains how JWT provides stateless user authentication while Session adds an extra security layer and state management, detailing their respective roles, the reasons for using Session alongside JWT, and offering Java code examples that illustrate their combined implementation.
This article explains Java serialization and deserialization concepts, outlines common use cases such as distributed systems and caching, compares multiple implementation methods including Serializable, Externalizable, JSON, XML, and binary libraries, and provides practical code examples, security tips, and best‑practice guidelines.
This article explains how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the JAR by loading it with a URLClassLoader and dynamically registering or deregistering Spring beans using reflection or annotation modes.
When a SMS service fails and messages need to be re‑sent, this article shows how to use RocketMQ's message backtracking feature to reset consumer offsets, verify the reset, and explore the internal workflow and alternative pull‑consumer strategies with concrete code examples and detailed analysis.
This article introduces the open‑source XXL-Job distributed task scheduling framework, explains its architecture and communication design, and provides a step‑by‑step hands‑on tutorial covering server deployment, executor configuration, task development (annotation, API, sharding), execution, and log inspection, with code examples and screenshots.
Apache Tomcat is the underlying servlet container and web server that Spring Boot automatically embeds via the spring‑boot‑starter‑web dependency, but junior developers often miss its core roles—managing servlet lifecycles, serving static resources, and compiling JSPs—so learning Tomcat (or swapping it for Jetty by adjusting Maven exclusions) clarifies what Spring Boot abstracts and enables flexible container choices.
This guide explains how to set up a Spring Boot project, add the Tess4J dependency, configure language data, implement an OCR service and REST controller, and test both local file uploads and remote image URLs for text recognition.
This article introduces JDFrame and SDFrame, two Java libraries that provide a DataFrame‑style, semantic API for simplifying stream operations, including dependency setup, quick‑start examples, matrix viewing, filtering, aggregation, deduplication, grouping, sorting, joining, pagination, window functions, and a comparison of their execution models, along with links to the source code and documentation.
This article presents fourteen practical Java backend optimization techniques—including configuration‑file management, Lombok’s @RequiredArgsConstructor, modular code design, exception handling, reducing DB queries, avoiding null returns, minimizing if‑else, slimming controllers, IDE shortcuts, source‑code reading, design patterns, and efficient collections—each illustrated with clear code examples.
This article provides an in‑depth tutorial on Alibaba Sentinel, covering its core concepts, installation of the dashboard, version selection, integration with Spring Boot microservices, detailed flow‑control and degrade rule configurations, hotspot parameter limiting, system adaptive protection, custom block handlers, blacklist/whitelist settings, rule persistence with Nacos, push‑mode synchronization, cluster flow control, gateway integration and OpenFeign fault‑tolerance, all illustrated with practical code examples.
This article explains five common ways to ensure thread safety in Java, covering synchronized blocks, the Lock interface, atomic variables, concurrent collections, and ThreadLocal usage, each with clear code examples and practical advice.
This article provides an in‑depth overview of the WebSocket protocol, covering its fundamentals, advantages, lifecycle, message formats, Java API usage, Spring Boot integration, performance considerations, and future development directions, complete with practical code examples for both server and client sides.
This article explains why using raw Thread or Runnable is discouraged in Java, introduces the core java.util.concurrent thread‑pool classes, compares the built‑in Executors factories, and provides detailed guidance on customizing ThreadPoolExecutor parameters, sizing strategies, rejection policies, hooks, shutdown procedures, and additional optimizations for robust production use.
The new OpenTelemetry Java instrumentation adds client and server request‑size metrics to gRPC by injecting a tracing interceptor via Byte‑Buddy bytecode enhancement, extracting payload sizes from protobuf messages, recording them with custom attributes and histograms, and applying analogous handler‑based logic for Go.
The article details a senior architect's investigation of Fastjson problems, including a date format priority bug that behaved differently on Windows and Linux due to an outdated library version, and a circular reference serialization issue resolved by disabling specific serializer features, while offering broader insights on version management and feature control.
This article explains how to standardize API responses in Spring Boot by defining a JSON result format, using custom annotations, interceptors, and ResponseBodyAdvice to automatically wrap controller return values, while also discussing status code design, message handling, and code simplification techniques.
This article explains how to implement unified data desensitization in Java Spring Boot applications by creating custom annotations, enums, serializers, and utility methods that automatically mask personal information during JSON serialization, complete with code examples and test results.
This article introduces five practical Java Streams techniques—including precise filtering, map transformation, aggregation with reduce, and advanced grouping—to help developers write clearer, more efficient backend code, complete with code examples and explanations of each operation.
This article explains why Java's BigDecimal class maintains exact precision by examining its internal fields, demonstrating usage through test code, and walking through the add method's implementation to show how values are scaled and computed as long integers before producing the final result.
This article explains why excessive if‑else statements increase cost and complexity in Java applications and demonstrates several refactoring techniques—including enums, the factory pattern, the strategy pattern, and Stream API maps—to produce cleaner, more maintainable code.
This article systematically catalogs every Spring and Spring Boot extension interface—from ApplicationContextInitializer to DisposableBean—illustrates their invocation order with a diagram, explains practical use‑cases, and provides concrete code samples for each hook, enabling developers to tap into the bean lifecycle for custom initialization, monitoring, and cleanup.
This article explains Java's escape analysis, covering method, thread, and non-escape scenarios, and shows how the JIT compiler can reduce heap allocation, remove unnecessary synchronization, and apply scalar replacement to improve performance.
This report analyzes performance bottlenecks caused by serialization in a search‑recommendation system, presents detailed measurements of request latency, evaluates multiple optimization strategies—including Redis caching, lazy metric handling, and custom byte‑array serialization—and documents the resulting latency reductions and implementation considerations.
This article provides a detailed walkthrough of Nacos' configuration center long‑polling mechanism, covering both client‑side initialization, reflection‑based service creation, scheduled tasks, cache handling, and server‑side request processing, with code examples and architectural diagrams to illustrate each step.
Recent disclosures revealed critical Spring DoS flaws (CVE‑2024‑38809 and CVE‑2024‑38808) exploitable via oversized If‑Match/If‑None‑Match headers and malicious SpEL expressions, plus a Nacos 2.4.1 vulnerability allowing arbitrary file read/write through port 7848, mitigated by upgrading to the patched Spring and Nacos releases or restricting the vulnerable ports.
This article explains how to implement an online‑user counter using Redis sorted sets by detailing the four essential ZSET commands, fingerprint‑based user identification, Java and JavaScript code examples, and scheduled cleanup for accurate real‑time statistics.
A large table with tens of millions of rows caused 20‑second query times, but by decoupling reads through RabbitMQ and writing data asynchronously to Elasticsearch, query latency dropped to 500 ms, with Java code examples for both producer and consumer, sync handling, and migration tips.
This article explains what a dynamic thread pool is, why it is needed, how to modify its core parameters at runtime, how to monitor and expose its metrics, and lists open‑source implementations and visualization/alerting options such as Prometheus, Grafana, Hippo4j and Dynamic TP.
This article explains how to replace repetitive try‑catch blocks in Java backend code with a unified exception handling mechanism based on Spring's @ControllerAdvice, custom Assert utilities, and error‑code enums, resulting in cleaner, more maintainable services and controllers.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering tenant isolation, database strategies, dynamic routing, security configuration, deployment scenarios, and provides complete code examples for building SaaS‑ready applications.
This tutorial demonstrates how to use the open‑source YARG library with Spring Boot 3.2.5 to create Word (.docx) reports by preparing a template, loading it, supplying JSON data, defining a data band, and running the report generation code, complete with Maven dependencies and example screenshots.
This article dissects Nacos' configuration center long‑polling mechanism, detailing the client‑side initialization, thread‑pool scheduling, cache handling, and server‑side request processing, while illustrating the flow with code snippets and diagrams to help developers understand real‑time config synchronization.
This article explains how to design a multi‑level workflow approval system using the Activiti engine, covering process diagram creation, deployment, task handling, variable management, exclusive gateways, and complete project configuration with Spring Boot and an H2 database.
This article explains how to dynamically load JAR files in a Spring Boot application, covering core concepts, benefits, usage of SpringBootClassLoader, creation of JARs, and alternative third‑party OSGi‑resource‑locator approaches with full code examples.
This guide explains SpringBoot's built‑in performance monitoring interceptors, demonstrates how to configure them with custom annotations, pointcuts, and advisors, and shows how to extend SimpleTraceInterceptor and CustomizableTraceInterceptor for detailed method‑execution logging and timing.
This article explains Java meta‑annotations—@Target, @Retention, @Documented, and @Inherited—detailing their purposes, possible values, and providing code examples to show how they control annotation scope, lifecycle, documentation inclusion, and inheritance in Java programs.
The article compares Maven and Gradle, detailing their histories, core concepts, advantages, disadvantages, and performance differences, and offers practical advice for Java developers on choosing the most suitable build tool for their projects.
The article explains how to protect Spring Boot applications from XSS attacks by using custom annotations such as @XSS with an XssValidator and by implementing a request‑filter chain—including XssFilter and XssWrapper—to sanitize input, demonstrating through tests that both approaches reliably secure user data.
This article details a step‑by‑step investigation of a Netty off‑heap memory leak that caused Nginx 5xx errors, covering background, alert analysis, multiple debugging stages, reflective monitoring, the root‑cause NPE fix, and verification in both local and production environments.
This article reviews the most popular Java frameworks for 2024, explaining their purpose, key features, and how they help developers build scalable, secure, and efficient web applications across various industries.
This article details a step‑by‑step investigation of a Spring Boot application that consumed far more physical memory than its 4 GB heap limit, revealing a native‑memory leak caused by MCC's package‑scanning using Reflections and the Spring Boot ZipInflaterInputStream, and explains how configuration changes and newer Spring Boot versions resolve the issue.
This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.
This article compares three approaches for verifying username uniqueness during app registration—direct database queries, Redis caching, and Redis-backed Bloom filters—detailing their performance, scalability, memory usage, and trade‑offs, and provides Java code examples for each solution.
This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.
This article walks through a Java Spring‑Boot implementation of a contract‑signing workflow, explains the original chain‑of‑responsibility design, shows its limitations, and demonstrates how to replace manual bean wiring with a strategy‑based annotation and enum configuration for flexible node management.
The article details how a production Spring Boot system consumed excessive memory due to default JVM heap settings, explains the underlying JVM defaults, demonstrates diagnostic commands, and provides practical recommendations for configuring JVM parameters and monitoring memory usage to prevent similar issues.
This article provides a concise yet comprehensive guide to the most common SpringBoot annotations—including @SpringBootApplication, @EnableAutoConfiguration, @ComponentScan, @Service, @Repository, @Component, @RestController, @Bean, @ResponseBody, and @Autowired—explaining their purpose, composition, and practical code examples for building robust Java backend applications.
This article explains the differences between placing a try‑catch block inside or outside a for loop in Java, covering usage scenarios, execution results, performance impact, and practical advice for choosing the appropriate approach during development and interviews.
This article explains Java thread pools, their advantages, internal mechanics, common pitfalls such as oversized queues, excessive threads, and data loss on crashes, and presents a persistence‑based solution using database‑stored tasks and scheduled retries to ensure no data is lost when services go down.
This article explains why Java ORM frameworks are essential for simplifying database access, outlines the critical criteria for selecting the right ORM, compares popular choices such as Hibernate, JPA, EclipseLink, and DataNucleus, and provides a step‑by‑step guide for successful implementation.
The article introduces mybatis-mate, an enterprise‑grade MyBatis module that supports sharding, multi‑datasource, data auditing, field encryption, sensitive‑data masking, automatic DDL maintenance, performance logging, and fine‑grained data‑scope control, providing code examples and configuration guidelines for Spring Boot projects.
This article explains traditional session mechanisms, challenges in clustered environments, and presents solutions such as session replication and centralized storage, then details the design and implementation of a CAS-based Single Sign-On system in Java, including code for user forms, controllers, filters, and configuration.
This article explains a real‑world incident where insecure API parameters led to leaderboard manipulation, then details how to securely combine RSA asymmetric encryption with AES symmetric encryption, covering key concepts, padding modes, implementation steps, and server‑side decryption using Java.
This article explains the concept of JavaAgent, its underlying mechanism using the JVM instrumentation API, and provides a step‑by‑step guide with code samples to build a JavaAgent that measures method execution time in a Spring application.
This course provides an in‑depth exploration of the technical challenges faced by Java architects, covering Spring bean lifecycle, AOP, transaction mechanisms, SpringBoot auto‑configuration, JVM memory models, MySQL indexing, Redis caching, microservice patterns, distributed locks, and performance optimization techniques across 99 video modules.
This article explains the motivations for upgrading to JDK21, introduces Generational ZGC, details integration steps and monitoring setup, presents performance test results comparing ZGC and Generational ZGC, and outlines future plans for Java services at Zhaozhuan.
This article explains how to use the Activiti workflow engine to design a multi‑level leave‑approval process, covering BPMN diagram creation, Spring Boot configuration, deployment, Java code for starting instances, task handling, database schema, API overview, and tips for extending the workflow without additional code.
Java virtual threads, introduced in JDK 21, decouple Java threads from OS threads by using continuations and a ForkJoinPool scheduler, allowing millions of cheap, blocking‑friendly threads that boost throughput and simplify concurrent code compared to traditional platform threads or reactive frameworks, as demonstrated by performance benchmarks.
The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.
This article introduces Java 8's Stream API, explains its declarative pipeline model for filtering, mapping, sorting, and collecting data, demonstrates each operation with a UserPo example, and provides complete runnable code including parallel streams and statistical summaries.
This article explains Java’s preview Null‑Restricted and Nullable type system, showing how the new syntax (Foo! and Foo?) lets developers explicitly declare nullability, improves compile‑time safety, integrates with existing code, and compares the approach to TypeScript’s ! and ? operators.
Learn how to simplify repetitive error-handling code in Spring Boot by creating a custom @ErrorHandler annotation that leverages Spring AOP to automatically log exceptions, with step-by-step instructions, required dependencies, annotation definition, aspect implementation, and usage examples.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts OSS object‑storage services via the Amazon S3 protocol, covering project setup, Maven dependencies, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
This article walks through SkyWalking, an open‑source APM solution, covering its architecture, server and client installation, configuration for MySQL persistence, log collection, performance profiling, and alerting, while comparing it with Spring Cloud Sleuth + Zipkin and showing practical code examples.
This article provides a detailed tutorial on Maven, covering repository configuration, basic project structure, dependency management, module inheritance, unified version control, and common build plugins such as jar, assembly, and shade, with practical XML examples and code snippets for Java backend projects.
This article explains how to use SLF4J as a facade for Logback or Log4j2, shows Maven dependencies, demonstrates logback.xml and logback‑spring.xml configurations, covers Spring Boot's default logging setup, custom log levels, profile‑based settings, and how to switch to Log4j2 for higher performance.
The article explains Java's parent delegation model for class loaders, its benefits for stability and security, how to break it by customizing loadClass or using thread‑context class loaders, and illustrates common scenarios such as JNDI, JDBC and Tomcat's own class‑loader hierarchy.
This article details the background, requirements, and evaluation of migration options for the appointment service, explains why a double‑write approach with a custom MyBatis plugin was chosen, and walks through the full‑sync, incremental sync, code refactoring, plugin implementation, switch‑over procedures, and post‑migration validation to achieve reliable data isolation and system stability.
This guide explains how to enable comprehensive request logging, use request/response wrappers, implement once‑per‑request filters, and define clean controller interfaces in Spring Boot 3.2.5, providing code examples and configuration tips for robust backend development.
The article explains how Java’s invokedynamic instruction and LambdaMetafactory create synthetic classes and MethodHandles to implement Lambda expressions, detailing compilation steps, stateless versus stateful handling, performance implications, and the requirement for captured variables to be effectively final.
This article explains how Java 8 functional interfaces such as Supplier, Consumer, Runnable and custom @FunctionalInterface types can replace verbose if‑else and exception handling code, providing clear examples, utility methods, and branch‑handling patterns for cleaner backend development.
Graceful Response is a Spring Boot component that offers one‑stop unified response packaging, global exception handling, and custom error code support, enabling developers to simplify controller code, reduce boilerplate, and improve readability and efficiency.
This article explains why exceptions thrown by tasks submitted to a Java thread pool behave differently with submit and execute, demonstrates how to capture those exceptions using Future.get, try‑catch, Thread.setDefaultUncaughtExceptionHandler, and by overriding afterExecute, and provides complete code examples for each approach.
This article provides a comprehensive guide on integrating Spring Boot with the open‑source distributed scheduler XXL‑Job, covering installation, configuration of the admin console and executor, code examples, parameter details, comparison with other schedulers, and best practices for reliable task management.
This article explains the concepts of role‑based access control (RBAC), compares RBAC models, shows how to configure permissions and user groups, and provides step‑by‑step code examples for integrating Spring Security with JWT, JSON login, password encryption and database authentication in Java backend applications.
Lock4j is a Java distributed lock library supporting Spring AOP, RedisTemplate, Redisson, and Zookeeper, offering simple usage, configurable properties, annotation-driven locking, custom executors, key generators, and failure strategies, with detailed setup, code examples, and advanced customization instructions.
This article explains the principles and source‑code flow of Nacos configuration center’s long‑polling mechanism, detailing how the client initiates periodic tasks, how the server processes listener requests, and how configuration changes are detected and propagated through various internal classes and threads.
This article introduces eight common Java asynchronous implementation techniques—including raw threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, third‑party utilities like Hutool ThreadUtil and Guava ListenableFuture—explaining their usage, code examples, advantages, and drawbacks for improving performance in scenarios such as sending SMS or emails.
This article explains how to implement interface debounce in Java backend services, covering the concept, identifying suitable APIs, generating unique keys, and applying distributed locking mechanisms with Redis and Redisson, including code examples and practical testing results.
The article outlines frequent Java pitfalls—including BigDecimal precision loss, immutable lists from Arrays.asList, double division by zero returning Infinity, null values in switch statements, stream filters mutating original objects, and autoboxing nulls causing NullPointerExceptions—and provides clear explanations and practical fixes to enhance code reliability.
This article explains why the backend services were upgraded from JDK 8 to JDK 21, introduces the generational ZGC garbage collector, details its architecture, tuning parameters, integration steps, monitoring setup, and presents performance test results that demonstrate reduced allocation stalls, lower latency, higher throughput, and near‑zero GC pauses.
This article explains Java's EnumMap, covering its definition, key characteristics, how to create and use it with code examples, its efficient array‑based implementation, and practical test cases, demonstrating why EnumMap is a high‑performance map for enum keys in backend development.
This article introduces the ArthasHotSwap plugin, explains why hot‑updating a few Java classes in a test environment can save minutes compared to full redeployment, and provides step‑by‑step instructions—including downloading, compiling, uploading bytecode to OSS, and applying the changes on the server—complete with code snippets and screenshots.
This article explains how to integrate JSON Schema validation into a Spring Boot application, covering dependency setup, schema definition, bean configuration, service implementation, controller exposure, and testing with curl to ensure JSON payloads conform to the defined rules.
This article explains how Java's ConcurrentHashMap provides thread‑safe, high‑performance map operations by comparing the segmented‑lock design of JDK 7 with the fine‑grained locking and CAS approach of JDK 8, and includes a practical multithreaded code example.
This article explains why API debounce is essential, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson lock—along with complete Java code examples and deployment tips for preventing duplicate submissions in a Spring Boot backend.
The article explains Java's virtual threads introduced in Java 19, compares them with traditional threads, and demonstrates how to configure Spring Boot to use virtual threads, including code samples and performance benchmarks that show dramatic latency reductions in both async services and HTTP requests.
This article provides a comprehensive overview of SpringBoot’s most commonly used annotations, covering MVC, bean, JPA, configuration, exception handling, and testing annotations, complete with clear explanations and practical code examples to help developers avoid pitfalls and write cleaner code.
Using JDK 21’s standardized Virtual Threads, this guide explains how to design and implement robust asynchronous batch processing, covering common pitfalls like CPU spikes and OOM, best‑practice concurrency controls, task queue architecture, and practical code illustrations.
This article explains how to use RocketMQ's message backtracking feature to reset consumer offsets, covering problem background, verification steps, core process analysis, code examples, and comparative evaluation of different approaches in real-world scenarios.
This article explains how to design a flexible TreeNode interface and a TreeUtil class in Java that convert flat collections into hierarchical tree structures, provides multiple static methods for object and JSON tree generation, and discusses optimization techniques for large data sets.
The article demonstrates how PowerMock can be used to unit‑test a Java FileParser class—showing basic mocks for files and streams, advanced techniques for final and static classes, and achieving full coverage—while warning that its heavy class‑loader overhead can dramatically slow large test suites and increase memory consumption.
