This article investigates a concurrency bug in MyBatis caused by OGNL expression evaluation using reflection, explains the root cause through stack trace and source code analysis, and proposes solutions such as upgrading MyBatis or avoiding private inner‑class methods like Arrays.asList.
This article explains Java virtual threads, compares them with traditional OS threads, shows how to enable them in SpringBoot 3, and presents performance benchmarks demonstrating up to 200‑fold speed improvements for I/O‑bound workloads.
This article details how to switch a SpringBoot‑MyBatisPlus‑MySQL application to PostgreSQL, covering driver addition, JDBC configuration changes, numerous SQL and type‑conversion pitfalls, helper scripts for bulk column updates, and essential migration notes.
This article explores why using an Integer as a lock can cause synchronized to malfunction, demonstrates the issue with a ticket‑selling example, analyzes thread dumps and JVM bytecode, and presents reliable alternatives such as class‑level locks or map‑based lock objects.
This article compares Java's standard ThreadLocal with Netty's FastThreadLocal, explains their internal mechanisms, shows practical code examples, runs a JMH microbenchmark, and discusses performance, memory management, and usage scenarios to help developers choose the right thread‑local storage solution.
This article explains how to let users dynamically enable or disable logging by managing Spring AOP advice at runtime, covering prerequisite concepts, core hot‑plug logic, detailed Java code for installing and removing plugins, a step‑by‑step demo, and a concise summary of the approach.
This article explains how to use Log4j's Mapped Diagnostic Context (MDC) to generate, propagate, and record a traceId across micro‑service calls, providing a low‑cost, non‑intrusive solution for full‑stack log tracing and debugging.
This article introduces eight ready‑to‑use Java Stream APIs—including Stream.ofNullable, Stream.iterate, collectingAndThen, dropWhile/takeWhile, IntStream, teeing, concat, and partitioningBy—showing how each can cleanly handle nulls, generate sequences, transform collections, and combine streams with concise code examples.
This article provides a comprehensive overview of Hystrix, covering its core functions such as fault isolation, service fallback, timeout control, and circuit breaking, and walks through adding Maven dependencies, annotating methods with @HystrixCommand, configuring properties, and explaining the underlying circuit‑breaker and thread‑pool isolation principles.
This comprehensive guide walks you through the concepts of Single Sign-On, the mechanics of JWT, RSA asymmetric encryption, and step‑by‑step integration of Spring Security with JWT, providing full Maven project setup, configuration files, utility classes, custom filters, and testing instructions for a robust distributed authentication system.
JetBrains' 2024.1 update for IntelliJ IDEA introduces full‑line code completion, Java 22 support, a revamped terminal, AI Assistant enhancements, improved version‑control integration, faster Maven project loading, advanced debugging, Spring framework upgrades, and numerous UI and refactoring refinements, all aimed at boosting developer productivity.
The article walks through real interview scenarios where MySQL or Java processes consume 900% CPU, detailing step‑by‑step diagnosis with top, processlist, jstack, and concrete remediation such as adding indexes, using caches, fixing busy loops, and tuning memory.
This article explains the core concepts of Java thread pools, walks through the ThreadPoolExecutor class hierarchy and key methods, analyzes thread‑pool states and execution flow, and provides practical guidelines for configuring parameters, avoiding memory leaks, handling task dependencies, and managing exceptions in production systems.
A mis‑handled exception in a ScheduledExecutorService can silently halt the entire scheduled thread pool, causing critical periodic jobs to stop; this article explains the underlying delay‑queue and thread‑pool mechanics, shows reproducible code, and provides practical safeguards to keep scheduled tasks alive.
This article explains what Java virtual threads are, how they differ from regular threads, shows how to enable them in SpringBoot 3.1.2 with Java 20, and presents performance benchmarks that demonstrate up to 200‑fold speed improvements for IO‑bound workloads.
The article explains how to embed the open‑source URule rule engine into a Spring Boot application, covering installation, datasource configuration, library definitions for variables, constants, parameters and actions, creating visual or script rule sets and decision tables, and demonstrates a membership‑upgrade use case.
This article explains the fundamentals of finite state machines, introduces Spring Statemachine, demonstrates how to model order lifecycle states, configure persistence with memory and Redis, handle exceptions during state transitions, and use AOP to log transition results, providing complete Java code examples.
This tutorial explains how to set up a simple yet powerful Java logging solution by installing Loki and Grafana via Docker, configuring Loki4j in a Spring Boot project, and visualizing logs in Grafana, providing step‑by‑step instructions and sample code.
This article explains how to create a custom insertable annotation processor in Java that automatically injects the jar version into component constants during the Gradle build, eliminating manual updates and enabling version monitoring via Prometheus.
This article demonstrates how to use the junixsocket library to add Unix domain socket support to Java applications, providing Maven dependency details, full server and client code examples, and cross‑language testing with a Go server implementation.
This article explains how to create a custom annotation and MyBatis‑Plus interceptor that automatically injects data‑permission WHERE clauses based on the current user's role, covering both a basic implementation and an advanced version with role‑based scope handling, complete with configuration and usage examples.
This article explains how Java's Arrays.asList creates a fixed‑size list that throws UnsupportedOperationException on add/remove, and how ArrayList.subList returns a mutable view whose non‑structural changes affect both the original list and the sublist while structural changes can trigger ConcurrentModificationException, providing code examples and practical guidelines.
This article explains the Java BigDecimal class, detailing its internal storage mechanisms, precision handling, immutable design, and common pitfalls, and provides best‑practice guidelines for constructing, comparing, dividing, and converting BigDecimal values to ensure accurate numerical computations.
This article explains why iterating a Java HashMap with keySet() involves two passes, examines the underlying iterator implementation, and walks through the relevant source code of HashMap’s KeySet, KeyIterator, and HashIterator classes to clarify the internal traversal mechanism.
This tutorial introduces Spring AI and Spring Cloud Alibaba AI, explains their core features, shows how to set up a Maven project with the required dependencies, and provides step‑by‑step code examples for invoking text, image, and audio generation models using Spring Boot.
This article explains the concepts of concurrency, parallelism, and serial execution, describes common multi‑core scheduling algorithms, and demonstrates Java's concurrent programming tools—including Future, Fork/Join, Stream API, and CompletableFuture—through clear code examples and practical guidelines.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, implementing token generation and validation services, configuring an interceptor, and providing test cases to demonstrate the workflow.
This article explains how to implement a configuration‑driven mechanism that dynamically switches between Spring's native @Scheduled tasks and XXL‑JOB execution, automatically registers jobs, disables Spring's scheduler when needed, and forwards logs to the XXL‑JOB console, providing a complete starter solution for backend developers.
This article explains why Maven runs unit tests during the package phase, describes the Maven lifecycle, and provides several practical methods—including command‑line flags, pom.xml configuration, and IDE settings—to skip tests when building a Java project.
This guide walks you through creating a dynamic, real‑time data visualization dashboard—covering design mockups, requirement planning, architecture using Echarts for the front‑end and Java for the back‑end, JSON data handling, deployment without installation, configuration steps, code structure, and source acquisition.
This article explains what Java Class Data Sharing (CDS) is, provides detailed commands for training and using a CDS archive with a Spring Boot demo, and shows how startup time can be cut by nearly one second, helping developers choose the right Java startup optimization technique.
This article dissects Pulsar’s storage layer by examining the Bookie component, detailing its architecture, the sequential write‑ahead log, ledger management, journal handling, caching mechanisms, and the complete read/write call chains with concrete code examples and performance considerations.
This article explains the roles of DTO, VO, and PO in Java applications, compares manual property copying with BeanUtils and MapStruct, provides complete code examples for both approaches, and offers guidance on choosing the appropriate method based on performance and project needs.
This article explains how to design an effective Java controller layer by separating concerns, introducing a unified response structure, applying global response wrapping, leveraging Spring's validation mechanisms, and handling custom exceptions to produce concise, maintainable backend code.
This article explains the concepts and step-by-step implementation of dynamically loading JAR packages in Spring Boot applications, covering built‑in classloader usage, creating JARs, and leveraging third‑party libraries to enhance flexibility and extensibility.
This article explains how to use Spring WebFlux's reactive, non‑blocking model to create a server‑sent events (SSE) endpoint that streams text data, and demonstrates a front‑end Vue implementation that splits the stream into characters to produce a realistic typing animation.
Java developers constantly battle NullPointerExceptions, a historic flaw introduced by Tony Hoare, but modern JDKs provide clearer messages and defensive techniques—such as explicit null checks, utility methods, avoiding null returns, and using Optional—can dramatically reduce these runtime errors.
This article provides a step‑by‑step tutorial on Apollo's configuration center, covering its core concepts, four‑dimensional model, client design, Spring Boot integration, testing of dynamic updates, and deployment via Docker and Kubernetes for cloud‑native applications.
This article explains how to use a custom CommonContext with conditional logging and lambda‑based delayed evaluation to quickly trace issues in high‑concurrency Java back‑end systems without degrading performance, and demonstrates the performance improvements through before‑and‑after measurements.
This article explains how Java developers can use thread pools and Apache Commons Pool2's GenericObjectPool to create a reusable process pool, covering the underlying concepts, required interfaces, Maven dependencies, configuration options, and practical code examples to improve performance.
This article explains the various ThreadPoolExecutor rejection policies, highlights the risks of using CallerRunsPolicy, provides code examples, and suggests mitigation strategies such as adjusting queue size, thread count, or persisting overflow tasks to databases or message queues.
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.
The article explains why API debounce is essential, identifies the types of endpoints that need it, and walks through two SpringBoot solutions—Redis‑based shared cache and Redisson distributed lock—complete with custom annotations, key generation, code samples, test results, and practical limitations.
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 article introduces Kafka's definition, core architecture, installation steps, command‑line tools, and shows how to integrate Kafka with Spring Boot through detailed Java examples, custom partitioners, and producer/consumer configurations.
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.
