Tagged articles
ConfigurationProperties
38 articles · Page 1 of 1
This article explains the differences between Spring Boot's ${} placeholder resolution and #{} SpEL evaluation, detailing their syntax, source code implementations, parsing order in @Value, common pitfalls, and why @ConfigurationProperties doesn't support SpEL.
@ValueConfigurationPropertiesEnvironment
0 likes · 14 min read

This article explains Spring Boot's @ConfigurationProperties binding mechanism, covering when binding occurs via BeanPostProcessor, how Binder handles relaxed binding and type conversion, differences between setter and constructor binding, validation triggering with @Validated, and common troubleshooting pitfalls.
BeanPostProcessorBinderConfigurationProperties
0 likes · 18 min read

This tutorial demonstrates three methods to read YML configuration in SpringBoot — using @Value annotations, the Environment abstraction, and @ConfigurationProperties binding — with complete code examples for each approach.
@ValueConfigurationConfigurationProperties
0 likes · 11 min read

This article details ten deprecated Spring Boot patterns — from field injection and @Value overuse to WebSecurityConfigurerAdapter and RestTemplate — and shows the recommended modern alternatives for Spring Boot 3.x and 4.x migrations.
ConfigurationPropertiesJUnit 5Jakarta EE
0 likes · 11 min read

This article demonstrates how to use Java enums together with Spring Boot's @ConfigurationProperties to replace hard‑coded strings in application.yml, improving readability, reducing maintenance effort, and enabling flexible configuration of user types displayed via a Thymeleaf front‑end.
ConfigurationPropertiesEnumJava
0 likes · 14 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

This article demonstrates three ways to bind a custom Author object from a single comma‑separated string in Spring Boot 3.5.0 using a custom ConversionService, a PropertyEditor, and the @ConfigurationPropertiesBinding annotation, complete with code samples and resulting output.
ConfigurationPropertiesConfigurationPropertiesBindingConversionService
0 likes · 6 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 explains why @Value, @ConfigurationProperties, and Environment cannot be used directly in BeanFactoryPostProcessor, and demonstrates two practical techniques—using Environment#getProperty and Binder with @ConfigurationProperties—to inject configuration properties without pain in early Spring Boot initialization.
BeanFactoryPostProcessorBinderConfigurationProperties
0 likes · 6 min read

This article demonstrates how to combine Spring Boot's @ConfigurationProperties with Java records to create concise, immutable, and type‑safe configuration classes, covering scanning setup, record definition, YAML binding, constructor injection, validation with @Validated, and best‑practice recommendations for managing configuration in Spring Boot 3.5.0.
ConfigurationPropertiesImmutable ConfigurationJava Records
0 likes · 6 min read

This article explains how @ConfigurationProperties provides batch binding, type safety, relaxed key matching, and validation for SpringBoot configuration, compares it with @Value, and walks through practical examples—including simple bindings, nested objects, collections, maps, validation, multi‑environment profiles, and advanced features like hot‑refresh and custom starters.
Configuration BindingConfigurationPropertiesJava
0 likes · 25 min read

This article provides a comprehensive guide to using Spring Boot's @ConfigurationProperties and @PropertySources annotations, covering their purpose, usage steps, code examples, and the differences between them for effective configuration management in Java backend applications.
Configuration ManagementConfigurationPropertiesJava
0 likes · 11 min read

This guide shows how to improve Spring Boot configuration management by using Java enums together with @ConfigurationProperties, providing clear, type‑safe settings, reducing magic numbers, and demonstrating a complete example with Maven dependencies, YAML files, a configuration class, controller, and Thymeleaf view.
BackendConfiguration ManagementConfigurationProperties
0 likes · 13 min read

This guide explains how to improve Spring Boot configuration management by defining configuration values as Java enums, mapping them with @ConfigurationProperties, and displaying them via a Thymeleaf front‑end, including Maven dependencies, YAML settings, enum class, config class, controller, and HTML template examples.
ConfigurationPropertiesEnumSpring Boot
0 likes · 11 min read

This comprehensive guide explores the most powerful Spring Boot capabilities—including @Conditional, @ConfigurationProperties, Actuator, DevTools, Retry, Cache, testing strategies, custom starters, Admin, and CLI—providing code examples and deep analysis to help developers boost productivity, reliability, and maintainability of their applications.
ActuatorCacheConfigurationProperties
0 likes · 20 min read

This article demonstrates six different techniques for loading external configuration data into Spring Boot 3 applications, covering command‑line arguments, spring.config.import, @PropertySource, EnvironmentPostProcessor, @TestPropertySource, and a custom PropertySourceLocator with complete code examples and expected outputs.
ConfigurationPropertiesEnvironmentPostProcessorExternal Configuration
0 likes · 9 min read

This guide explains how to improve Spring Boot configuration management by mapping external properties to Java enums using @ConfigurationProperties, demonstrating a complete example with Maven dependencies, YAML settings, enum definitions, configuration classes, a controller, and a Thymeleaf view to achieve flexible and readable code.
ConfigurationPropertiesEnumJava
0 likes · 11 min read

This article introduces a comprehensive Spring Boot 3 case collection and provides a detailed guide on using @ConfigurationProperties, constructor binding, @DefaultValue, and record types for type‑safe configuration, including examples of nested properties, collections, and default values, while promising ongoing updates and free source code for subscribers.
ConfigurationPropertiesDefaultValueJava
0 likes · 9 min read

The article shows how to replace hard‑coded strings in Spring Boot configuration files with type‑safe Java enums, using @ConfigurationProperties to bind YAML values to enum fields, thereby improving readability, maintainability, and eliminating magic numbers, illustrated through a user‑role example with controller and Thymeleaf view.
ConfigurationPropertiesEnumJava
0 likes · 12 min read

This guide walks through eight Spring Boot property injection techniques—including @Value placeholders, SpEL expressions, @ConfigurationProperties, custom @PropertySource, YAML factories, Environment access, custom annotations, programmatic loading, and command‑line arguments—showing code examples and expected outputs for each method.
@ValueConfigurationPropertiesEnvironment
0 likes · 9 min read

This article explains the drawbacks of using Spring Boot's @Value for configuration injection, demonstrates how @ConfigurationProperties provides a cleaner, maintainable alternative, and shows how to add validation with @Validated and standard bean validation annotations.
@ValueConfigurationConfigurationProperties
0 likes · 4 min read

This article explains how Spring's @ConfigurationProperties and @PropertySources annotations work, compares their purposes, and provides step‑by‑step examples for binding external configuration to Java beans and loading multiple property files in a Spring Boot application.
ConfigurationPropertiesJavaPropertySources
0 likes · 11 min read

This article explains how Spring Cloud discovers classes annotated with @ConfigurationProperties, wraps them into ConfigurationPropertiesBean objects, and dynamically rebinds them at runtime using RefreshScope, EnvironmentChangeEvent, and the RefreshEndpoint actuator, enhancing application flexibility and scalability.
@RefreshScopeConfigurationPropertiesJava
0 likes · 9 min read

This article explains the purpose and differences of Spring's @ConfigurationProperties and @PropertySources annotations, provides step‑by‑step guidance for creating POJOs, configuration classes, property files, and demonstrates how to bind and inject configuration values in a Spring Boot application with code examples.
AnnotationsConfiguration ManagementConfigurationProperties
0 likes · 12 min read

This article explains multiple ways to read configuration properties in Spring Boot—including Environment, @Value, @ConfigurationProperties, @PropertySources, and custom YAML loading—detailing their underlying mechanisms, common pitfalls, and code examples so developers can choose the most suitable approach for their projects.
@ValueConfigurationPropertiesEnvironment
0 likes · 17 min read

This article presents fourteen actionable Spring Boot optimization techniques—from using @ConfigurationProperties and @RequiredArgsConstructor to modularizing code, avoiding null returns, leveraging IDE suggestions, and applying design patterns—aimed at improving code readability, performance, and maintainability for Java backend developers.
Best PracticesConfigurationPropertiescode optimization
0 likes · 7 min read

This article explains how Spring Boot's auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories mechanism, conditional annotations, and how configuration properties are bound to beans such as ServerProperties, providing a clear understanding for developers and interview preparation.
Auto-configurationConfigurationPropertiesJava
0 likes · 9 min read

This article explains how Spring Boot’s auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories file, conditional annotations, and how configuration properties are bound to beans such as ServerProperties to make settings like server.port effective at runtime.
Auto-configurationConfigurationPropertiesJava
0 likes · 7 min read

This article provides a comprehensive walkthrough of SpringBoot’s auto‑configuration mechanism, covering common annotations, configuration property binding, import strategies, conditional beans, the application startup flow, and the role of META‑INF/spring.factories in loading auto‑configuration classes.
AnnotationsAuto-configurationConfigurationProperties
0 likes · 16 min read

This article explains how Spring Boot's auto‑configuration works by loading configuration classes from spring.factories, using @EnableAutoConfiguration and conditional annotations to bind properties from application.properties or application.yml to beans such as ServerProperties, enabling rapid backend development without extensive manual setup.
Auto-configurationConfigurationPropertiesJava
0 likes · 8 min read

After launching a Spring Boot 2.3.9 application, you can execute custom tasks using ApplicationRunner or CommandLineRunner, access startup arguments, generate random configuration values, disable command-line properties, understand configuration file loading order, and correctly use @EnableConfigurationProperties for bean binding.
ApplicationRunnerConfigurationPropertiesSpring Boot
0 likes · 6 min read

This guide shows how to externalize fixed settings like file upload paths in a SpringBoot backend by defining them in application.yml, creating a @ConfigurationProperties‑annotated config class with matching fields, and accessing the values via static methods or bean injection.
BackendConfigurationPropertiesJava
0 likes · 4 min read

This guide explains how to use Spring Boot's @ConfigurationProperties for type‑safe property binding, covering basic usage, custom property files, third‑party component binding, relaxed naming rules, validation, and extending support to YAML files with code examples and tests.
ConfigurationPropertiesJavaSpring Boot
0 likes · 7 min read

Spring Boot 2.2.1, released on November 7, 2019, introduces 110 fixes and disables automatic @ConfigurationProperties scanning by default, requiring developers to add @ConfigurationPropertiesScan manually, with full details available in the official GitHub issue.
ConfigurationPropertiesJavaSpring Boot
0 likes · 2 min read

This article explains how @ConfigurationProperties and @ConfigurationPropertiesScan work in Spring Boot, the differences from @Value, and why upgrading from 2.2.0 to 2.2.1 may cause configuration beans to stop loading.
ConfigurationPropertiesJavaSpring
0 likes · 4 min read

This tutorial explains how to use Spring Boot's Configuration Processor to generate JSON metadata for configuration properties, covering dependency setup, Java bean definitions, property files, tests, and how the resulting metadata improves IDE auto‑completion and documentation.
Configuration ProcessorConfigurationPropertiesJava
0 likes · 10 min read

Spring Boot 2.2 follows the release of Spring Framework 5.2, bringing updated component versions, major performance gains, Java 13 support, immutable configuration properties, RSocket starter, health‑check grouping, and numerous other enhancements for Java backend developers.
ConfigurationPropertiesJavaSpring Boot
0 likes · 6 min read
