This article demonstrates how to implement unified global exception handling in a Spring Boot application by defining custom exceptions, creating a @RestControllerAdvice with specific @ExceptionHandler methods, and wiring sample controller endpoints to showcase both system and custom error responses.
This tutorial walks you through setting up a complete CI/CD pipeline on CentOS 7 using Docker, Jenkins, and Spring Boot, covering Docker installation, Jenkins container deployment, plugin and Maven configuration, job creation, Dockerfile setup, and automated project build and run.
This article explains why browsers enforce the Same‑Origin Policy, defines cross‑origin requests, lists the restrictions of non‑same‑origin access, and provides five practical ways—global filter, WebMvcConfigurer, @CrossOrigin annotation, manual header setting, and a custom filter—to enable CORS in Java Spring Boot applications, complete with code examples.
This article provides a comprehensive overview of Spring and Spring Boot's extension points, detailing each lifecycle hook, its purpose, typical use cases, and sample implementations, enabling developers to customize bean initialization, configuration, and shutdown processes with concrete code examples.
This article explains the concept of database read‑write splitting, discusses its limitations, and provides a step‑by‑step guide with Spring Boot code to configure master‑slave data sources, implement dynamic routing, context handling, custom annotations, and AOP for seamless switching.
This tutorial demonstrates how to set up a Spring Security FormLogin authentication flow, including creating a demo project, customizing the login page, configuring security rules, defining users and roles, and testing the login process with custom success and failure handlers.
This guide walks you through configuring the new Alipay transfer API in a Java Spring Boot project, covering certificate placement, property files, Maven dependencies, bean definitions, client configuration, utility methods, and the data models required for secure payments.
This article provides a detailed tutorial on Quartz, a powerful Java scheduling framework, covering its core concepts, basic usage with SimpleTrigger and CronTrigger, advanced features such as multiple triggers, bean injection, and persistence, and includes complete Spring Boot code examples.
This tutorial explains how to install Spring Boot CLI, demonstrates the project layout, creates a Hello World application using Groovy, shows how to use @Grab for dependencies, run tests, package the app into an executable JAR, and generate new projects with the init command.
This guide walks through configuring Spring Security with a custom AuthenticationProvider that authenticates users against a database, covering environment setup, core filter mechanics, custom UserDetails, UserDetailsService, PasswordEncoder implementations, and bean configuration with full code examples.
This comprehensive tutorial walks through the evolution of Sharding-JDBC into ShardingSphere, explains core concepts like sharding, data nodes, and algorithms, demonstrates MySQL master‑slave setup with Docker, and provides step‑by‑step code examples for implementing read‑write separation, horizontal and vertical sharding, and distributed primary keys.
This article explains why a Spring Boot application that runs fine in an IDE may throw NoSuchMethodError or NoSuchFieldError when packaged as an executable jar, and provides systematic steps—including JVM class‑loading flags, Maven enforcer rules, and class‑path inspection—to locate and resolve the root cause.
This article walks through building a QR‑code based login system using Spring Boot, detailing database design, role analysis, required APIs, step‑by‑step implementation, and full Java and JavaScript code for generating QR codes, handling WebSocket communication, and confirming user authentication.
This article explains the core @SpringBootApplication annotation, its composition of @EnableAutoConfiguration, @ComponentScan, and @SpringBootConfiguration, shows its source code, demonstrates custom composite annotations, and details how Spring Boot performs component scanning and automatic bean configuration.
This article explains why traditional application releases cause downtime, introduces maturity levels for nonstop deployment, compares release patterns, details essential technical components such as load balancers and service registries, and provides step‑by‑step graceful‑shutdown procedures using Spring Boot Actuator and Eureka.
This guide introduces MinIO, an open‑source, S3‑compatible object storage written in Go, outlines its key features and deployment via Docker, and demonstrates step‑by‑step integration with Spring Boot to upload files through the MinIO SDK, including configuration, controller code, and testing.
This article explains how to implement robust retry mechanisms in Java applications by comparing Spring‑Retry's declarative exception‑based approach with Guava‑Retry's flexible result‑oriented strategy, covering dependencies, configuration, policies, back‑off options, annotation usage, and practical code examples.
This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing datasource, managing context with ThreadLocal, and using custom annotations with AOP to switch between read and write databases at runtime.
This article introduces an open‑source Spring Boot starter that lets developers integrate, configure, monitor, and visualize thread pools without altering Spring Boot's core implementation, addressing common issues of unmanaged resources and difficult runtime adjustments.
This article demonstrates how to integrate Spring Boot with RabbitMQ using a direct exchange, configuring queues, producers, and two consumers, and explains manual acknowledgment mechanisms (ACK, NACK, Reject) to ensure reliable message processing and handling of consumer failures.
This article presents seven practical Spring Boot performance optimization methods—including asynchronous execution, increasing embedded Tomcat connection limits, component scanning, switching to Undertow, using BufferedWriter, DeferredResult, and AsyncHandlerInterceptor—each illustrated with code samples and explanations for improving Java backend applications.
This article explains a configurable multi‑strategy data‑masking solution for Spring Boot APIs, covering the design of a custom annotation, serializer, AnnotationIntrospector, ObjectMapper integration, and example usage on response objects.
This article provides a comprehensive guide on using the Quartz job‑scheduling library in Java, covering core concepts such as Job, Trigger, and Scheduler, showing Maven setup, sample job and trigger code, Spring Boot configuration, utility classes for creating and managing jobs, handling concurrency, misfire policies, and REST‑based job management.
This guide explains how Spring Security processes authentication and authorization failures, walks through the default exception flow, and demonstrates multiple ways to customize error handling—including custom failure handlers, access‑denied pages, and JSON responses—using Spring Boot 2.4.12.
This article introduces the open‑source MinIO object storage system, outlines its high‑performance and cloud‑native features, provides step‑by‑step Docker installation and UI configuration, and demonstrates how to integrate MinIO with Spring Boot for secure file uploads via SDKs.
This article provides a comprehensive guide on implementing role‑based access control (RBAC) with Spring Security, covering RBAC models, password encryption, in‑memory authentication, JWT integration, custom authentication filters for JSON login, and detailed configuration examples with full source code snippets.
This tutorial demonstrates how to configure Spring Security to selectively intercept requests, permit static resources, enforce role‑based access, and replace the default login page with a custom Thymeleaf view, complete with code examples and screenshots.
This guide explains why Logback is the preferred logging framework for Spring Boot, shows how to add the necessary dependencies, configure console and file appenders, customize log patterns, use rolling policies, apply filters, and optimize logging statements with placeholders, all illustrated with clean XML and Java code examples.
This article explains why a configuration center is essential for microservices, introduces Nacos as a centralized solution, and provides step‑by‑step instructions with code examples for integrating Nacos into Spring Boot, managing Data IDs, namespaces, groups, and dynamic configuration refresh.
This article explains why Logback is the preferred logging framework for Spring Boot, shows how to add the necessary dependencies, configure logback‑spring.xml with appenders, encoders, filters and rolling policies, and provides best practices for efficient log statements in Java code.
This step‑by‑step guide shows how to enable Alibaba Cloud Function Compute, create a service and Java 17 function, configure a custom domain, export and edit the generated Spring Boot project, and adjust the listening port, enabling rapid serverless deployment for beginners.
This guide explains how to obtain a client’s IP address behind proxies in Java, choose appropriate HTTP headers, and use the open‑source ip2region library to query offline databases for accurate, millisecond‑level IP geolocation, including code examples for Spring Boot integration.
This article introduces Spring WebFlux, explains the concept of reactive programming, compares it with Spring WebMVC, describes its concurrency model, and provides complete code examples for building a reactive Spring Boot application using Mono, Flux, functional routing, and WebClient.
This tutorial walks through configuring Spring Security 5.4 on Spring Boot 2.4, demonstrating how to set up in‑memory user credentials, handle CSRF tokens during GET and POST requests, and customize the security filter chain to enable or disable CSRF protection.
This guide walks through setting up Docker and Jenkins on CentOS, configuring a Spring Boot project, creating a Jenkins pipeline, and automating build, test, and deployment steps to achieve one‑click continuous integration and delivery.
This tutorial demonstrates how to use the MyBatis-Plus-Join (MPJ) library to perform left and right join queries in Spring Boot without writing XML SQL, covering dependency setup, entity and mapper modifications, query construction with MPJLambdaWrapper and MPJQueryWrapper, pagination support, and practical tips.
This tutorial walks through the complete process of configuring MySQL master‑slave replication, preparing Docker containers, configuring MyBatisPlus and ShardingSphereJDBC for read‑write splitting, building a Spring Boot project with the necessary dependencies, generating code, and testing the setup with sample controller endpoints.
This article explains how to structure Spring Boot controller requests, apply elegant parameter validation, wrap responses with a consistent ResultVo format, handle validation and business exceptions uniformly using @RestControllerAdvice, and selectively disable wrapping for specific endpoints, providing a complete backend development guide.
This guide walks beginners through the concepts, advantages, and practical steps of using Alibaba Cloud Function Compute to deploy popular web frameworks like Spring Boot and Express, create a custom Web IDE, and configure domains, while highlighting serverless architecture benefits and cost considerations.
When generating large IDs using Snowflake-like algorithms, Java's 64‑bit long values exceed JavaScript's safe integer range, causing display errors; the article explains how to resolve this by serializing Long values as strings in Spring Boot using Jackson's ToStringSerializer, both via configuration and annotations.
Learn how to enable JAX‑RS (Jersey) support in Spring Boot 2.4.12 by adding the starter dependency, defining custom endpoints, configuring ResourceConfig, and managing servlets, filters, and listeners, including advanced customizations of embedded servlet containers such as Tomcat, Jetty, and Undertow.
This article details how a hidden 100 ms latency in a Spring Boot channel service was identified and resolved by tracing request flow, using the Arthas Java diagnostic tool, and ultimately fixing a Tomcat‑embed bug caused by Swagger‑ui resources.
This article outlines the latest Spring Framework 5.3.20 release, highlighting new GraphQL MIME support, SAML logout policy tweaks, numerous bug fixes—including property precedence and logging issues—and a comprehensive list of updated third‑party dependencies.
This tutorial walks through integrating MyBatis-Plus into a Spring Boot project, covering dependency setup, configuration, entity annotations, CRUD service and mapper usage, pagination, logical deletion, enum handling, automatic field filling, and multi‑data‑source management, complete with code examples and testing.
This guide walks through integrating MyBatis-Plus with Spring Boot, covering environment setup, Maven dependencies, configuration of data sources, entity annotations, CRUD services, pagination, logical deletion, enum handling, automatic field filling, multi‑data‑source strategies, and testing with full code examples.
This article explains the concept of idempotency, why it is needed for HTTP interfaces, the impact on system design, and presents several practical backend solutions—including database unique keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples using Redis for token management.
This article demonstrates how to create a simple lottery application using Spring Boot, MyBatis‑Plus, and Redis, covering project setup, database schema, dependency configuration, Redis integration, event‑driven data initialization, lottery draw logic, stock management, and asynchronous record handling.
This article provides a comprehensive guide to building a JWT authentication service in Java, covering JWT fundamentals, Spring Boot configuration, entity and DAO definitions, service interfaces, token generation and parsing, RSA key handling, controller endpoints, testing procedures, and a comparison with traditional session-based authentication.
This article explains how Spring Boot's default /error mapping works, how to customize error responses with ErrorController, ErrorAttributes, @ControllerAdvice, custom HTML pages, ErrorViewResolver, ErrorPageRegistrar, and how to configure CORS globally or per controller.
This article provides a comprehensive guide to integrating the Quartz job‑scheduling library with Spring Boot, covering core concepts, Maven setup, job and trigger definitions, concurrency control, dynamic task creation via REST, and initialization strategies, all illustrated with complete Java code examples and diagrams.
This article provides a detailed tutorial on integrating MyBatis-Plus into a Spring Boot project, covering dependency setup, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, and multi‑datasource support, with complete code examples.
This article explains traditional HTTP session handling, the problems of session sharing in clustered environments, two common session‑sharing strategies, and introduces single sign‑on (SSO) concepts with a detailed CAS‑based implementation using Spring Boot, Redis, and Java filters.
This article walks through the complete process of creating and validating software license certificates using the open‑source TrueLicense engine, covering keytool key‑pair generation, Spring Boot integration, RESTful license issuance, and runtime verification with system‑info checks.
This guide details nine practical techniques for accessing files in a Java project's resources folder, covering classloader paths, URL decoding, getFile vs getPath, InputStream retrieval, ClassPathResource usage, absolute paths, and environment variable methods, with complete code examples for each approach.
This article explains how Spring Boot serves static resources from default locations, how to customize static path patterns and resource locations, handle Webjars, configure content negotiation with parameters and custom media types, and integrate template engines such as Thymeleaf, FreeMarker, and Mustache.
This article explains why unified authentication is essential for product suites, reviews traditional session mechanisms and their limitations in clustered environments, explores session‑sharing strategies, introduces CAS‑based SSO workflows, compares CAS with OAuth2, and provides a complete Spring Boot demo with code snippets and configuration details.
A comprehensive guide walks you through integrating MyBatis-Plus with Spring Boot, detailing dependency setup, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum mapping, automatic field filling, multi‑datasource handling, and testing, all illustrated with runnable code examples.
This article explains the concept of idempotency in computing and HTTP, why it is essential for APIs, the impact on system design, which RESTful methods are idempotent, and presents four practical implementation strategies—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples and testing procedures.
This tutorial explains how to configure MySQL master‑slave replication using Docker, set up read‑write splitting with ShardingSphereJDBC, integrate MyBatis‑Plus, and build a Spring Boot application that demonstrates write operations on the master and read operations on the slave.
This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and emails in MySQL and Java applications by combining SQL string functions with the MyBatis‑Mate Sensitive Jackson plugin, providing complete configuration, custom strategies, and runnable Spring Boot examples.
This article introduces asynchronous programming concepts in Java, explaining how multithreading, Future, FutureTask, CompletableFuture, and Spring's @Async annotation can transform synchronous workflows into high‑throughput, low‑latency solutions, with code examples and practical guidance for implementing each technique.
This article explains several server‑side techniques for real‑time web message push—including short and long polling, hidden‑iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides their principles, advantages, drawbacks, and complete Spring Boot/Java code examples for each approach.
Passing an HttpServletRequest into an asynchronous thread in Spring Boot can cause mysterious parameter loss and request‑recycling bugs, because Tomcat reuses request objects; the proper solution is to employ the servlet's startAsync and AsyncContext.complete methods for safe async processing.
This guide introduces the open‑source mica‑mqtt library built on t‑io, explains how to add the Spring Boot starter dependency, configure client options, implement connection listeners, customize settings, perform subscriptions and publishing, and also covers shared subscription modes, jfinal integration, and usage in plain Java projects.
This article explains how to create and configure Spring Boot scheduled tasks with @Scheduled, covering property‑based settings, cron expressions, fixed‑rate and fixed‑delay options, the required @EnableScheduling annotation, and how to switch from the default single‑thread executor to a multi‑threaded pool for concurrent execution.
This guide explains how Spring Boot 2.4.12 automatically configures Spring MVC components such as view resolvers, converters, and message handlers, and shows how to customize them via WebMvcConfigurer, WebMvcRegistrations, HttpMessageConverters, and @JsonComponent, including code examples for full control over the Web MVC setup.
This article demonstrates how to configure Spring Boot for multiple environments, retrieve custom parameters, package and run the application, modify startup settings via system variables or command‑line arguments, and explains the priority and detailed JVM options for optimizing a Spring Boot service.
This article explains the principles behind Spring Boot Starters, how auto‑configuration works via META‑INF/spring.factories, provides practical code examples, and lists the most common starters to help Java developers streamline dependency management and reduce configuration complexity.
This tutorial walks through setting up MySQL master‑slave replication using Docker, configuring ShardingSphereJDBC for read‑write splitting, and integrating it into a Spring Boot project with MyBatis‑Plus, covering environment preparation, core theory, detailed configuration, and testing procedures.
This article explains how to implement WeChat QR code login using OAuth2.0 in a Spring Boot backend, detailing the authorization flow, required configuration, code examples for obtaining access tokens, user authentication, Spring AOP login verification, and exception handling to securely integrate WeChat login into a Java application.
This article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, and inappropriate parameters—and demonstrates how a unified ResultBean, strict controller conventions, and AOP logging can dramatically improve code readability, maintainability, and error management in Spring Boot projects.
This article explains what Flyway is, its migration types and common commands, shows how to integrate Flyway with Spring Boot via Maven dependencies and YAML configuration, provides sample versioned and repeatable migration scripts, and demonstrates the migration process with log output.
This article provides a comprehensive step‑by‑step guide on building a permission management system with Spring Security, covering database design, entity classes, Maven configuration, security configuration, dynamic menu loading, front‑end rendering using Thymeleaf, and complete testing with sample code and screenshots.
This article details a step‑by‑step investigation of a Java Spring‑Boot service that suffered nightly response‑time alerts, revealing that misconfigured Logback file paths caused cross‑volume log rotation, thread blocking, and ultimately a production outage, and shows how gray‑deployment and environment fixes resolved the issue.
This article presents a comprehensive overview of a hand‑crafted RPC framework built with Spring Boot, Netty, and Zookeeper, covering its core concepts, architecture, custom message protocol, load‑balancing strategies, serialization choices, starter design, deployment steps, and testing procedures.
This article demonstrates how to create a Java annotation for access limiting, implement the corresponding Spring Boot interceptor that checks Redis counters, register the interceptor in the application, and apply the annotation to a controller method to enforce request rate limits.
This article explains the advantages of Caffeine Cache's W‑TinyLFU algorithm over traditional FIFO, LRU, and LFU policies, details its eviction and reference‑type strategies, and provides step‑by‑step guidance for integrating Caffeine into Spring Boot applications with code examples and configuration tips.
This article explains how to implement a unified response format and centralized exception handling in Spring Boot applications using @RestControllerAdvice, @ControllerAdvice, ResponseBodyAdvice, and custom response entities, providing code examples and best‑practice guidelines for robust backend APIs.
This tutorial explains what SSO and CAS are, outlines the required development environment, walks through downloading, building, and deploying the CAS Server, shows how to configure the server and client (including disabling HTTPS for testing), and demonstrates successful cross‑application authentication with code examples.
This article demonstrates how to create a configurable, multi‑strategy data‑masking solution in Spring Boot by defining custom annotations, serializers, and integrating them with Jackson's ObjectMapper to automatically mask sensitive fields in API responses.
This guide walks through obtaining a free SSL certificate, exporting it from the provider, and configuring a Spring Boot application to use the certificate, including detailed steps, screenshots, and the necessary server.yml configuration.
This article demonstrates how to implement a flexible data‑masking solution for sensitive fields in Spring Boot APIs by defining a custom annotation, creating a serializer, integrating it with Jackson via an AnnotationIntrospector, configuring the ObjectMapper, and applying the annotation to domain objects.
This article explains how to integrate the CAS (Central Authentication Service) single sign‑on solution into a Spring Boot backend by adding necessary dependencies, configuring a series of CAS filters, creating a custom MyAuthenticationFilter to handle AJAX requests, and demonstrating a Vue.js frontend that interacts with the authentication flow, complete with screenshots of the login, ticket validation, and logout processes.
This article explains Spring Boot's caching mechanism based on the JSR‑107 JCache specification, details core interfaces and implementations like Cache, AbstractValueAdaptingCache, and ConcurrentMapCache, demonstrates cache annotations such as @Cacheable, @CachePut and @CacheEvict, and shows how to replace the default in‑memory cache with Redis using Docker, StringRedisTemplate, and custom serialization.
This article explains how to create a flexible, annotation‑driven data‑masking solution for Spring Boot APIs by defining custom masking strategies, integrating a Jackson serializer, and configuring the ObjectMapper to automatically mask sensitive fields in response objects.
This article introduces an open‑source, Java‑backed and Vue‑fronted online exam platform, detailing its student and admin features, mini‑program support, technology stack, deployment options, usage steps, architecture diagram, screenshots, and source code download links.
This article explains the high‑performance Caffeine Cache library, its W‑TinyLFU eviction algorithm, various loading and eviction strategies, statistics collection, and how to integrate and configure it in Spring Boot using annotations and programmatic beans.
This article presents a complete food delivery system project built with Spring Boot and Vue.js, detailing its technology stack, modules, database setup, and step‑by‑step instructions for launching both the admin backend and mobile client, along with resource download links.
This guide explains how to create a music website using Vue 3 for the front‑end and Spring Boot with MyBatis for the back‑end, covering project features, technology stack, development environment, repository cloning, resource setup, configuration, and launch commands.
This article explains why a Spring Boot application can end up with two UserManager beans—one from @Configuration + @Bean and another from @Component—by analyzing bean definition overriding, the role of ConfigurationClassPostProcessor, and the impact of the allowBeanDefinitionOverriding setting across Spring versions.
This article explains multiple Spring Boot asynchronous execution techniques—such as @Async, CompletableFuture, WebAsyncTask, DeferredResult, and AsyncHandlerInterceptor—provides complete Java code examples, and discusses performance optimizations like increasing Tomcat connection limits, switching to Undertow, using ComponentScan, and buffered I/O.
This article introduces a music website built with Vue 3 on the client side and Spring Boot + MyBatis on the server side, detailing its features, technology stack, development environment, and step‑by‑step instructions for downloading, configuring, and running the full‑stack application.
This article explains Spring Boot’s auto‑configuration mechanism, focusing on how the spring‑boot‑autoconfigure module automatically sets up the embedded Tomcat server, detailing the relevant Maven dependencies, configuration classes, conditional annotations, and the lifecycle steps that create and start the Tomcat container.
This article walks through implementing symmetric request and response encryption for Spring Boot APIs—covering requirements, data models, controller examples, debugging serialization issues, and using ControllerAdvice with Jackson to ensure encrypted payloads remain compatible across Android, iOS, and H5 clients.
The article explains multiple methods for implementing asynchronous execution in Spring Boot, covering @Async annotation, Java 8 CompletableFuture, Callable, WebAsyncTask, DeferredResult, Tomcat connection tuning, container switching to Undertow, and async interception, all illustrated with complete code examples.
This article explains how to design and implement a stateless JWT‑based authentication center in Java, covering JWT fundamentals, token structure, RSA signing, Spring Boot microservice setup, JPA entity and DAO creation, service interfaces, REST endpoints, and a comparison with traditional session authentication.
This article explains how to structure Spring Boot controller methods to receive parameters, implement unified status codes, validation with @Validated, and automatic response wrapping using ResultVo and @RestControllerAdvice, while also providing custom exception handling and optional exclusion annotations for flexible API design.
This tutorial explains how to structure a Spring Boot controller layer, validate request parameters with @Validated, wrap responses in a standard ResultVo format, define unified status codes, and handle exceptions globally using @RestControllerAdvice and AOP, while also providing a way to skip wrapping for specific endpoints.
This article explains Spring Boot caching by introducing the JSR‑107 JCache specification, detailing core cache interfaces, showing the Spring Cache abstraction and its implementations, demonstrating cache annotations such as @Cacheable, @CachePut and @CacheEvict, and finally covering Redis setup and custom CacheManager usage.
This article explains how @InitBinder methods in Spring MVC can initialize WebDataBinder, register custom PropertyEditors, Converters, and Formatters, and demonstrates a complete example with code snippets, while also detailing the internal request‑handling flow that performs parameter binding and type conversion.
