CDI Error: Injection of inherited class

[rafaelfnx]

Hello!
I am attempting to implement dependency injection in a class that is inherited from a base abstract class, and I get the following error: "javax.enterprise.inject.spi.DeploymentException: It's not possible to automatically add a synthetic no-args constructor to an unproxyable bean class. You need to manually add a non-private no-args constructor to com...ExampleIntegrationProvider in order to fulfill the requirements for normal scoped/intercepted/decorated beans."

From what I researched, it seems that this happens because classes that are annotated with normal scoped beans such as @ApplicationScoped for example, need a non-private constructor without arguments, so that CDI can create a proxy of that class when it is injected in lazy mode. I was a bit surprised to find out, as I've never had problems with code like this:

@ApplicationScoped
public class UserService {

    private final UserRepository userRepository;

    @Inject
    public UserUseCase(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User findById(long id) { ... }
}

--

Even though Quarkus magically adds a synthetic no-args constructor, how could it overcome the final field UserRepository? There would be a problem with its initialization as it needs to receive a value, I imagine it might end up being passed a null value..

Anyway, going straight to my case, here's an example of my current situation, with 3 important base classes and 1 implementation for a "Example" partner:

PartnerIntegration.java

@MappedSuperclass
public abstract class PartnerIntegration {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

     // other common fields ...
}

--

PartnerIntegrationRepository.java

public interface PartnerIntegrationRepository<I extends PartnerIntegration> extends PanacheRepository<I> {
    // common methods ...
}

--

PartnerIntegrationProvider.java

public abstract class PartnerIntegrationProvider<I extends PartnerIntegration> {

    protected final PartnerIntegrationRepository<I> partnerIntegrationRepository;

    protected PartnerIntegrationProvider(PartnerIntegrationRepository<I> partnerIntegrationRepository) {
        this.partnerIntegrationRepository = partnerIntegrationRepository;
    }

    // code ...
}

--

And finally the final implementation ExampleIntegrationProvider.java:

@ApplicationScoped
public class ExampleIntegrationProvider extends PartnerIntegrationProvider<ExampleIntegration> {

    @Inject
    public ExampleIntegrationProvider(ExampleIntegrationRepository  exampleIntegrationRepository) {
        super(exampleIntegrationRepository);
    }

    // code ...
}

--

The abstract class PartnerIntegrationProvider is not annotated with any scope as I did not consider it necessary since it only receives the PartnerIntegrationRepository interface and not a concrete repository. But ExampleIntegrationProvider receives a concrete repository that is implementing that interface, so I annotated it with @ApplicationScoped to be able to inject the concrete repository with @Inject.

But this generated that error, I tried creating a public constructor method that passes the null parameter to the parent class, and the error disappeared, but this ends up polluting my code, since I do not want to allow that class to be instantiated without receiving a repository, so I removed the @ApplicationScoped and @Inject annotations from ExampleIntegrationProvider and created that class to produce the instance that will be injected from it:

ExampleIntegrationProviderBean.java

@Dependent
public class ExampleIntegrationProviderBean {

    private static ExampleIntegrationProvider INSTANCE;

    private final ExampleIntegrationRepository exampleIntegrationRepository;

    @Inject
    public ExampleIntegrationProviderBean(ExampleIntegrationRepository exampleIntegrationRepository) {
        this.exampleIntegrationRepository = exampleIntegrationRepository;
    }

    @Produces
    public ExampleIntegrationProvider exampleIntegrationProvider() {
        return INSTANCE == null ?
                (INSTANCE = new ExampleIntegrationProvider(exampleIntegrationRepository)) : INSTANCE;
    }
}

But the number of partners may grow quickly, I wouldn't like to have to create other classes like this one to produce the instances, and even if it was just one partner, it doesn't seem like a very elegant solution...

Does anyone have any ideas on how I can resolve this in a better way?

[quarkus-bot[bot]]

/cc @Ladicek (arc), @manovotn (arc), @mkouba (arc)

[mkouba]

From what I researched, it seems that this happens because classes that are annotated with normal scoped beans such as @ApplicationScoped

Correct.

Even though Quarkus magically adds a synthetic no-args constructor, how could it overcome the final field UserRepository? There would be a problem with its initialization as it needs to receive a value, I imagine it might end up being passed a null value..

But Quarkus does not have to overcome anything here - the final field is simply set in the constructor. And if UserRepository is produced by a @Dependent producer then it could be null. There's no issue.

But this generated that error, I tried creating a public constructor method that passes the null parameter to the parent class, and the error disappeared, but this ends up polluting my code, since I do not want to allow that class to be instantiated without receiving a repository

A package-private no-args construtor should do the trick - note that it's only used to create a CDI client proxy; the @Inject constructor is used otherwise:

@ApplicationScoped
public class ExampleIntegrationProvider extends PartnerIntegrationProvider<ExampleIntegration> {
    
    // this constructor is only used to create a CDI client proxy
    ExampleIntegrationProvider() {
       super(null);
     }

}

[manovotn]

Martin is right, the no-arg constructor is a standard way to overcome this and one required by CDI specification.
True, it is a bit of a boiler plate code but it's only ever used for proxy creation, which are stateless, and for most CDI impls it cannot really be bypassed (Quarkus being an exception because it's build time oriented and can fiddle with bytecode).

Other option is to use a @Singleton instead of @ApplicationScoped as was suggested in your SO copy of the question - @rafaelfnx please link the two for future reference :)

Theoretically, we could also revisit what Quarkus does in terms of generating the no-arg constructor. I recall we originally discussed that it might be possible to generate it for arbitrary class hierarchy.

[palaknagdaminna]

The issue with using @Singleton is that it fails when you want to mock this class in Junit tests.
Even after using @MockitoConfig(convertScopes = true) the injected mock beans are changed to @ApplicationScoped from @Singleton and we get the same

It's not possible to automatically add a synthetic no-args constructor to an unproxyable bean class. You need to manually add a non-private no-args constructor

error when the tests are compiled and run

[manovotn]

Please create a separate issue with the description of your problem/reproducer and we can look into it there.

[rafaelfnx]

Thank you @mkouba for the detailed explanation and @manovotn for complementing it.
I will use @Singleton to resolve this issue, avoiding a bit of boilerplate.
Thank you very much for the information, I now understand this CDI mechanism a bit better.

And @manovotn, if possible, I would like to express interest in this possible feature.
Do you think I can create a "feature request" for this?

[manovotn]

You can definitely create a tracking issue.
You can even go as far as submitting a PR ;-)