Spring Boot: Strategy Design Pattern - Convenience and Limitation
Let's solve the problem of having different strategies using the same keys in our code by highlighting the convenience and limitations in Spring Boot.
Join the DZone community and get the full member experience.Join For Free
You might have already used the strategy pattern in relationship with Spring Boot where it is very convenient to use. You simply define an interface for example (I use the prefixing I only in these examples for clarity):
Define some implementations like this:
Now you can simply implement a service which will execute the appropriate strategy based on the given name which looks similar like this:
In the real-world you make several implementations of the strategy interface like
OneStrategyThird. Sometimes the usage is to use the parameter of
executeStrategyOne which is provided by a REST API or some other domain-specific code which needs different implementations.
The convenience here is that Spring Boot (Spring Framework to be more accurate) handles the injection of the different implementation into the strategies Map within
ExecuteStrategyOne via the constructor. This results in a Map where the key is the value which is given by
@Service("FIRST") and the value of the map contains an instantiates class of every implementation of the interface
IOneStrategy which can be found.
In real life, it happens that you need to have a different strategy that use the same keys as FIRST, SECOND, and THIRD in the examples? Let us define the following:
If you try to start that Spring Boot application you will see an exception like this:
So what can we do to solve the problem without losing much of the convenience which Spring Boot provides us here?
First, we have to define in each of the strategy implementation class the annotations like this:
By using the key in a different annotation we prevent the duplication of the bean names in contradiction to use
@Service("FIRST") instead. The usage of
@Qualifier("FIRST") gives us criteria to handle that difference.
Now we have to change the
ExecuteStrategyOne class like the following:
I would like to emphasis the usage of the constructor parameter
List<IOneStrategy> strategies instead of the previously used
Map<String, IOneStrategy> strategies which is a convenience to get a list of all implementations off the given interface into that list by Spring Boot. Now we need to translate that into a map with the key we have defined by using
@Qualifier annotation. The whole thing can be solved by a stream like this:
We go through the implementations and extract the annotation
@Qualifier and read out the
value() which is the key we want to have. We collect the result by using the Collectors.toMap into a Map and assign the result to the instance variable
private Map<String, IOneStrategy> strategies;. Depending on your need it is, of course, possible to define the instance variable as final and you can create an unmodifiable map by using the appropriate
Collectors.toUnmodifiableMap instead of the
toMap(..) if needed.
So with a few changes in the code, we can easily solve the problem of having different strategies using the same keys in our code.
The given code is available as a full working example on GitHub.
Opinions expressed by DZone contributors are their own.