CDI：基于对象类的注入

Question

I have class hierarchy where I would like to inject field using CDI based on type of subclass. This situation is described in following Java code:

@Stateless
public class A {
    @Inject
    @MyInjection
    D d;
    ...
    public void templateMethod(){...};
    protected void step1(){...};
    protected void step2(){...};
}

@Stateless
public class B extends A {
...
    protected void step1(){...};
    protected void step2(){...};
}

@Stateless
public class C extends A {
...
    protected void step1(){...};
    protected void step2(){...};
}

public class F {

    @Produces
    @MyInjection
    D myProducer(InjectionPoint ip){
        Class<?> clazz = ip.getMember().getDeclaringClass();

        //if clazz is B then inject one type

        //if clazz is C then inject other type

        //default inject default type
    }
}

These beans are packaged appropriate ejb.jar archive as part of EAR and there is beans.xml file in proper place. The code is executing on Wildfly 10 server using Java EE 7.

Using this code I get class of hierarchy base class (in this specific case class A), which is when I think about it logical, beacause InjectionPoint field is indeed in class A. The point is that I would like to make distinction based on subclasses although I do inject in superclass.

Could I achieve this using InjectionPoint class? Is there any possible way to achieve this?

More on that what I would like to achieve with this piece of code. This hierarchy implements template method Design Pattern and all classes are concrete, you can use class A which implements general algorithm and specific steps, but you can opt out to redefine steps in some subclass. Also there is need to inject specific type D, which might be different based on sublclass.

Unfortunately there is strong desire not to redesign bass class A. So I am trying to find I way to inject something in base class using CDI and not using deployment descriptor.

Answer 1

From your question I understood that you want to determine what bean are you injecting it into. This can be achieved in the following way:

@Produces
@MyInjection
D myProducer(InjectionPoint ip){
    // this will give you the class of the bean you injected into
    ip.getBean().getBeanClass();
}

For completeness, your previous solution used ip.getMember() which returns a Method objects (or Field for field producers). Therefore, subsequent call to getDeclaringClass() will give you class A .

Answer 2

After a bit of tinkering I found a way to achieve behaviour stated in my question. This required different approach to CDI injection: instead of field injection constructor injection did the job.

public class A {
    D d;
    ...

    public A(){
        this.d = null;
    }

    @Inject
    public A(@MyInjection D d){
        this.d = d;
    }
    ...
    public void templateMethod(){...};
    protected void step1(){...};
    protected void step2(){...};
}

@Stateless
public class B extends A {
    ...
    public B(){
        super();
    }

    @Inject
    public B(@MyInjection D d){
        super(d);
    }
    ...
    protected void step1(){...};
    protected void step2(){...};
}

@Stateless
public class C extends A {
    ...
    public B(){
        super();
    }

    @Inject
    public B(@MyInjection D d){
        super(d);
    }
    ...
    protected void step1(){...};
    protected void step2(){...};
}

public class F {

    @Produces
    @MyInjection
    D myProducer(InjectionPoint ip){
        Class<?> clazz = ip.getMember().getDeclaringClass();

        //if clazz is B then inject one type

        //if clazz is C then inject other type

        //default inject default type
    }
}

Organizing code this way I am able to discriminate injection based on leaf classes, although the requirement of not changing code of the base class (part of an API) might not be possible to achieve.