This article explains how Spring’s ResponseBodyEmitter, SseEmitter, and StreamingResponseBody can be used to build asynchronous streaming endpoints that continuously push data to clients, avoid servlet thread blocking, and prevent request‑timeout problems, with complete code examples and usage guidelines.
This article walks through a systematic investigation of a slow‑starting Dubbo service built on Spring 3.2, using JProfile to pinpoint costly class‑loading checks, disabling unnecessary annotation processing, and resolving thread‑waiting issues caused by RabbitMQ and other components, ultimately reducing deployment time by about 40%.
This article walks through creating a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common Maven configurations, provides global exception handling and logging aspects, and lists useful backend tools such as embedded Redis, MyBatis‑Plus, and Redisson.
The article introduces Fluent Mybatis, a compile‑time code‑generating ORM that merges Mybatis‑Plus, Dynamic SQL and JPA features, eliminates XML mappers, offers a fluent, type‑safe Java API, and demonstrates through concise examples how it reduces boilerplate compared with native Mybatis and Mybatis‑Plus.
The article explains how to simplify Spring MVC controller code by introducing a unified response wrapper, handling String return types with ResponseBodyAdvice, adjusting HttpMessageConverter order, applying JSR‑303 validation for @RequestParam, @PathVariable and @RequestBody, creating custom validation annotations, and implementing global exception handling for consistent API responses.
This article guides readers through the concepts of large language models, embeddings, vector databases, and Retrieval‑Augmented Generation, then demonstrates step‑by‑step how to set up Ollama, install a local Chroma vector store, configure Maven dependencies, and write Java code using LangChain4J to build and test a functional AI Q&A application.
This article explains Java's built‑in Service Provider Interface (SPI) mechanism, demonstrates how to implement and test SPI with sample code, analyzes its internal workings and limitations, and then shows how Spring extends SPI using spring.factories with comparable examples and source‑code insights.
This article explains why the == operator yields false when comparing two Integer objects with the value 1000 but true for the value 100, covering Java's reference comparison, the IntegerCache mechanism, its performance rationale, and a reflective hack that can even make 2+2 equal 5.
Oracle’s release of Java 23 introduces a suite of preview JEPs—including primitive pattern matching, module import declarations, flexible constructors, and new library APIs—while also previewing performance, tooling, and management enhancements, and it hints at upcoming features slated for Java 24.
The article demonstrates how combining Java generics with functional programming—using lambda‑based callbacks and generic pagination utilities—can transform repetitive data‑access code into a concise, reusable structure, while also discussing the benefits, trade‑offs, and potential debugging challenges of this approach.
This article explains why the author created the EasyQuery ORM for Java, demonstrates a wide range of query patterns—including single‑record, pagination, joins, subqueries, streaming, custom VO mapping, dynamic conditions, grouping, native SQL, function columns, and high‑performance encryption—while providing complete code snippets and links to documentation and source repositories.
The article explains why forcibly stopping a Java thread is unsafe, outlines common scenarios requiring thread exit, compares graceful and forced termination methods, and provides practical techniques such as flag checks and Thread.interrupt() with recommended interrupt‑handling strategies.
This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.
This article provides a concise, hands‑on overview of Java’s most useful language enhancements from Java 9 through Java 17—including private interface methods, Optional API upgrades, Stream API additions, var type inference, the new HTTP client, switch expressions, text blocks, records, instanceof pattern matching, and sealed classes—complete with clear code examples for each feature.
This article examines whether the @Service annotation can replace @Controller in Spring Boot by presenting a functional example, explaining the component‑scanning and request‑mapping mechanisms that allow a @Service‑annotated class to handle HTTP requests just like a controller.
This article explains why overusing null‑check statements in Java leads to verbose code, distinguishes cases where null is a valid response versus an error, and offers practical techniques such as assertions, throwing exceptions, returning empty collections, and applying the Null Object pattern to write cleaner backend code.
This guide explains Java's try-with-resources statement introduced in JDK 7, showing how it automatically closes AutoCloseable resources, eliminates boilerplate finally blocks, manages closure order and suppressed exceptions, avoids common decorator pitfalls, and provides best‑practice examples for robust production code.
This article explains the purpose of Spring Boot's ApplicationRunner and CommandLineRunner interfaces, demonstrates common startup tasks such as data initialization, configuration loading, cache population and license verification, compares their parameter handling, shows how to control execution order with @Order, and reveals the internal call chain that Spring uses to invoke these runners.
This article details the discovery, analysis, and fix of a severe thread‑leak issue in a Java Spring MVC service caused by unsafe use of a shared CloseableHttpAsyncClient, showing how multithreaded testing reproduced the problem and how refactoring the client to a local variable eliminated the runaway thread growth.
The article first shares a frustrated JD interview experience regarding a 'personality' assessment, then introduces LeetCode problem 814 – Binary Tree Pruning – detailing the problem statement, examples, and providing concise post‑order traversal solutions in Java, C++, and Python.
This article explains the TCC (Try‑Confirm‑Cancel) distributed transaction model, its three phases, three practical variants, and provides a complete Seata‑based Java implementation with code samples, exception handling strategies, and deployment tips for backend services.
This article explains defensive programming as a proactive coding paradigm that anticipates and mitigates errors through input validation, error handling, assertions, and continuous testing, and demonstrates its application with detailed Java examples covering pagination, loop safety, exception management, and boundary checks.
This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.
This article explains how to launch Java processes from the command line, explores JVM -X and -XX tuning parameters, details garbage‑collection algorithms, describes reference strengths, and clarifies object reachability to help developers optimize Java application performance.
This article introduces RediSearch, compares its memory usage and query performance with Elasticsearch on modest hardware, shows installation steps, demonstrates core index commands and Java integration, and concludes with practical advice on using RediSearch as a lightweight full‑text search engine.
This article explains how to use the iTextPdf library in Java to design a PDF template, fill fixed fields, dynamically generate product tables, and merge the two parts into a single invoice PDF, including Maven dependencies and sample code.
JEP 453 integrates StructuredTaskScope into Java 21, offering a preview API that replaces Future with Subtask, enabling lightweight virtual‑thread based concurrent tasks, such as fetching data from multiple servers and automatically cancelling slower calls, while simplifying error handling and improving observability.
This article explains seven practical methods for loading property files in Spring Boot, covering default locations, external files, classpath resources, profile‑specific files, custom @PropertySource usage, and overriding via environment variables or JVM system properties.
Domain‑Driven Design (DDD) structures software around a rich domain model—entities, value objects, aggregates, and services—organized into UI, application, domain, and infrastructure layers, employing patterns such as aggregate roots, domain events, and event‑driven microservices to improve maintainability, scalability, and collaboration between developers and domain experts.
This article shares a ByteDance interview experience and provides detailed technical explanations on Java thread pools, Redis internals, message queue usage, computer networking processes, HTTP/HTTPS differences, and a sample algorithm problem, offering valuable insights for backend developers.
This article explains how Nacos’s ConfigService initiates a long‑polling task on the client side, how the client periodically checks for configuration changes, and how the Nacos server processes long‑polling requests, detailing the relevant classes, methods, and code flow.
The article explains that storing IPv4 addresses as a 32‑bit UNSIGNED INT in MySQL saves storage and index space, enables faster range queries, outlines conversion functions like INET_ATON/INET_NTOA, discusses drawbacks such as readability, and provides Java utilities for IP‑long transformations.
This article explains how to implement runtime switching of multiple service providers, such as SMS vendors, in a Spring-based backend using the spring‑smart‑di library, @EnvironmentProxySPI, and @AutowiredProxySPI annotations, with configuration stored in Nacos, databases, or environment variables.
This guide provides step‑by‑step instructions for installing the Allure test reporting tool on Windows, macOS, and Linux, covering Java setup, environment variables, verification commands, important considerations, and how to generate and view test reports.
This guide introduces Google’s Guava library for Java, covering Maven integration, data validation with Preconditions, immutable collections, factory methods, counting collections, multimap usage, advanced string joining and splitting, and simple caching, showing how each feature can make code cleaner, safer, and more efficient.
This article introduces RabbitMQ, explains its core features and messaging model, discusses why to use it for asynchronous, decoupled, and throttled processing, and provides step‑by‑step installation instructions for macOS, Windows, and CentOS along with Java code examples for configuring and using delayed messages via the rabbitmq_delayed_message_exchange plugin.
By implementing a plug‑in architecture that uses a custom URLClassLoader to load and unload JAR‑packaged governance tasks at runtime, the Spring Boot application can dynamically register Spring beans and XXL‑Job handlers, remove them cleanly, update configuration via YAML or Nacos, and package the solution with Maven Shade without restarting services.
This guide walks engineers through every stage of technical interview preparation—from researching job requirements and mastering core backend concepts to systematic coding practice, project presentation, soft‑skill polishing, resume crafting, submission strategies, mock interviews, and maintaining a positive mindset for success.
This article examines the limitations of using JPA for complex queries in SpringBoot projects and demonstrates how MyBatis‑Flex can simplify conditional queries, partial field selection, Kotlin integration, and code generation through clear code examples and practical guidance.
This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.
The article describes a year‑long development experience where a senior architect designs, plans, and implements a sharding solution for loan and repayment tables using ShardingSphere, Spring Boot 3, MySQL, and custom synchronization code to migrate billions of rows while ensuring data consistency and operational continuity.
This article explains the concept of gray (canary) release, details the core components and version configuration, and provides a complete Spring Cloud implementation—including custom request holders, gateway filters, Ribbon load‑balancer extensions, Feign interceptors, and deployment instructions—for smoothly rolling out new service versions.
This article outlines the twelve new JEPs introduced in JDK 23, highlighting language previews, API enhancements, and performance boosts, while also reviewing the BenQ RD280U monitor’s larger screen, programming mode, Moonhalo backlight, eye‑care technologies, and software integration that together can significantly improve developer productivity.
JDK 24, slated for a March 2025 release as a non‑LTS version, introduces JNI usage warnings, a G1 garbage‑collector post‑barrier extension, a finalized Class File API, and several potential enhancements, while offering six months of premium support following the recent JDK 23 launch.
Learn how the Interface Segregation Principle (ISP) of SOLID design encourages splitting large interfaces into focused, minimal ones, reducing unnecessary method implementations, improving maintainability, and enhancing modularity across backend Java code, frontend React components, and state‑management modules, while also noting its trade‑offs.
This article explains what syntactic sugar is, outlines its benefits such as readability, reduced boilerplate, and lower error rates, and then showcases ten concrete Java syntactic‑sugar features—including autoboxing, enhanced for‑loops, generics, varargs, try‑with‑resources, lambdas, method references, string concatenation, switch expressions, and type inference—complete with code examples.
JD’s hot‑key detection framework instantly identifies bursty hot requests, pushes the hot keys to a clustered memory layer, and broadcasts them to all JVMs, enabling client‑side caching, user blocking, and circuit breaking, while handling up to 370 000 detections and 800 000 pushes per second and reducing backend query load by over 50 % in large‑scale events.
The article explains how exposed API endpoints can be intercepted and altered, and presents practical security measures—including HTTPS, encrypted parameters, timestamp‑based signatures, and a Spring Boot filter implementation—to detect and block tampering and replay attacks in a Java backend.
This article explains how to design a two‑level leave‑approval process using the Activiti BPMN engine, covering diagram creation, Spring‑Boot configuration, deployment, task handling, exclusive gateways, database tables, API overview, and practical tips for extending the workflow.
This article details a real-world performance optimization of a high‑concurrency Java backend interface, reducing response time from 30 seconds to under 0.8 seconds through SQL analysis, array aggregation, moving logic to PostgreSQL, and introducing Caffeine caching, with code examples and lessons learned.
This guide explains how to use Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, and maven-jar-plugin to package a Spring Boot application into an executable JAR with external lib dependencies, and shows how to deploy the resulting artifacts in a Docker container using a custom Dockerfile.
JD’s Hotkey framework provides millisecond‑level detection and cluster‑wide push of hot data, users, and interfaces, dramatically reducing backend query load, improving performance, and supporting scenarios such as local caching and rate limiting, with proven scalability demonstrated in large‑scale e‑commerce promotions.
This article clarifies the purpose of Java classes ending with “O”—BO, DTO, VO, PO—explains their proper usage in a typical front‑end/back‑end workflow, and compares mapping solutions like Spring BeanUtils and MapStruct with code examples.
This guide explains why MySQL or Java processes can consume 700‑900% CPU in production, walks through step‑by‑step diagnosis using Linux tools, and provides concrete remediation techniques such as indexing, caching, thread analysis, and code adjustments to restore normal performance.
This article explains the concepts, characteristics, and ideal scenarios for unbounded and bounded queues in Java, provides step‑by‑step Maven setup and complete code examples for asynchronous task scheduling, event‑driven processing, and API rate‑limiting, and highlights practical considerations such as resource management and performance.
This article explains Xxl-Job’s lightweight distributed scheduling architecture, covering the admin console, executor startup, JobHandler initialization, HTTP server registration, task triggering logic with scheduling threads, fast/slow thread pools, routing and blocking strategies, and result callbacks, illustrated with code snippets and diagrams.
This guide introduces Java performance analysis fundamentals, covering profiling tools, key metrics such as CPU, memory, thread behavior, and practical methods to detect and resolve common issues like memory leaks, GC pauses, high CPU usage, I/O bottlenecks, and inefficient collection usage.
This article explains the theoretical and practical limits of Java String length, covering compile‑time restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and JDK 9 optimizations, with illustrative code examples.
This article explains how to design and implement a fixed-size FIFO export queue in a Java backend using Spring components and EasyExcel, covering business requirements, class definitions, code examples, testing results, and considerations for further enhancements such as Redis queues and high‑concurrency scenarios.
This article walks through building a local AI question‑answer system using Java, Ollama, LangChain4J, embeddings, and a Chroma vector database, covering LLM fundamentals, embedding techniques, RAG architecture, setup steps, Maven dependencies, and sample code to retrieve and answer queries.
This guide walks you through installing Appium Desktop, configuring and launching the server, creating a simple Java test for the Android calculator app, exploring multiple element‑locating strategies (ID, class name, XPath, Accessibility ID, UIAutomator), and using the desktop tool’s element inspector and recording features to generate test scripts.
This article provides a detailed tutorial on using Maven for Java projects, covering basic repository setup, dependency declaration, scope options, indirect dependencies, exclusions, variable properties, multi‑module configuration, dependencyManagement, and essential plugins such as jar, assembly, and shade, with practical code examples and best‑practice recommendations.
This article critiques overly complex Spring Boot controllers filled with try-catch and validation logic, demonstrates a cleaner implementation using @Valid annotations and reduced code, provides global exception handling examples, and concludes with advice on maintaining concise controller methods while also promoting related community resources.
The article explains how adding a new reducePrincipal field to the RepayPlan class caused existing interfaces to miscalculate remaining principal, and demonstrates fixing the low‑cohesion bug by centralizing the updated calculation in a RepaymentCalculator utility so future changes occur in one place.
The article explains how to store and deduplicate billions of identifiers efficiently by using a bitmap backed by Redis and extending it with a Bloom filter implementation in Java, highlighting memory calculations, practical commands, and code examples.
This article explains the difference between static and dynamic proxies in Java, walks through JDK dynamic‑proxy implementation steps, analyzes the underlying Proxy class generation process, and compares performance and usage with static proxies and CGLIB.
This article explores the CQRS (Command Query Responsibility Segregation) pattern, detailing its core concepts, implementation approaches—including logical, storage, and asynchronous separation—its benefits and challenges, and practical best‑practice guidelines for applying CQRS in modern high‑performance, scalable systems.
This article provides an in‑depth introduction to Java's BigDecimal class, covering its purpose for high‑precision arithmetic, frequently used constructors, essential arithmetic and conversion methods, comparison techniques, number‑formatting examples, common exceptions during division, and a utility class that encapsulates typical operations.
This article demonstrates how to secure API interfaces by implementing symmetric encryption and decryption for both GET and POST requests in a Spring MVC application, using ControllerAdvice to intercept and process request and response bodies, handling key management, signature verification, and serialization issues across H5, Android, and iOS clients.
This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.
This guide explains how Java can communicate with industrial hardware by using the Modbus protocol with jLibModbus, accessing low‑level registers via JNI, and employing serial‑port libraries such as JSerialComm or RXTX, providing step‑by‑step setup, code examples, dependency configuration, and practical considerations for reliable device integration.
This article explains how to automatically include userId and orderId in log messages by storing them in MDC, defining a custom @UserLog annotation, and using Spring AOP to inject the values at runtime, eliminating manual log parameter handling.
This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.
The article explains the trade‑offs of placing a Java try‑catch block inside versus outside a for‑loop, illustrating both approaches with code examples, and advises choosing the placement based on whether you need unified error handling or per‑iteration resilience, while also noting a free book promotion.
This article explains how Guava's RateLimiter, built on the token‑bucket algorithm, provides smooth burst handling, configurable rates, warm‑up support, and thread safety, and demonstrates its usage through detailed code examples and best‑practice recommendations for API, database, and crawler throttling.
This article examines the core implementation of SOFAJRaft, a high‑performance Java library based on the Raft consensus algorithm, covering node initialization, leader election, log replication, snapshot handling, fault recovery, and multi‑Raft‑Group support with detailed code examples.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This article presents a concise, hands‑on review of the most useful Java language enhancements introduced between Java 9 and Java 17—including private interface methods, Optional API upgrades, var type inference, the new HTTP client, switch expressions, text blocks, records, instanceof pattern matching, and sealed classes—illustrated with clear code examples.
The article outlines the twelve preview features introduced in JDK 23, from primitive pattern matching to structured concurrency, and argues that mastering timeless programming principles from Effective Java can help developers adapt to such language evolutions.
This article breaks down the four Java ThreadPool rejection policies—AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, and DiscardPolicy—detailing their implementation, ideal use cases, advantages, and drawbacks to help developers choose the right strategy for handling overloaded executors.
This article explains the State design pattern, demonstrates its Java implementation with example code, introduces Spring State Machine concepts, and provides a complete step‑by‑step guide to building and testing an order status workflow using Spring State Machine, including configuration, listeners, services, and a controller.
This article explains how to extend large language models with domain‑specific knowledge using Retrieval‑Augmented Generation (RAG) in LangChain4j, covering the concepts of RAG, its indexing and retrieval stages, simple RAG setup, detailed API usage, and advanced customization options such as query transformers and content injectors.
This article explains the background, creation, and detailed parameters of Java's ThreadPoolExecutor, walks through its task execution flow, warns against using Executors factory methods, and provides practical formulas for setting core pool sizes based on CPU‑bound or I/O‑bound workloads.
The article describes a Java‑based FIFO export queue that limits concurrent MySQL export operations, outlines the related classes (ExportQueue, AbstractExport, ExportImpl, and a test controller), provides full source code, and presents test results showing how the queue manages up to ten simultaneous export requests.
This article introduces tldb's distributed lock mechanism, explains lock, trylock, and unlock methods, provides Go and Java client examples, and also includes promotional information about ChatGPT services and a developer community for developers.
This article examines common pitfalls in Spring Boot controller implementations, demonstrates how excessive if‑else checks and business logic in controllers degrade code quality, and provides clean, refactored examples using @Valid validation, concise error handling, and a global exception handler to achieve more maintainable backend services.
This article explains the Singleton design pattern, compares lazy and eager implementations in Java, discusses thread‑safety issues with double‑checked locking, presents complete code examples, and outlines the advantages, disadvantages, and appropriate use‑cases for singletons.
This article provides a concise guide to SpringBoot’s built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, key methods, and offering ready‑to‑use code examples to boost development efficiency.
This guide explains why MySQL and Java processes can exceed 900% CPU usage in production, and provides step‑by‑step methods—using top, show processlist, jstack, index tuning, caching, and code adjustments—to diagnose, mitigate, and prevent such spikes.
The article investigates why a RocketMQ consumer service running on a 4‑core ECS experiences sustained high load despite low CPU, I/O and memory usage, identifies excessive thread creation and frequent trace‑module context switches as the main causes, and proposes configuration and SDK upgrades to resolve the issue.
After upgrading from Tomcat 7 to Tomcat 8, the application’s mixed log4j‑1.4 and logback‑1.2.3 dependencies caused the SLF4J binder to be loaded nondeterministically, so Tomcat 8 sometimes selected the Log4j binder without a configuration file, resulting in completely missing log output; removing the conflicting jars or enforcing a deterministic class‑loading order restored logging.
This guide presents 28 practical IntelliJ IDEA tricks—from viewing code history and adjusting memory settings to customizing keymaps, code inspections, Maven dependency visualization, and multi‑instance debugging—helping Java developers dramatically boost productivity and streamline daily workflows.
This article walks through the eight critical phases of a Spring bean's lifecycle—from instantiation and property population to initialization, post‑processor hooks, usage, and destruction—detailing how Spring creates, configures, enhances, and finally disposes of beans, with code snippets and diagrams for clarity.
This article presents five practical Java performance tweaks—pre‑allocating HashMap capacity, using object keys, caching Enum values, replacing String constants with Enums, and upgrading the JDK—backed by JMH benchmarks that show up to 9.5× speed gains.
mica-mqtt is a lightweight, low‑latency, high‑performance open‑source MQTT component built on Java AIO that simplifies integration, supports multiple protocols and frameworks, and offers extensive features for IoT, edge, and messaging applications.
This article demonstrates multiple methods to add text or image watermarks to PDF documents in a Spring Boot application, covering Java libraries such as Apache PDFBox, iText, Ghostscript command line, Free Spire.PDF, and Aspose.PDF, with code examples and usage instructions.
This article introduces MapStruct, a compile‑time Java bean‑mapping framework, and demonstrates advanced features such as expression mapping, qualifiedByName for custom conversions, null‑value handling strategies, and the use of decorators to extend mapper behavior, complete with code examples.
This article introduces Java 8's Stream API, explains its declarative data‑processing style with operations such as filter, map, sorted, forEach, collect, statistics and parallelStream, and provides complete example code demonstrating these concepts on a UserPo class.
This article explains why rate limiting is essential for microservice stability, introduces basic concepts like thresholds and rejection strategies, and walks through multiple algorithms—including fixed‑window, sliding‑window, sliding‑log, leaky‑bucket, token‑bucket—and their Java implementations as well as Redis‑based distributed approaches, complete with code samples and performance considerations.
This article explains how Spring Boot’s @Transactional annotation works, introduces programmatic transaction management, and demonstrates how to create custom transaction hook functions with TransactionSynchronizationManager and TransactionSynchronization to execute custom logic at each transaction phase, improving robustness and maintainability.
