Intro
Is this blog post I’ll show a way how to use Spring Boot functionality to create a more automatized way to use beans that are some what created as component or features.
The idea is that we way have functionalities or features which we want to have easy and clear access through code, so the following things should be true:
- If I want I can use a set of beans easily
- If I want I can use a specific bean or beans within the previous set of beans
- It should be easily told to Spring what beans to load, a only liner preferably
- Configuration of beans should be not hidden from a developer, the developer should be noticed if a configuration is missing from a required bean ( By configuration I mean application properties)
- A bean or set of beans should be able to be used from a common library so that when the library is references in a project the beans will not be automatically created and thus creating mandatory dependencies that would break the other project code and/or add functionalities which are not required
All of the above will happen if the following three things are created and used properly within a code base:
- Custom annotations to represent features or functionalities by tagging wanted code
- Usage of component scan to load up the wanted features or functionalities based on the set annotations
- Usage of properties classes which extend from a properties base class handling application properties dependencies and configuration logic and logging
Notice: I assume that you are familiar with Java and Spring Boot, so I’ll skip some of the minor details regarding the implementation.
Implementation
Custom annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyFeature {
}
To use this annotation you need to apply it to bean creation process which you want the component scan to pick up.
@Bean(name = "MY_FEATURE_BEAN")
@Autowired
@Profile({"primary"})
@MyFeature
public MyFeatureClass createMyFeatureBean(MyFeatureProperties myfeatureProperties) {
MyFeatureClass myFeature = new MyFeatureClass(myfeatureProperties);
// Do someething else with the class
return myFeature; // Return the class to be used as a bean
}
You can also directly apply it to a class. This way the class is used directly to create a bean out of it.
Component Scanning
You can use the Spring Boot component scanning in many different ways (I recommend looking at what the component scan can do).
In this example it is enough for you to tell which annotation to include in your project, notice that you have to create a configuration class for this to work:
@Configuration
@ComponentScan(basePackages = "com.my.library.common",
includeFilters = @ComponentScan.Filter(MyFeature.class))
public class MyFeaturesConfiguration {
}
Extended properties configuration
For this example we need two things to happen for the custom properties configuration and handling/logging to work:
- Create a properties class that represents a set of properties for a feature or set or features and/or functionalities
- Extend it from a base properties class that will examine each field in the class and determine if a property has been set, not set or if it is optional.
What we want to achieve here is that we want to show a developer which properties from a feature or functionalities are missing or not missing. We don’t show the values since the values may contain sensitive data, we only list ALL of the properties in a properties class no matter if they have set values or not. This is to show to a developer all the needed fields and which are invalid, including optional properties.
This approach will significantly improve a developers or a system admins daily work load by decreasing. You won’t have to guess what is missing. And combining with good documentation on the property level of a configuration class you should figure out easily what is missing.
BaseProperties class
Extend this class in all classes that you want to define properties.
import com.sato.library.common.general.exceptions.SettingsException;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.util.StringUtils;
import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.util.Optional;
public class BaseProperties {
@PostConstruct
private void init() throws Exception {
boolean failedSettingsCheck = false;
StringBuilder sb = new StringBuilder();
// Go through every field in the class and log it's situation if it has problems(missing property value). NOTICE: A report of the settings properties is only logged IF a required field is not set
for (Field f : getClass().getDeclaredFields()) {
f.setAccessible(true);
String optionalFieldPostFixText = " ";
boolean isOptionalSetting = false;
String classConfigurationPropertyFieldPrefixText = "";
// Check to see if the class has a configuration properties annontation, if so add the defined property path to the logging
if (getClass().getDeclaredAnnotation(ConfigurationProperties.class) != null) {
final ConfigurationProperties configurationPropertiesAnnotation = getClass().getDeclaredAnnotation(ConfigurationProperties.class);
if (!StringUtils.isEmpty(configurationPropertiesAnnotation.value()))
classConfigurationPropertyFieldPrefixText = configurationPropertiesAnnotation.value() + ".";
if (StringUtils.isEmpty(classConfigurationPropertyFieldPrefixText) && !StringUtils.isEmpty(configurationPropertiesAnnotation.prefix()))
classConfigurationPropertyFieldPrefixText = configurationPropertiesAnnotation.prefix() + ".";
}
// Check to see if this field is optional
if (f.getDeclaredAnnotation(OptionalSetting.class) != null) {
optionalFieldPostFixText = " - Optional";
isOptionalSetting = true;
}
// Check to see if a settings field is empty, if so then set the execution of the application to stop and logg the situations
if (f.get(this) == null || (f.getType() == String.class && StringUtils.isEmpty(f.get(this)))) {
// Skip empty field if they are set as optional
if (!isOptionalSetting) {
failedSettingsCheck = true;
}
sb.append(classConfigurationPropertyFieldPrefixText + f.getName() + ": Missing" + optionalFieldPostFixText + System.lineSeparator());
} else {
// If the field is OK then mark than in the logging to give a better overview of the properties
sb.append(classConfigurationPropertyFieldPrefixText + f.getName() + ": OK" + optionalFieldPostFixText + System.lineSeparator());
}
}
// If even one required setting property is empty then stop the application execution and log the findings
if(failedSettingsCheck) {
throw new SettingsException(Optional.of(System.lineSeparator() + "SETTINGS FAILURE: You can't use these settings values of " + this.getClass() + " without setting all of the properties: " + System.lineSeparator() + sb.toString()));
}
}
}
Optional Annotation for optional properties
Use the following code to set optional properties in properties classes. This means that in the properties base classes any optional property is ignored as a fatal exception that needs to stop the execution of the application.
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface OptionalProperty {
}
Using all of the above
@ConfigurationProperties(prefix = "myfeature")
@MyFeature
public class MyFeatureProperties extends BaseProperties {
@OptionalProperty
private String secretKey;
private String region;
public String getSecretKey() {
return secretKey;
}
public void setSecretKey(String secretKey) {
this.secretKey = secretKey;
}
public String getRegion() {
return region;
}
public void setRegion(String region) {
this.region = region;
}
}
Notice: In the usage example code above I do not set a @Configuration annotation to the class, this is because the component scan will pick up this class and automatically determine it is a configuration class because of the @ConfigurationProperties annotation, yep this is a trick but it work nicely.
