Avoid boilerplate code with this typable Spring beans tutorial

Typable Spring bean tutorial

Start by creating a custom annotation that you can put on each implementation to make them all typable Spring beans. I might even use the new annotation in the ComponentScan so that this annotation will be on a class and make each implementation a Spring bean without even having to add @Component type annotations on it.

Using our example, here is the annotation I might create:

package com.serverside.typable.beans,annotation
 
import java.lang.annotation.ElementType
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target
 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface StateFormParser {
 
   String state();
   String format() default "text";
}

I can use this annotation on each of my parsers and then set the state and format values. Here is an example of a parser for California that supports the HTML format:

@StateFormParser(state="CA", format="html")
public class CaliforniaParser extends StateFormParserBaseClass {
}

In my Spring configuration for Component Scan, I would add it to my includeFilters property of the componentScan configuration. When you use @ComponentScan, it would look like this:

@ComponentScan(basePackages = ["com.serverside],includeFilters = [
  @ComponentScan.Filter(type=FilterType.ANNOTATION, value=StateFormParser.class),
  @ComponentScan.Filter(type=FilterType.ANNOTATION, value=Repository.class),
  @ComponentScan.Filter(type=FilterType.ANNOTATION, value=Service.class),                
  @ComponentScan.Filter(type=FilterType.ANNOTATION, value=Controller.class)
  ]
)

When the Spring IoC container creates its ApplicationContext/BeanFactory, the parser beans will be in the context. But how do you retrieve them?

Spring has a method in the ListableBeanFactory that extends BeanFactory, which you can find within the ApplicationContext.

Map<String, Object> getBeansWithAnnotation(
Class<? extends Annotation> annotationType) 
throws BeansException;

We could use this method to retrieve all the beans with our annotations, but we can also do an autowiring trick if each implementation operates in the same interface or base class.

@Autowired Map<String, StateFormParserBaseClass> formParserMap;

In the autowired trick, the String of the map is the bean name, and the value is the bean instance.

Since we have the base classes and not a Map/List by the annotation, we will then need to search for the correct bean in the map.

This code will loop through the values of the map, pull the annotation off of each one that we can then compare to the dynamic data and find the one instance that we want to use. You could use Java 8 streams and incorporate a stream().filter() call if you like.

private StateFormParserBaseClass getFormParser(String state, String format) {
  StateFormParserBaseClass beanFormParser = null;
 
  for (StateFormParserBaseClass formParser: formParserMap.values()) {
    StateFormParser stateFormParser = formParser.getClass().getAnnotation(StateFormParser.class);
    if (stateFormParser.state().equals(state) && stateFormParser.format().equals(format)) {
    beanFormParser = formParser;
    }
  }
    return beanFormParser
}

There are many other ways to retrieve the correct parser bean, but with this Spring beans tutorial, you can simplify the problem with annotations and a simple reflection method or a Spring application method call.