This article explains how to replace Shiro with Spring Security, integrate JWT for stateless authentication, configure the filter chain, set up the necessary Maven dependencies, write the security configuration, custom authentication and verification filters, and manage user details in a Spring Boot backend.
This comprehensive guide walks you through Spring Security fundamentals, setting up a Spring Boot project, configuring authentication with JWT and Redis, implementing RBAC permission management, customizing error handling, enabling CORS, and addressing CSRF, providing complete code examples and detailed explanations for secure backend development.
This article explains how to structure Spring Boot controller layers by receiving request parameters, unifying status codes and response formats, applying @Validated for automatic input validation, using @RestControllerAdvice for centralized exception handling, and optionally disabling wrapping with a custom annotation, providing complete code examples for each step.
Spring Cloud 2022, built on Spring Framework 6.x and Spring Boot 3.x, requires Java 17 and introduces crucial bug fixes across modules like Gateway, Commons, and Kubernetes, along with new features such as a secure flag for service instances and optimized load‑balancing.
Spring Cloud 2022, built on Spring Framework 6.x and Spring Boot 3.x, introduces critical bug fixes—including memory leaks and Kotlin DSL issues—and requires Java 17, with updated dependency management and new features across Gateway, Commons, and Kubernetes modules.
This article walks through building a robust Spring Boot controller layer by standardizing parameter binding, status codes, response wrapping, validation, and exception handling using annotations, enums, ResultVo, ResponseBodyAdvice, and custom exception advice to deliver consistent API responses.
This article explains the fundamentals, characteristics, and use‑cases of distributed caching, compares Memcached and Redis, and provides a step‑by‑step Spring Boot implementation with code samples, testing guidance, and solutions to common cache pitfalls such as hot keys, penetration, and avalanche.
Spring Boot 3.0.2 is now available from repo.spring.io and Maven Central, bringing 66 bug fixes, numerous dependency upgrades, and no new features, providing developers with a more stable and up‑to‑date backend framework.
magic‑api is a Java‑based rapid API development framework that lets you create HTTP endpoints through a UI without writing Controllers, Services, DAOs, XML or VO files, supporting multiple databases, clustering, pagination, custom scripts, and Swagger documentation.
This guide walks you through deploying the Mall e‑commerce application on Rainbond, covering both quick deployment via the open‑source app store and a full manual setup of all required services, middleware, backend and frontend components, with configuration examples and troubleshooting tips.
The article explains Nacos’s open‑source service registry and discovery mechanisms, detailing client auto‑configuration, registration and health‑check workflows, server‑side instance handling, asynchronous copy‑on‑write processing, heartbeat cleanup, and cluster synchronization, while comparing its AP/CP capabilities to Zookeeper and Eureka.
This article introduces jCasbin as a lightweight alternative to Shiro for permission management in Spring Boot, explains Maven setup, configuration files, Enforcer initialization, policy model definition, and demonstrates how to enforce, add, and delete permissions dynamically using filters and REST endpoints.
This guide details a music website project featuring admin and user roles, outlines the Spring Boot and Vue 3 technology stack, provides environment setup, installation steps, configuration tweaks, and commands to launch both backend services and frontend interfaces.
This article details the requirements analysis, design approach, database schema, and step‑by‑step implementation of a follow/unfollow microservice using MySQL for persistence and Redis Sets for efficient set operations, including Maven dependencies, Spring Boot configuration, RedisTemplate setup, service, controller, and testing of common‑follow queries.
This article walks through the complete design and implementation of a friend‑follow microservice, covering requirement analysis, MySQL table schema, Redis set operations, Spring Boot dependencies, configuration, service and controller code, gateway routing, and end‑to‑end testing with concrete examples and performance insights.
This article introduces the Disruptor library, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategy, and provides a complete eight‑step Spring Boot example with code to create, publish, and consume high‑throughput messages in Java.
This article introduces RabbitMQ's core concepts, key features, and typical use cases, then provides step‑by‑step installation instructions for macOS, Windows, and CentOS, and demonstrates how to configure and use the delayed‑message plugin with Java Spring Boot code examples.
This article demonstrates how to build a robust large‑file upload and download solution in Spring Boot by using Baidu's WebUploader for client‑side chunking, handling resumable uploads on the server, and implementing HTTP range requests for efficient chunked downloads.
This guide demonstrates how to modify Spring Boot 2.4.12 logger levels at runtime using LoggingSystem, enabling per‑package or whole‑application log level changes without editing configuration files or restarting the service.
This article presents five common batch‑insert approaches for MyBatis and MyBatis‑Plus—including a for‑loop, manual batch commit, collection‑based batch, saveBatch, and InsertBatchSomeColumn—provides complete code examples, configuration steps, and measured execution times to help Java backend developers choose the most efficient method.
Diboot is a Spring Boot‑based low‑code platform that eliminates most SQL, accelerates CRUD development, offers powerful RBAC, supports multiple databases and front‑end Vue UI, and provides devtools for one‑click backend and frontend code generation.
This article explains how to use RabbitMQ's delayed message plugin, covering its features, installation on multiple platforms, configuration steps, and complete Java Spring Boot code examples for producing and consuming delayed messages in a backend system.
This guide explains how to integrate the Jersey RESTful framework with Spring Boot, covering its relationship to JAX‑RS, configuration steps, essential annotations, code examples, and advanced customizations such as ResourceConfig, filters, servlets, and application path settings.
This article introduces AJ-Report, an open‑source drag‑and‑drop visual design tool built with Spring Boot and Vue, walks through its technology stack, shows how to clone the repository, set up backend and frontend environments, and demonstrates creating dashboards with multiple data sources.
This guide introduces the open‑source AJ‑Report project, explains its Spring Boot and Vue technology stack, and provides step‑by‑step instructions for cloning the repository, configuring the backend and frontend environments, and creating interactive visual dashboards using drag‑and‑drop components.
Learn how Spring Boot automatically configures ThreadPoolTaskExecutor and ThreadPoolTaskScheduler, customize them via spring.task.execution and spring.task.scheduling properties, and use @EnableAsync, @Scheduled, and @Async annotations—including advanced options like cron expressions, time units, executor qualifiers, and exception handling—to efficiently manage asynchronous and scheduled tasks.
This article explains how to create a Spring Boot package that keeps dependencies external by configuring the spring-boot-maven-plugin and maven-assembly-plugin, using a ZIP layout and PropertiesLauncher, so the application can be started with a custom loader.path that points to a libs directory.
This tutorial walks you through setting up a complete Jenkins‑Docker‑SpringBoot CI/CD pipeline on CentOS 7, covering Docker and Jenkins installation, plugin configuration, Maven setup, job creation, automated building, Docker image creation, and final verification, all with practical command examples.
This article explains four techniques—including manual setting, TaskDecorator, InheritableThreadLocal, and TransmittableThreadLocal—to reliably transfer user context and other thread‑local data from parent to child threads in Spring Boot asynchronous execution, with complete code samples and best‑practice recommendations.
Learn how the RFC 6455 WebSocket protocol works with Spring Boot 2.4.13, covering the HTTP upgrade handshake, server response, custom HandlerMapping, annotation‑driven routing, and a reactive chat handler implementation with code examples and deployment tips.
This article demonstrates how to build a robust large‑file upload and download solution in Java by integrating Baidu's WebUploader on the front end with Spring Boot back‑end APIs that handle chunked uploads, breakpoint resume, file merging, and multi‑threaded range‑based downloads.
This article explains how Spring Boot 3 introduces a native declarative HTTP client via HttpServiceProxyFactory, showing required dependencies, supported annotations, interface definition, and complete code examples for building, configuring, and invoking remote HTTP services without third‑party libraries.
This article provides a detailed tutorial on using Spring Cloud Sleuth with Zipkin to monitor and troubleshoot distributed micro‑service calls, covering concepts, configuration, Maven dependencies, YAML settings, controller examples, RabbitMQ integration, logback adjustments, and alternative tracing solutions.
This article explains why common Redis‑based flash‑sale demos that rely on WATCH transactions, distributed locks, or Lua scripts are unreliable, and presents a simple, lock‑free solution using Redis list operations (LPUSH/RPOP) with Spring Boot's StringRedisTemplate, including full Java code and usage examples.
This article demonstrates how to create a dynamically configurable thread pool in a Spring Boot backend by leveraging Nacos as a configuration center, covering dependency setup, YAML configuration, Java implementation with @RefreshScope, runtime parameter updates, and a simple controller for testing.
The article explains how to merge multiple user queries into a single batch request using a queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby reducing database connections and improving resource utilization while handling high‑concurrency scenarios.
This article provides a comprehensive guide to implementing asynchronous processing in Spring Boot, covering annotation‑based @Async, CompletableFuture patterns, WebAsyncTask, DeferredResult, custom thread pools, Tomcat tuning, component scanning, and switching to Undertow, with complete code examples and configuration details.
This article provides a comprehensive guide on using Spring Batch within a Spring Boot application, covering CSV and database data sources, detailed configuration beans, custom readers, processors, writers, listeners, validation, and execution via a REST controller, along with practical troubleshooting tips.
This article walks through the design and implementation of a friend‑follow microservice using MySQL for persistence, Redis Sets for fast set operations, and Spring Boot, covering requirement analysis, data modeling, dependency setup, configuration, service logic, and testing with concrete code examples and performance insights.
This guide explains how to create a custom Oracle datasource plugin for Nacos 2.2 by adding Maven dependencies, importing the Oracle SQL script, configuring connection properties, and setting the datasource platform, enabling Nacos to use Oracle instead of the default MySQL or Derby.
This article explains the Decorator (Wrapper) pattern, shows how to apply it in a Spring Boot project with concrete surfing‑service examples, demonstrates single‑ and multi‑layer decorators, and provides complete Java code and controller snippets to illustrate dynamic behavior extension without modifying existing classes.
This article demonstrates how to package a Spring Boot application using Maven profiles and the Maven Assembly Plugin to create a zip release, and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the service on Linux.
This guide shows how to eliminate manual Controller code by automatically exposing CommandService and QueryService as web endpoints, integrating with Swagger for dynamic API documentation, and explains the underlying unified controller architecture and extension points.
This article explains why private controller methods in Spring Boot fail when AOP logging is enabled, revealing that CGLIB proxies cannot intercept private methods, which leads to null service injection, and provides code examples and a final conclusion.
Huolala's data team created a cloud‑based real‑device platform that centralizes phone resources, enables remote screen casting and control via adb, minicap, and minitouch, and uses Spring Boot and Netty‑WebSocket to deliver scalable, cost‑effective mobile testing across multiple scenarios.
This tutorial demonstrates how to add Micrometer to a Spring Boot project, configure JVM and custom metrics, expose them via Actuator, and then integrate Prometheus and Grafana to collect and visualize the monitoring data, providing a complete end‑to‑end observability solution.
This article explains why the Controller layer should stay thin, identifies common pitfalls such as tangled validation and inconsistent responses, and demonstrates how to introduce a unified result wrapper, global response advice, robust parameter validation, custom validators, and centralized exception handling to produce concise, maintainable backend code.
This article demonstrates how to use the Decorator (Wrapper) pattern in a Spring Boot application to extend existing services with additional responsibilities, showing both single‑layer and multi‑layer decorations through concrete code examples and controller endpoints.
This article explains why using the forceful kill -9 command can cause data loss, demonstrates how to gracefully stop Spring Boot services with kill -15, the Actuator shutdown endpoint, and custom Tomcat shutdown configurations, and shows how to run cleanup tasks such as data backup during shutdown.
This article provides a step‑by‑step guide on building a Single Sign‑On solution using OAuth2, JWT tokens, and Spring Security within a Spring Boot application, covering the underlying concepts, Maven dependencies, configuration files, server setup, client integration, and logout handling.
This tutorial walks through installing GraalVM, configuring Spring Native, building a native Spring Boot application using Buildpacks or the native‑image plugin, creating Docker containers, and comparing startup speed and memory usage against traditional Java execution, providing full pom.xml examples and official documentation links.
This guide walks through converting a functional Spring Boot jar into a Windows executable using exe4j, then bundling the exe with a local JRE into a single installer with Inno Setup, providing step‑by‑step instructions, required tools, configuration details, and a code snippet for the installer script.
This guide shows how to replace Shiro with jCasbin in a Spring Boot microservice, covering Maven dependencies, configuration files, Enforcer initialization, policy handling, and a custom filter for runtime permission checks, enabling dynamic role‑based access control without server restarts.
This guide walks through preparing a Spring Boot jar, converting it to a Windows executable with exe4j, bundling the executable and a local JRE using Inno Setup, and creating an installer that runs on machines without a pre‑installed JDK.
This article introduces TLog, a lightweight, near‑zero‑intrusion log tracing framework for microservices that automatically tags logs with traceId and other context, explains its core principles, integration steps, supported adapters for various frameworks, and best‑practice usage scenarios.
This article explains how to design and implement a friend/follow microservice using MySQL for persistence and Redis sets for efficient set operations, covering database schema, Spring Boot configuration, Redis template setup, service and controller logic, and testing of follow, unfollow, and mutual‑follow features.
This article explains why using the Linux kill -9 command to stop Java services can cause data loss, demonstrates the differences between forceful and graceful termination, and provides multiple Spring Boot shutdown solutions—including kill -15, actuator endpoints, custom Tomcat connectors, and @PreDestroy hooks—complete with code examples.
This article walks through a complete Spring Boot solution for encrypting and decrypting API requests and responses, covering requirement analysis, data models, custom ControllerAdvice implementations, serialization challenges, and practical code examples using AES and Jackson.
This article explains how to create a reusable Spring Boot starter that automatically encrypts outgoing responses and decrypts incoming requests using AES, provides a request‑wrapper to allow multiple reads of the input stream, and integrates Spring Validation to simplify parameter checking, all illustrated with complete Java code examples.
The article provides a step‑by‑step guide for integrating Elasticsearch into a Spring Boot project, including Maven dependency configuration, creating a RestHighLevelClient, performing index and document CRUD operations, bulk processing, and advanced search queries with highlighting.
This article explains why common Redis‑based flash‑sale demos using WATCH or distributed locks are unreliable, and presents a simple, atomic solution that leverages Spring Boot's StringRedisTemplate with Redis list operations (LPUSH/RPOP) to achieve high‑concurrency秒杀 without explicit locking.
This article introduces the Spring‑Retry and Guava‑Retry frameworks for Java, explains their dependencies, configuration, policies, and back‑off strategies, demonstrates both XML/annotation and programmatic usage with detailed code samples, and compares their flexibility and suitability for backend applications.
This article presents a detailed overview of five commonly used MyBatis and MyBatis-Plus batch insertion methods, including code examples, configuration steps, and performance measurements for inserting ten thousand records, helping developers choose the most efficient approach for large‑scale data insertion in Java backend projects.
This article explains how to design and implement a friend follow microservice by combining MySQL for persistent storage with Redis sets for efficient follow/unfollow operations and mutual follow queries, covering database schema, Maven dependencies, Spring Boot configuration, RedisTemplate setup, service and controller logic, and testing procedures.
Spring Boot 3.0 adds a Native Executables feature that lets Java code be compiled ahead‑of‑time into machine code, contrasting with the traditional JIT approach, and provides a Maven command to generate platform‑specific executables for faster startup and performance.
This article explains how the Linux kill -9 command can cause data inconsistency and service disruption, demonstrates why it should be avoided in production, and provides several graceful shutdown techniques for Spring Boot—including using kill -15, the built‑in shutdown hook, Actuator endpoints, and a custom Tomcat connector configuration—along with code examples and best‑practice recommendations.
The mica-auto Spring Boot starter tool leverages Java Annotation Processors to automatically generate essential configuration files such as spring.factories, AutoConfiguration.imports, aot.factories, and spring‑devtools.properties, supporting Spring Boot 2.7+ and 3.0, and simplifying native image builds with GraalVM.
The article explains how the Linux kill command, especially kill -9, can abruptly terminate processes causing data inconsistency, and demonstrates safer alternatives for stopping Spring Boot applications—including kill -15, the built‑in shutdown script, Actuator endpoints, custom Tomcat connector shutdown, and @PreDestroy backup hooks—providing complete code examples.
This tutorial demonstrates how to use the MyBatis-Plus-Join (MPJ) library to perform left and right join queries in a Spring Boot project without writing XML SQL, covering dependency setup, mapper modification, query construction with MPJLambdaWrapper and MPJQueryWrapper, and pagination support.
This article explains how Spring Boot 3's Http Interface feature enables declarative HTTP service calls by defining Java interfaces, covering dependency setup, interface definitions, token handling, WebClient configuration, controller integration, testing with Postman, and discusses its reliance on WebFlux.
This article provides a comprehensive step‑by‑step guide on integrating Spring Batch with Spring Boot, covering configuration, entity and mapper definitions, job, step, reader, processor, writer implementations, database setup, error handling, and execution via a REST controller, complete with code examples.
This article demonstrates how to create a custom Spring Boot starter that provides automatic request body decryption and response body encryption using Hutool‑crypto, HttpServletRequestWrapper, RequestBodyAdvice, ResponseBodyAdvice, and validation utilities, enabling secure data transmission with timestamp verification.
This article explains multiple ways to perform asynchronous processing in Spring Boot, including @Async annotation, CompletableFuture (supplyAsync, runAsync), WebAsyncTask, DeferredResult, custom AsyncHandlerInterceptor, and server‑side optimizations such as increasing Tomcat connections and switching to Undertow, with complete code examples.
This article explains how to implement a comprehensive unified exception handling mechanism in Spring Boot by using @ControllerAdvice, custom BaseException/BusinessException classes, enum‑based error codes, assertion utilities, and standardized response objects to simplify error management across controller and service layers.
This article presents and compares five practical batch‑insert methods for MyBatis and MyBatis‑Plus, covering preparation steps, code implementations, configuration details, and performance results, helping developers choose the most efficient approach for inserting large volumes of data in Java backend projects.
This tutorial shows how to combine Spring Boot and Netty‑SocketIO to build a simple real‑time push system with broadcast, group and single‑user messaging, providing Maven dependencies, configuration files, Java classes, a REST controller and two HTML client pages for demonstration.
This article provides a step‑by‑step guide for building a CAS server and client with Spring Boot, covering WAR deployment, configuration file adjustments, custom authentication redirect strategies, CORS setup, and troubleshooting ticket validation and cross‑origin issues.
This article introduces Groovy as a JVM scripting language, outlines its typical use cases, and provides a detailed, code‑rich tutorial on how to integrate Groovy scripts into a Spring Boot application, including dependency setup, script execution, bean access, and security considerations.
This article explains why back‑end parameter validation is essential, introduces the JSR‑303 Bean Validation specification and Hibernate Validator, demonstrates common constraint annotations, shows how to integrate validation in Spring Boot, create custom annotations, and resolve typical pitfalls.
This article explains how to replace Shiro with jCasbin in a Spring Boot application, covering Maven dependencies, configuration files, Enforcer initialization, policy definition, and practical usage through a servlet filter and REST endpoints for adding or removing permissions.
This article provides a step‑by‑step guide on integrating Elasticsearch into a Spring Boot project, covering Maven dependency configuration, creation of a RestHighLevelClient, basic index and document CRUD operations, bulk data handling, advanced search queries with highlighting, and key implementation notes.
This article walks developers through upgrading Spring Cloud Tencent to the 2022 release, covering JDK 17 installation, Maven dependency updates, handling package conflicts, migrating javax to jakarta imports, adapting auto‑configuration files, and provides practical tips for a smooth transition to Java 17, Spring 6, and Spring Boot 3.
This article introduces OKHttpUtil, a lightweight wrapper for OkHttp that simplifies HTTP GET, POST, file upload/download, and chainable requests in Java, provides Maven integration, Spring Boot configuration, and demonstrates how to encapsulate external APIs such as eBay with concise code examples.
This article explains what Spring Native is, how to set up the required environment, the two main ways to build a native Spring Boot image using either Buildpacks or the GraalVM native-image Maven plugin, and demonstrates container deployment and performance comparison with traditional JVM execution.
This article explains how Spring Boot launches an application by invoking SpringApplication.run(), initializing the SpringApplication instance, and executing the run method, detailing each internal step, configuration loading, listener handling, and context refresh with illustrative code examples.
This article explains how to securely encrypt sensitive Spring Boot configuration properties such as database passwords using the Jasypt library, covering dependency setup, YAML configuration, encryption/decryption testing, custom encryptors, property detectors, resolvers, filters, and Maven plugin usage, all with practical code examples.
This article provides a comprehensive step‑by‑step migration guide for upgrading Spring Boot applications to version 3.0, covering JDK updates, dependency assessment, configuration changes, Jakarta EE package renaming, key feature alterations, and practical code snippets.
Learn how to compress large JSON payloads in a Spring Boot advertising API using GZIP, implement a servlet filter and request wrapper to decompress on the server, and evaluate bandwidth, CPU trade‑offs, testing methods, and deployment steps to halve request size.
Spring Boot 3.0, the first major release since 2.0, introduces Java 17 baseline, GraalVM native image support, enhanced observability with Micrometer, and Jakarta EE 10 compatibility, while providing a detailed migration guide for upgrading from earlier Spring Boot versions.
The article explains why browsers enforce same‑origin policies, then presents three practical ways to solve cross‑origin issues in a Spring Boot backend—using the @CrossOrigin annotation, routing through Spring Cloud Gateway, and making server‑side requests with HttpClient—accompanied by configuration examples and full code snippets.
This tutorial provides a complete, step‑by‑step guide to automatically deploy a Spring Boot project on CentOS 7 by installing Docker and Jenkins, configuring Maven and required plugins, creating a Jenkins pipeline, building the Docker image, and running the container, while avoiding common pitfalls.
This article explains ElasticSearch’s role in modern applications, compares its clients, shows how to configure RestHighLevelClient in Spring Boot, and details the four Spring Data Elasticsearch Operations interfaces with code examples for building queries using CriteriaQuery, StringQuery, and NativeSearchQuery.
This tutorial demonstrates how to integrate the Decorator design pattern into a Spring Boot application, showing a basic interface, concrete services, a simple decorator, and a multi‑layer decorator with full code examples and runtime output.
This article provides a thorough tutorial on using Spring Validation for request parameter checking, covering simple usage, dependency setup, requestBody and requestParam validation, group and nested validation, collection handling, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation in Spring MVC and Hibernate Validator.
This article explains the concept of distributed transactions, presents typical microservice scenarios that generate them, and demonstrates a complete implementation using RocketMQ transactional messages and SEATA, including database schema, producer and consumer code, transaction listeners, and idempotent consumption handling.
This article explains how to design an open API authentication mechanism by creating app credentials, storing them in a MySQL table, generating short‑lived access tokens with a utility class, exposing a token endpoint, and securing all /openApi/* routes with a Spring interceptor, complete with code examples.
This article explains why browsers enforce same‑origin policies, presents common CORS solutions such as the @CrossOrigin annotation, gateway integration with Spring Cloud Gateway, and using HttpClient, and provides detailed configuration and code examples for implementing these approaches in a Java backend project.
This article provides a comprehensive tutorial on implementing Single Sign-On using the Central Authentication Service (CAS), covering its concepts, features, architecture, environment setup, server and client configuration, and testing procedures with detailed code examples for Java developers.
This article presents a comprehensive Spring Boot tutorial on implementing non‑intrusive login authentication using three techniques—Filter, Interceptor, and AOP with custom annotations—plus extensions such as ThreadLocal storage and a Spring MVC argument resolver, complete with project setup, Maven dependencies, and test screenshots.
This article presents a comprehensive guide on designing a unified JSON response structure, implementing global exception handling with @ControllerAdvice, and configuring Logback for console and file logging in Spring Boot applications, complete with code examples and best‑practice recommendations.
