Investigate generating a proxy for `@Lazy` annotated beans

[SentryMan]

I was thinking about how quarkus injects a proxy for lazy beans, and it seems pretty convenient.

Given a class:

@Lazy
@Singleton
class SomeClass {

   void something(){
    //something
   }

}

Something like the following should be work:

public class ExampleService {

  private final SomeClass some;

  public ExampleService(SomeClass some) {
    this.some = some; // a generated proxy class is wired
  }

  public void example() {
   some.something(); //someclass is initialized here
  }
}

[SentryMan]

It seems for this to work on non-factory bean interfaces, the target class must be non-final and have a no-args constructor so that the generated proxy class can extend it.

AOP isn't an issue because we can simply generate a lazy proxy to extend the regular AOP proxy.

[SentryMan]

If the class doesn't have a no-arg constructor, then we just default to the current behavior.

So we have a couple of scenarios where we can generate a proxy:

1. class with a no-arg constructor
2. factory method returning a class with a no-arg constructor
3. class without a no-arg constructor, but a @BeanTypes(SomeInterface.class)
4. factory method of a class without a no-arg constructor but a @BeanTypes(SomeInterface.class)
5. factory method, but an interface is the return type