It is possible to inject map with enums keys?

Question

From this question, it is possible to inject map with enums?

For example, i have enum:

class enum SomeEnum (val value) {
  ONE("one"),
  TWO("two"),
  THREE("three")
}

And i have some interface with implementations:

interface SomeInterface {
}

@Component
@Qualifier("one")
class OneClass: SomeInterface {
...
}

@Component
@Qualifier("two")
class TwoClass: SomeInterface {
...
}

@Component
@Qualifier("three")
class ThreeClass: SomeInterface {
...
}

But such injection not works:

@Component
@ConfigurationProperties
class SomeProperties {
   @Autowired
   lateinit var someMap: Map<SomeEnum, SomeInterface>
}

I want to autoinject someMap. How can i fix it, to make such code on spring framework side?

var someMap: Map<SomeEnum, SomeInterface> = Map.of(ONE, oneClass,
                                                   TWO, twoClass,
                                                   THREE, threeClass)

// Where oneClass, twoClass, threeClass - beans instances

Patrick · Answer 1 · 2020-07-06T09:38:10.433

Not quite sure what you want to do, but from my point of view you dont need this mapping. I assume you want to know which implementation to use for certain case. So just autowire a list or set of your interface and iterate trough it to find the right implementation. (I show the stuff in Java)

@Autowired
List<SomeInterface> someInterfaces;

In this list you will have all the injected implementations of this interface. If you still need an Enum to see which implementation to use, just add this as an attribute to every of your implementation class. So you can get the Enum value by its implementation.

EDIT: Create a config class and autowire the list of implementations. In this config class you create a Bean of your map.

@Configuration
public class MyMapConfig {

    @Autowired
    List<SomeInterface> someInterfaces;

    @Bean
    public Map<SomeEnum, SomeInterface> myMap() {
        Map<SomeEnum, SomeInterface> map = new HashMap<>();
        someInterfaces.forEach(s -> {
            // logic here to add correct Enum to its implementation.
            map.put(SomeEnum.A, s);
        });
        return map;

    }

    public enum SomeEnum {
        A, B, C
    }
}

Then you can autowire your map anywhere you want:

@Autowired
Map<SomeEnum, SomeInterface> myMap;

I need map because of business logic point. So, looks like spring cannot autowire it. I will inject list and then iterate over it and add to map. — SlandShow, Jul 06 '20 at 08:30

Nikolai Shevchenko · Accepted Answer · 2020-07-07T05:57:01.370

First of all you misuse @Qualifier annotation. It's intended not to name the bean but to help Spring to choose single autowire candidate among multiple. @Qualifier is only meaningful at injection point - either in pair with @Autowired for class properties

@Autowired
@Qualifier("one")
lateinit var someImpl: SomeInterface

or for injection into method/constructor arguments

@Bean
fun createSomeService(@Qualifier("two") someImpl: SomeInterface): SomeService {
   return SomeService(someImpl)
}

//or

class SomeService(@Qualifier("three") private val someImpl: SomeInterface) { 
    ... 
}

Correct way to name a bean is simply @Component("name") (or @Service("name"))

As far as I know, you can only autowire Maps with String keys, where key is the name of the bean. However you can easily convert this map into enum-key map like this:

interface SomeInterface

@Component("one")
class OneClass: SomeInterface

@Component("two")
class TwoClass: SomeInterface

@Component("three")
class ThreeClass: SomeInterface

@Component
@ConfigurationProperties
class SomeProperties(implMap: Map<String, SomeInterface>) {

    val someMap: Map<SomeEnum, SomeInterface> = implMap.mapKeys {
        SomeEnum.values().firstOrNull { e -> e.value == it.key }!!
    }
}

UPDATED:

or using field injection (not recommended)

@Component
@ConfigurationProperties
class SomeProperties {
    private lateinit var someMap: Map<SomeEnum, SomeInterface>

    @Autowired
    private lateinit var implMap: Map<String, SomeInterface>

    @PostConstruct
    fun initMap() {
        someMap = implMap.mapKeys {
            SomeEnum.values().firstOrNull { e -> e.value == it.key }!!
        } 
    }
}

@SlandShow what do you mean by "define"? It's already defined by Spring — Nikolai Shevchenko, Jul 06 '20 at 14:21
I have some unit tests, which create this `SomeProperties` instance. And yes, can i somehow inject `implMap` without constructor? From my point - `lateinit var implMap` not working — SlandShow, Jul 06 '20 at 14:25
@SlandShow it's hard to say why it's not working without seeing the code of the unit-test. And why do you avoid constructor-injection? It's considered to be best practice (unlike field-injection) — Nikolai Shevchenko, Jul 06 '20 at 15:04
Why field-injection is bad practice? It's common and convenient — SlandShow, Jul 06 '20 at 20:28

It is possible to inject map with enums keys?

2 Answers2