This article walks through the complete process of obtaining a WeChat Mini Program user's OpenID by using wx.login to get a code, calling the updated auth.code2Session API with appid and appsecret, and handling the server‑side Java implementation that extracts the OpenID and session key.
Through a controlled experiment with four Spring Boot service groups on Kubernetes, this article shows that relying on Java’s default GC and heap settings can drastically reduce throughput and increase tail latency, especially under higher load, and demonstrates how explicit GC algorithm and Xms/Xmx tuning restores performance.
This article compares LangChain4j and Spring AI, outlining their design philosophies, core features, ecosystem integration, community maturity, and provides concrete code examples and selection guidelines to help Java developers decide which framework best fits their AI application needs.
The article walks through the discovery of an arbitrary ZIP‑file download vulnerability in a large OA front‑end, detailing how the attacker traced the vulnerable Spring MVC controller, built a PoC using a controllable cookie, achieved directory‑traversal reads, demonstrated a DOS extension, and finally suggested input‑filter mitigations.
An online payment service failed when a newly added business logic forgot to commit its transaction, leaving a polluted connection that silently blocked subsequent orders, and the post‑mortem explains the root cause, debugging steps, code fixes, and preventive measures.
The article details the design and evolution of the Multiplicative Tree framework—from version 1.0 to 3.0—showing how a DSL‑based, compile‑time‑checked configuration system delivers instant formula deployment, robust stability safeguards, and significant performance gains for multi‑objective ranking models.
This article explains how to replace manual encryption code with a lightweight, annotation‑driven solution that uses a custom MyBatis interceptor to automatically encrypt and decrypt sensitive fields such as phone numbers, emails, and ID cards, improving code readability, maintainability, and security compliance.
This article shows Java developers how to add generative AI to enterprise applications using the open‑source LangChain4j library and Quarkus, covering a chatbot example, streaming responses, chat memory management, and structured output without learning a new programming language.
The article analyzes the cumbersome MyBatis IN‑statement foreach template, explores three implementation paths, and presents a custom LanguageDriver that lets developers write simple "in #{param}" syntax, cutting XML boilerplate in half while generating correct SQL at runtime.
This article explains MyBatis’s plugin mechanism, detailing the Interceptor interface methods, how plugins form an interceptor chain to wrap core components like Executor, and provides a step‑by‑step example of a logging plugin with code and configuration, illustrating the runtime flow and extension capabilities.
The article shows how to replace repetitive System.currentTimeMillis() timing code with a concise TimeTracker utility that leverages try‑with‑resources, functional interfaces, and flexible exception handling to achieve millisecond‑level measurement and dramatically improve code readability and performance.
Claude Code’s new Auto Memory feature automatically captures build commands, code conventions, architecture notes, and debugging experiences into local markdown files, eliminating the need for manual CLAUDE.md maintenance and enabling seamless project context across terminal sessions.
The article explains three typical traps when working with Java List: Arrays.asList returns a fixed‑size list that throws UnsupportedOperationException on add/remove, iterating and removing elements directly also fails, and converting primitive arrays with Arrays.asList produces an unexpected single‑element list.
This guide details how to select a Java logging framework, defines a decision tree for when to log, maps log levels (ERROR, WARN, INFO, DEBUG) to concrete scenarios, provides code‑handling principles, outlines prohibited logging patterns, and includes a quick reference for alerting rules.
By profiling a three‑year‑old order service and applying six data‑driven optimizations—including log reduction, object‑allocation cuts, HashMap replacement, Java 21 virtual threads, JSON caching, and ZGC tuning—the team achieved a 9.5× throughput increase and a ten‑fold drop in P99 latency.
This article presents a complete design and implementation of a high‑throughput, asynchronous OCR pipeline built with Spring Boot and Tesseract, covering distributed architecture, thread‑pool tuning, image‑preprocessing, multi‑engine recognition, data extraction strategies, Kubernetes deployment, security compliance, chaos testing, and future AI‑driven enhancements.
This article introduces AgentScope, Alibaba's open‑source Java multi‑agent framework, compares its design, advantages, and use cases with Spring AI Alibaba, showcases key features such as ReAct reasoning, built‑in RAG and memory, and provides quick‑start code examples and the project repository.
This article explains the @Nullable annotation in Java, showing how it can be applied to methods, fields, and parameters with concrete Spring examples, code snippets, and a look at its usage inside the Spring framework itself.
The article explains how Spring Boot 4 introduces a built‑in ApiVersionStrategy that replaces custom interceptors and duplicated controllers with a single configuration property and a version attribute, dramatically cutting API versioning code from hundreds of lines to just three.
This article combines Li Auto's 2026 campus recruitment salary data—showing typical offers ranging from 25k to 32k monthly with 14‑16 month packages—and a comprehensive Java interview cheat‑sheet covering inheritance vs interfaces, Map implementations, String handling, ConcurrentHashMap internals, reference types, memory‑leak detection, design patterns, observer pattern, multithreading, Future execution, and deadlock prevention.
Easy Work is a Java workflow engine that offers a simple API and modular components, enabling developers to create, execute, pause, and serialize complex workflows using code, JSON definitions, and rich conditional predicates, with detailed examples covering repeat, sequential, parallel, and conditional flows.
This guide explains how to use Maven's assembly plugin to create executable JARs, ZIP/TAR archives, and custom distribution packages by configuring the plugin in pom.xml, writing assembly descriptors, and running a single Maven command, with multiple real‑world examples and a sample project structure.
This article explains the interview focus on MyBatis placeholders, detailing the syntax, security implications, performance differences, appropriate scenarios, best‑practice guidelines, common pitfalls, and provides concrete code examples to help candidates master #{} and ${} usage.
This article explains the fundamental differences between Spring MVC interceptors and servlet filters—including definition, scope, configuration, lifecycle, and execution timing—and details their processing order with illustrative code samples and a request flow diagram.
This article reveals eight frequent Java collection pitfalls—such as costly ArrayList insertions, inefficient LinkedList access, repeated contains checks, missing initial capacities, unordered HashMaps, modifying collections during streams, misuse of parallelStream, and in‑memory caches—explaining why they degrade performance and providing concrete, code‑driven alternatives.
The article first reflects on the importance of quick reaction and solid fundamentals for new developers, then presents an efficient Java implementation that counts how many times the digit 1 appears in the range 1 to n using a digit‑by‑digit analysis.
This article introduces Guardian, a lightweight Spring Boot starter that provides anti‑duplicate‑submission protection and request rate limiting, explains how to integrate it via Maven, configure it with annotations or YAML, and details its internal workflow, storage options, concurrency handling, and monitoring capabilities.
This article examines why Java is often labeled slow, dispels three major misconceptions about interpretation, garbage‑collection pauses, and startup time, presents concrete benchmark data against other languages, and explains how modern JVM features and framework choices actually shape performance.
This guide shows how to leverage IntelliJ IDEA's diagram feature to visualize inheritance and interface relationships of Java classes, prune irrelevant nodes, inspect members, filter visibility, add additional classes, and quickly jump to source code, making code navigation far more efficient.
A developer asks whether monetary amounts should be stored as Long or BigDecimal, and the article compiles ten varied community suggestions—ranging from using Long, BigDecimal, String, custom types, Protobuf, leadership directives, AI answers, frugal choices, to whimsical ideas—each with brief explanations and illustrative images.
The article explains how Java records, with their built‑in immutability and auto‑generated methods, eliminate mutable state, reduce lock contention, and improve throughput in high‑concurrency architectures, providing concrete code examples and comparisons with traditional mutable beans.
The article analyzes a custom TraceIdGenerator that uses a simple AtomicInteger counter and IP‑based prefix, identifying how its reset logic and CAS competition can cause duplicate IDs in high‑concurrency scenarios, and proposes timestamp checks, larger ranges, retry mechanisms, and true Snowflake implementation as solutions.
This article explains how the @Nullable annotation can be applied to methods, fields, and parameters in Java, provides concrete code examples for each case, and shows a real‑world usage from Spring's StringUtils utility.
Redis Cluster can lose writes due to asynchronous replication, network partitions, inadequate persistence settings, or unconfirmed client operations, but enabling AOF, configuring replication acknowledgments, using Sentinel or built‑in HA, and adding client retry logic can mitigate these risks, as demonstrated with a Java Jedis example.
This article reveals how Java records serve as immutable data‑modeling tools, demonstrating compact constructors for validation, embedding business logic, static factory methods, pattern‑matching integration, and response‑object usage, while also outlining their thread‑safety benefits and scenarios where records are unsuitable.
JetBrains' IntelliJ IDEA 2026.1 EAP 3 finally moves deleted files to the system recycle bin, adds extensive Spring, Java, Kotlin, AI, and performance improvements, and fixes over 70 known issues, preparing the IDE for remote and distributed development.
This article examines Spring's common dependency injection methods, compares @Autowired and @Resource annotations, outlines the pros and cons of constructor, setter, and field injection, highlights the drawbacks of field injection, and explains why IntelliJ IDEA only flags @Autowired with a warning.
The article outlines the motivation, phased planning, architecture, task breakdown, implementation, and testing of a compact reminder platform built with Java 17/SpringBoot 3, Vue 3, Uniapp, MyBatisPlus, Redis, and RocketMQ, detailing each functional module and UI screen.
A recent production incident revealed that a forgotten transaction commit in one service left a database connection polluted, causing unrelated payment requests to fail silently, and the article walks through the root cause, debugging steps, code fixes, and preventive measures.
Learn how to seamlessly convert uploaded .docx files to PDF in a Spring Boot application using the pure‑Java docx4j library, covering solution comparison, Maven dependencies, a utility class, controller implementation, and Windows/Linux font‑encoding fixes for reliable, high‑fidelity document rendering.
This article explains the interview focus points for RocketMQ ordered messages, details the partition‑ordered model and its two‑step guarantee mechanism, provides in‑depth analysis of producer and consumer processes, includes full Java code examples, and outlines best practices, pitfalls, and common misconceptions.
This article explains RabbitMQ's transaction mechanism, walks through the four-step process of opening, executing, committing, or rolling back a transaction, provides a complete Java example with Maven setup, and discusses performance impacts and when to prefer acknowledgments over transactions.
This guide presents a lightweight Spring Boot dependency vulnerability scanner that automatically collects all project JARs, matches them against a CVE database, visualizes risk levels, provides detailed remediation steps and can be integrated into local development, emergency response, and CI/CD pipelines.
This article presents eight concrete rules for handling null values in Spring Boot 3 applications, illustrating common pitfalls with code snippets, explaining production‑impact risks, and offering best‑practice solutions such as using empty collections, explicit null checks, proper Optional usage, and consistent API design.
This article walks through a real‑world Java service on Kubernetes, detailing the initial confidence, recurring OOM and rollout issues, and a multi‑round remediation that introduced container‑aware JVM settings, refined resource requests, OOM dumps, probes, and metrics, ultimately achieving three years of stable operation with lower resource usage.
This article walks through Spring Boot 4's built‑in HTTP Interface, showing how to replace RestTemplate/WebClient with a type‑safe, annotation‑driven RestClient, covering Maven setup, DTO and interface definitions, configuration, error handling, header injection, timeout control, reactive alternatives, design principles, and a side‑by‑side comparison with the legacy approach.
This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom enums, and assertion utilities, providing clean, maintainable code, internationalized error messages, and consistent response structures for both business and system errors.
This article introduces a Maven aggregation Quickstart plugin for IntelliJ IDEA that automates the creation of multi‑module Java projects, explains its core features, provides step‑by‑step installation and usage instructions, shows how to customize templates, and offers troubleshooting tips along with the source repository.
Spring Data AOT Repositories, introduced in Spring Boot 4, move repository parsing and query generation from runtime to compile time, dramatically reducing startup time, memory usage, and enabling early detection of method‑name or JPQL errors for large Java backend applications.
This article explains how to build a real‑time online user counter by identifying users via tokens or browser fingerprints, storing them in a Redis sorted set, and using ZADD, ZRANGEBYSCORE, ZREMRANGEBYSCORE and ZREM commands to add, query, and clean the data.
The article explains how excessive if‑else branching in multi‑business systems harms code maintainability, and demonstrates how a workflow engine combined with a plugin extension mechanism can isolate business logic, simplify testing, and enable flexible execution chains, using the open‑source MemberClub project as a concrete example.
Based on JetBrains' 2025 developer ecosystem report, this article reveals why Java still dominates Chinese enterprises, why Python is essential for AI development, how JavaScript fits the full‑stack future, and which AI coding assistants are gaining traction among local developers.
The article explains how Lombok’s @Data annotation generates getter and setter methods with a lowercase first letter for camel‑case fields, causing Jackson to serialize JSON property names in all lowercase, and offers three fixes: write methods manually, use @JsonProperty, or rename fields to avoid lower‑upper patterns.
This article explains why large file downloads can fail on unstable networks, how to use HTTP Range headers and status codes for resumable downloads, and provides a complete SpringBoot implementation—including controller, service logic, and range‑parsing code—to enable reliable partial content delivery.
The article outlines the most impactful Java 25 enhancements—including compact object headers, generational Shenandoah GC, ahead‑of‑time compilation, JFR improvements, security updates, and the removal of 32‑bit support—explaining how each change boosts performance, safety, and observability for developers.
Spring Debugger’s new remote debugging feature lets developers inspect Spring beans, execute SQL, view configuration, and analyze transactions on running applications without using Java agents, leveraging container thread models like Tomcat’s persistent workers, with simple JDWP setup and a few limitations.
This article explains why raw collections are unsafe, how Java generics enforce compile‑time type safety, reduce casting, improve code readability, and boost performance, and it walks through generic interfaces, collections, custom generic classes, inheritance rules, diamond syntax, and common restrictions with concrete code examples and diagrams.
A payment service showed successful orders but no data in the database, leading to lock timeouts; the root cause was a hidden missing commit in a special code path that polluted the connection pool, causing other services to inherit an uncommitted transaction and fail intermittently.
This article explains how the @CacheEvict annotation in Spring Cache can be used to delete specific cache entries or clear entire caches, detailing its parameters such as value, allEntries, and beforeInvocation with a concrete code example.
The article explains how Spring Cache, introduced after Spring 3.1, uses the @Cacheable annotation to declaratively cache method results, detailing each attribute such as cacheNames, key, keyGenerator, and unless, with code examples illustrating key generation and conditional caching.
The article explains that @CachePut serves as a trigger to update or add cache entries in Spring Cache, contrasting its behavior with @Cacheable, detailing execution flow, handling of null results, and the recommendation against using both annotations on the same method.
This article walks through the complete development of a minimal Model Context Protocol (MCP) server using Spring Boot 3 and Server‑Sent Events, illustrating how OpenSpec drives the workflow from proposal and task breakdown to design, implementation, testing, and integration with Claude Code.
This article compares ten community‑sourced approaches for representing monetary values in Java, explaining when a simple Long, a precise BigDecimal, a String, custom wrappers, Protobuf tricks, leadership directives, AI assistance, or even minimal integer types are appropriate, and why each choice matters.
This article explains how aspect‑oriented programming (AOP) addresses cross‑cutting concerns by defining joinpoint interfaces, describing their design, illustrating Java examples, and comparing static and dynamic weaving techniques used in frameworks like Spring.
This article explains why Java generics were introduced, demonstrates how they improve type safety and reduce casting through concrete examples with generic classes, interfaces, collections, custom generic methods, and highlights common pitfalls such as generic arrays and static methods.
A payment service failed to insert orders despite successful payments, showing no errors, occasional lock timeouts, and intermittent success, which was traced to a missing transaction commit that polluted reused connections, causing unrelated business failures until the bug was fixed and preventive measures were added.
JetBrains' IntelliJ IDEA 2026.1 EAP 3 introduces a long‑awaited feature that moves deleted files to the system recycle bin instead of permanently erasing them, while also delivering a host of Spring, Java, Kotlin, editor, AI, platform, and performance enhancements for developers.
This article walks through converting a Maven‑based Java Spring Boot project (mall‑tiny) to Gradle, explains Gradle's key features and plugins, provides step‑by‑step setup with screenshots, shows the full build.gradle file, and compares build times to demonstrate Gradle's speed advantage.
This article explains why the previous custom WebMvcStreamableServerTransportProvider approach is fragile, introduces Spring AI's standard TransportContextExtractor, and provides step‑by‑step code and screenshots showing how to configure the extractor, capture ServerRequest, and read HTTP headers, URL, query parameters, and other request data in an MCP Server.
This tutorial explains how to add the EasyCaptcha library to a Spring Boot 3.5.0 project, covering dependency setup, generating various captcha types (arithmetic, Chinese, font‑based), converting them to images or Base64, and integrating the captcha flow with Redis in a Spring MVC controller.
This article introduces an open‑source MyBatis‑Plus dynamic‑table starter, explains why dynamic table names are needed for large‑scale data, outlines its key features, provides step‑by‑step installation and quick‑start instructions, demonstrates advanced usage, debugging tips, FAQs, and real‑world scenarios.
This article demonstrates how to encapsulate common RedisTemplate operations—such as deleting single or multiple keys, setting expiration, checking existence, and performing String and Hash CRUD actions—by providing concrete Java code examples and step‑by‑step method implementations.
This article explains the common Redis caching tools, introduces Spring Data Redis's bound operation APIs, and provides step‑by‑step configuration examples for RedisTemplate, helping developers choose and set up a Redis client in Java applications.
This guide shows how to break down tangled Java services using Domain‑Driven Design and Command‑Query Responsibility Segregation, providing concrete terminology, layered diagrams, code examples, and step‑by‑step migration strategies to improve maintainability, performance, and team communication.
The article explains the JSR‑250 @Resource annotation in Spring Boot, detailing its name‑first injection logic, differences from @Autowired, common pitfalls with multiple implementations, and proper usage patterns—including explicit name specification and why constructor injection is preferred—providing code examples and interview‑ready explanations.
The article details Du Xiaoman's 2023 campus hiring salaries for Java backend roles, explains the significance of signing bonuses, shares a successful intern story, and provides in‑depth interview preparation covering thread pools, locks, AQS, CAS, SQL optimization, sharding, MVCC, and transaction isolation levels.
Maven 4, released at the end of 2025, introduces a 4.1.0 POM model, separates build and consumer POMs to flatten dependencies, adds explicit classpath‑jar and module‑jar artifact types, renames modules to subprojects, and implements a tree‑based lifecycle for true parallel builds, all while remaining backward compatible.
This article breaks down the interview focus points, core answer, deep analysis, code examples, and common pitfalls for ensuring RocketMQ messages never get lost, covering producer, broker, and consumer configurations, trade‑offs, and practical troubleshooting steps.
A production incident where payment requests succeeded but no order rows were inserted was traced to a missing commit in a special code path, causing a polluted connection to be reused by other services; the article details the debugging steps, root‑cause analysis, code fixes, and preventive measures.
This guide walks you through a fully open‑source, pure‑Java solution for converting uploaded .docx files to PDF in a Spring Boot application, covering library selection, Maven dependencies, a reusable utility class, controller implementation, and handling Chinese font issues on Windows and Linux.
JetBrains' IntelliJ IDEA 2026.1 EAP 3 introduces a long‑awaited feature that moves deleted files to the system recycle bin instead of permanently erasing them, while also delivering a host of Spring, Java, Kotlin, editor, AI, platform, and performance improvements aimed at modern remote and AI‑enhanced development workflows.
An in‑depth look at why Java’s TreeSet can trigger ConcurrentModificationException under high concurrency, exploring the red‑black tree’s non‑atomic operations, thread scheduling nuances, and how various concurrent set implementations—synchronized wrappers, read‑write locks, ConcurrentSkipListSet, CopyOnWriteArraySet, and custom designs—compare in performance and suitability.
This article explains the principles of Single Sign-On (SSO) and OAuth2.0, compares their workflows, outlines the four OAuth2.0 grant types, and clarifies terminology differences, providing clear step‑by‑step diagrams and practical examples.
The article explains why traditional static utility classes become hard‑to‑maintain technical debt, and demonstrates how Java 8’s functional interfaces and lambdas can replace them with injectable, testable, composable validation rules, reducing refactoring cost and improving code evolution.
The article explains how excessive if‑else logic harms maintainability in a business middle‑platform, introduces a flow‑engine and plugin‑extension approach to isolate code and support rapid business expansion, and demonstrates the design with the open‑source MemberClub project, including configuration, node definitions, execution principles and core Java implementation.
Learn how to convert user‑uploaded .docx files to PDF in a Spring Boot application using the pure‑Java docx4j library, covering solution comparison, Maven dependencies, utility class implementation, controller endpoint, and handling Chinese font issues on Windows and Linux.
The 2026.1 EAP 3 release of IntelliJ IDEA introduces several practical updates, including moving deleted files to the system recycle bin, deeper AI assistant integration with Roots and improved commands, automatic SQL dialect detection, enhanced Spring debugging, built‑in Git Worktree support, UI refinements, and numerous bug fixes across Java, Kotlin, Docker, and HTTP client features.
IntelliJ IDEA 2026.1 EAP 3 finally adds a recycle‑bin‑style file deletion, alongside dozens of enhancements for Spring, Java, Kotlin, editor experience, AI‑assisted completion, platform architecture, and performance, addressing long‑standing developer complaints and preparing the IDE for remote and AI‑driven workflows.
This article introduces MyPerf4J, a Java‑agent based, low‑overhead performance monitoring tool that provides real‑time metrics such as RPS, latency percentiles, memory usage and GC statistics, and explains how to install, configure, run and uninstall it in development and production environments.
This article explains Java's reflection mechanism, covering its main uses such as dynamic class loading, handling unknown types, accessing private members, and framework development, then walks through basic steps, a complete code example, and discusses its advantages and drawbacks.
The article explains that the “invalid source release: 10” error occurs because the IDE is set to JDK 10 while the system JDK is 8, and it walks through checking the JDK version and aligning IDEA project, compiler, and pom.xml settings to resolve the issue.
This article introduces Easy Work, a Java workflow engine, explaining its core concepts, showing how to define work units, compose complex sequential, parallel, and conditional flows, use breakpoints to pause execution, and construct workflows via JSON with complete code examples and repository links.
The Eclipse Foundation announced Jakarta EE 11, highlighting streamlined data access via the new Jakarta Data spec, support for Java 21 including virtual threads, modernized testing tools, deprecation of Managed Beans, and early certification of several enterprise servers, marking a major step toward cloud‑native Java development.
The author shares a workplace frustration about unfair performance metrics, then illustrates how a hidden 1024‑byte boundary bug led to a discussion of the classic “power‑of‑two” problem, providing clear bit‑wise logic, edge‑case handling, and ready‑to‑run Java code for detecting powers of two.
This article breaks down the interview focus points, core solution framework, underlying RocketMQ mechanisms, step‑by‑step remediation actions, common pitfalls, and a concluding strategy for handling message backlog through emergency scaling, consumer optimization, degradation, dead‑letter handling, and proactive capacity planning.
The article explains what occurs when a Redis distributed lock expires before a business operation completes, and details how Redisson’s watch‑dog mechanism automatically renews the lock, covering the underlying principles, configuration, code examples, and comparisons with alternative renewal approaches.
The article analyzes why many enterprises continue using JDK 8 despite newer releases like JDK 25, examining compatibility issues, stability, learning costs, third‑party library support, performance trade‑offs, commercial licensing, and toolchain considerations while offering migration guidance.
The article explains why naïve reliance on databases causes performance bottlenecks, introduces cache fundamentals, details Redis’s strengths, and walks through a full Spring Boot‑Redis integration deployed with Docker, including configuration, annotations, and practical API testing.
The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.
This guide explains how to integrate the asyncTool library into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and use the provided Builder API to define serial, parallel, and mixed task flows with detailed code examples and best‑practice cautions.
