Generic Bean with less code

[cancech]

I have a generic bean, where I am making a lot of instances for different types but I want the instance for each type to be a singleton. From my experimentation, if I annotate the class @Singleton, then only a single instance of the class is created and then reused for each subsequent instance (which is of course bad). If I annotate the class @Prototype, then each type will receive its own instance... however a new instance is created even repeatedly injecting beans of the same type (which is not what I want).

From my experimentation the only way I've been able to figure out to get around this would be to use a factory

public class MyGeneric<T> {
}

@Factory
public class MyGenericFactory {

    @Bean
    @Singleton
    MyGeneric<String> stringGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<Integer> intGeneric() { return new MyGeneric<>(); }
}

or to subclass for each type. While both approaches are functional, it translates into a lot of boilerplate/repetitive code.

Is there a better way of achieving the same end result, and avoiding the repetition?

[mboogi]

Have you considered using "Named" annotation ?
https://docs.micronaut.io/1.1.0.M2/guide/index.html#qualifiers
Also please take a look at :
https://stackoverflow.com/questions/69304075/could-not-inject-different-beans-with-named-qualifier-in-micronaut
BR
MB

[cancech]

Wouldn't @Named only be beneficial in differentiating the instances the factory creates? As in, given the generic class above

@Factory
public class MyGenericFactory {

    @Bean
    @Singleton
    @Named("MyStringGeneric")
    MyGeneric<String> stringGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    @Named("MyIntGeneric")
    MyGeneric<Integer> intGeneric() { return new MyGeneric<>(); }
}


@Singleton
public class StringGenericConsumer {

    @Inject
    public StringGenericConsumer(@Named("MyStringGeneric") MyGeneric<String> stringGeneric) {
        // Do Something
    }
}

That would allow me to differentiate multiple singleton instances of the same type (i.e.: if I wanted to have multiple MyGeneric<String> beans floating around), however while I want any number of MyGeneric beans I want to ensure that there's only a single instance for a specific type (i.e.: any number of MyGeneric<?> while just a single MyGeneric<String>. The easiest way I'm seen to achieve this is through a factory, but that is forcing me to copy/paste a lot of boilerplate code. So far I have about 40 different MyGeneric instances of different types and I want each of those types to have a unique (singleton) bean, however this is forcing me to create the Factory as such

@Factory
public class MyGenericFactory {

    @Bean
    @Singleton
    MyGeneric<String> stringGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<Integer> intGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<Double> dblGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<Long> longGeneric() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<MyClass1> class1Generic() { return new MyGeneric<>(); }

    @Bean
    @Singleton
    MyGeneric<MyClass2> class2Generic() { return new MyGeneric<>(); }

    // Copy-paste ad nausea ~40 times, alternating the type that's used with the generic
}

I'm wondering/hoping if there's a way to condense the factory to avoid all of this repetition, or if there's a better way of achieving the same end-goal, without using a factory?

@Prototype
public class MyGeneric<@Singleton T> {
}

Would be ideal, but it doesn't work like that! :-P