This guide walks through building a high‑performance, scalable MQTT access gateway for IoT using Spring Boot for service orchestration and Netty for connection handling, covering protocol fundamentals, modular architecture, multi‑protocol adaptation, session management, high‑concurrency optimizations, clustering, observability, and deployment best practices.
The article explains why Spring Boot continues to use Jackson as its default JSON serializer, detailing the automatic ObjectMapper/JsonMapper creation, the HTTP message conversion process, Jackson’s balanced strengths, practical code samples, and how to switch to alternatives like Gson, JSON‑B, or Fastjson2.
This article compares Spring Data JDBC and Spring Data R2DBC for Spring Boot 3.x/4.x projects, detailing setup, Maven dependencies, configuration, entity definitions, repository and service implementations, transaction handling, performance trade‑offs, and provides a hybrid approach that wraps JDBC calls in reactive Monos for WebFlux, helping developers decide which persistence layer best fits their reactive architecture.
The article explains why AI‑assisted coding works smoothly for lightweight projects but stalls on Java micro‑services due to cloud‑only dependencies, and presents a five‑principle harness‑engineering approach—dependency inversion, zero‑intrusion profile isolation, CLI tool integration, local validation scripts, and a checklist—to create a fully local, AI‑friendly development loop that dramatically reduces iteration time.
JDK 27 changes the default garbage collector from a resource‑aware Serial GC to G1, which can unexpectedly increase CPU usage, alter latency and throughput for small‑container Java services even when no code or JVM flags are changed, so teams must verify the GC in use and benchmark both collectors under realistic limits.
This article explains why a Spring Boot executable JAR runs with an embedded Tomcat while a WAR relies on an external Tomcat, how port and context‑path settings differ, how to modify them, and which packaging is preferable for interviews and production.
This article walks through why manual if‑else checks are cumbersome for API input validation, introduces Java Bean Validation (JSR‑303/349/380) and its implementations, shows how to use @Validated and @Valid annotations in Spring Boot, and demonstrates unified exception handling for clean error responses.
The article explains why ad‑hoc third‑party integrations quickly become unmaintainable, identifies four common pain points, and presents a layered architecture using template method, strategy and factory patterns that abstracts common concerns such as retries, logging and signing, dramatically reducing duplicated code and maintenance effort.
This article details a production-ready dynamic data permission system using Spring Boot 3.x and MyBatis-Plus 3.5+, covering row-level interception via JSqlParser, column-level masking with Jackson serialization, RBAC+ABAC hybrid model, two-level caching with Caffeine and Redis, and lessons learned from handling complex JOINs, hot updates, and performance overhead.
This comprehensive guide analyzes four production-ready strategies for MySQL-Redis dual-write consistency, from basic cache-aside with delayed double-delete to binlog-based CDC, including Spring Boot code examples, concurrency pitfalls, and interview-focused scenario breakdowns.
The article explains why native Apache POI causes memory‑explosion and maintenance headaches for Excel import/export in Java back‑ends, introduces Alibaba's EasyExcel as a low‑memory, annotation‑driven alternative, and provides step‑by‑step Spring Boot code for exporting, importing, custom conversion, validation, complex headers, pagination, template filling, and common pitfalls with concrete solutions.
This guide shows how enterprise developers can quickly add full‑featured online Word, Excel and PPT editing to Spring Boot 4.x applications by deploying OnlyOffice via Docker, configuring JWT authentication, and implementing backend endpoints for file storage, editor configuration, and save callbacks.
This article provides a production-ready guide to replacing traditional HttpSession with Spring Session backed by Redis, covering multi-client session unification, performance tuning, security hardening, high-availability patterns, and practical Spring Boot 3.x configuration with code examples.
This article details a production-hardened Spring Boot integration with HashiCorp Vault for centralized secret management, covering Kubernetes Auth and AppRole authentication, dynamic database credential issuance, lease renewal aligned with HikariCP connection pools, security policies, audit logging, high-availability Raft deployment with Auto-Unseal, and practical patterns for config reload, fallback, and multi-environment isolation.
This guide walks through installing ZLMediaKit via Docker, setting up FFmpeg, configuring a Spring Boot backend with streaming services, and using a simple HTML player with flv.js to push and play local video streams over RTMP.
The article explains why enterprise applications need a unified large‑model gateway, outlines a layered architecture using Spring Boot 3.x, strategy pattern and interface‑driven design, and provides production‑grade features such as retry, circuit‑breaker, token accounting and easy addition of new model providers.
This article details production-ready gRPC integration with Spring Boot 3.x, covering contract-first Protobuf design, Maven code generation, timeout and retry strategies with Resilience4j, mTLS and JWT interceptors, JVM/Netty tuning for 40k+ QPS, Spring Cloud service discovery integration, and cross-language Java-Go benchmarking results showing 2x throughput over REST.
Spring Boot 4.0 removes support for the Undertow embedded server because it is not compatible with the required Servlet 6.1 baseline and lacks sufficient maintenance, prompting developers to switch to Tomcat or Jetty and follow detailed migration steps to avoid startup failures and configuration loss.
A newly disclosed CVE-2026-16723 shows that fastjson2’s AutoType parsing can be exploited for remote code execution, affecting all released versions, with a fix only expected on August 2, and the article explains how to mitigate the risk by enabling SafeMode before upgrading.
A newly discovered gadget‑free RCE in Fastjson 1.2.83 targets Spring Boot executable fat‑JARs, has already been seen in the wild, and can be mitigated by enabling SafeMode, tightening outbound HTTP, and migrating to Fastjson2.
The article explains the drawbacks of manually using System.currentTimeMillis for multi‑stage timing, introduces Spring’s StopWatch utility from spring‑core, demonstrates its API and code examples, shows three common usage scenarios, warns about pitfalls, compares it with raw timers, and argues why Spring itself adopts StopWatch for concise, structured performance monitoring.
Spring Boot 4.0, built on Spring Framework 7, requires Servlet 6.1, leading to the removal of Undertow support; the article explains the technical reasons, the impact on existing projects, and provides step‑by‑step migration paths to Tomcat or Jetty, including configuration changes and risk considerations.
This guide walks through deploying OnlyOffice, wiring a Vue front‑end with Element UI, implementing Spring Boot back‑end endpoints to load, edit, and save Word documents, handling token verification, and troubleshooting common deployment and configuration issues.
A comprehensive guide to running Spring Boot reliably on Kubernetes covering layered Docker image builds, JVM container-aware memory and CPU configuration, OOMKilled root-cause analysis using Native Memory Tracking and heap dumps, Prometheus monitoring integration, and Cloud Native Buildpacks for automated CI/CD pipelines.
This article walks through the end‑to‑end creation of a production‑grade table‑reservation platform, covering the three‑tier client architecture (WeChat Mini‑Program, H5/App via UniApp, and a Vue3 + Element Plus PC admin), a dual Spring Boot backend, Redis distributed locking combined with MySQL unique indexes for high‑concurrency seat booking, JWT‑based authentication, RBAC permission control, and an Apple‑inspired design system, all illustrated with concrete code snippets and deployment tips.
The article explains why Druid connection pools can fail in production and provides a step‑by‑step guide to extreme optimization, covering environment setup, core pool parameter tuning, monitoring with StatFilter and web UI, security hardening, leak detection, dynamic adjustments, and common pitfalls.
This article presents a comprehensive interview self‑test checklist for Spring Boot Starters, offering detailed reference answers that explain the distinction between Starters and AutoConfiguration, Maven transitive dependencies, registration files for Spring Boot 3.x, the inner workings of @ConfigurationProperties and Binder, changes to relaxed binding, essential annotations, naming conventions, exclusion techniques, the impact of excessive Starters, the design rationale behind separating dependency description from auto‑configuration, conditional property semantics, and the differences between ApplicationContextRunner and @SpringBootTest for testing auto‑configuration.
This article explains why native Apache POI causes memory‑heavy, boilerplate Excel import/export code, introduces Alibaba's EasyExcel as a low‑memory, annotation‑driven alternative, and provides step‑by‑step Spring Boot examples for exporting, importing, custom conversion, validation, pagination, and template filling while highlighting common pitfalls and solutions.
This article details how to integrate Drools with Spring Boot for complex business decisions, covering architecture design, hot-reload implementation using AtomicReference and KieContainer disposal, memory leak prevention, stateless session best practices, conflict detection via AgendaEventListener, and production observability with trace logging and dry-run sandboxes.
This article introduces the Liteflow rule‑engine framework, explains its core concepts, syntax, and configuration options, and walks through a complete Spring Boot 3.2 / Java 17 project that demonstrates building, deploying, and testing a multi‑step workflow with practical code examples.
The article explains the exact execution order of Spring Boot's Filter, Interceptor, and AOP layers, details the nine‑step request lifecycle, clarifies sorting rules, outlines common pitfalls, and provides guidance on choosing the right component for specific scenarios.
This article explains the purpose, structure, and usage of Qoder’s .qoder directory, detailing the rules and repowiki sub‑folders, how they feed AI context, example Spring Boot configurations, comparisons with other AI tools, and best‑practice recommendations.
This article shows how to replace hard‑coded if‑else approval logic with Flowable workflow in a Spring Boot 3.x project, using the three core annotations @EnableProcessApplication, @Deployment and @ProcessVariable to auto‑configure the engine, deploy BPMN files, inject variables, and implement a complete leave‑request service.
This guide walks you through creating a Claude Code Skill for Spring Boot projects that automates comprehensive, security‑aware code reviews by encapsulating architectural standards, generating structured reports, and integrating with CI/CD pipelines to boost code quality and team productivity.
This guide walks through setting up Spring Boot 3.x with JDK 17+, adding Actuator and test dependencies, and implementing a comprehensive JUnit 5 test suite that validates health endpoint aggregation, status priority, show‑details configuration, custom endpoints, JVM metrics, endpoint exposure, health groups, and custom HTTP status mapping, with instructions for running the tests via Maven or an IDE.
This guide shares a year of production experience migrating from basic @Scheduled to PowerJob for high-availability distributed task scheduling, covering Spring Boot integration, DAG workflow orchestration, MapReduce sharding, lease-based failover, JVM tuning, metadata DB protection, and idempotency patterns.
DAG WorkflowDistributed Task SchedulingHigh Availability
Spring Boot 3 projects quickly outgrow single‑module structures, so this guide shows how to split a codebase into Maven multi‑module layers, define clear dependency rules, configure parent and child POMs, and use ArchUnit tests to automatically enforce architectural boundaries during builds.
This article details integrating ShardingSphere-Encrypt into Spring Boot for transparent, field-level data masking, covering architecture selection, internal SQL rewrite mechanics, YAML configuration, custom algorithm SPI, common pitfalls like fuzzy queries and sharding interactions, performance benchmarks, caching strategies, and a three-phase historical data migration approach.
The article analyzes why logging in modern Spring Boot microservices shifts from a simple debug tool to a critical data pipeline, compares Logback and Log4j2 async setups, reveals hidden costs and risks, and walks through eight concrete production scenarios to build a controllable, high‑performance logging architecture.
This article explains how to implement a double‑token JWT authentication scheme in Spring Boot 3.x, using short‑lived AccessTokens for API security and long‑lived RefreshTokens for seamless background renewal, while addressing token revocation, refresh thresholds, blacklist handling, and multi‑device considerations.
This article demonstrates how to implement field-level encryption in Spring Boot using HashiCorp Vault's Transit engine, covering client configuration, unified encryption service, JPA and MyBatis integration, blind indexing for query performance, key rotation without downtime, disaster recovery, and defense-in-depth practices like HSM-backed root keys and audit logging.
This article examines five practical ways to improve Spring Boot 3.5.0 transaction performance—read‑only transactions, explicit propagation settings, correctly sized HikariCP pools, JDBC prepared‑statement caching, and Hibernate batch writes—showing the underlying overhead and providing concrete code and configuration examples.
This guide explains Domain‑Driven Design (DDD) and shows how to structure Spring Boot microservices by organizing code around business domains, detailing strategic and tactical concepts, package layouts, layer responsibilities, cross‑domain communication, comparisons with traditional layering, evolution steps, and common FAQs.
The article details how a Spring Boot‑based intelligent customer service evolves from a simple chat endpoint to a robust Function Calling architecture, addressing challenges such as real‑time data access, permission checks, idempotency, error handling, token management, and scaling to tens of millions of daily conversations.
This article walks through 14 real‑world failure scenarios of Spring Boot distributed caching, explains why high cache hit rates are misleading, and provides concrete analysis, code samples, and step‑by‑step recommendations for designing a resilient cache layer that isolates faults, handles hot keys, and ensures data consistency across Redis, local caches, and databases.
This article provides a step‑by‑step guide to testing Spring Boot 3.x auto‑configuration with JUnit 5 and ApplicationContextRunner, covering SpringFactoriesLoader loading, conditional annotation filtering, user‑defined bean overrides, exclusion mechanisms, and the new .imports file format, plus Maven and IDE run instructions.
Security researchers disclosed a remote code execution flaw in fastjson 1.2.66‑1.2.83 that bypasses autoType, exploits @JSONType with Spring Boot’s LaunchedURLClassLoader, and works on JDK 8, providing detailed payloads, proof‑of‑concept scripts, detection tools, and mitigation recommendations.
By replacing the naive List‑based deserialization with Jackson’s JsonParser streaming in Spring Boot 3.5.0, the article shows how processing ~300 k Student records can cut peak heap from 220 MB to 22 MB, avoiding OOM while filtering records on the fly.
This article explains the major breaking changes introduced in Jackson 3—including the JDK 17 baseline, package and groupId renames, immutable JsonMapper, unchecked exceptions, default configuration shifts, performance tweaks, and module consolidation—while providing step‑by‑step migration advice and a quick‑reference table for developers upgrading from Jackson 2.
This article analyzes why Spring Framework introduced the native @HttpExchange HTTP client to replace OpenFeign, comparing their architectures, dependencies, proxy mechanisms, performance benchmarks, and offering migration guidance for developers deciding between the two declarative HTTP solutions.
Spring Data AOT in Spring Boot 4 moves all repository parsing, reflection and query generation to compile time, dramatically cutting startup time, reducing memory and Metaspace usage, enabling compile‑time SQL validation, simplifying GraalVM native‑image configuration, and providing measurable performance gains backed by real‑world benchmarks.
This article details a production-grade logging system for Spring Boot microservices covering structured JSON output, MDC-based TraceId propagation across async threads and RPC calls, dynamic log level updates via Actuator or config centers, sensitive data masking, and disk protection strategies with async appenders and containerized log collection.
This article shows how the open‑source Passay library replaces hand‑written password regex with a unified, extensible rule set, covering dependency setup, rule definitions, custom messages, N‑of‑M character requirements, history checks, and password generation, all demonstrated with runnable Java code.
This article walks through eight Java file‑writing approaches—from the modern Files.writeString() API to low‑level FileChannel and asynchronous channels—detailing their parameters, performance characteristics, and ideal use cases such as large files, high‑throughput logging, and cross‑platform line handling.
The article explains why RabbitMQ provides at‑least‑once delivery, how duplicate consumption arises in publish‑subscribe scenarios, and presents a step‑by‑step design—including deduplication keys, a deduplication table, transactional writes, proper ACK ordering, and a checklist of common pitfalls—to ensure idempotent processing stays within acceptable business tolerances.
This tutorial shows how to integrate gRPC with Spring Boot 4.0 using the grpc‑spring‑boot‑starter in just four concise steps, covering a side‑by‑side comparison with REST, Maven setup, protobuf contract definition, server implementation, and client invocation with streaming support.
This article demonstrates three ways to bind a custom Author object from a single comma‑separated string in Spring Boot 3.5.0 using a custom ConversionService, a PropertyEditor, and the @ConfigurationPropertiesBinding annotation, complete with code samples and resulting output.
This guide explains how to use JLink together with jdeps and a multi‑stage Docker build to create a minimal custom Java runtime, reducing Spring Boot Docker image size from over 200 MB to under 50 MB while improving startup speed and security.
This guide walks through enabling CRaC in a Spring Boot application, building a CRaC‑compatible Docker image, creating a checkpoint job in Kubernetes, restoring the snapshot at pod start, and comparing the startup speed with GraalVM native compilation.
This article explains how to simplify handling deeply nested JSON responses in Spring Boot by creating a custom @JsonPath annotation that leverages JsonPath expressions, allowing one‑line extraction, filtering, and modification of JSON data directly in controller method parameters.
The article demonstrates how Spring Boot can automatically convert strings to enums for query and path parameters, introduces a unified StringToEnumConverterFactory, configures Jackson for case‑insensitive enum deserialization in @RequestBody, and uses a JPA AttributeConverter to persist enums, removing repetitive manual conversion code.
This article details a production-ready cross-database synchronization architecture using CDC and Outbox pattern with Spring Boot, Debezium, and Kafka, covering schema design, connector configuration, transaction boundaries, ordering guarantees, idempotent consumption, dead-letter queues, and monitoring strategies.
This article introduces JSONata4Java, shows how to add the library to a Spring Boot 3.5.0 project, and demonstrates a wide range of JSONata expressions—including property access, predicates, functions, object construction, grouping, aggregation, and sorting—through concrete code examples and expected outputs.
Java developers often dread taking over an undocumented, multi‑module Spring Boot system, but by using Claude Code for read‑only analysis you can generate a module map, risk report, live documentation and a step‑by‑step migration plan before touching any code.
A production incident where core API latency spiked from 50ms to 30s+ due to connection leaks and exhausted MySQL max_connections is dissected, revealing how default HikariCP settings become time bombs under load and how to build a defense system with leak detection, parameter tuning, slow SQL interception, and kill mechanisms.
This article introduces Spring Boot 4.1.0’s @RedisListener annotation, showing how it simplifies Redis Pub/Sub integration by eliminating boilerplate, supporting multiple topics, custom converters, and validation, with step‑by‑step code examples and CLI demonstrations.
The article explains how @RequestBody binds JSON via HttpMessageConverter using Jackson, then details four frequent issues—empty bodies, extra or unknown fields, date‑format mismatches, and deep nesting causing circular serialization—and provides concrete code‑level solutions such as validation, global exception handling, Jackson configuration, and DTO usage.
The article explains why Java developers waste time on repetitive ad‑hoc reports, proposes using GPT as a natural‑language front‑end to call secure Spring Boot metric tools, and walks through a step‑by‑step implementation that includes tool definition, permission checks, audit logging, and safe prompt engineering.
The article explains why Spring AI Ollama requests time out after 10 seconds despite server‑side timeout settings, analyzes the independent OkHttp read timeout and other ineffective configurations, and provides a step‑by‑step solution that creates a custom OllamaApi bean with a longer OkHttp read timeout to permanently fix the issue.
This article walks through the ten most frequently asked Spring interview topics—including IoC/DI concepts, bean lifecycle, AOP mechanics, circular‑dependency resolution, @Transactional behavior, Spring Boot startup steps, auto‑configuration, @Autowired vs @Resource, bean scopes, and the differences between servlet filters and Spring interceptors—providing concrete code examples and key points that can earn interviewers' extra credit.
This article presents a production‑grade design for a social private‑messaging system that handles billions of messages with millisecond latency, detailing how MySQL serves as the message fact store, RabbitMQ provides low‑latency distribution, Redis manages online state and indexes, and Outbox plus idempotent consumption ensure reliability and ordering.
To support millions of persistent MQTT connections with sub‑millisecond latency, the article walks through a Spring Boot + Netty cloud‑native gateway design that separates connection, event, state and governance planes, details async authentication, back‑pressure handling, command state machines, and loss‑less Kubernetes roll‑outs.
Quarkus, Red Hat's cloud‑native Java framework, achieves dramatically faster startup (0.3‑1 s vs 2‑5 s) and roughly half the memory usage (150‑200 MB vs 300‑500 MB) by moving many optimizations to compile time, and offers a Spring‑like developer experience with extensions, reactive support, and hot‑reload tooling.
This article details a complete Spring Boot implementation of a smart vending cabinet that uses WeChat QR‑code scanning to open doors, reports purchased items, and automatically deducts payment via WeChat's no‑password delegated‑deduction API, covering configuration, database design, code examples, and error‑handling strategies.
SmartCall is an open‑source AI‑driven call‑center platform that combines large language models, Asterisk telephony, IVR orchestration, ASR/TTS, and a knowledge‑base agent to deliver scalable, emotion‑aware voice customer service across industries.
The article argues that the biggest shift in the AI field is not model improvements but GPT becoming an actual employee, urging Java developers to redesign Spring Boot projects from simple REST endpoints to AI‑friendly business capabilities using tools like Spring AI 2.0.
This article explains why a payment system is more than a simple SDK integration, presents a four‑layer architecture (access, state, event, governance), details state machines, idempotent callbacks, outbox pattern, reconciliation, high‑concurrency handling, observability, security, and provides Java code examples for integrating Alipay and WeChat across all channels.
This guide walks through integrating Spring AI 2.0 into a Spring Boot application, covering Maven dependency setup, model configuration, ChatClient usage for synchronous and streaming calls, Redis‑backed chat memory for multi‑turn conversations, and testing with Postman and a UI component.
This guide details implementing CQRS and Event Sourcing in Spring Boot, covering command/query separation, event bus choices (Outbox pattern, Kafka), projection idempotency, state snapshots for performance, Saga-based compensation for distributed transactions, and practical tuning tips for production workloads.
This article introduces a runnable microservices learning project built with three independent Spring Boot applications (gateway, order, stock) and middleware such as Nacos, MySQL, Redis, RocketMQ, and Seata, guiding readers through cloning the repository, starting the environment with Docker Compose, and verifying the end‑to‑end product‑order‑stock flow.
This article walks through five practical ways to implement gray (canary) releases in Spring Boot 3.5.0, covering gateway‑based weight and header routing, programmatic route configuration, a custom reactive load‑balancer, and application‑layer annotations with custom HandlerMapping, each illustrated with concrete code samples.
Java developers should move beyond using GPT for code generation and instead expose existing Spring Boot services as secure, auditable AI tools, covering permission checks, data desensitization, tool descriptions, system prompts, and comprehensive logging to safely integrate GPT into business workflows.
This article walks through building a fault‑tolerant Spring Boot 3.5.0 API using Resilience4j, covering circuit breaking, rate limiting, timeout handling, bulkhead isolation, and retry strategies, complete with configuration snippets, code examples, and execution‑order adjustments.
This tutorial walks through creating a Spring Boot application that integrates the Spring AI Alibaba framework with a local Ollama model to enable function calling, covering environment setup, Maven dependencies, configuration, core code, testing, best practices, and common troubleshooting steps.
This article walks through the principles of database connection pools, common causes of pool exhaustion such as leaks, mis‑configuration, slow SQL and DB limits, and provides a step‑by‑step methodology with monitoring, thread‑stack analysis, and concrete configuration and SQL optimizations to restore stability.
Bboss v7.5.6 adds full Easysearch 1.x/2.x compatibility, allowing existing Bboss Java projects to migrate by only changing the connection address, while the article details a five‑minute setup, three typical pitfalls (HTTPS, credentials, version), and criteria for when to adopt or skip Bboss.
The article demonstrates how to create a custom @BatchProcess annotation combined with AOP to aggregate high‑frequency requests into batches, persist metadata in Redis, and process them efficiently, thereby reducing connection, I/O, and CPU overhead in distributed, high‑concurrency Spring Boot 3.5.0 applications.
The article explains how Java developers can treat Codex as an engineering agent that executes complete, well‑scoped Spring Boot tasks—by defining project rules, isolating work in a Git worktree, crafting detailed prompts with acceptance criteria, and reviewing changes in stages—to save repetitive development effort.
This article explains why and how to separate a system into four DDD layers—User Interface, Application, Domain, and Infrastructure—illustrates the benefits of clear responsibilities, demonstrates dependency inversion and hexagonal architecture with concrete Spring Boot examples, and warns of common pitfalls.
The article explains why cross‑aggregate business logic belongs in domain services, how domain events capture immutable business facts, and demonstrates practical Spring Boot implementations—including in‑process publishing, message‑queue integration, and the Outbox pattern—while highlighting pitfalls and verification techniques.
The article uses the ambiguous term “product” across product, inventory, order, and promotion teams to illustrate how bounded contexts and a ubiquitous language prevent model confusion, guide code organization, and enable safe evolution of a Spring Boot system.
Spring AI 2.0 lets Java developers integrate large‑language‑model capabilities with minimal code by adding a starter, configuring model parameters, injecting a ChatClient bean, and optionally enabling Redis‑backed chat memory for multi‑turn conversations, all demonstrated with runnable examples and screenshots.
This article compares Spring AI 2.0 and Spring AI Alibaba, detailing their design philosophies, core architectures, recent upgrades, code examples, strengths, weaknesses, and ideal use‑cases, and explains how the two frameworks can be combined for enterprise AI solutions.
The article critically examines the recent Java ecosystem upgrades—Jakarta namespace changes, Spring Boot 3.0’s Java 17 requirement, GraalVM Native Image hype, and Virtual Threads—showing that the promised benefits are minimal while migration costs and compatibility risks are substantial, and it highlights Feat as a pragmatic alternative.
This article details replacing hardcoded business routing with LiteFlow in a Spring Boot production system, covering component design, EL-based flow orchestration, Nacos-powered hot rule updates, thread-pool tuning, exception isolation, observability, and rule versioning — with concrete code, config, and lessons learned.
The article shows how overusing ResponseEntity in Spring Boot controllers makes code noisy and mixes business logic with HTTP handling, and introduces four declarative alternatives—@ResponseStatus on methods or exceptions, direct object returns, global ProblemDetail via @ControllerAdvice, and a ResponseBodyAdvice wrapper—to produce cleaner, more testable APIs.
This tutorial walks through installing Ollama, configuring JDK 17, adding Spring AI dependencies, setting up application.yml, implementing a chat controller, creating launch scripts, testing the endpoints, and comparing local Ollama with Alibaba Cloud Bailei, highlighting cost‑free, private, offline AI chat in a Spring Boot project.
This article explains MQ consumption failure retry mechanisms in depth, using a courier analogy, detailing ACK modes, Spring Boot RabbitMQ and Kafka configurations, local vs MQ re‑delivery strategies, dead‑letter queue setup, retry interval policies, exception handling, monitoring tips, and common FAQs.