Inject several of the Same CDI bean into a class?

Question

Currently, I have everything working with one injection of my CDI bean, but I need about 6 to 10 separate instances(?) depending on my inputs. (Ideally, I would like to be able to inject a dynamic number of the same CDI beans depending on how many I need.)

Unfortunately, I need to have the beans injected since the class depends on another CDI bean. (See the 2.CDI bean class below)

1. Clients class

@ApplicationScoped
public class Clients {
   Publisher pub;
   Subscriber sub;
   @Inject
   ListenerBean listener;

   public void init(){
      pub = new Publisher();
      sub = new Subscriber(listener);
   }
}

2. CDI bean class

@Dependent
public class ListenerBean{
   @Inject
   private eventHandler h;

   public void onMessage(Msg msg){
      h.doesSomething();
   }
}

The functionality I'm looking for, but not sure what's available out there. I haven't found anyone looking to accomplish the same thing.

for(Subscriber s: listOfSubscribers){
   @Inject
   ListenerBean l;
   s = new Subscriber(l);
}

// The only thing I can do right now is
@Inject
ListenerBean listener1;
@Inject
ListenerBean listener2;
@Inject
ListenerBean listener3;
@Inject
ListenerBean listener4;

---

Edit: The listeners do need to be identifiable. (Calls a setter after injection.) Probably not the best practice but not sure how else to implement this-

• The listeners will listen to different topics (declared by the respective consumer)
• Each listener must handle their messages based off of the topic

@Inject
ListenerBean listener1;
listener1.setTopic("TopicA");

Answer 1

If you need to inject several different instances of a @Dependent scoped bean, you could do it via programmatic lookup - in other words via Instance<T>.

Every bean resolution for a @Dependent bean via Instance will result in a new bean instance created. Following code illustrates that:

@Inject Instance<ListenerBean> instance;

public void createMultipleBeanInstances() {
  // bean1 and bean2 are two different instances because the bean is @Dependent
  // you can OFC do this in a cycle and generate as many as you like
  ListenerBean bean1 = instance.get(); 
  ListenerBean bean2 = instance.get();
}

Just note that dependent beans you create via programmatic lookup have their lifecycle bound to the Instance object meaning they will exist so long as does the Instance. Given that you @Inject Instance into the bean, it will be destroyed along with the bean it was injected into.

Answer 2

Explanation following my comment. I might be misunderstanding your question though.

First of all, your code looks basically like the implementation of a multicaster: you inject several objects which all implement a common interface to call the same method.

I think, that in trying to inject the various receiver objects, you basically have an X-Y-problem: does the emitter really need to know the receivers, or is it enough, that the event reaches the targets?

If I am right with the assumption, that your emitter does not really need to know the subscribers, you can simply use the Event standard mechanism:

First, define a message (which can carry additional information, but this is not specifically necessary, you just need a class):

public class MyMessage {
     // if needed, add some fields
}

Then, in your emitter, inject the corresponding event type, and use it to fire the message:

@Inject
private Event<MyMessage> myEvent;  // note: type is message, not the bean

...

myEvent.fire(new MyMessage()); // to broadcast the message to everyone who is interested

In your subscribers, just @Observe the message:

public void theMethodWeWantCalled(@Observes MyMessage messageObject) {
    // do things here
}

That's it: no need to couple emitter and subscriber.