This article explains how to prevent duplicate order submissions in e‑commerce systems by using a token mechanism and Redis‑based distributed locks within a Spring Boot backend, detailing the workflow, code implementation, and best‑practice optimizations for idempotent processing.
This tutorial demonstrates how to programmatically customize JSON serialization and deserialization in Spring Boot by implementing JsonSerializer, JsonDeserializer, JsonObjectSerializer, and JsonObjectDeserializer, complete with code examples, test endpoints, and important usage notes.
This guide walks through installing the kkfileviewer Docker container, building its image, running it, and then shows how to add MinIO support to a Spring Boot application with Maven dependencies, configuration, utility classes, and REST endpoints for file upload and preview.
This article walks through the design and implementation of symmetric AES encryption for both GET and POST API endpoints in a Spring Boot application, covering requirement analysis, data model definition, custom RequestBodyAdvice and ResponseBodyAdvice, serialization challenges with FastJSON vs Jackson, and final configuration to ensure consistent JSON output across encrypted and non‑encrypted responses.
This article demonstrates how to use Spring Boot 3 Actuator together with Prometheus and Grafana to monitor JVM, Tomcat, database, Redis, and remote HTTP calls, providing real‑time metrics that help detect bottlenecks, optimize resources, and ensure stable performance under high load.
This guide presents eleven practical recommendations—including avoiding large keys, disabling costly commands, using UNLINK, enabling lazy free, batching operations, and configuring connection pools—to help developers maintain Redis performance and prevent latency spikes in production environments.
This article explains the Spring container's refresh process, details every extensible hook in a bean's lifecycle—from ApplicationContextInitializer to DisposableBean—provides usage scenarios, and includes complete Java code snippets illustrating how to implement each extension point for custom middleware and application development.
This tutorial explains how Spring's DataBinder binds request parameters to objects, demonstrates practical code examples for successful and erroneous bindings, shows how to add custom validation, set required fields, and customize error codes for clearer user feedback.
This article details the design, architecture, and step‑by‑step implementation of a Spring Boot log auditing plugin built with AOP, Maven plugins, auto‑configuration, thread‑pool execution, and optional message‑queue streaming to improve operation logging and exception tracing in backend services.
This article provides a comprehensive overview of OAuth 2.0 concepts, grant types, and step‑by‑step instructions for building an authorization server and a resource server using Spring Boot, including configuration classes, token services, security settings, and testing procedures.
This article evaluates the startup speed, memory consumption, and request‑handling throughput of a Spring Boot application built as a GraalVM native binary, a regular JAR, and equivalent services written in Go and Rust, highlighting the trade‑offs of AOT compilation for backend development.
This article explains Java and Spring Boot plugin mechanisms, covering benefits, common implementation strategies such as ServiceLoader, custom configuration files, and Spring Factories, and provides practical code examples and a real‑world case study to illustrate extensible architecture design.
Spring Boot 3.4.0 introduces stronger type‑safe configuration, unified multi‑source support (YAML, properties, environment variables, command‑line), and improved IDE assistance, providing developers with clearer, safer, and more flexible ways to manage application settings compared with version 3.3.
This article details the creation of a Japanese language analysis tool using Java, Kotlin, Spring Boot, and Gradle, explaining the multi‑module project structure, parent and child Gradle configurations, integration of Swing UI with an embedded Chromium engine, and practical tips for mixing Java and Kotlin code.
This article explains how to manage environment‑specific configuration in Spring Boot 3 using profile‑based YAML files, the spring.profiles.active property, the newer spring.config.activate.on‑profile feature, multi‑document files, and conditional activation for cloud platforms such as Kubernetes.
This article provides a comprehensive analysis of Spring Boot 2.7.10's embedded Tomcat 9.0.73 default settings, core parameters, internal thread architecture, configuration examples, performance testing with various concurrent connections, and includes detailed code snippets and diagrams, while also containing promotional material for AI services.
This article explains how Spring Boot's built‑in logging filter, request and response caching wrappers, the OncePerRequestFilter base class, and AOP helper classes such as AopContext, AopUtils, and ReflectionUtils can be configured and used to record, modify, and monitor HTTP traffic and simplify proxy‑based programming.
To avoid performance degradation caused by simultaneous large‑scale data exports, this guide demonstrates building a fixed‑size FIFO export queue in Spring Boot, integrating EasyExcel for million‑row exports, handling asynchronous processing, and providing sample code for the queue, export service, and controller.
This article explains the purpose and inner workings of Spring Boot's @RefreshScope annotation, showing how it creates proxy and target beans, the proxy generation process, and how the /actuator/refresh endpoint triggers a full refresh of scoped beans at runtime.
This tutorial walks through creating a simulated SMS verification system using Spring Boot, Redis, and scheduled tasks, covering requirements, dependency setup, controller and service implementation, rate limiting, code expiration, validation logic, and daily reset of usage counters.
This article compares Server‑Sent Events, traditional polling, and WebSocket for server‑to‑client real‑time messaging, explains why WebSocket may be overkill for one‑way push scenarios, and provides a Spring Boot example of an SSE endpoint with code and configuration details.
This article explains why a Spring Boot controller can read the request body only once, demonstrates wrapping multiple objects in a DTO, and provides a custom HttpServletRequestWrapper with a filter to enable multiple @RequestBody parameters while noting the performance impact.
This article examines the pitfalls of using Redis key‑expiration notifications for delayed business actions, presents a Docker‑based benchmark, provides Spring‑Boot code for scheduling and listening to expirations, and analyzes how notification latency grows as the number of keys increases.
This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.
The article demonstrates how to implement a bounded FIFO export queue in a Spring Boot application, using synchronized wait/notify methods to limit concurrent large‑data exports to ten threads, integrating with an abstract EasyExcel exporter and a controller that spawns export tasks, while noting future enhancements such as persistent storage and Redis‑based queues.
Java 21's virtual threads provide lightweight, high‑concurrency execution managed by the JVM, and this article explains their fundamentals, demonstrates basic creation, shows how to enable them in Spring Boot, and presents performance benchmarks comparing virtual threads to traditional threads.
This article walks through the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, and provides a complete Spring Boot integration tutorial—including Maven setup, BPMN modeling, service task implementation, diagram generation, unit testing and common troubleshooting—using a concrete leave‑request example.
This article explains three hot‑deployment methods for Spring Boot—IDEA's configuration options, the spring‑boot‑devtools library, and the JRebel plugin—detailing how to set them up, their underlying mechanisms, and best‑practice recommendations to avoid costly full restarts during development.
This article explains the Chain of Responsibility design pattern, outlines typical use cases, and demonstrates three concrete ways to implement it in Spring Boot with full Java code examples, unit tests, and execution results, helping developers build clean, extensible backend workflows.
This article walks through replacing MyBatis with MyBatis-Plus in a Spring Boot project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, and shows how upgrading the connector resolves the issue while highlighting the risks of component upgrades.
This article introduces Java 21 virtual threads, explains their lightweight and automatically managed nature, demonstrates basic creation and Spring Boot configuration, and presents performance experiments comparing traditional and virtual threads in both CPU‑bound and HTTP request scenarios.
The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.
This article introduces OAuth 2.0 concepts, roles, and grant types, then provides a step‑by‑step Spring Boot implementation for an authorization server and a resource server, including configuration classes, Maven dependencies, test endpoints, and screenshots of the authentication and token‑validation process.
Spring Boot leverages Hibernate Validator to replace repetitive manual checks with declarative annotations on DTO fields, automatically enforcing constraints via @Valid, while a global exception handler formats failures into clear JSON, and advanced features such as validation groups and custom annotations further enhance maintainability and user‑friendly error reporting.
This article explains why ChatGPT adopts Server-Sent Events for streaming responses, compares SSE with WebSocket, outlines SSE's core principles and best‑practice considerations, and provides a complete Spring Boot example—including server‑side Java code and client‑side HTML—to demonstrate real‑time data push.
This tutorial provides a step‑by‑step guide to set up a fully automated CI/CD pipeline on CentOS 7 that installs Docker, deploys Jenkins in a container, configures Maven and required plugins, creates a Jenkins job, builds a Spring Boot application with Dockerfile, and runs the resulting container, all with minimal pitfalls.
This article walks through initializing a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common scaffolding code such as global exception handling, logging, CORS configuration, and recommends useful tools like Maven, embedded Redis, MyBatis‑Plus, and MapStruct for backend development.
This article presents a comprehensive collection of over 50 Spring Boot 3 practical examples, covering core topics such as the Lifecycle and SmartLifecycle interfaces, custom FactoryBean implementations, graceful shutdown in non‑web environments, resource injection, parameter validation, and type conversion techniques.
Spring Boot 3.4 adds automatic multi‑client RestClient configuration, Bean‑Validation‑based property checks, default graceful shutdown, ECS/GELF/Logstash structured logging, enhanced observability with application grouping and OTLP tracing, upgraded core and third‑party dependencies, AssertJ‑enabled MockMvc testing, and replaces old management endpoint settings with access‑based properties.
This comprehensive guide explores Spring Boot 3.4’s performance boosts, enhanced observability, and developer experience improvements, detailing major changes such as RestClient/RestTemplate auto‑configuration, bean validation updates, graceful shutdown, structured logging formats, observability enhancements, dependency upgrades, testing enhancements, and deprecated feature handling, with practical code snippets.
This article presents a collection of over 50 practical Spring Boot 3 examples, demonstrating how to directly write responses with OutputStream, read request bodies via InputStream, use @Value and SpEL for fixed parameters, combine body and headers with HttpEntity, access security data through @CurrentSecurityContext, and handle Map parameters with @ModelAttribute.
This article provides a comprehensive guide on dynamically loading JAR packages in Spring Boot, covering core concepts, benefits, and step‑by‑step implementations using SpringBootClassLoader and third‑party OSGi libraries, complete with practical code examples.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts object storage services (OSS) via the Amazon S3 protocol, covering dependency selection, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing for cloud‑native backend applications.
This article explains how to design a QR‑code login flow, create the necessary database table, define the required APIs, and integrate front‑end JavaScript with a Spring Boot back‑end using WebSocket to notify the client of successful authentication.
This article introduces the basic concepts of supervised and unsupervised machine learning, explains the core mechanisms of large language models such as Transformers, and provides a step‑by‑step guide with code to build a simple chatbot using Alibaba's Tongyi LLM via Spring Boot.
This article explains why manual if‑statement checks are problematic, introduces Spring Boot's built‑in validation using Hibernate Validator annotations, shows how to handle errors globally, and covers advanced techniques such as group validation and custom constraint annotations for clean, maintainable backend code.
This article explains how to protect front‑end and back‑end communication in a Spring Boot application by encrypting request and response data using a hybrid AES and RSA scheme, custom request wrappers, filters, and AOP‑based response encryption, complete with code examples and implementation details.
Spring Boot 3.4.0 introduces stronger type‑safe configuration, unified multi‑source support, and improved IDE assistance, enabling developers to manage application settings more safely and efficiently compared with version 3.3, with practical examples for microservice scenarios.
This article explains the fundamentals and implementation of a Nacos service registry in a Spring Cloud microservice architecture, covering registration concepts, building a standalone Nacos server, creating provider and consumer services, and deep-diving into the underlying registration code and HTTP interactions.
This article introduces the JTE template engine for Spring Boot 3, compares its performance with other engines, provides step‑by‑step code examples for defining models, writing templates, rendering them, and integrating JTE into a Spring Boot project, along with configuration tips and advanced features such as loops, conditionals, and template inclusion.
This article explains the concept of plugin-based development, outlines its benefits such as module decoupling and extensibility, and provides detailed Java implementations using ServiceLoader, custom configuration files, dynamic JAR loading, and Spring Boot's spring.factories mechanism with complete code examples.
Upgrading to Spring Boot 3.3.5 can cause Hibernate to generate table columns in a different order than the fields in your @Entity class, but by copying and adjusting the PropertyContainer class you can restore the original field order and avoid schema inconsistencies.
This tutorial shows how to set up MinIO and the open‑source kkFileView tool using Docker, configure a storage bucket, and generate preview URLs so that any file type—images, Word, PDF, PPT, markdown, Excel, or archives—can be viewed directly in a web browser without writing additional code.
This article explains how to implement One-Time Token (OTT) authentication in Spring Boot 3.4 using Spring Security, covering environment setup, required dependencies, security configuration, token generation handlers, custom storage options, custom login pages, and testing procedures with complete code examples.
The article examines common pain points of oversized Spring controllers, contrasts a verbose implementation with a concise version that leverages @Valid and assertion utilities, and provides step‑by‑step guidance on validation annotations, global exception handling, and best‑practice refactoring to improve readability and maintainability.
This article introduces UniHttp, a declarative HTTP client framework that simplifies third‑party API integration in Java backend applications by replacing manual HttpClient/OkHttp code with annotated interfaces, provides quick‑start instructions, detailed annotation usage, lifecycle hooks, custom channel integration examples, and configuration tips.
This article explains four techniques—manual setting, TaskDecorator, InheritableThreadLocal, and TransmittableThreadLocal—for propagating context such as user information from a parent thread to child threads in Spring Boot asynchronous execution, providing code examples and recommendations.
Spring Boot 3.4 introduces performance boosts, enhanced observability, and developer experience improvements, and this guide walks you through the most critical changes—including RestClient auto‑configuration, bean validation updates, graceful shutdown, structured logging formats, dependency upgrades, testing enhancements, and deprecated feature handling—complete with configuration snippets and code examples.
This article summarizes the major Spring Boot 3.4 enhancements, including RestClient auto‑configuration, refined Bean Validation for @ConfigurationProperties, default graceful shutdown, revamped Actuator endpoint access control, structured logging formats, @Fallback beans, a new ClientHttpRequestFactoryBuilder, additional logging properties, virtual‑thread support, and a host of miscellaneous improvements.
This guide explains why logging is essential for Java applications, compares popular logging frameworks such as Logback, Log4j2, and SLF4J, shows how to integrate them with Spring Boot, and provides concrete best‑practice recommendations for levels, formatting, async handling, rotation, and security.
This article explains how to integrate Spring Boot with the open‑source XXL‑Job distributed task scheduler, covering XXL‑Job fundamentals, configuration of the admin console and executor, Maven dependencies, property settings, code examples, @XxlJob annotation parameters, best practices, and includes additional promotional material.
This article demonstrates how to implement a login attempt limiting mechanism using Spring Boot, Redis, and Lua scripts, explaining the problem of repeated password failures, the design of IP-based rate limiting, and providing complete front‑end and back‑end code examples with configuration details.
This article explains how to ensure secure data transmission between front‑end and back‑end in a Spring Boot application by employing hybrid AES/RSA encryption, custom request wrappers, filters for decryption, and AOP for response encryption, complete with utility classes and testing examples.
This article introduces MyBatis-Plus, an enhancement library for MyBatis, outlines its major advantages, explains performance‑analysis and advanced plugins, and provides a step‑by‑step tutorial with code examples for integrating, configuring, and using the framework in Java Spring Boot projects.
This tutorial demonstrates how to record and display website visitor statistics by using a Spring Boot backend with an IP‑based visitor identifier, a custom @VisitLog annotation, a MySQL visit‑log table, and a Vue front‑end component that shows PV and UV counts.
This article demonstrates how to achieve real‑time synchronization of MySQL data to Redis using Spring Boot 3, the open‑source mysql‑binlog‑connector‑java library, and optional JMX exposure, providing step‑by‑step setup, code examples for parsing binlog events, listening to changes, and configuring Maven dependencies.
This article explains how to solve interleaved logs in multi‑threaded pods by adding a unique X‑App‑Trace‑Id header, propagating it through a TraceIdFilter, storing it in SLF4J MDC, adapting Feign and thread pools, and integrating SkyWalking to enrich log patterns with trace identifiers.
This tutorial shows how to configure Spring Boot 3 to start multiple Tomcat servers, isolate services into separate modules with shared parent configuration, and test the endpoints, providing full code snippets and screenshots for each step.
This article walks through step‑by‑step how to create a simple CRUD service using Go's Gin framework with Gorm and MySQL, then shows the equivalent implementation with Java Spring Boot, MyBatis‑Plus and MySQL, comparing the two approaches and providing complete source code.
This tutorial demonstrates how to install Portainer, use it to deploy a Redis‑Sentinel cluster with master‑slave replication and custom bridge networking, test failover, and then integrate the Sentinel setup into a Spring Boot application with Lettuce connection pooling.
This article explains how to securely upload files to MinIO, generate token‑protected download links, and create kkfile preview URLs using Spring Boot, while avoiding exposure of the MinIO address and adding token authentication for enhanced security.
Learn how to use the lightweight Jpom automation tool to set up Docker‑based CI/CD pipelines, configure repositories, build and package a Spring Boot 3 + Vue e‑commerce project, and deploy both backend and frontend services seamlessly on a Kubernetes‑ready environment.
Explore comprehensive Spring Boot 3 Actuator capabilities—including enabling CORS, creating custom endpoints, configuring health indicators, HTTP tracing, security auditing, and process monitoring—through detailed explanations, YAML configurations, and full Java code examples, empowering developers to effectively monitor and manage production-ready applications.
This article explains how to package a Spring Boot application using Maven profiles and the assembly plugin, generate a zip deployment bundle, and deploy it on Linux with a custom shell script that supports start, stop, restart, and unzip operations.
This guide explains how to design and build a privacy‑focused, view‑once image sharing system using Spring Boot, MySQL, Thymeleaf, and optional cloud storage, covering requirements analysis, architecture, environment setup, code implementation, security considerations, performance optimizations, testing, and deployment.
This article walks through Spring Boot 3.2.5 enhancements including multithreaded bean initialization, the new @Fallback annotation, handling duplicate bean names, RestClient.create(URI) usage, header binding to records, expanded task‑scheduler metadata, and a host of other backend improvements.
This article demonstrates how to integrate Spring Boot with Minio, covering two upload strategies (backend‑mediated and presigned‑URL direct upload), environment setup, Maven dependency, configuration classes, generating upload credentials, front‑end upload logic, chunked/instant/resumable uploads, and merging file parts.
This article introduces the evolution of Java‑based workflow engines, compares Activiti, Flowable and Camunda, explains core BPMN concepts, and provides a detailed Spring Boot integration tutorial—including Maven dependencies, BPMN diagram creation, service task implementation, REST endpoint for diagram viewing, unit tests, and common troubleshooting tips.
This article explains how the @Order annotation and Ordered interfaces control bean, listener, runner, and aspect execution order in Spring Boot 3, providing step‑by‑step code examples, output demonstrations, and guidance on applying ordering to various Spring components.
This guide walks through building a Spring Boot and MySQL‑backed “burn after viewing” image sharing service, covering architecture, environment setup, entity and repository design, upload and automatic deletion logic, Thymeleaf UI with burn animation, error handling, optimization, and Docker deployment.
This article shares Hikvision software engineer salary data, interview experiences, detailed explanations of Spring Boot startup, Spring MVC request flow, MySQL index types and optimization, as well as Redis performance characteristics, multithreading support, and distributed lock usage.
This article presents a comprehensive guide to building a Spring Boot backend system by outlining essential design principles, detailing a multi‑module architecture with clear responsibilities, and providing complete Maven POM configurations for each module to enable scalable and maintainable development.
The article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that streamlines Spring Boot backend API testing by providing in‑IDE request execution, method timing statistics, interceptor bypass, job triggering, Java pre/post scripts, response preview, and export to third‑party tools, complete with usage examples and code snippets.
This article introduces the core concepts and roles of OAuth 2.0, explains its four grant types, and provides a step‑by‑step Spring Boot implementation with complete configuration classes, dependency setup, and testing procedures for both authorization and resource servers.
This article explains how to use the Flowable BPMN engine in a Spring Boot project, covering workflow basics, related BPMN concepts, Maven dependencies, diagram creation, service‑task implementation, REST API for diagram viewing, unit testing, and common pitfalls such as font configuration and process definition updates.
This article explains how Spring Boot supports asynchronous request handling after Servlet 3.0, demonstrates three practical approaches—Callable, WebAsyncTask, and DeferredResult—with code examples, shows how to configure a custom thread pool, and discusses when asynchronous processing improves throughput.
This article explains how to use Spring Boot 3's TaskScheduler API, @Scheduled annotations, cron expressions, macro shortcuts, reactive support, virtual threads, and custom scheduling configuration, providing code examples and configuration tips for reliable backend task execution.
This article benchmarks several popular JDK distributions on Kubernetes using a Spring Boot 3 application, measuring image size, startup time, memory consumption, and throughput with k6, and concludes that performance differences are minimal after repeated testing.
This tutorial walks through creating an intelligent airline‑ticket customer‑service agent using Spring AI Alibaba, covering requirements, architecture, RAG integration, function calling, chat memory, core capabilities, code implementation with ChatClient, and a sample running result.
This guide walks through building and running the kkfileviewer Docker container, then shows how to add MinIO to a Spring Boot application with configuration, a client bean, utility methods, and REST endpoints for uploading files and retrieving presigned preview URLs to display in the kkfileviewer UI.
This article explains how to externalize and dynamically adjust a Spring Boot thread pool's core and maximum sizes using Nacos as a configuration center, allowing runtime changes without service restarts and demonstrating the setup, code, and testing procedures.
This tutorial explains Java Agent technology, shows how to implement a custom agent using the Instrumentation API and Javassist, integrates it with a Spring Boot 3 application to log API execution time, and provides step‑by‑step packaging and execution instructions.
This tutorial explains how to use Netty to create a Java backend server with WebSocket support, covering server initialization, channel configuration, pipeline setup, custom handlers, and message‑push services, and includes complete code examples for each component.
This article introduces a Spring Boot code‑generation tool that automatically creates database tables, entity classes, DAO interfaces, service layers and controllers, turning weeks of manual CRUD development for dozens of tables into a matter of minutes, and explains its design, templates, dynamic parameters and usage.
This article explains why consistent date formatting is crucial in Spring Boot APIs, outlines common scenarios such as front‑end data exchange, database storage and logging, and presents multiple server‑side and client‑side solutions—including SimpleDateFormat, DateTimeFormatter, global Jackson settings, annotations, custom converters, and timestamp output—complete with code examples.
This tutorial explains how to replace the basic @Scheduled annotation with the flexible XXL‑Job distributed scheduler, covering repository download, admin deployment, database initialization, Spring‑Boot executor configuration, job registration for Douyin and Bilibili hot‑search crawling, and a Vue front‑end component for displaying ranked results with real‑time update timestamps.
This guide demonstrates how to integrate OpenFeign with Resilience4j in Spring Boot, covering dependency setup, Feign client definition, fallback implementation, circuit breaker configuration, custom timeout settings, and generating circuit names, enabling robust, fault‑tolerant microservice communication.
This article presents a step‑by‑step guide on building a Snapchat‑style “burn after reading” image sharing system using Spring Boot, MySQL, Thymeleaf, and optional cloud storage, covering background analysis, architecture design, environment setup, code implementation, optimization, testing, and deployment.
This article explains Apache Shiro’s fundamental components—Subject, SecurityManager, Realm, Session, authentication, authorization, and cryptography—then walks through a complete configuration example, a custom Realm, JWT integration, and a Spring Boot microservice scenario to illustrate secure, stateless authentication and fine‑grained permission control.
This article introduces a comprehensive set of Spring Boot utility classes—including assertion helpers, object and string utilities, collection operations, file and resource handling, reflection tools, and AOP utilities—providing code examples and usage guidelines for Java backend development.
