Tagged articles
Starter
53 articles · Page 1 of 1
This comprehensive guide walks through creating a production-ready Spring Boot 3.x starter, covering auto-configuration mechanics, conditional annotations, configuration properties, registration files, and a complete token-bucket rate-limiter implementation with AOP, plus debugging tips and common pitfalls.
AOPAuto-configurationConditional Assembly
0 likes · 53 min read

This article explains why adding a Spring Boot starter dependency instantly creates the required beans without XML or manual configuration, walks through the auto‑configuration mechanism—including @EnableAutoConfiguration, AutoConfigurationImportSelector, and conditional annotations—and shows step‑by‑step how to build a custom starter from scratch with Maven, configuration properties, an aspect, and registration files.
Auto-configurationConditional AnnotationsJava
0 likes · 21 min read

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.
AutoConfigurationConfigurationPropertiesMaven
0 likes · 23 min read

The article walks through creating a custom Spring Boot starter that bundles common utilities such as unified response wrapping, global exception handling, type converters, thread pools, login context, and data masking, showing the standard two‑module structure, Maven setup, configuration properties, conditional annotations, and usage in a business project.
Auto-configurationBest PracticesJava
0 likes · 15 min read

A comprehensive guide to building production-ready Spring Boot Starters covering auto-configuration registration via AutoConfiguration.imports, conditional annotations (@ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty), type-safe configuration binding with @ConfigurationProperties and validation, IDE metadata generation, lightweight health indicators, version alignment with Spring Boot, testing with ApplicationContextRunner, and dependency hygiene using optional/exclusions.
ApplicationContextRunnerAutoConfigurationConditional Assembly
0 likes · 16 min read

This article explains why using @Value for configuration leads to scattered, unvalidated settings and demonstrates how Spring Boot's @ConfigurationProperties provides batch binding, nested object support, built‑in validation, default values, and starter integration for clean, maintainable configuration management.
BackendConfigurationPropertiesJava
0 likes · 18 min read

This article introduces Guardian, a lightweight Spring Boot starter that provides anti‑duplicate‑submission protection and request rate limiting, explains how to integrate it via Maven, configure it with annotations or YAML, and details its internal workflow, storage options, concurrency handling, and monitoring capabilities.
JavaRedisSpring Boot
0 likes · 17 min read

This article introduces an open‑source MyBatis‑Plus dynamic‑table starter, explains why dynamic table names are needed for large‑scale data, outlines its key features, provides step‑by‑step installation and quick‑start instructions, demonstrates advanced usage, debugging tips, FAQs, and real‑world scenarios.
Dynamic TableJavaMyBatis Plus
0 likes · 9 min read

This guide walks through creating a reusable Spring Boot starter that abstracts object storage services (OSS) via the Amazon S3 API, covering project setup, Maven dependencies, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and a simple test case.
Amazon S3OSSStarter
0 likes · 15 min read

This step‑by‑step guide explains why Amazon S3 is chosen as a universal protocol, walks through creating a Spring Boot project, defining configuration properties, implementing an OSS template, auto‑configuring beans, packaging the starter, and testing it against services like MinIO, Alibaba OSS, and Tencent COS.
Amazon S3JavaOSS
0 likes · 15 min read

This article walks through creating a custom Spring Boot starter that uses conditional auto‑configuration to provide primary and secondary data sources, DAOs, and services, enabling high‑frequency Dubbo calls to be replaced with direct database access and dramatically improving performance.
Auto-configurationConditional BeansDubbo
0 likes · 13 min read


Java OneAug 23, 2025 · Backend Development
This guide explains how Spring Boot starters simplify dependency management, how the Spring Boot starter parent centralizes version control, and how to use the built‑in Maven plugin and DevTools for automatic restarts, including step‑by‑step Maven and IntelliJ configurations with code examples.
DevToolsJavaMaven
0 likes · 7 min read

This article explains how to create a Spring Boot starter that lets you toggle between the native @Scheduled scheduler and XXL‑JOB at runtime via a configuration property, automatically scanning annotated methods, disabling Spring's tasks, and registering them as XXL‑JOB jobs with proper logging.
Auto-configurationJavaSpring Boot
0 likes · 24 min read

This article explains the problems of traditional Spring MVC setup, introduces Spring Boot starters as a solution, details naming conventions and project structure for custom starters, and walks through the implementation of auto‑configuration classes, properties binding, and the spring.factories registration process.
Auto-configurationBackendJava
0 likes · 9 min read

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.
Amazon S3BackendJava
0 likes · 15 min read

This article walks through the JustAuth Spring Boot Starter’s architecture, detailing how the auto‑configuration class, property‑driven bean creation, and factory pattern enable third‑party login integration, while also offering practical tips for reading its source code and understanding key components.
Auto-configurationFactory PatternJava
0 likes · 8 min read

This article provides a step‑by‑step guide to creating a Spring Boot starter for enterprise‑grade object storage services, explaining OSS concepts, Amazon S3 basics, project setup, Maven dependencies, configuration classes, template interfaces, implementation details, auto‑configuration, packaging, and testing.
Amazon S3JavaOSS
0 likes · 21 min read

This article walks through four advanced Spring Boot Starter design patterns—Customizer, Enable/ConditionalOnProperty, SPI file migration, and AOP interception—showing concrete code examples, the reasoning behind each approach, and practical tips for learning and applying these techniques.
AOPConditionalOnPropertyCustomizer
0 likes · 16 min read

This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts OSS object‑storage services via the Amazon S3 protocol, covering project setup, Maven dependencies, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
Amazon S3JavaOSS
0 likes · 17 min read

This article walks through the complete process of creating a Spring Boot Starter that wraps the GrowingIO Java SDK, covering the motivation, project setup, property abstraction, auto‑configuration, custom logging, service implementation, and a simple test to verify the starter works in a Spring Boot application.
Auto-configurationGrowingIOJava SDK
0 likes · 20 min read

This article explains how to build a reusable Spring Boot starter that automatically encrypts outgoing responses and decrypts incoming requests using hutool‑crypto, custom request wrappers, validation utilities, and Spring Boot advice components, providing a secure, zero‑boilerplate solution for Java backend services.
BackendJavaRequestBodyAdvice
0 likes · 21 min read

This article explains how to build a reusable Spring Boot starter that automatically encrypts response data and decrypts request payloads using Hutool-Crypto's AES utilities, covering request stream handling, validation, custom starter configuration, and example code for controllers and entities.
AESHutoolRequestBodyAdvice
0 likes · 23 min read

This article walks you through creating a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration classes, registration via spring.factories (or the new imports file), and comprehensive unit testing strategies to ensure reliable conditional behavior.
Auto-configurationJavaSpring Boot
0 likes · 7 min read

This tutorial walks you through creating a custom Spring Boot Starter, from Maven project setup and dependency configuration to defining auto‑configuration classes, registering them, and writing comprehensive unit tests to verify conditional behavior.
Auto-configurationJavaSpring Boot
0 likes · 6 min read

This tutorial explains how to create a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration class creation, registration via spring.factories, and comprehensive unit testing to ensure correct conditional behavior.
Auto-configurationJavaSpring Boot
0 likes · 7 min read

This article explains the concepts behind SpringBoot Starters, walks through the creation of a custom starter that provides global request/response encryption and decryption using SM2, shows the project structure, key configuration files, core code, testing steps, and subsequent optimizations.
BackendJavaSpringBoot
0 likes · 10 min read

This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts Amazon S3‑compatible object storage services such as Alibaba Cloud OSS, Tencent COS, Qiniu OSS, and MinIO, covering dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
Amazon S3BackendJava
0 likes · 15 min read

This article introduces mica-auto, an annotation‑processor‑based tool that automatically generates Spring Boot starter configuration files—including spring.factories, AutoConfiguration.imports, and java SPI settings—enabling seamless compatibility with Spring Boot 3.x without maintaining separate branches.
Annotation ProcessorAuto-configurationSpring Boot
0 likes · 4 min read

This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
AutoConfigurationDependency ManagementJava
0 likes · 10 min read

This article explains how to standardize API return formats with a generic Result object, define error codes and custom exceptions, implement a global exception handler, use ResponseBodyAdvice for automatic response wrapping, and package these utilities into a reusable Spring Boot starter for cleaner backend code.
Global ExceptionResponseBodyAdviceResult Wrapper
0 likes · 14 min read

This article explains how to eliminate manual configuration of XXL‑Job executors and job handlers by creating a SpringBoot starter that automatically registers them to the XXL‑Job admin center, covering the required APIs, authentication, annotation design, and implementation details with full code examples.
Starterauto registrationtask-scheduling
0 likes · 15 min read

This article provides an in‑depth tutorial on designing and implementing various rate‑limiting strategies—such as token bucket, leaky bucket, and sliding window—in Java microservice architectures, with practical code examples using Guava, Sentinel, Redis+Lua, and a reusable Spring Boot starter.
GuavaLuaRedis
0 likes · 31 min read

This article explains the concept and purpose of Spring Boot starters, compares mybatis‑spring with mybatis‑spring‑boot‑starter through code examples, and details how the starter simplifies MyBatis integration by handling dependencies, configuration files, auto‑configuration, and mapper scanning for Java backend projects.
Auto-configurationJavaMyBatis
0 likes · 7 min read

This tutorial walks through creating a reusable SpringBoot starter that combines Guava's local token‑bucket limiter and Redis's distributed limiter, allowing developers to toggle between them via a simple configuration property and integrate the solution seamlessly with AOP and conditional beans.
AOPGuavaJava
0 likes · 9 min read

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.
JavaRequest WrapperSpring Boot
0 likes · 25 min read

This article explains how to create a Spring Boot starter that automatically registers XXL-Job executors and job handlers to the scheduling center, eliminating manual configuration through code examples, API analysis, and step‑by‑step implementation details.
JavaSpring BootStarter
0 likes · 15 min read

This article explains how to build a Spring Boot starter that automatically registers XXL‑Job executors and job handlers by logging into the admin center, invoking the necessary REST APIs, and using custom annotations to capture job metadata, eliminating manual configuration for large numbers of scheduled tasks.
StarterTask SchedulingXXL-JOB
0 likes · 12 min read

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.
Auto-configurationJavaSpring Boot
0 likes · 9 min read

This article explains why Spring Boot was created, outlines its key features such as convention over configuration and automatic wiring, dives into the inner workings of annotations like @EnableAutoConfiguration, demonstrates how SpringFactoriesLoader implements SPI, and guides you through building a simple starter component step by step.
Auto-configurationJavaSpring Boot
0 likes · 13 min read

This guide explains why Spring Boot deprecates the META-INF/spring.factories file, how the change affects custom starters, and provides step‑by‑step code examples for migrating to the new AutoConfiguration.imports mechanism.
AutoConfigurationJavaSpring Boot
0 likes · 4 min read

This article explains the history, recent updates, and step‑by‑step usage of the Spring Boot Swagger starter, including dependency setup, detailed configuration options, grouping, JSR‑303 validation support, custom response messages, UI tweaks, ignored parameter types, and authorization settings.
API DocumentationConfigurationSpring Boot
0 likes · 17 min read

This article explains how Spring Boot’s @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are loaded from META‑INF/spring.factories, and demonstrates building a custom starter that configures a Tomcat web server, with full code examples and Maven setup.
Auto-configurationJavaSpring Boot
0 likes · 14 min read

This article explains how Spring Boot’s @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration is loaded from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat server and custom starter creation.
Auto-configurationStarterdependency-injection
0 likes · 13 min read

This article explains how to create a custom Spring Boot starter, register its auto‑configuration class in spring.factories, and precisely control the execution order of auto‑configuration classes using @AutoConfigureAfter, @AutoConfigureBefore, and @AutoConfigureOrder annotations.
Auto-configurationBackendConfiguration Order
0 likes · 7 min read

This article walks you through creating a custom Spring Boot starter for SMS services, covering naming conventions, Maven dependencies, configuration properties, auto‑configuration, sender implementations, activation methods, packaging, and usage with practical code examples and diagrams.
Auto-configurationBackendJava
0 likes · 12 min read

This article explains why SpringBoot fails to initialize components after extracting common modules due to mismatched package names, demonstrates how to use @ComponentScan and custom @Enable annotations to specify scan paths, and outlines the basics of creating a custom starter for automated configuration.
BackendComponentScanCustomAnnotation
0 likes · 7 min read

This guide explains how to integrate Retrofit into a Spring Boot project using the retrofit‑spring‑boot‑starter, covering dependency setup, annotation configuration, custom interceptors, connection pool management, logging, exception formatting, call adapters, converters, and global interception to make HTTP client development more elegant and maintainable.
HTTP ClientInterceptorRetrofit
0 likes · 15 min read

This tutorial explains how to build a custom Spring Boot starter in four steps—setting up a Maven project, defining auto‑configuration with AOP, registering the starter via spring.factories, and packaging it—so that methods annotated with a custom @AspectLog annotation automatically log their execution duration.
AOPBackendSpring Boot
0 likes · 9 min read

This tutorial walks you through creating a custom Spring Boot starter, covering project structure, naming conventions, auto‑configuration module, property management, Maven setup, sample usage, and best practices, enabling you to package reusable cross‑cutting functionality for any Spring application.
Auto-ConfigurationJavaMaven
0 likes · 14 min read

This guide walks through creating a Spring Boot starter from scratch, covering Maven project setup, defining service and utility classes, configuring properties, implementing auto‑configuration with conditional annotations, registering the starter via spring.factories, and consuming it in another Spring Boot application.
JavaMavenSpring Boot
0 likes · 9 min read

This guide explains how to build a Spring Boot starter that automatically counts and logs the number of entries for each entity at application startup, covering starter concepts, Maven setup, code implementation, auto‑configuration, and integration into a main project.
CommandLineRunnerMavenSpring Boot
0 likes · 8 min read

This article provides a comprehensive, question‑driven guide to Spring Boot, covering its differences from Spring and Spring MVC, auto‑configuration, starter projects, embedded servers, Maven plugins, DevTools, static resources, Spring Data, REST support, request mapping nuances, and profile‑based configuration for building production‑ready Java backend applications.
Auto-configurationJavaMaven
0 likes · 17 min read

This guide introduces the spring-boot-starter-mongodb-plus library, shows how to add it to a Spring Boot project, enables easy annotation-based activation, and provides a comprehensive list of configurable MongoDB connection properties with their default values for fine‑tuned backend performance.
BackendConfigurationJava
0 likes · 5 min read
