Finding a bean instance

[nedelva]

Suppose I have a bean factory that creates @RequestScope beans:

@Singleton
public class MyBeanFactory {
    @Bean
    @RequestScope
    public RequestScopedBean create(XmlMapper xmlMapper, Locale locale) {
        return new RequestScopedBean(xmlMapper, locale);
    }
}

Assuming I want to use RequestScopedBean instances inside my REST method, the following attempt won't work:

@Controller
HomeController {
    @Inject RequestScopedBean bean;
    //..more code
    @Get("/myResource")
    public String getResource(Locale locale) {
        //at this point I expect that a new instance of RequestScopedBean to be available in this particular
        //bean context (scope request) 
        //moreover, I want this instance has to be injected with an XmlMapper (singleton) and the "locale" Locale (request scoped)
        //bean that was discovered by the RequestLocaleResolver and put on this bean context
        bean.doStuff();
    }
}

It does not work simply because controllers have singleton scope and one cannot inject beans with narrower scope there.

So I have a few questions:

1. How could someone use ApplicationContext API to select a particular bean instance that belongs to a custom context?
2. How could I use the MyBeanFactory in the above usage scenario to obtain an instance of RequestScopedBean when needed?

Regarding point 1
In CDI this could be achieved with this fragment:

import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.spi.CDI;

@RequestScoped
public class RequestScopedBean {
    // impl here
}

public class MyClass {
    public void doSomethingWithRequestScopedBean() {
        // obtain the current instance of RequestScopedBean within the request scope
        RequestScopedBean requestScopedBean = CDI.current().select(RequestScopedBean.class).get();
        requestScopedBean.doStuff();
    }
}

[dstepanov]

It does not work simply because controllers have singleton scope and one cannot inject beans with narrower scope there.

That's not how it works; instead of RequestScopedBean, it will inject a proxy, and the proxy will delegate to the scope to extract the current instance based on the request.

[nedelva]

I stand corrected @dstepanov . Thank you for clarifying this aspect.

I still don't see how I could write the code that uses the MyBeanFactory to inject a RequestScopedBean bean into a controller..
First off, it is not even possible to create a bean factory like this one:

@Slf4j
@Singleton
@Factory
public class MyBeanFactory {
    @Bean
    @RequestScope
    public RequestScopedBean create(XmlMapper xmlMapper, Locale locale) {
        log.info("About to create a RequestScopedBean");
        return new RequestScopedBean(xmlMapper, locale);
    }
}

If we do this we get a compilation error saying

java: The produced type from a factory which has AOP proxy advice specified must define an accessible no arguments constructor. Proxying types with constructor arguments can lead to unexpected behaviour. See the javadoc for for Around.ProxyTargetConstructorMode for more information and possible solutions: create

Here is a Micronaut test that exemplifies my scenario (but without the factory):

@MicronautTest
class RequestScopedBeanFactoryTest {
    @Inject
    @Client("/")
    HttpClient httpClient;

    @BeforeAll
    static void init() {
        // Locale.setDefault(Locale.GERMAN);   /* (1) */
    }
    @Test
    void itWorks() {
        String response = httpClient.toBlocking()
                .retrieve(HttpRequest.GET("/check").header("accept-language", "de"));
        assertEquals("using locale de", response);
    }

    @Controller
    //@RequestScope /* (2) */
    public static class TestController {
        @Inject
        RequestScopedBean requestScopedBean;

        @Get("/check")
        public String check(Locale locale) {
            return "using locale " + requestScopedBean.getLocale();
        }
    }
}

Where all I can do is to define bean as:

@Getter
@Slf4j
@RequestScope
public class RequestScopedBean {
    private final XmlMapper xmlMapper;
    private final Locale locale;

    //@Inject
    public RequestScopedBean(XmlMapper xmlMapper, Locale locale) {
        this.xmlMapper = xmlMapper;
        this.locale = locale;
        //do something with it
        log.info("Using locale {}", locale);
    }
}

The test is successful only if you uncomment both lines marked with (1) and (2). This shows that:

• (1) : the RequestLocaleResolver is not able to inject the Locale into the custom scope
• (2): the RequestScopedBean is not injected into the controller UNLESS the controller is brought into the same scope as the injected bean.

[graemerocher]

as per the error message if you want to do that introduce an interface that you inject. Proxying types with constructors needs a public no args constructor by default.