This article explains how Jackson's @JsonAnySetter and @JsonAnyGetter annotations let Java classes gracefully handle unknown JSON properties by collecting them into a map during deserialization and emitting them as regular fields during serialization, complete with practical code examples and usage tips.
This article explains how to implement a precise sliding‑window rate‑limiting algorithm using Redis Sorted Sets, detailing the problem scenario, the algorithm steps, Lua script implementation, Java integration, and practical extensions for high‑performance backend services.
This article explains how Java 8's LambdaMetafactory combines the flexibility of reflection with performance close to direct method calls, covering its usage, underlying mechanics, benchmark results, and practical trade‑offs for high‑frequency invocation scenarios.
This article explains the distinct roles of Spring's BeanFactory and FactoryBean, compares their functionalities, outlines how to retrieve beans and FactoryBeans, and provides practical code examples and usage scenarios for creating complex objects within the Spring IoC container.
Jakarta EE 11 adds record support in persistence and validation, maps java.time types, deprecates legacy date APIs, enables CDI injection for EntityManager, introduces virtual‑thread support, expands query syntax, allows Java‑based persistence unit configuration, and removes several outdated specifications such as SOAP with Attachments, XML Binding, CORBA, ManagedBean, and SecurityManager dependencies.
This guide introduces essential Java code‑quality tools—including Alibaba Java Coding Guidelines, CheckStyle, PMD, FindBugs, and SonarLint—explaining their installation, usage, and key features so developers can automate static analysis, reduce bugs, and improve maintainability across projects.
This article categorizes Spring Boot utility classes into built‑in and third‑party groups, explains their purposes, and provides practical code examples for each, helping developers streamline code, improve efficiency, and avoid reinventing common functionality.
The article first marvels at the record‑breaking sales of Xiaomi's YU7 electric SUV, then provides a comprehensive set of Java and Spring interview questions—including B‑tree differences, MySQL hash indexes, ReentrantLock internals, Spring's circular‑dependency resolution, AOP principles, and Spring Cloud components—to help candidates prepare for Xiaomi's upcoming campus recruitment.
This article introduces the Disruptor in‑memory message queue—its architecture, core concepts such as Ring Buffer, Sequence, Sequencer and Wait Strategies, key features like multicast and gating, tuning options for producers and wait strategies, and provides a complete Java example to help developers build ultra‑low‑latency systems.
This article explains why using raw Java NIO for network communication is problematic, highlights Netty's advantages such as simplified APIs, high performance, and extensive adoption, and provides a complete server‑client demo with detailed code and design insights.
This article explains Spring's three‑level cache mechanism for resolving bean circular dependencies, dives into why the cache alone is insufficient, and presents three practical scenarios with concrete solutions such as redesigning constructors, using @Lazy, and handling AOP proxy consistency.
This guide explains Maven’s dependency mechanism, including transitive dependencies and mediation, demonstrates ordering problems with Apache POI and OpenCSV, shows how to detect version conflicts using Maven plugins, and provides practical tips to avoid compile‑time and runtime errors in Java projects.
This article walks through building a Java interface, providing two implementation styles (Spring‑managed and pure‑reflection), loading user‑uploaded JARs at runtime, dynamically registering or removing beans in the Spring container, and testing the whole hot‑deployment cycle with concrete code examples.
Learn how to design and implement a Redis-based distributed lock in Java using custom annotations, AOP interception, and a scheduled executor to automatically extend lock expiration, ensuring safe concurrent access to critical resources while handling timeouts, retries, and thread interruptions.
This article walks through optimizing a 60,000‑row XML‑to‑MySQL import by profiling the environment, measuring baseline performance, and applying JDBC batch rewriting, write aggregation, and asynchronous writes with LMAX Disruptor, ultimately reducing execution time from 300 seconds to about four seconds while keeping memory usage reasonable.
This guide shows how to use IntelliJ IDEA’s diagram feature to view, clean up, and explore Java inheritance and interface relationships, including removing unwanted classes, displaying member details, adding related classes, and jumping directly to source code for faster backend development.
A recent deployment added a log line that caused FastJSON to invoke unexpected methods during serialization, leading to a NullPointerException; this article reconstructs the scenario, analyzes the FastJSON internals, and offers best‑practice annotations to prevent similar bugs.
This article explains Kafka’s high‑performance distributed streaming architecture, key components such as topics, partitions, producers, consumers, brokers, offsets, and ZooKeeper, and provides step‑by‑step workflows for producers and consumers along with performance‑testing tips and Maven setup.
This article explains what Java native memory is, outlines the JVM's native memory regions, describes the symptoms of native memory leaks, and provides step‑by‑step methods—including Native Memory Tracking and OutOfMemoryError analysis—to identify and resolve leaks effectively.
This article introduces multi‑agent architectures and the Agents Handoff pattern, then demonstrates a complete implementation using Spring Boot 3.4.2, Langgraph4j, and Spring AI, including code for a marketplace agent, a payment agent, configuration, testing, and suggestions for further improvement.
This article explains how Maven dependency conflicts arise, demonstrates practical troubleshooting with mvn dependency:tree, and guides you through creating a reusable Spring Boot starter to enforce consistent configurations, dramatically reducing runtime errors and improving team efficiency.
This article explains five frequent scenarios where Spring @Transactional fails—such as internal method calls, non‑public methods, swallowed exceptions, final/static methods, and unsupported MySQL engines—and provides concrete solutions and best‑practice rules for reliable transaction management.
This guide explains how to improve Spring Boot configuration management by mapping external properties to Java enums using @ConfigurationProperties, demonstrating a complete example with Maven dependencies, YAML settings, enum definitions, configuration classes, a controller, and a Thymeleaf view to achieve flexible and readable code.
This guide explains two straightforward steps to load external JAR files into the JVM and make Spring Boot scan them, covering three implementation options—extending the classpath, using Spring Boot’s loader.path parameter, and creating a custom classloader—along with configuration details, Maven settings, and runtime considerations.
This article explains how the open‑source JManus framework enables Java developers to create, configure, and deploy multi‑agent AI applications on Alibaba Cloud's Serverless SAE and Function Compute platforms, highlighting its OpenManus compatibility, MCP protocol support, PLAN‑ACT mode, high‑availability architecture, performance advantages over low‑code solutions, and step‑by‑step deployment instructions.
This article explains how TDMQ RocketMQ's transactional messaging works, covering the underlying concepts, three‑phase processing flow, key terminology, source‑code details, practical Java examples, and important considerations for building reliable distributed transactions.
This tutorial walks through the fundamentals of large language models, prompt engineering, word embeddings, and shows how to use the LangChain framework (including its Java implementation LangChain4j) to build, memory‑manage, retrieve, and chain AI‑driven applications with practical code examples.
This article explains why retrieving Spring beans from classes not managed by Spring can cause NullPointerExceptions and failed autowiring, demonstrates two code examples—using a utility class and @Autowired in a plain class—and recommends registering such classes as Spring components to ensure proper dependency management.
This article explains the inner workings of Nacos' configuration center, detailing the client‑side long‑polling mechanism, the server‑side handling of listener requests, and the key classes and code paths that enable real‑time config updates in microservice environments.
This article explores various techniques for implementing delayed tasks in Java, comparing Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, and RabbitMQ delayed queues, detailing their implementations, advantages, drawbacks, and practical code examples for handling order timeouts.
This tutorial shows how to extend MyBatis‑Plus functionality to the controller layer by creating a reusable BaseController, utility methods, pagination configuration, and concrete controllers, enabling full CRUD, list, page, and count operations with minimal code.
This article explains how Spring's @Autowired annotation can inject collections such as List, Set, and Map, detailing injection mechanisms, ordering, practical examples like filter chains and validators, advanced features like @Qualifier and custom ordering, and important considerations such as circular dependencies and performance impacts.
This article walks through integrating Atomikos with Spring Boot 3 to implement JTA‑based distributed transactions, covering the concepts of Atomikos and JTA, detailed configuration of multiple data sources, domain and repository definitions, service implementation, and comprehensive test cases with expected outcomes.
This article walks through configuring multiple data sources in Spring Boot 3, covering @Primary usage, YAML datasource definitions, bean setup with DataSourceBuilder, JPA entity manager factories, transaction managers, and unit testing to ensure each datasource operates independently.
This article shares real‑world stories and step‑by‑step techniques for diagnosing Maven dependency conflicts, enforcing version control, and building reusable Spring Boot starters to streamline configuration, improve team efficiency, and prevent costly runtime failures.
This article explains what streaming queries are, why MyBatis's Cursor requires an open database connection, and presents three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to correctly implement MyBatis streaming queries in Spring applications while avoiding common pitfalls.
The article shares a detailed SF interview experience, covering typical Java interview questions such as self‑introduction, challenging projects, learning paths, abstract class vs interface, HashMap vs Hashtable, insertion steps, red‑black and B+ trees, MySQL and Redis indexing choices, large‑table optimization, JVM memory model, and the purpose of the Survivor space.
The article explains how over‑design can be avoided by using workflow orchestration and plugin extensions to isolate business logic, reduce if‑else sprawl, and improve extensibility, illustrated with the open‑source MemberClub project and its Java flow‑engine implementation.
A week‑long API freeze in a sandbox environment was traced to a misconfigured Redis connection pool in a Spring Java application, where threads waited indefinitely for a Jedis resource, and the fix involved setting proper pool timeouts, using RedisCallback for scans, and correctly releasing connections.
This article presents a production‑tested, six‑strategy solution—including MyBatis‑Plus auto‑fill, AOP, JWT, multi‑datasource handling, distributed ID generation, and audit logging—to eliminate repetitive maintenance of common fields in Java order modules, boosting efficiency and reducing bugs.
This article details a systematic, zero‑failure migration of 660 backend Java services from JDK 8 to JDK 21, covering performance gains, new language features, compatibility risks, a three‑phase upgrade workflow, custom tooling, and the measurable benefits achieved.
Learn how to create and use non‑blocking (asynchronous) and streaming gRPC clients in Java, covering stub creation, request handling with ListenableFuture, blocking vs listener approaches, and stream observer implementation, enabling high‑concurrency performance testing and real‑time data processing scenarios.
This article explains how Spring’s @Value annotation injects List values differently from version 3.x through Spring Boot, highlights pitfalls such as immutable lists and delimiter issues, and provides practical testing strategies—including manual splitting, custom converters, and post‑construct adjustments—to ensure reliable configuration handling.
This article introduces Hutool, a powerful Java utility library, outlines its extensive features, shows how to add it via Maven, and provides practical code examples for date handling, string manipulation, numeric operations, map utilities, security hashing, and captcha generation.
This guide walks through replacing verbose RestTemplate calls with Spring Cloud OpenFeign's declarative REST client, covering dependency setup, client interfaces, annotations, logging, timeout, retry, interceptors, fallback handling with Sentinel, and advanced configurations to streamline microservice communication.
Maven‑mvnd, a Maven daemon that keeps a long‑running JVM alive, dramatically speeds up Java project builds by eliminating repeated JVM startup, reducing resource consumption, supporting parallel builds, and offering seamless migration from Maven, making it ideal for large multi‑module projects and CI/CD pipelines.
The article examines recurring Java backend problems such as duplicated configuration files, hard‑coded parameters, mixed logging practices, unchecked code releases, unsynchronized databases, and Maven dependency issues, then offers concrete solutions like externalized configuration, standardized logging, proper code review, and correct Maven pom settings.
This article introduces LiteFlow, a lightweight Java workflow engine, explains its key features, rule syntax, IDE plugin, integration steps with SpringBoot, component development, context handling, and provides practical code examples for building a complex order‑price calculation flow.
This guide compares five Java Swing packaging approaches, evaluates their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing app with a minimal JRE into a standalone executable, complete with example Maven configuration and source code.
This tutorial walks you through installing the EasyCode IntelliJ plugin, creating a MySQL database, configuring IDEA’s database connection, setting up Maven dependencies and application.yml, generating entity, DAO, service, and controller code automatically, and finally running the Spring Boot project.
This tutorial walks Java developers through using Redis in Spring Boot projects, covering the essential spring-boot-starter-data-redis dependency, RedisTemplate basics, the underlying RedisConnectionFactory design, custom connection configurations for single‑node and sentinel modes, and seamless integration of the Redisson client for advanced distributed features.
Tencent has donated its high‑performance OpenKona JDK to the OpenAtom foundation, offering a domestically optimized Java runtime that outperforms community versions by over 15% in big‑data, AI and cloud scenarios, and provides detailed installation steps for its LTS releases.
This article explains the concept and benefits of plugin-based development in Java, introduces common implementation approaches such as SPI, custom configuration, and Spring Boot's spring.factories, and provides step‑by‑step code examples and a real‑world case study to help developers build extensible backend systems.
This article explains Spring AOP fundamentals—including aspects, advice types, pointcuts, join points, and advice parameters—provides detailed code examples for each component, outlines the AOP workflow, showcases common use cases, and demonstrates a complete logging implementation with practical code snippets.
This article explains how to build outbound Webhooks in Spring Boot 3 using the non‑blocking WebClient, demonstrates event‑driven publishing, shows code for custom events, retry mechanisms, and provides practical examples for integrating microservices with reliable HTTP callbacks.
This article recounts a midnight production outage caused by inadequate Postman tests, explains three hidden pitfalls of Postman, demonstrates how MockMvc provides precise, code‑level assertions and automated scenarios, and offers a step‑by‑step guide to boost API test automation from 30% to 90% coverage.
This article explains how the @Validated annotation in SpringBoot can automatically enforce request parameter validation, reducing boilerplate code, supporting group validation, and improving code readability and maintainability for backend developers.
This article explains how to handle JSON objects with unknown or changing fields in Java by using Jackson's @JsonAnySetter to collect them during deserialization and @JsonAnyGetter to serialize them back, complete with code examples, pitfalls, and a concise analogy.
This article explains what debounce means for web APIs, identifies which endpoints need it, describes how to detect duplicate requests, and provides complete Java implementations using shared Redis caches and Redisson distributed locks with code examples and key generation strategies.
This article explains how to generate a unique traceId at request entry, propagate it through Rest, MQ, and RPC modules using Log4j2, MDC, and custom converters, and format logs so that distributed traces become easily readable and correlated across services.
This article explains why using Thread.sleep() in Java ExecutorService unit tests is unreliable and inefficient, and introduces three robust alternatives—Future.get(), CountDownLatch, and shutdown/awaitTermination—to ensure stable, performant testing of asynchronous WebSocket query scenarios.
This article explains the need for lightweight batch processing, outlines a layered architecture and robustness strategies, and demonstrates how Spring Batch implements these concepts with clear interfaces, job management, and support for ignore, retry, and restart mechanisms.
This article explains how the SpringBoot @Around annotation empowers developers to handle logging, security, validation and other cross‑cutting concerns in a concise, reusable way, reducing boilerplate code and improving maintainability across multiple modules.
The article recounts a Java developer’s journey from Java 8 to Java 21, highlighting how new language features like var, text blocks, switch expressions, records, pattern matching, and virtual threads dramatically improve readability, reduce boilerplate, and boost concurrency performance.
GPULlama3.java, released by Manchester University's Beehive Lab, is the first native Java implementation of Llama 3 that leverages TornadoVM to automatically accelerate inference on GPUs without writing CUDA or native code, supporting NVIDIA, Intel and Apple Silicon back‑ends and modern Java 21 features.
This article presents twelve practical strategies for optimizing Java backend performance—including parallel processing with CompletableFuture, minimizing transaction scope, effective caching, proper thread‑pool configuration, service warm‑up, cache‑line alignment, reducing object creation, asynchronous execution, loop optimization, shrinking network payloads, and decreasing inter‑service dependencies—each illustrated with code examples and benchmark results.
This article analyzes 58.com’s recent business struggles and layoffs, then presents a comprehensive set of Java interview questions covering synchronized vs. Lock, JVM memory layout, garbage collection, TCP connection teardown, MySQL indexing pitfalls, and common sorting algorithms, providing detailed explanations and code examples.
Beyond the hype of counting code lines, this article explores why quality matters and presents a classic interview problem—finding the second‑strongest contestant in a knockout tournament—using a binary‑tree simulation with a concise Java implementation that runs in optimal time.
This article dissects Guava Cache's source code, explaining its segment‑based locking, data structures, put/get implementations, cleanup and eviction mechanisms, and then contrasts its performance and design choices with the more modern Caffeine cache, highlighting why Guava falls short.
Quarkdown is an open‑source, Java‑based Markdown engine that extends the language with Turing‑complete features, enabling functions, variables, conditionals, and loops, while offering one‑click generation of HTML, PDF, slides, and books, live preview, fast compilation, and a rich standard library for modern documentation workflows.
Learn how to effectively use Java's Stream API to convert a list of User objects into a Map, handle duplicate keys by providing a merge function, and avoid common pitfalls like IllegalStateException and NullPointerException using Optional and concise code examples.
This article explains how to protect file downloads in Spring Boot by generating short‑lived or token‑based URLs, preventing static URL exposure, handling path‑traversal attacks, supporting in‑memory or streamed files, and optionally tying downloads to authenticated users.
This guide explains why Java architects should understand CUDA, describes the GPU programming model, compares CPU and GPU designs, and details three practical ways—JNI, JCuda, and TornadoVM—to integrate CUDA acceleration into Java applications, with tips for using A100 GPUs effectively.
This article examines frequent RocketMQ problems such as duplicate sending, flow‑control throttling, message retries, duplicate consumption, backlog, and loss, and provides practical configuration tweaks, scaling strategies, batch sending, idempotent handling, and retry mechanisms to ensure reliable message delivery.
This tutorial explains the purpose and usage of JVM argument prefixes—including system properties, standard, non‑standard, and advanced options—along with execution modes like interpreted, compiled, and mixed, providing code examples and performance comparisons to help Java developers optimize and debug their applications.
This guide introduces JVM performance monitoring by explaining built‑in tools like JConsole and VisualVM, showcasing third‑party solutions such as Arthas, and providing step‑by‑step commands and screenshots to help developers quickly visualize and troubleshoot Java applications.
This article systematically breaks down RocketMQ's core mechanisms—covering message roles, disk storage, push/pull delivery, expiration handling, retry queues, and cluster failover—so developers can understand every stage a message undergoes from creation to cleanup and ensure reliable, high‑performance messaging.
This article highlights common pitfalls in Spring Boot development—such as exposing sensitive data, neglecting records, field injection, using RestTemplate, bloated controllers, and poor exception handling—and provides concise, code‑driven solutions to write cleaner, more secure, and maintainable backend applications.
This article walks through a common Java scenario of matching two large lists with nested loops, measures the poor performance, then demonstrates two optimizations—adding a break statement and replacing the inner loop with a HashMap—to dramatically cut execution time.
This article walks through the fundamentals of large language models, their stateless and structured-output nature, explains how Spring‑AI provides a Java‑friendly API for model integration, covers RAG architecture, the MCP protocol, and demonstrates end‑to‑end code examples for building intelligent agents.
This article walks through integrating the Retrofit HTTP client into Spring Boot applications using the retrofit‑spring‑boot‑starter, covering dependency setup, basic request definitions, token handling, custom interceptors, global logging, timeout and retry configurations, and provides concise code examples for each step.
This article explains how to address common on‑call debugging pain points by analyzing error screenshots, extracting key information, and developing a lightweight Java tool that leverages StackTraceElement to generate a clear, filtered method‑call chain, dramatically speeding up code‑origin identification and issue resolution.
This tutorial walks through creating a natural‑language‑to‑SQL chatbot using Spring AI, configuring a MySQL school database with Flyway, defining system prompts for a DeepSeek LLM, implementing service beans and a REST API, and interacting with the bot via curl commands.
This article explains Spring configuration files, comparing XML and Java (annotation‑based) approaches, details bean creation, scopes, initialization and destruction, and demonstrates advanced techniques such as conditional beans and profile‑specific configurations with clear code examples.
This article demystifies MyBatis’s caching system, explaining the architecture of first- and second-level caches, how SqlSession, Executor and Cache interact, key generation rules, configuration steps, and best practices for achieving optimal database query performance.
This guide explains why Java applications can hit 100% CPU in production, introduces the two primary diagnostic tools jstack and Arthas, and provides step‑by‑step commands and code examples to locate the exact source line responsible for the CPU spike.
This article explains why traditional file uploads fail for large files, outlines the advantages of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, performance benchmarks, and best‑practice recommendations.
This guide walks you through the realities of joining state‑owned enterprises, offers practical tips for Java backend interview preparation—including self‑introduction, project presentation, database choices, Redis eviction policies, common design patterns, singleton usage, thread‑safety concepts, and commands to terminate Java processes on Linux, macOS, and Windows.
This article walks you through installing and using the RocketMQ Dashboard to monitor topics, brokers, producers, consumers, and message details, explains common pitfalls such as client‑ID conflicts in Docker, and demonstrates how to troubleshoot consumption issues, TPS metrics, and dead‑letter handling.
This article explains Java Bean introspection, its core APIs, practical code examples, common usage scenarios in Spring, advantages and drawbacks, and how it differs from reflection, providing developers with a comprehensive guide to dynamic bean manipulation.
Sa-Token is a lightweight Java permission authentication framework that offers zero‑configuration login, comprehensive permission checks, session management, single sign‑on, OAuth2.0 support, distributed sessions, token customization, and many advanced features, with simple one‑line API calls illustrated by clear code examples.
This article walks through the challenges of handling millions of requests per second for a short‑URL service and presents a complete backend solution—including ID generation, Base62 encoding, cache‑layer design, Nginx redirect optimization, disaster‑recovery strategies, sharding, and performance test results—while providing Java code snippets and design principles for high‑throughput, resilient systems.
This article demonstrates how to replace cumbersome if‑else logic in Spring Boot 3.4.2 by using the Service Locator pattern with ServiceLocatorFactoryBean, providing a clean way to select parsers for different file types through an enum, interface, and Spring‑managed beans.
This guide explains why storing AWS access keys in config files is risky, how IAM roles eliminate those risks, and provides a three‑step, code‑free process to grant a Java application running on EC2 secure, temporary credentials via the AWS SDK.
This article explains why traditional polling fails for large‑scale delayed tasks, compares built‑in Java, RocketMQ, and RabbitMQ delay queues, and provides a detailed Redis‑based design with architecture diagrams, message structures, and a 2.0 version that uses real‑time locking for low‑latency delivery.
This article introduces the fundamentals of augmented large language model agents, explains six workflow patterns—including chain, parallel, routing, orchestrator‑workers, evaluator‑optimizer, and autonomous agents—and provides complete Spring Boot 3 code examples, configuration, and test results for each pattern.
This article examines the conflict between rapidly changing business rules and system stability, introduces rule engines as a solution, compares five widely used Java rule engines—including Drools, Easy Rules, QLExpress, Aviator, and LiteFlow—by their scenarios, advantages, disadvantages, performance, and provides practical guidance for selecting and avoiding common pitfalls.
This article explains why silent token refresh is needed, outlines backend and front‑end strategies for automatically renewing JWTs, provides a complete Java implementation with Maven dependencies, utility methods, unit tests, and discusses handling edge cases such as long‑idle forms.
This article explores why top engineers speak concisely, then dives into the classic LeetCode "Rotten Oranges" BFS interview question, providing a clear Java implementation, step‑by‑step analysis, and key takeaways for mastering grid‑based graph traversal.
This article systematically breaks down the eight most common design patterns used inside the Spring framework, explains how the template pattern powers bean lifecycle, compares classic and Spring‑specific implementations, and provides concrete code examples and step‑by‑step walkthroughs to help you ace interview questions.
