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
1 2 3
Define some implementations like this:
1 2 3 4 5 6 7 8
Now you can simply implement a service which will execute the appropriate strategy based on the given name which looks similar like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
In 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
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
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 which use the same
THIRD in the examples? Let us define the following:
1 2 3 4 5 6 7 8
If you try to start that Spring Boot application you will see an exception like this:
1 2 3 4 5 6
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:
1 2 3 4 5 6 7 8 9
By using the key in a different annotation we prevent the duplication of the bean names in contradiction
@Service("FIRST") instead. The usage of
@Qualifier("FIRST") gives us a criteria to handle that
Now we have to change the
ExecuteStrategyOne class like the following:
1 2 3 4 5 6 7 8 9 10 11 12 13
I would like to emphasis the usage of the constructor parameter
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:
1 2 3 4 5
We go through the implementations and extract the annotation
@Qualifier and read out the
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
you can create an unmodifiable map by using the appropriate
instead of the
toMap(..) if needed.
So with a few changes in the code we can easily solve the problem of having different strategies which using the same keys in our code.
The given code is available as a full working example on GitHub.