This tutorial walks through configuring MyBatis with XML for database operations, covering Maven dependencies, project structure, core configuration files, mapper interfaces, dynamic SQL, and JUnit testing with a complete employee CRUD example.
This article reveals big tech's zero-tolerance policy on AI-assisted interview cheating — including lifetime bans recorded in feedback systems — and provides a detailed solution to LeetCode 1224 (Maximum Equal Frequency) with counting-based case analysis and implementations in Java, C++, Python, and TypeScript.
This tutorial demonstrates Java Stream API for filtering and extracting collection data, covering stream creation from Lists, Sets, Maps, and arrays, key operations like filter, limit, skip, concat, distinct, and collecting results into List, Set, or Map with practical code examples.
This article introduces an open-source code generator that automatically creates complete Spring Boot CRUD layers—entities, DAOs, MyBatis mappers, services, converters, and controllers—from database schemas or SQL, featuring customizable templates with dynamic parameters and reusable code blocks for team-specific conventions.
This article details how to design effective RAG prompts that prevent hallucination, enforce source citation, handle missing information, concatenate multiple documents with metadata, manage multi-turn conversations with history compression, and provides a complete prompt template with a tuning checklist.
This tutorial demonstrates three methods to read YML configuration in SpringBoot — using @Value annotations, the Environment abstraction, and @ConfigurationProperties binding — with complete code examples for each approach.
This article demonstrates how to build a bounded LRU cache in three lines by extending LinkedHashMap with access-order enabled and overriding removeEldestEntry, detailing the internal doubly-linked list mechanics, thread-safety limitations, memory overhead, and when to migrate to Caffeine for advanced features like TTL and high concurrency.
Spring Boot 4.1 introduces InetAddressFilter to block internal network access at the HTTP client level, replacing scattered string checks with a centralized allowlist approach. The article demonstrates configuring RestClient.Builder for external-only access, adding URI validation, disabling auto-redirects, setting timeouts, limiting response size, and enforcing secure patterns via tests and code reviews.
This article compares four Java approaches for calling WebServices — Axis2 code generation, RPC, HttpURLConnection, and HttpClient — detailing pros, cons, code samples, and a real-world namespace mismatch issue when integrating with C-based services.
This article explains how Java's reachability analysis garbage collection handles circular references, contrasts it with reference counting's failure on cycles, details GC roots, three-color marking, finalize() resurrection, and identifies real memory leak patterns caused by lingering root references.
The article reviews JetBrains' official 'Java and Kotlin by IntelliJ IDEA' VS Code plugin, which runs IntelliJ's language server via LSP to deliver code completion, navigation, refactoring, debugging, and Gradle/Maven/Bazel project import, though test discovery and execution are not yet supported.
This article introduces five mobile apps — c4droid for C/C++, AIDE for Java, QPython3 for Python, w3cschool for web development, and Termux for Linux — with installation steps and basic usage guides for learning programming on smartphones.
This article explains the four types of Java method references (static, bound instance, arbitrary instance, constructor), their equivalent lambdas, compiler overload resolution, readability trade-offs, and practical examples showing when method references improve clarity versus when lambdas remain preferable.
This final chapter of a 20-part Java series presents a 7-step fault review SOP, categorizes 99% of production faults into six root causes, defines eight high-availability architecture principles, and outlines a four-layer risk prevention system to shift from reactive firefighting to proactive stability.
The article presents a Java solution for allocating order-level discounts to individual items using integer arithmetic and deterministic remainder distribution, ensuring accurate partial refunds by persisting per-unit prices, allocated discounts, and payable amounts at checkout, with database schema and concurrency considerations.
This article analyzes Java 8+ interface default and static methods, explaining their original purpose for backward-compatible interface evolution, valid use cases like optional capabilities and mixin-style derived methods, and common pitfalls including hidden assumptions, silent failures, fixed workflows that prevent customization, and binary vs semantic compatibility issues. It includes a real-world refactoring example for payment callback handlers.
This tutorial shows two standard Java approaches for loading a jdbc.properties file: using ClassLoader.getResourceAsStream with Properties, and using ResourceBundle.getBundle, each with complete code examples and output verification.
This article explains why internationalization and localization should be implemented from the start, covering UTF-8 encoding, locale handling, resource bundles, dynamic content translation strategies, time zone and currency best practices, legal compliance like GDPR, and real-world failure cases.
This article provides a comprehensive guide to enterprise-grade Java stress testing, covering full-chain testing processes, four core performance metrics (TPS, RT, error rate, resource usage), eight common bottleneck types, standardized testing SOP, and production capacity planning with rate limiting thresholds.
MateClaw is an open-source, self-hosted AI workbench that deploys via a single Docker command, providing digital employees with roles, knowledge bases, and tool permissions, team collaboration via DAG task graphs, a traceable wiki-style knowledge base with page-level citations, model failover across 14+ providers, and enterprise-grade RBAC, audit logs, and approval workflows — all in a Java 21 Spring Boot stack.
This tutorial covers Java's three main IO stream types—byte, character, and conversion streams—demonstrating low-level vs high-level stream performance with file copy benchmarks, text file processing, console input handling, and character encoding conversion solutions.
Oracle reveals the feature roadmap for JDK 28, a non-LTS release due March 2027, including value objects, generational Shenandoah GC, strictly initialized fields, a standard JSON API, PEM encoding for crypto objects, and ahead-of-time compilation to cut startup time.
This article details a distributed Redis-based solution for enforcing multiple rate-limiting rules simultaneously (e.g., 10 requests per minute and 20 per two minutes) while preventing duplicate submissions, using Zset data structures, Lua scripts for atomicity, and Spring AOP annotations.
This guide covers integrating Spring Boot with Apache CXF to publish and consume SOAP web services, detailing WSDL-first vs code-first approaches, endpoint configuration, client invocation patterns, WS-Security (username tokens, signatures, encryption), MTOM attachments, message validation, exception handling, testing strategies, and production hardening against XXE, large payloads, and version conflicts.
The article demonstrates how Spring Boot 4.1's new InetAddressFilter.externalAddresses() simplifies SSRF protection for user-supplied URLs, replacing manual IP checks with a centralized HTTP client filter, while also covering URL validation, redirect handling, timeouts, response size limits, and testing strategies to secure link preview and similar features.
A senior Java engineer recounts how a team evolved from a MyBatis interceptor for environment-based data isolation to a clean annotation-plus-AOP solution after a junior developer's ThreadLocal-based quick fix caused nested-call bugs and scattered boilerplate across the codebase.
This guide demonstrates integrating Passkey/WebAuthn authentication into a Spring Boot application using Spring Security 7.1's built-in support, covering dependency setup, security configuration, frontend JavaScript implementation for credential registration and authentication, database persistence with JDBC repositories, and a migration strategy that retains password login while adding Passkey as a second factor.
This article explains five common Java memory leak scenarios—long-lived collections, unclosed resources, ThreadLocal misuse, inner class references, and unregistered listeners—with code examples and recommends MAT and VisualVM for leak detection.
This guide categorizes six major Java AI frameworks into infrastructure and orchestration layers, detailing Spring AI 2.0's Advisor chain, LangChain4j's model breadth, Solon AI's Java 8 compatibility, Spring AI Alibaba's workflow engine, AgentScope's production-grade harness, and Embabel's deterministic GOAP planning to match frameworks to project constraints and scenarios.
This article details 18 advanced Java coding techniques (19-36) for high-performance, low-CPU systems, covering void/null avoidance, nested code flattening, final/static method optimization, primitive type usage, collection pre-sizing, memory management, immutable collections, loop optimization, wrapper caching, exception reuse, stack trace reduction, try-catch narrowing, bitwise operations, regex precompilation, memory alignment, constant-first comparisons, and batch processing.
Lithe is an open-source lightweight IDE for Java and Spring Boot development that complements AI coding tools, offering project navigation, run/debug, Git diff, and database tools with ~300-400MB memory usage, auto-detected run configurations, and AI-generated commit messages.
The article shows a Java if-else chain that applies different discounts and actions based on user type, then asks which design pattern can refactor it into more elegant code.
This comprehensive guide covers 10 hidden Java memory leak scenarios, a 6-step MAT-based investigation SOP, code-level fixes for ThreadLocal and static collections, emergency mitigation tactics, and long-term prevention standards to eliminate recurring OOM crashes.
This article analyzes Apache PDFBox 3's major improvements over 2.x, including the new Loader API, incremental parsing for memory efficiency, rewritten IO layer with java.nio, and cleaner APIs, while providing practical code examples for loading PDFs, extracting text, and generating documents.
This article explains the critical behavioral difference when placing try-catch inside versus outside a for loop: outside placement terminates the loop on exception, while inside allows continuation. It also analyzes performance implications, showing negligible overhead when no exceptions occur but increased memory consumption if many iterations throw exceptions, and details the JVM exception table mechanics that underlie this behavior.
This article demonstrates how to implement per-endpoint dynamic field validation in Spring Boot 3.5.0 using a custom @DynamicValid annotation and HandlerMethodArgumentResolver, allowing flexible control over required, optional, and unknown fields for Map, JsonNode, or POJO parameters, with support for custom validators and integration with @Validated.
This article explores hidden pitfalls in Java's Collectors.toMap including duplicate key exceptions, null value handling limitations, null key behavior, and null list safety, providing practical workarounds like merge functions and Optional-based null handling for robust stream-to-map conversions.
This article introduces Apache Fory, a high-performance multi-language serialization framework, and demonstrates its integration with Spring Boot 3.5.0, showing up to 3x throughput improvement over Jackson in JSON benchmarks with code examples for binary, JSON, and row-format serialization.
LangChain4j provides a Java-native framework for integrating 20+ LLM providers and 30+ vector stores via a unified API, declarative AiServices, RAG pipelines, tool calling, and MCP support, enabling Spring Boot teams to add AI capabilities without Python dependencies.
This series finale presents a universal 6-step SOP for Java production troubleshooting, a bottom-up layered diagnosis model, a quick-reference guide for 10 common failure patterns with symptoms, root causes, and tools, plus five golden principles for incident handling.
This article details the implementation of a generic @UserPermission annotation for horizontal authorization in Java web applications, covering annotation design, AOP-based interception, reflection-based parameter extraction, and compile-time validation using JDK8 annotation processors to prevent configuration errors.
Graphify uses tree-sitter AST parsing to generate queryable code knowledge graphs with confidence-labeled edges, community detection, and God node identification, enabling offline architecture governance for legacy Java and microservices without vector databases or LLM tokens.
This tutorial demonstrates how to use the Easy Random library to automatically generate realistic test data for Java objects, covering basic usage, configuration parameters, field-level customization, and custom randomizers for domain-specific values.
This article presents 18 practical coding techniques derived from million-QPS production systems to reduce CPU consumption and improve performance, covering type unification, string handling, loop optimization, caching strategies, and data structure selection with concrete before/after code examples.
This article dissects seven frequent misuses of Java's Optional that still lead to NullPointerExceptions, explains Optional's design intent as a method return contract, and demonstrates correct patterns including chained map/flatMap, orElse vs orElseGet, and proper default handling.
This article demonstrates how to implement dynamic data source switching in Spring Boot using ThreadLocal and AbstractRoutingDataSource, covering configuration, annotation-based switching, and runtime data source registration with Druid.
This comprehensive guide covers four Java OOM types (heap, metaspace, stack, direct memory), details enterprise troubleshooting SOP using jmap and MAT analysis, identifies five common memory leak root causes, and provides a six-step production emergency response plus long-term prevention rules.
This article identifies five common MapStruct misuses — complex logic in @Mapping expressions, missing bidirectional relationship handling, over-mapping in hot paths, injecting business services into mappers, and naive PATCH updates — and shows correct Java alternatives for each case.
This guide covers real-world diagnosis and resolution of Java thread deadlocks and thread pool exhaustion — the two most common causes of service hangs with zero errors — using jstack, Arthas, and thread-state analysis to pinpoint root causes and apply permanent fixes.
This article introduces Maven-mvnd (mvnd), a drop-in replacement for Apache Maven that uses a persistent daemon process and GraalVM native executables to dramatically accelerate build times, especially for multi-module projects, while maintaining full compatibility with existing Maven POM files and commands.
This article explains how Java lambda expressions function without explicit types through target typing and functional interfaces, covering type inference contexts, invokedynamic implementation, differences from anonymous classes, effectively final variable capture, and method references.
This article provides a comprehensive guide to troubleshooting Java CPU 100% spikes in production, covering root cause categories, a standard SOP using top, jstack, and thread analysis, a real-world infinite loop case study, GC-related CPU issues, emergency mitigation steps, and long-term prevention practices.
This guide teaches how to read Java GC logs field by field, distinguish Minor/Major/Full GC, apply production-ready criteria to judge normal vs abnormal GC, and resolve four common GC anomaly scenarios with root-cause analysis and solutions.
This article provides a comprehensive tutorial on Apollo configuration center, covering its core concepts (application, environment, cluster, namespace), client architecture with long-polling and local caching, overall system design with Config/Admin services and Eureka, availability scenarios, hands-on SpringBoot integration with Maven setup, dynamic configuration testing (updates, rollbacks, offline fallback), multi-environment/cluster/namespace usage, and Kubernetes deployment via Docker and YAML manifests.
This guide demonstrates how to use Arthas, Alibaba's open-source Java diagnostic tool, to troubleshoot production issues without downtime—covering installation, core commands (dashboard, trace, watch, stack, logger, redefine), three real-world case studies, and critical production safety rules.
A distributed Redis lock collision returns a default success response with null data, causing client-side NullPointerException when unpacking; the article analyzes the root cause, shows the flawed code, and provides fixes for both server and client sides.
The article debunks the myth that try-catch hurts Java performance by analyzing JVM exception tables, bytecode, and running benchmarks under interpreted and compiled modes, showing negligible overhead when no exception is thrown and that JIT compilation eliminates even minor goto costs.
This article explains the Java Adapter design pattern, covering its definition, roles (Target, Adapter, Adaptee), and two implementation approaches—class adapter using inheritance and object adapter using composition—with complete code examples for each.
This article teaches how to analyze G1 GC logs beyond simple pause times by breaking down phase timings, heap changes, GC causes, and concurrent marking overhead, then mapping log signals like high Update RS or Object Copy to concrete code-level issues such as excessive reference writes, humongous allocations, or weak reference abuse.
This article explains why a custom java.lang.String class cannot replace the JDK's String, detailing the parent delegation class loading model, Bootstrap ClassLoader's role, core class protection mechanisms, Java 9+ module system restrictions, and why attempts to bypass these (custom class loaders, -Xbootclasspath, --patch-module, Java Agents) fail or are unsafe.
The article illustrates Separation of Concerns beyond AOP by refactoring a reconciliation service that mixes WeChat Pay and Alipay SDK calls with business logic, introducing a wrapper layer with custom types to isolate SDK-specific parsing from core matching rules, enabling independent evolution of each concern.
This tutorial demonstrates how to integrate Tess4j with Spring Boot to create an OCR REST API, covering dependency setup, Tesseract engine initialization with language data configuration, image preprocessing tips, and a working controller example, plus a comparison of popular OCR engines and alternatives for improved Chinese text recognition.
The article demonstrates how to correctly apply the DRY principle by refactoring seven duplicated notification service classes in Spring Boot 3.5.0 using the template method pattern and a NotificationMessage value object, consolidating 40 lines of repeated validation, logging, and error handling into a single abstract base class.
This article analyzes why Hutool 5 has become the standard Java utility library, detailing its modular design, code reduction benefits, performance improvements over JDK, and comparison with Guava and Apache Commons, while providing practical migration examples for strings, dates, files, HTTP, JSON, and AI integration.
This article provides a comprehensive explanation of the Java Decorator pattern, covering its definition, purpose, advantages, disadvantages, and a complete implementation example with four key roles and runnable code demonstrating dynamic behavior extension.
This article contrasts junior developers' trial-and-error debugging with senior engineers' structured four-step method — confirm symptoms, layer-by-layer isolation, evidence-based root-cause analysis, and closed-loop remediation — to cut production incident resolution from hours to minutes.
The article analyzes why Java virtual threads, despite promising million-concurrency with minimal code changes, see little production adoption due to pinning with synchronized, ThreadLocal memory pressure, incomplete framework support, and CPU-bound workload mismatch, while showing benchmarks where they excel in I/O-heavy services but migration costs deter legacy systems.
This article analyzes why Java virtual threads, despite promising million-concurrency with minimal overhead, see little production adoption due to pinning with synchronized blocks, ThreadLocal memory explosions, incomplete framework support, and unsuitability for CPU-bound workloads, while showing benchmarks where they excel in I/O-heavy scenarios.
This article explains four approaches to implementing distributed locks with Redis: basic SETNX with expiration, atomic Lua scripts for lock acquire/release, the Redisson Java client with watchdog renewal, and the Redlock algorithm for high-availability multi-master deployments.
This article traces a Java method call through five stages: compilation to bytecode, class loading with vtable resolution, interpretation via stack frames, JIT compilation with optimizations like inlining and escape analysis, and final execution as machine code on CPU pipelines.
The author migrates a Spring AI Agent with 30+ business tools to Spring AI 2.0's Tool Search, which uses Lucene indexing to let the model search for relevant tools before calling them, reducing context overload and improving selection accuracy, while sharing best practices for tool descriptions and safe write-operation handling.
This article reviews three open-source Java solutions for integrating ComfyUI AI image generation: a lightweight SDK (ComfyUiApiJava), an API aggregation layer (comfy-flow-api) with Spring Boot 3, and a full-stack enterprise platform (comfyui-openrouter-ai) with user management, credits, and WebSocket progress, helping developers choose by complexity and needs.
This tutorial demonstrates how to use Spring-Smart-DI's @AutowiredProxySPI annotation to dynamically switch between multiple service implementations (e.g., SMS providers) at runtime by changing configuration values, without application restarts, using proxy-based injection that resolves the active implementation on each call.
This article reviews two open-source projects — comfy-flow-api and comfyui-openrouter-ai — and a three-layer production architecture for integrating ComfyUI AI image generation into Java backends, covering RESTful API wrapping, load balancing, workflow JSON templating, and deployment strategies.
This article explains Java callback mechanisms — synchronous and asynchronous — through interfaces, anonymous classes, lambdas, and CompletableFuture, demonstrates their use in Spring's BeanFactory and a payment integration, and shows how functional interfaces enable flexible data transformation for multi-bank integration.
This article details MyBatis-Plus 3.5.15's new support for Spring Boot 4.0 and Jackson 3.0, providing step-by-step migration guidance including starter dependency changes, JSON field handling with Jackson3TypeHandler, and common upgrade pitfalls like starter mismatches and factoryBeanObjectType errors.
This article explains how Java's implicit serialVersionUID causes deserialization failures when class structure changes, details how the JVM calculates it, shows source-level version checking in ObjectStreamClass, lists compatible and incompatible changes, and covers custom serialization mechanisms like transient, writeObject/readObject, and Externalizable.
The article compares Spring @Scheduled, Quartz, and db-scheduler for clustered scheduling, showing how db-scheduler uses a single database table to provide cluster-safe mutex, persistence, and one-time delayed tasks without the overhead of Quartz's eleven tables or external middleware.
This article demonstrates how to store four independent notification channel switches (SMS, email, in-app, WeChat) in a single MySQL TINYINT column using bitwise operations, covering schema design, SQL queries, Java enum and utility classes, service and controller layers, MyBatis mapper, extensibility to N channels, and key considerations like indexing, concurrency, and readability.
The article explains why notification services are hard—slow delivery, unreliable third‑party providers, and status tracking—and shows how to solve these issues by fully decoupling the API from workers using a message queue, with detailed Spring Boot code examples and scaling strategies.
The author refactors an old Spring Cloud project by removing Feign, replacing @FeignClient with Spring Boot 4.x’s native @HttpExchange and @ImportHttpServices, and demonstrates that Spring’s built‑in HTTP Service Client provides the same declarative convenience with less boilerplate, while still supporting custom configuration, error handling, and reactive use cases.
The article explains that Java static blocks are not always the first code to run during class loading because static field initializers and static blocks are executed in the order they appear in the source, and a static field can trigger instance initialization.
Sa-Token has rapidly become the go‑to Java permission framework because it abstracts and automates common security concerns, offers a lightweight Core‑Plugin‑Adapter architecture, supports plug‑in storage like Redis, and lets developers implement login, logout and permission checks with a single line of code, dramatically reducing development time compared with Spring Security.
The article details how the massive 700‑plus error‑code validation system in AliExpress’s marketing pipeline is protected by an AI‑driven, multi‑phase attack‑defence pipeline that leverages Saiga Mock for non‑destructive testing, MQ‑driven orchestration, and plug‑in sub‑engines to achieve rapid, risk‑free verification.
The article examines a common duplicate‑order bug caused by client retries after network timeouts, explains why @Transactional alone cannot guarantee idempotency, critiques simple Redis SETNX solutions, and presents a robust Spring Boot design that stores idempotency records together with order data in a single MySQL transaction, uses request fingerprints, unique keys, and owner tokens to safely replay or reject retries while handling concurrency and cleanup.
The article explains how excessive if‑else logic in Java back‑ends harms code isolation and scalability, and demonstrates a practical workflow‑orchestration solution using a FlowChain engine, complete with configuration, node definitions, execution flow, and source code examples from the open‑source MemberClub project.
The article details a critical RCE flaw in Fastjson 1.x versions, explains why the vulnerability is easily exploitable, examines community backlash and double standards, and offers concrete mitigation steps while urging a responsible open‑source mindset.
The article explains that Java arrays, unlike regular objects, lack constructors because the JVM creates them directly via special bytecode instructions, automatically zero‑initialising elements and exposing length as a field, which trades flexibility for simplicity and performance.
This article explains why adding a Spring Boot starter dependency instantly creates the required beans without XML or manual configuration, walks through the auto‑configuration mechanism—including @EnableAutoConfiguration, AutoConfigurationImportSelector, and conditional annotations—and shows step‑by‑step how to build a custom starter from scratch with Maven, configuration properties, an aspect, and registration files.
Spring Framework 7 introduces @Retryable and @ConcurrencyLimit annotations for method-level retry and concurrency control, enabling developers to handle transient failures and limit parallel executions without third-party libraries, though they operate per-JVM and lack distributed coordination.
The article explains how the old pattern of GET‑ing an entire JSON string from Redis, deserializing it in Java, modifying a single field and writing it back is inefficient and error‑prone, and shows how Spring Data Redis 4.2’s RedisJsonTemplate lets you update or read individual JSON paths directly, reducing code, network traffic and race‑condition risks.
The article explains the Open‑Closed Principle, shows how Spring leaves empty hook methods like onRefresh() for extensions, demonstrates the concept with a Java demo, compares inheritance‑based and interface‑based extension approaches, and discusses trade‑offs and practical guidelines for designing extension points.
This article presents eight self‑test gRPC interview questions covering performance, contract, cross‑language support, streaming, HTTP/2 fundamentals, Protobuf field tags, call patterns, retryable status codes, load‑balancing policies, interceptor usage, and Spring Boot 3 integration, each accompanied by concise reference answers.
A real‑world case shows that using @Transactional with the default REQUIRED propagation caused a long‑running transaction, frequent deadlocks, data inconsistency and higher timeout rates, and the article walks through the root cause, investigation steps, and practical fixes such as REQUIRES_NEW, self‑proxy calls, and async eventual consistency.
This comprehensive guide walks through Harness Engineering concepts, the seven‑layer architecture, environment setup, full Spring Boot codebase, agent configuration, best‑practice recommendations, testing procedures, common issues, and advanced directions for building controllable AI agents with Spring AI Alibaba.
The article demonstrates that although List.of, Arrays.asList, and unmodifiableList implement the List interface, they violate the Liskov Substitution Principle because their optional add/remove operations throw UnsupportedOperationException, revealing a hidden contract mismatch between interface documentation and runtime behavior.
A production outage caused by Java 8 parallel streams exposed the dangers of the default commonPool, unlimited task queuing, and long‑running API calls, leading to 100% CPU, 30+ GC events per hour, and a near‑service collapse, which was resolved by custom thread pools, timeouts, and CompletableFuture alternatives.
The article dissects why Java 8’s Optional, despite being a dedicated null‑pointer remedy, remains unpopular, examines common misconceptions, misuse pitfalls, unsuitable scenarios, and finally presents three concrete situations where Optional truly shines, backed by code examples and practical guidance.
This article categorizes essential Linux commands for Java developers, explains why interviewers focus on real‑world usage, provides scene‑based command tables, demonstrates log‑analysis and performance‑monitoring workflows, and offers concise answers to common interview follow‑up questions.
This article details Redis's evolution into a comprehensive AI data infrastructure, covering its four core capabilities—vector search with hybrid queries, native Vector Sets data type, LangCache semantic caching for 70% LLM cost reduction, and Redis Iris context engine for AI agent memory—with technical implementations, performance benchmarks, and use-case recommendations.
