This article explains how moving to JDK 17 and the low‑latency ZGC garbage collector can reduce pause times to under 10 ms, improve throughput, and meet demanding real‑time service requirements, while providing practical upgrade steps, JVM tuning parameters, and performance comparisons.
This article introduces Ehcache, an open‑source Java local‑cache framework, explains its layered storage options, flexible expiration policies, eviction strategies, and provides comprehensive code examples for configuring in‑memory, off‑heap, and disk‑persistent caches, along with practical usage tips and performance considerations.
This article walks through six practical web‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—explaining their principles, trade‑offs, and providing complete Spring Boot and JavaScript code samples to help developers implement real‑time notification badges.
This article explains three common multi‑tenant implementation strategies—separate databases, separate schemas, and partitioned (discriminator) data—detailing their advantages, drawbacks, and practical Spring Boot 3.3 code examples for entity definition, tenant‑ID resolution, data source routing, and request interception to achieve secure, scalable SaaS applications.
The COLA (Clean Object‑Oriented and Layered Architecture) framework replaces traditional monolithic MVC Service layers with a clear, multi‑layered structure—Adapter, Application, Domain, Infrastructure, and Client—enhancing code cohesion, reducing coupling, and improving maintainability, as illustrated through a detailed order‑creation example with refactored Java code.
The article analyzes common inventory‑deduction scenarios, compares three approaches—single‑row MySQL, multi‑row MySQL, and Redis INCRBY—highlights the limitations of database‑based methods under heavy load, and presents a robust Redis‑Lua solution with distributed locking and Java code examples for reliable stock management.
The author celebrates landing a new job while emphasizing that mastering Java's garbage collection—identifying and reclaiming memory from unreachable objects via algorithms like reference counting or reachability analysis—is essential for robust backend development and preventing memory overflow.
This article explains why upgrading to JDK 17 and switching to the low‑latency ZGC garbage collector can dramatically reduce pause times and improve throughput, compares GC and CPU metrics against G1, and provides step‑by‑step installation and JVM tuning instructions with code examples.
This article introduces ShardingSphere, an open‑source distributed database middleware, explains its core features such as horizontal sharding, read‑write separation, and distributed transactions, and provides a step‑by‑step configuration and Java usage example.
This article explains why Java logging can become a performance bottleneck, identifies common misuse patterns, and provides practical steps—such as dynamic log levels, avoiding string concatenation, selective location info, and cautious async logging—to dramatically improve throughput and latency.
An old Java project using MySQL, MyBatis, and an outdated mysql‑connector‑java driver encounters a “Conversion not supported for type java.time.LocalDateTime” error after swapping MyBatis for MyBatis‑Plus; the article walks through reproducing the issue, analyzing MyBatis version changes, upgrading the JDBC driver, and fixing subsequent bugs.
This article provides a detailed overview of the most commonly used Spring Boot annotations, covering core, prototype, Spring Boot, Spring Cloud, caching, testing, database access, JPA, and global exception handling annotations, with clear explanations and practical Java code examples for each.
The article demonstrates how to achieve high abstraction in Java by using abstract methods overridden by subclasses, passing behavior through anonymous inner classes, and implementing an asynchronous Future pattern with listeners to handle request results, providing complete code examples for each technique.
This article explains how to prevent duplicate form submissions in Java web applications by generating and validating JWT tokens on the backend, provides complete utility classes and controller examples, and includes step‑by‑step usage instructions with full source code.
Spring AI brings artificial‑intelligence capabilities to the Spring Boot ecosystem, offering model support, vector‑database integration, SQL‑like filtering, and easy Maven configuration, enabling Java developers to add generative AI, semantic search, and AI‑driven image generation to their backend applications.
This article explains the core Spring IoC concepts by analyzing the top‑level BeanFactory interface and its three important sub‑interfaces—HierarchicalBeanFactory, ListableBeanFactory, and AutowireCapableBeanFactory—illustrating their responsibilities, inheritance relationships, and practical usage with code examples.
This guide explains how to implement a Retrieval‑Augmented Generation (RAG) workflow by loading a beer‑info JSON dataset into a Redis vector store, wiring it with Spring Cloud Alibaba AI Starter, and exposing a web API that returns LLM‑generated answers.
This article walks through a real‑world approval workflow where a business user adds a company, explains why MySQL REGEXP is chosen over Elasticsearch for fuzzy matching, and details the step‑by‑step implementation—including name preprocessing, tokenization with IKAnalyzer, and a custom SQL query that ranks results by match degree.
This article analyses the memory consumption of tasks submitted to a Java ThreadPoolExecutor using execute and submit, compares lambda and queue implementations, and quantifies the overhead of internal objects such as Worker, Node, FutureTask, and RunnableAdapter.
The author recounts a debugging saga with Alibaba's Fastjson library, detailing how a global date‑format setting failed on Linux, how an outdated Fastjson version caused the issue, and how circular‑reference detection with $ref can surprise developers, offering practical solutions and version recommendations.
This article demonstrates how to use Spring's ApplicationContextInitializer together with Javassist to intercept class loading in a Spring Cloud environment, modify the bytecode of org.apache.commons.lang3.RandomStringUtils, and record method calls, handling parent‑child container initialization nuances.
This article explains how to combine MVEL expressions with the Chain of Responsibility design pattern to build a decoupled, extensible message‑processing framework, using an order‑splitting MQ example to illustrate the architecture, code implementation, and benefits for backend Java services.
This article explains why large database transactions degrade backend API performance and presents practical techniques—such as avoiding RPC inside transactions, using programmatic transactions, batching data, splitting into smaller transactions, and applying asynchronous processing—to dramatically improve efficiency.
This guide explains how to enable Java remote debugging, step by step, to efficiently locate issues that only appear in pre‑release or production environments, using IDEA and a simple command‑line configuration.
This article explains how ZGC in JDK 17 eliminates long GC pauses, compares performance and CPU usage against G1, outlines upgrade reasons, suitable scenarios, and provides step‑by‑step installation and JVM tuning instructions for production Java back‑ends.
This guide explains six common Spring Boot techniques—@RequestParam, @PathVariable, @MatrixVariable, @RequestBody, @RequestHeader, and @CookieValue—for extracting URL query strings, path variables, matrix variables, request bodies, headers, and cookies, complete with code examples for each method.
This article explains the core principles of object‑oriented and functional programming, demonstrates each paradigm with Java code examples, and provides a detailed side‑by‑side comparison covering mutability, composition vs inheritance, side effects, concurrency, and readability.
This article explains what a service gateway is, why it is essential for microservice architectures, outlines its core functions such as routing, filtering, authentication, monitoring, and presents a practical Java‑based technical stack including Spring Boot, Zuul, Consul, JWT, Prometheus, ELK and JMeter.
This article introduces the MybatisX IDEA plugin, outlines its benefits for reducing boilerplate in MyBatis/MyBatis‑Plus projects, and provides a step‑by‑step tutorial—including database setup, Maven dependency configuration, plugin installation, connection troubleshooting, and code generation—complete with Maven and Java code examples.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, outlines the configuration steps, compares their performance and memory usage through benchmark results, and concludes that Undertow offers superior throughput for high‑concurrency Java web applications.
This article explains how to build a reusable Spring Boot starter that automatically encrypts outgoing responses and decrypts incoming requests using hutool‑crypto, custom request wrappers, validation utilities, and Spring Boot advice components, providing a secure, zero‑boilerplate solution for Java backend services.
This article explains the MVVM (Model-View-ViewModel) architecture for modern Android development, detailing its three core components, their responsibilities, and provides a step‑by‑step example with Jetpack components, including LiveData, ViewModel, View Binding, and complete code snippets to build a simple user list UI.
This guide explains why validating configuration properties in SpringBoot 2.7 is essential, outlines the benefits such as increased robustness and faster debugging, and provides a step‑by‑step example with code snippets showing how to use @ConfigurationProperties, @Validated, and BeanPostProcessor for automatic validation at application startup.
The article explains how a custom java.net.spi.InetAddressResolverProvider SPI that works in a regular Spring Boot 3.x JAR fails when the OpenTelemetry Java agent is added because the agent’s JarLoader cannot read the SPI configuration inside the BOOT‑INF layout, and resolves the issue by disabling the agent’s own resolver resource so the custom provider is used.
This article shares hands‑on experience of applying Domain‑Driven Design in real projects, detailing a typical four‑layer architecture (domain, infrastructure, application, adapter), code examples, packaging guidelines, and practical tips for clean, maintainable backend systems.
This article provides a comprehensive guide to standardizing the Spring Boot controller layer by explaining how to receive parameters, define unified status codes, apply validation annotations, wrap responses consistently, and handle exceptions globally, all illustrated with practical Java code examples.
This article explains the fundamentals of distributed systems, introduces Apache Kafka’s architecture and core components, describes how Kafka ensures message ordering within partitions, and provides practical Java consumer configurations and techniques to guarantee ordered consumption of messages.
This article introduces a Spring Boot starter that provides a ready‑to‑use Redis utility suite—including common tools, distributed locks, message queues, delay queues, pagination queries and web helpers—explains how to add the Maven dependency, configure modules via YAML, and details the internal auto‑configuration and bean implementations for MQ and delayed messaging.
This article introduces three request‑collapsing techniques—Hystrix Collapser, a custom BatchCollapser implementation, and Guava's ConcurrentHashMultiset—explaining their design, configuration, code examples, and suitable scenarios for reducing downstream load and improving system throughput.
This article explains the motivations for adopting message queues, outlines core concepts and protocols, compares mainstream MQ products, and provides a detailed walkthrough of Kafka architecture, cluster setup, native Java APIs, and Spring Boot integration with extensive code examples.
This article explores the proper usage of Java's Optional class, debunks common misconceptions, examines its internal implementation, compares methods like map, orElse, orElseGet, and provides practical code examples to help developers avoid null‑pointer pitfalls and write cleaner backend code.
This article explains how zero‑copy technology eliminates redundant memory copies and context switches during data transmission, compares traditional read‑send workflows with zero‑copy approaches such as Linux sendfile/splice and Java's FileChannel.transferTo, and discusses performance benefits and practical considerations.
This article provides a comprehensive set of Netty interview questions and detailed answers covering its architecture, Reactor pattern, core components such as Channel, ChannelHandler, ChannelPipeline, ByteBuf advantages, EventLoop groups, codecs, handling of packet framing, and graceful shutdown procedures.
This article explains the fundamentals of role‑based access control (RBAC), its model variants, and user‑group usage, then demonstrates how to configure Spring Security with in‑memory authentication, integrate JWT for stateless token‑based authentication, customize JSON login, and securely encrypt passwords using BCrypt.
This article explains what a microservice gateway is, outlines the advantages of Spring Cloud Gateway, and provides step‑by‑step instructions with code examples to create, configure, and run a reactive API gateway for Java microservices.
MaxKey is an enterprise‑grade single sign‑on solution that supports OAuth 2.x, OpenID Connect, SAML 2.0, JWT, CAS and SCIM, offering secure identity management, RBAC, multi‑tenant capabilities, robust password policies, brute‑force protection, session control, and BCrypt‑based password encryption.
This article explains why threads are essential for performance, how to create and configure Java thread pools using the Executors utility, distinguishes CPU, IO, and scheduled pool types, and demonstrates monitoring techniques for latency and deadlock detection with practical code examples.
This guide explains how Spring's @Qualifier annotation eliminates bean injection ambiguities, shows basic usage, custom qualifier creation, generic qualifiers, fully custom annotations, and advanced attribute‑based qualifiers, all illustrated with clear Java code examples for Spring 6.1.2.
After an Alibaba Cloud RDS host failure caused a HA switch, the bme‑trade‑order‑svc service experienced prolonged unavailability; this article dissects how thread‑pool saturation, HikariCP connection‑pool mechanics, and CPU load interplay, and outlines systematic investigations that pinpointed thread waiting, pod restarts, and CPU throttling as root causes.
This article introduces Groovy as a JVM‑based dynamic scripting language, explains why it suits rapidly changing business rules such as payment integration, marketing and risk‑control, and provides step‑by‑step code examples, advanced usage patterns, best practices and common pitfalls for Java backend developers.
A developer debates whether placing a try‑catch block inside a Java for‑loop impacts performance, runs JMH benchmarks comparing try‑catch inside the loop versus around it, examines bytecode differences, references Effective Java’s warnings, and concludes the overhead is minimal unless exceptions are actually thrown.
To simplify RocketMQ usage, I designed an internal SDK that abstracts complex client configurations, offering single‑call ordered message sending, per‑message consumption, unified result handling, and enforced consistent subscription settings, thereby reducing developer effort and preventing common integration errors.
This article demonstrates how to implement a hot‑pluggable AOP solution in Spring by exposing endpoints that let users dynamically add or remove Advice, covering the underlying concepts, core implementation code, a demo service, and test scenarios that show logging being enabled and disabled at runtime.
This article explains the principles and implementation of a Java RPC framework, covering service registration with Zookeeper, serialization, compression, network communication via Netty, dynamic proxy generation using reflection and Javassist, and performance considerations, providing extensive code examples for each component.
This article introduces retrofit-spring-boot-starter, a lightweight, type‑safe HTTP client starter that seamlessly integrates Retrofit into Spring Boot projects, outlines its key features, provides quick usage examples with Maven/Gradle dependencies, interface definitions, injection, configuration options, and advanced capabilities such as custom OkHttpClient injection, annotation‑based interceptors, connection‑pool management, logging, and retry mechanisms.
This article analyzes a FastJSON serialization issue where a getter method is unexpectedly invoked, explains the underlying ASM-generated serializer workflow, details which methods are considered during serialization, and provides best‑practice code annotations to prevent unwanted method execution.
This article explains how to design a clean, maintainable Spring Boot backend by applying core software principles, organizing modules such as core, common, business, and admin, and providing complete Maven pom examples to illustrate a modular multi‑module project layout.
This article examines the Matrix middle‑platform framework used at JD.com, detailing its hot‑deployment mechanism, the push‑and‑pull integration chains, class‑loader isolation based on the parent‑delegation model, and the design of business‑identity recognition, while offering best‑practice recommendations and code examples.
This article explains Redis databases, the structure of the keyspace, how to set key expiration, and the various memory reclamation and eviction policies, providing Java developers with the essential knowledge needed for advanced Redis interview questions.
After a year of using Project Lombok, the author reflects on how its annotations dramatically shrink boilerplate but also introduce version incompatibilities, hidden dependencies, reduced readability, tighter coupling, and technical debt, urging developers to weigh its benefits against long‑term maintenance risks.
The article recounts a real‑world incident where a game’s leaderboard showed absurd scores due to insecure API parameters, then explains RSA and AES fundamentals, demonstrates how to combine asymmetric and symmetric encryption for secure request handling, and provides Java code, custom annotations, and AOP logic to automate decryption on the server side.
This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine’s core features, walks through a complete Java implementation with database schema, persistence (memory and Redis), REST APIs, exception handling, and an AOP‑based solution for reliable state transitions.
This guide explains the fundamentals of AES symmetric encryption, compares Java and PHP implementations, highlights their shared features and differences, provides complete code samples for encryption and decryption, and offers practical advice on key management, IV usage, and performance considerations.
This article presents a concise, beginner-friendly approach to building a Spring Boot unit testing environment using only essential Maven dependencies and test classes, covering both integration-style and pure unit test techniques, complete with annotated examples and practical testing tips.
The article explains how Java’s BigDecimal class maintains exact financial precision by storing numbers as an unscaled integer and a scale, scaling operands to a common decimal place, performing integer arithmetic—including handling differing scales—and finally reconstructing a correctly scaled result.
The article introduces retrofit-spring-boot-starter, a lightweight HTTP client library for Spring Boot that simplifies HTTP calls, offers extensive features such as custom OkHttpClient injection, annotation‑based interceptors, retry, logging, circuit‑breaker, and provides detailed usage examples, configuration options, and advanced customization techniques.
This article explains why publicly exposed APIs are vulnerable to tampering and replay attacks, outlines anti‑tampering and anti‑replay strategies such as HTTPS, request signing, timestamp and nonce mechanisms, and provides a complete Spring Boot implementation with Redis support.
The article introduces Graceful Response, a Spring Boot component that unifies response structures, centralizes exception handling, and simplifies validation, thereby reducing boilerplate code, improving readability, and enhancing development efficiency for backend services.
This article explains how to improve a Java Spring Boot contract signing workflow by combining the Strategy pattern, Chain of Responsibility, and Composite patterns, detailing the process steps, project structure, code implementations, custom annotations, and dynamic bean injection to achieve a flexible and maintainable solution.
The article explains why a locally created ThreadPoolExecutor cannot be reclaimed by Java's garbage collector, detailing GC root analysis, the role of live threads, inner‑class references, static versus non‑static nesting, and how these concepts can cause memory leaks.
Learn how to use Spring's @ControllerAdvice, @ExceptionHandler, @InitBinder, and @ModelAttribute annotations to implement global exception handling, data binding, and pre-processing, including custom exceptions, order control with @Order, and practical code examples for robust backend development.
Oracle announced its upcoming AI coding assistant, Code Assist, tailored for Java, Oracle Database, NetSuite scripts, and Oracle Cloud, offering chat-driven code suggestions, documentation generation, and security scanning across VS Code and JetBrains IDEs, while emphasizing multi‑language support and data privacy.
This article introduces Arthas, an open‑source Java diagnostic tool from Alibaba, explains its key features, shows how to install it via Maven, and provides step‑by‑step commands for entering the shell, monitoring JVM status, tracing method calls, observing system resources, dynamically redefining code, and connecting to applications using default or Telnet modes.
This article explains the timing of Spring's @Transactional commit relative to lock release, analyzes why committing after unlock can cause overselling, shows how to trace the transaction lifecycle in the source code, and offers practical solutions to ensure atomicity in high‑concurrency scenarios.
This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.
This article recounts a leaderboard data breach caused by tampered Base64 request parameters, then details a hybrid RSA‑AES encryption strategy—using RSA to protect the AES key, IV and timestamp while AES encrypts the actual payload—along with Java implementations, key‑generation utilities, and a Spring AOP aspect for automatic decryption, providing a comprehensive guide to securing API communications.
Disruptor is an open‑source, lock‑free Java framework that uses a ring‑buffer and sequencer to achieve ultra‑high‑throughput, handling millions of events per second, and is employed by projects like LMAX, Storm, Camel, and Log4j2, with detailed concepts, wait strategies, and usage examples.
This article explains TCP packet fragmentation and aggregation (sticky/unsticky packets), demonstrates the phenomena with examples, and provides detailed solutions using Netty's built‑in decoders such as FixedLengthFrameDecoder, LineBasedFrameDecoder, DelimiterBasedFrameDecoder, and LengthFieldBasedFrameDecoder, including code samples and configuration tips.
This article explores the lesser‑known Apache Commons Lang StringUtils methods such as isAnyEmpty, isNoneEmpty, isAnyBlank and isNoneBlank, showing how they differ from the classic isEmpty/isBlank checks with clear code examples and usage guidelines.
The investigation revealed that G1GC pauses were caused by uncontrolled growth of the JVM StringTable, triggered by Jackson’s InternCache interning countless random JSON field names, and was mitigated by enlarging the young generation, disabling field‑name interning, tuning G1 parameters, and monitoring StringTable size.
This guide explains why SpringBoot JARs become bulky when many dependencies are included, shows how to inspect the packaged libraries, and provides step‑by‑step Maven configurations and runtime commands to build a leaner JAR that loads external libs only when needed, dramatically speeding up deployment.
This article demonstrates how to secure Spring Boot APIs by encrypting request and response bodies using custom ControllerAdvice, switching from FastJson to Jackson for proper enum and date serialization, and configuring ObjectMapper to produce consistent JSON output across encrypted and non‑encrypted endpoints.
This article demonstrates how to design a simple Calculator interface in Java, implement it using both Spring‑managed and reflection‑based approaches, and achieve hot deployment by loading user‑provided JAR files at runtime, including code for class loading, bean registration, and cleanup.
This article explains why servers cannot know your original password, covering the principles of password hashing, the difference between cryptographic and non‑cryptographic hash functions, the role of salts, and a Java example using SHA‑256 with salt to securely store passwords.
Learn how to enforce role‑based data permission filtering in MyBatis‑Plus by creating custom annotations, implementing an InnerInterceptor, and integrating a permission handler that dynamically builds WHERE clauses based on user roles, with both basic and advanced examples covering SQL parsing, role scopes, and plugin configuration.
This guide walks you through the fundamentals of Java Spring Boot projects, explains WAR vs JAR deployment, sets up Maven and Jenkins, configures SSH and DingTalk notifications, and provides a complete CI/CD pipeline with scripts for automated builds and releases.
This article explains the rules of platform coupons, demonstrates a concrete example, and details three generations of algorithms—from a Cartesian‑product approach to Map‑based and array‑index methods—highlighting their implementations, performance trade‑offs, and a comparative benchmark.
This article explores the default behavior of Spring's @Autowired annotation, how to resolve bean name conflicts, use @Qualifier and @Primary, apply @Autowired on constructors, methods, parameters, and collections, and troubleshoot common issues such as missing annotations, filter injection, component scanning, and circular dependencies.
This article walks through three ways to map JSON columns to Java objects in MyBatis, explains why simple String or JSONObject approaches are fragile, and provides a complete custom TypeHandler implementation, registration, and usage example for complex entity fields.
Learn how to configure Spring Boot 3.2.5 to let a single controller endpoint dynamically produce JSON, XML, or custom YAML responses using Accept headers, request parameters, path extensions, and custom HttpMessageConverters, with step‑by‑step code examples and necessary Maven dependencies.
This guide explains step‑by‑step how to configure IntelliJ IDEA’s Live Templates to automatically generate Javadoc comments for Java methods, including creating a custom template group, defining variables, setting scope, and showcasing useful Java‑8 snippets, while also noting promotional offers for activation tools.
This guide walks through implementing a complete product management module in a Java e‑commerce system, covering Snowflake distributed ID generation, database schema design for SPU and SKU tables, CRUD operations, category‑brand linking, audit workflow, status toggling, batch processing, and logical deletion, all with concrete code examples.
This article explains three common methods for implementing delayed queues with Redis—using key expiration notifications, Zset with scheduled tasks, and Redisson’s RDelayedQueue—detailing their concepts, core code examples, advantages, and limitations for backend developers.
The article walks through MyBatis’s internal execution pipeline, from loading the configuration file and building a SqlSessionFactory, to creating a SqlSession, generating a MapperProxy for the mapper interface, and finally invoking the mapped method which triggers JDBC operations, while detailing caching and executor mechanisms.
This article demonstrates three practical approaches for invoking external services in a Spring Boot application—using a raw HttpClient, the RestTemplate utility, and the Feign declarative client—complete with code examples, configuration steps, and tips for handling headers and tokens.
This article explains how using an off‑heap local cache (OHC) can dramatically lower GC pauses and cut interface latency by up to tenfold, covering the underlying principles, configuration, custom serializers, performance testing, monitoring metrics, and practical optimization recommendations for high‑traffic Java backend services.
This article introduces a powerful Java parameter‑validation library based on Spring Expression Language, explains its features, supported annotations, usage examples, configuration steps, and how to extend it with custom constraints, providing a complete guide for backend developers.
This article explains nine typical scenarios that cause the Spring @Async annotation to fail—ranging from missing @EnableAsync to improper method visibility, return types, static or final modifiers, missing @Service, manual object creation, and incorrect component scanning—providing clear explanations and code examples for each case.
This article compares common global ID generation strategies for microservice architectures, covering database‑level solutions like auto‑increment configuration and MyCat + ZooKeeper, as well as application‑level approaches such as UUID, Snowflake, Leaf (segment and Snowflake modes), Redis, and ZooKeeper, with configuration steps, code samples, and pros‑cons.
This tutorial explains RSA asymmetric encryption and signing, then walks through securing Spring Boot API endpoints by adding annotations, configuring keys, integrating JavaScript decryption, and addressing practical deployment considerations to protect data from interception and tampering.
