This article explores how mutating the fields of an object used as a HashMap key corrupts its hash code, causing look‑ups to fail, and walks through the underlying source code of put, hash, getNode and related methods to reveal why this happens.
This article explains how Agrona's lightweight AgentRunner replaces the standard Java ExecutorService to manage long‑running tasks with minimal thread‑context switching, using the Agent model and customizable IdleStrategy to achieve high throughput and low latency in concurrent Java systems.
This article walks through installing Ollama, downloading the DeepSeek‑r1:1.5b model, configuring Spring AI in a Spring Boot 3 project, and exposing the model via a REST endpoint with Server‑Sent Events, providing complete code snippets and step‑by‑step screenshots for a functional AI integration.
This article explains how ThreadLocal stores values per thread, details the internal set and get mechanisms, discusses potential memory‑leak problems caused by stale entries, and provides best‑practice guidelines such as using remove() and InheritableThreadLocal for child threads.
This article introduces the Java JSch library for Spring Boot 3, demonstrating how to read remote files without downloading, execute commands on a remote host, and obtain an interactive shell prompt, complete with Maven dependency setup, code examples, and execution results, while promising ongoing updates to the case collection.
This guide walks you through downloading Byteman, setting up BYTEMAN_HOME, using Ant or Maven for integration, building from source, configuring the Java agent with detailed options, and leveraging tutorials for effective fault‑injection testing in Java applications.
This article explains the LeetCode 75 "Sort Colors" challenge, detailing the problem statement, constraints, a three‑pointer Dutch National Flag solution, and provides complete implementations in Java, C++, C, and Python without using built‑in sorting functions.
The article presents a comprehensive design for securing third‑party API calls by generating unique Access Key/Secret Key pairs, defining permission scopes, implementing signature generation and verification, employing timestamps and nonces to prevent replay attacks, and outlining practical API endpoint specifications and response standards.
This article explains how the @TableLogic annotation in MyBatis-Plus implements logical deletion by converting delete operations into updates, details its parameters, supported field types, global configuration, and provides complete Java and SQL code examples for practical usage.
This comprehensive guide covers RabbitMQ fundamentals, installation on Windows, Linux, and Docker, configuration for durability and monitoring, Java integration examples, high‑availability architectures, clustering, and practical troubleshooting tips for building reliable distributed systems.
This article explains the differences and usage of Apache Commons Lang3 StringUtils methods such as isEmpty, isNotEmpty, isAnyEmpty, isNoneEmpty, isBlank, isNotBlank, isAnyBlank, and isNoneBlank, providing code examples and behavioral details for handling null, empty, and whitespace strings in Java.
This article introduces the Liteflow lightweight rule engine for Java, explains its architecture, configuration, component types, EL rule file syntax, data context handling, and demonstrates a practical e‑commerce workflow, highlighting hot‑deployment and performance benefits for backend development.
This article demonstrates how to improve the performance of nested for‑loops that match user IDs between two large lists by adding a break statement and by converting the inner list into a hash map, reducing execution time from tens of seconds to a few seconds.
This tutorial explains China’s electronic‑seal regulations, shows how to generate a CA‑based X.509 certificate and a custom seal image with BouncyCastle, and demonstrates signing a PDF in Java using iText 5 to embed a visible seal and a verifiable digital signature.
This article explains how to integrate DeepSeek's large language models—both the chat‑oriented deepseek‑chat and the reasoning‑focused deepseek‑reasoner—into a Spring AI application, covering API key setup, base‑URL configuration, model selection, and providing full code examples for dependency, configuration, and a simple chat controller.
This guide walks through the need for PDF generation in business scenarios, introduces the iText library (both iText5 and iText7), shows how to add Maven dependencies, provides a minimal “Hello World” PDF example, then details converting HTML (with CSS, images, and Freemarker variables) into PDF, and discusses when custom adaptation is required.
This article explains how Spring's @Value annotation can inject literal strings, file values, system properties, defaults, arrays, maps, and SpEL expressions into fields, constructors, setters, and Java records, providing practical code examples for each scenario.
This article explains the design and implementation of a flexible, extensible Java multithreaded task class for performance testing, covering the choice of Runnable over Thread, execution control mechanisms, data collection methods, and sample abstract code illustrating before, test, and after lifecycle hooks.
This guide explains how to configure the Alipay sandbox, set up an Ngrok tunnel for external callbacks, add the Alipay Java SDK dependency, create Spring Boot configuration and controller classes, implement the payment flow and callback handling, and troubleshoot common initialization errors.
The article examines Python's recent dominance in AI, cites industry rankings and surveys, presents Simon Ritter's claim that 2025 may be Python's last peak year, and explores whether Java's performance projects and enterprise strengths could soon make it the leading language for AI development.
The article explains the Facade design pattern and demonstrates its use in a Spring Boot travel‑booking application, where a BookingFacade aggregates FlightService, HotelService, and PackageService to provide a single bookTravel method that a REST controller calls, simplifying the API and reducing coupling.
This tutorial explains how to prepare the environment, install the CodeGPT plugin, configure DeepSeek API keys and model settings in IntelliJ IDEA, and use the AI assistant for code generation, completion, explanation, and troubleshooting, while also showing usage statistics and a complete Java example.
This article introduces the lightweight Lua scripting language, outlines its key features and typical use cases, and provides a complete example of using Redis together with Lua scripts (and a Java client) to enforce IP‑based login‑attempt limits for improved security.
This article explains why and how to use Maven's dependency:analyze command in IntelliJ IDEA to identify used undeclared and unused declared dependencies, offering practical steps, risk considerations, and tips for maintaining clean Java backend projects.
This article explains the Concurrent Mark Sweep (CMS) garbage collector, detailing its five phases—Initial Mark, Concurrent Mark, Remark, Concurrent Sweep, and Concurrent Reset—while highlighting how each step works to minimize pause times during old‑generation memory reclamation in Java.
This article presents a continuously updated collection of over 90 practical Spring Boot 3 examples, covering request/response access, ThreadLocal handling, async interceptors, request metadata extraction, custom type converters, 404 error handling, and related source code to help developers build robust backend services.
This article analyzes Kuaishou's development of a Java 17 transparent coroutine solution, detailing its architectural evolution, scheduling and I/O optimizations, performance gains in cloud‑native high‑load environments, and future directions for large‑scale production deployment.
This article explains how Spring AI Alibaba enables AI agents to leverage Retrieval‑Augmented Generation and Tool Calling by providing over twenty ready‑made RAG data source connectors and more than twenty function‑calling interfaces, along with practical code examples for integrating document readers and weather services.
This article reviews major open‑source Java workflow engines—including Osworkflow, JBPM, Activiti, Flowable, and Camunda—examines their features, version histories, and suitability, then provides a detailed functional and performance comparison between Flowable and Camunda, concluding with a recommendation to adopt Camunda with bpmn‑js for enterprise projects.
This article investigates the time cost of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and simple code examples to quantify latency and illustrate why connection pooling is essential for high‑traffic services.
The article explains the Helper class’s built‑in thread coordination operations—including Waiters, Rendezvous, Joiners, and execution‑aborting methods—detailing their APIs, usage scenarios, parameters, and behavior such as signaling, timeouts, rejoinable points, and how they differ from standard Java synchronization primitives.
This article explains how Byteman's IMPORT declaration lets developers explicitly reference classes across modules, handling classloader scopes, providing code examples, key points, and plugin support for various Java module systems.
This article introduces a continuously updated Spring Boot 3 case collection and PDF e‑book, then dives into the @Conditional annotation, custom condition interfaces, parameterized enhancements, SpringBootCondition usage, and multi‑condition combinations, providing complete code examples and test results.
The article reviews several Java backend technologies—JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC, and XML—explaining why they are now considered obsolete or low‑priority and recommending modern alternatives such as Spring MVC, MyBatis, and deep Servlet knowledge for current development.
The article examines how Java Stream and Lambda, while powerful for concise code, can become cumbersome when overused, and offers practical tips such as proper line breaks, function extraction, predicate reuse, cautious Optional handling, and mindful use of parallel streams to maintain readability and performance.
The article shows how to replace hard‑coded strings in Spring Boot configuration files with type‑safe Java enums, using @ConfigurationProperties to bind YAML values to enum fields, thereby improving readability, maintainability, and eliminating magic numbers, illustrated through a user‑role example with controller and Thymeleaf view.
This article examines the drawbacks of using Java's primitive int type to store phone numbers, explains how primitive and reference types differ in memory and performance, and demonstrates why the String type, with JVM optimizations like the string pool, provides a safer, more flexible solution for global telephone data.
This article explains Apache Tika’s core features and architecture, outlines common use‑cases, and provides a step‑by‑step Spring Boot tutorial—including Maven/Gradle setup, a service that extracts text with Tika, regex‑based sensitive‑info detection, a REST controller, optional front‑end, testing instructions, expected output, and extension ideas.
Java serialization, while convenient for object persistence, suffers from security vulnerabilities, versioning issues, performance constraints, and difficulties handling complex object graphs, prompting developers to evaluate alternatives such as JSON, Protocol Buffers, and Apache Avro, each offering distinct trade‑offs in readability, efficiency, and safety.
Learn step-by-step how Java developers can obtain a DeepSeek API key, understand the chat and reasoning models, and implement them with Apache HttpClient, covering code examples, key parameters, best practices, and real-world use cases such as smart customer service, education tools, and code generation assistants.
This article demonstrates how to wrap EasyExcel within a Spring Boot + MyBatis‑Plus project, providing step‑by‑step guidance on environment preparation, component design, usage examples, full source code, and solutions to common issues such as template export, date conversion, and POI version compatibility.
This guide explains why real‑time data synchronization between MySQL and services like Redis, Memcached, Solr, or Elasticsearch is essential in modern micro‑service architectures, and demonstrates four synchronization methods—inline code, scheduled tasks, message queues, and Canal—complete with setup, configuration, and Java code examples.
This article explains why asynchronous programming boosts Java application performance and walks through seven practical methods—Thread, FutureTask, CompletableFuture, Guava ListenableFuture, EA‑Async, Cactoos, and Jcabi‑Aspects—each illustrated with complete, runnable code examples.
This tutorial explains how to prepare the environment, install the CodeGPT plugin, configure DeepSeek with an API key, set up chat and inference models in IntelliJ IDEA, and use the AI assistant for code generation, completion, explanation, and token usage monitoring, all illustrated with Java examples.
This article explains how to handle image resizing, watermarking, rotation, and batch processing in Java using the Thumbnailator library, provides Maven setup, detailed code examples, and demonstrates seamless integration with Spring Boot for uploading and serving processed images.
A recent Azul Systems study suggests that Java may surpass Python in enterprise AI development within the next 18‑36 months, highlighting Java's scalability, performance, and emerging GPU projects while acknowledging cultural and tooling advantages that still favor Python.
The article explains how to manage Maven dependencies in Java projects by using the mvn dependency:analyze command in IntelliJ IDEA to detect unused or undeclared libraries, interpret the results, clean up the pom.xml, and follow best‑practice testing to ensure project stability.
This guide walks Java developers through preparing the environment, installing the CodeGPT proxy plugin, adding the DeepSeek AI plugin, configuring API keys and model endpoints, and using the assistant for code generation, completion, explanation, and troubleshooting within IntelliJ IDEA.
This article provides a step‑by‑step guide to installing the DeepSeek AI code‑assistant plugin (via CodeGPT) in IntelliJ IDEA, configuring the required Python environment and API key, using its code‑completion, explanation, and question‑answer features, and also includes usage statistics and a brief promotion of a paid plugin bundle.
This guide walks through setting up a Spring Boot project, adding PDF.js static assets, creating a preview page, implementing a backend controller to serve PDF files, configuring MIME types, and testing the integrated PDF viewer for proper functionality.
The article highlights how vague requirements, weak architecture, and inconsistent team habits undermine non‑functional quality, then offers Java‑focused guidance on using concise comments, proper Javadoc, self‑documenting code, clear exception versus business‑error handling, and balancing standard interfaces with targeted specialization to improve maintainability and performance.
FastExcel is a high‑performance Java library that extends EasyExcel, offering streamlined APIs, streaming read/write, event listeners, and PDF conversion, enabling developers to efficiently handle large Excel files with low memory usage in enterprise applications.
This article explains how to create custom Java class loaders by extending java.lang.ClassLoader, when to override findClass versus loadClass, demonstrates both adhering to and breaking the parent delegation model with complete code examples, and discusses common scenarios such as web servers, SPI, and hot deployment where the delegation mechanism is intentionally altered.
This article explains Java's class loading mechanism, the three built‑in class loaders, the parent‑delegation model, reasons for using it, how to create custom loaders, and the detailed phases of loading, linking, initialization, usage, and unloading.
This guide walks you through preparing the environment, installing the CodeGPT plugin, configuring DeepSeek with API keys, and using its code generation, completion, explanation, and question‑answer features inside IntelliJ IDEA, while also showing how to monitor token usage.
This guide walks Java developers through preparing the environment, installing the CodeGPT plugin, configuring DeepSeek API keys, and using the DeepSeek AI assistant within IntelliJ IDEA to generate, complete, explain, and troubleshoot code, while also showing usage statistics.
This article walks senior Java developers through MyBatis fundamentals, core components, result mapping, the trade‑offs between #{} and ${}, dynamic SQL, second‑level caching, batch inserts, plugin creation, thread‑safety concerns, and concrete interview‑question solutions, all illustrated with real code snippets and performance numbers.
This article explains Byteman's injection point specifiers—AT LINE, AT READ, AFTER READ, AT WRITE, AFTER WRITE, AT INVOKE, AFTER INVOKE, AT NEW, AFTER NEW, AT SYNCHRONIZE, AFTER SYNCHRONIZE, AT THROW, and AT EXCEPTION EXIT—detailing their syntax, matching rules, counting options, and practical usage in Java bytecode instrumentation.
This article explains why Spring Boot 3 uses Jackson for JSON handling, describes four effective methods—JsonNode, Map, @JsonAnySetter, and custom deserializer—to process dynamic JSON properties, and promotes a continuously updated collection of over 90 Spring Boot case studies with source code.
This article provides a step‑by‑step tutorial on integrating the Flowable BPMN workflow engine into a Spring Boot application, covering dependencies, BPMN diagram creation, task configuration, service implementation, process visualization, and common pitfalls such as font issues and process definition updates.
This guide shows how to implement dynamic MySQL master‑slave switching in a SpringBoot 3 project using AOP and a custom @DataSource annotation, configuring Druid pools, defining a routing datasource, and automatically falling back to the master when a slave fails for high availability.
This article explains the Facade design pattern, its purpose of simplifying complex systems, outlines its benefits and UML structure, and demonstrates a complete Spring Boot example that encapsulates flight, hotel, and package services behind a BookingFacade for a travel‑booking application.
This article explains how to improve performance of massive IN‑list database queries in Java by defining custom Spring AOP annotations that automatically split the parameter list, execute the sub‑queries concurrently in a thread pool, and merge the results using a configurable return‑handling strategy.
This article explains the Java Virtual Machine's two subsystems—Class Loader and Execution Engine—and its two main components—Runtime Data Area and Native Interface—detailing their functions, internal structures, and the overall execution workflow of Java programs.
This article explains how to select and customize a Java thread pool for performance testing, covering parameter considerations, modifications to the standard fixed thread pool, custom thread factories, work queue choices, and provides complete example code for both fixed and TPS models.
Explore how Spring Boot 3 leverages the @ExceptionHandler annotation to centralize error handling, customize responses based on the Accept header, configure view beans for HTML errors, and utilize new Spring 6.2 attributes, with complete code examples and testing guidance.
When a Linux server's CPU spikes to 100%, this guide walks you through a systematic investigation—from identifying the high‑load process and pinpointing the offending Java thread to applying a streamlined shell script—so you can resolve the issue and restore normal performance.
By combining EasyExcel’s low‑memory parsing with Java 8 functional style, reflection‑based generic annotations, a thread‑pool‑driven batch listener, and flexible export utilities that support dynamic headers and map‑based rows, Java back‑ends can safely import and export millions of Excel rows without OOM errors.
Java 24, a short‑term JDK release slated for March 2025, introduces 24 new features—including two experimental JEPs, one incubator JEP, seven preview JEPs, and fourteen permanent JEPs—while outlining Oracle’s roadmap toward the subsequent long‑term Java 25 version.
This guide details how to integrate WeChat native payment into a Java backend, covering merchant setup, Spring configuration, QR‑code generation with the official SDK, handling HTTPS callbacks, and implementing front‑end polling using Redis and Bloom filters for reliable membership upgrades.
The Next Permutation problem asks to rearrange an integer array into the immediate lexicographically larger ordering—or the smallest order if none exists—by scanning from the right to find the first decreasing pair, swapping with the next larger element, and reversing the suffix, using O(1) extra space, with implementations provided in Java, C++, and Python.
This article introduces the lightweight Sa-Token Java authentication framework, explains why it is chosen over Spring Security and Shiro, details its login and permission APIs with code examples, shows how to configure it in Spring Boot and WebFlux projects, and lists its extensive feature set for secure backend development.
This article explains Java's reflection mechanisms, comparing Class.forName and ClassLoader as two primary ways to load classes, detailing their behavior, static initialization effects, code examples, and practical scenarios such as loading JDBC drivers versus custom dynamic loading.
MapStruct is a compile‑time Java annotation processor that automates bean mapping, offering concise, high‑performance, type‑safe conversions, and advanced features such as expression mapping, qualifiedByName methods, null‑value strategies, and decorators, with full IDE support and illustrative code examples.
The Spring Boot starter automatically registers XXL‑Job executors and job handlers at application startup by logging into the admin console, scanning beans for methods annotated with @XxlJob and @XxlRegister, and invoking the admin APIs to create missing groups and jobs, eliminating manual configuration.
This article introduces the QLExpress rule engine, outlines its key features such as thread‑safety and high‑performance execution, and provides step‑by‑step Spring Boot 3 integration examples—including dependency setup, simple expressions, function definitions, operator aliases, macro usage, and variable querying—complete with runnable code snippets and output illustrations.
This article reviews Java Spring code for a coupon claim and approval workflow, identifies concurrency and transaction issues such as missing locks and inconsistent update order, and proposes optimizations including user‑level locking, simplifying lock management, and aligning transactional update sequences to prevent deadlocks.
By switching from a naïve per‑record insert to JDBC batch writes with rewriteBatchedStatements and then off‑loading those batches to multiple consumer threads via a LMAX Disruptor ring buffer, the XML‑to‑MySQL import of 60,000 rows dropped from roughly 300 seconds to about 4 seconds while keeping memory usage modest.
This article introduces UniHttp, a declarative Java HTTP client framework that simplifies third‑party API integration by using annotations to generate request metadata, supports various parameter types, lifecycle hooks, custom processors, and provides practical enterprise‑level examples with full code snippets.
This article compares three Java concurrency approaches—Future with Callable, CompletableFuture, and FutureTask—explaining their underlying principles, step‑by‑step usage, code examples, and trade‑offs so you can decide which asynchronous tool best fits your reporting workload.
To avoid the O(n × m) cost of naïve nested loops when matching IDs, replace the inner scan with a break after a unique match or, far more efficiently, build a HashMap of the secondary list so each lookup becomes O(1), dropping overall complexity to O(n + m) and cutting execution time from tens of seconds to a few hundred milliseconds.
This article describes an experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated per HTTP and RPC request, detailing the setup, GC logging configuration, results showing average memory consumption around 34 KB per request, and recommendations for logging and performance optimization.
Java 21’s virtual threads provide a lightweight, JVM‑managed alternative to OS threads that enables hundreds of thousands of concurrent tasks, simplifies scheduling, integrates easily into Spring Boot via a preview flag and Tomcat executor, and delivers up to five‑fold speed‑ups and lower latency in high‑load I/O‑intensive applications.
This article presents seven practical methods for recording API request logs in Spring Boot 3, including Filter, HandlerInterceptor, AOP, event listeners, Logbook, custom HandlerMethod, and RestTemplate/RestClient interceptors, complete with code samples, configuration steps, and execution screenshots.
This article presents fifteen useful Spring techniques—including bean retrieval, event handling, custom interceptors, retry mechanisms, global exception handling, startup initialization, bean lifecycle methods, resource cleanup, dynamic configuration injection, conditional bean registration, caching, transaction management, bean loading order, AOP aspects, and conditional bean creation—each illustrated with clear Java code examples.
This article lists eight common beginner programming mistakes—from using wrong punctuation and forgetting WHERE clauses to leaking resources, storing passwords in plain text, exposing API keys, mixing environments, force‑pushing code, and committing secrets—explaining why they happen, showing concrete code examples, and offering practical fixes.
This article walks through a systematic, eight‑step approach to sizing and configuring JVM memory parameters—including heap, young generation, stack, object age thresholds, and garbage‑collector selection—so that a service handling one million daily logins on an 8 GB machine can achieve stable performance and predictable GC behavior.
This tutorial explains how to combine Spring Boot and Redis using Lua scripts, covering Lua fundamentals, performance advantages, practical use cases, step‑by‑step implementation in Spring Boot, error handling, security considerations, and best‑practice recommendations for backend developers.
This article explains common interview questions on frequent Full GC and high CPU usage in Java backend development, detailing root causes, JVM parameter adjustments, memory leak prevention, and code optimization techniques, along with practical code examples and tool recommendations for effective performance tuning.
LeetCode 57 asks you to insert a new interval into a sorted list of non‑overlapping intervals, merging any overlaps so the result stays sorted and disjoint, and the article explains the O(n) algorithm and provides concise implementations in Java, C++ and Python.
This article presents twelve practical MyBatisPlus optimization techniques—including avoiding isNull, specifying select fields, batch operations, using EXISTS, safe ordering, LambdaQuery, between, index‑aware sorting, pagination, null‑handling, performance tracking, enum mapping, logical deletion, and optimistic locking—to help Java developers write cleaner, more efficient backend code.
This article explains common CPU and JVM memory bottlenecks in Java applications, shows how to detect abnormal usage with monitoring and alerts, and provides step‑by‑step methods—including top, jstack, flame‑graph analysis, and APM tools—to pinpoint and resolve performance hotspots efficiently.
This article systematically explains the importance of rate limiting in microservice systems, compares various governance frameworks such as Dubbo and Spring Cloud, introduces common algorithms like token‑bucket and leaky‑bucket, and provides detailed implementation examples using Guava, Sentinel, Redis+Lua, and a custom Spring Boot starter.
This article introduces MapStruct, a compile‑time Java bean mapping framework, and demonstrates advanced features such as expression‑based mappings, qualifiedByName custom converters, nullValueMappingStrategy handling, and decorator‑based post‑processing with concrete code examples for Spring‑based projects.
This article introduces the LiteFlow rule engine, explaining its architecture, supported rule file formats, component types, EL rule definitions, data context handling, configuration options, and demonstrates its application in an e‑commerce order processing scenario, highlighting hot‑deployment and performance benefits for Java backend development.
This article details a Java GC optimization performed on a nightly batch service, describing the original high GC and CPU load issues, the JVM parameter adjustments, memory re‑allocation, and the resulting significant reductions in GC frequency, CPU usage, and request latency.
This article explores practical HTTP retry solutions for offline store applications, covering a basic loop retry, the built‑in retry mechanism of Apache HttpClient with custom handlers, and an asynchronous retry approach using message queues to achieve higher reliability and eventual consistency.
This article explains how to use Spring Boot's @Import annotation to modularize applications, add scanning entry points, and dynamically register beans via ImportSelector and ImportBeanDefinitionRegistrar, including code examples and configuration tips for Maven multi‑module projects.
This article announces a Spring Boot 3 practical case collection and provides a comprehensive Flyway tutorial—including installation, configuration, migration scripts, multi‑datasource usage, and visual verification—so developers can confidently manage database schema changes in Java backend projects.
This article explains the concepts, lifecycle methods, and configuration of Spring Boot's Filter, Interceptor, and AOP mechanisms, compares their execution order, and shows code examples to help developers choose the right technique for adding cross‑cutting functionality without altering core business logic.
