Guice injection not working in web application
1,009 views
Skip to first unread message
Adil Quraish
Jun 18, 2018, 11:19:46 AM6/18/18
to google-guice
I am trying to get Guice to work in a web application deployed on JBoss EAP 6.4 When I try to step through the Guice code, I notice that the binding is happening. However, when I try to inject the bound object, I always get null. The following are the code changes I have done to enable Guice -
1) web.xml
<listener>
<listener-class>com.univeris.guice.GuiceConfig</listener-class>
</listener>
<filter>
<filter-name>guiceFilter</filter-name>
<filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>guiceFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
2) GuiceConfig
@Singleton
public class GuiceConfig extends GuiceServletContextListener {
@Override
protected Injector getInjector() {
Injector injector = Guice.createInjector(
new ServletModule() {
@Override
protected void configureServlets() {
serve("/uif/*").with(UIFInitializeServlet.class);
serve("/upm/*").with(IDPServlet.class, ImmutableMap.of("instance-name","upm"));
serve("/uiw/*").with(IDPServlet.class, ImmutableMap.of("instance-name","uiw"));
}
},
new MainModule()
);
return injector;
}
}
3) MainModule
public class MainModule extends AbstractModule {
@Override
protected void configure() {
install(new BankAccountModule());
install(new CoreModule());
}
}
4) BankAccountModule
public class BankAccountModule extends AbstractModule {
@Override
protected void configure() {
bind(BankAccountProvider.class).toProvider(BankAccountGuiceProvider.class);
bind(BankAccountService.class).toProvider(BankAccountServiceProvider.class);
}
}
5) BankAccountGuiceProvider
public class BankAccountGuiceProvider implements Provider<BankAccountProvider> {
@Override
public BankAccountProvider get() {
return ProviderLocator.locateProvider(BankAccountProvider.class);
}
}
6) BankAccountServiceUVS
@Stateless
@Interceptors(ServiceInterceptor.class)
public class BankAccountServiceUVS implements BankAccountService {
@Inject
private BankAccountProvider _bankAccountProvider;
@Override
public BankAccountCollection getAllBankAccounts(final Integer entityId, final String entityType) {
BankAccountCollection retVal = _bankAccountProvider.getAllBankAccounts(entityId,
return PojoHelper.cloneObject(retVal);
}
}
The _bankAccountProvider is always injected as null. I have been pouring through several forums for several days to no avail. Can someone point out what I am missing?
Stephan Classen
Jun 18, 2018, 6:44:07 PM6/18/18
to google...@googlegroups.com
Unless you tell guice that a dependency is optional it will never inject null. It would fail with an exception if it could not fullfil a dependency.
So for me the most likely cause of you seeing null is that the instance you are inspecting is created by calling new, using reflection or by another DI framework (like CDI or Spring).
Best strategy to debug this would be to make the field
_bankAccountProvider final. Then create a constructor to pass in the instance and annotate the constructor with @Inject.
Now you can place a breakpoint in the constructor. This will show you who is creating the instance. And if somebody is calling new the compiler may already tell you before you execute the code.
By the way: I would always favour constructor injection over field injection
- because it makes writing tests simpler (just call the constructor from your test class)
- an ugly constructor with 5+ arguments smells stronger than 5+ fields with annotation. And this is good because having that many dependency is often a sign that a class has too many responsebilities...
So for me the most likely cause of you seeing null is that the instance you are inspecting is created by calling new, using reflection or by another DI framework (like CDI or Spring).
Best strategy to debug this would be to make the field
_bankAccountProvider final. Then create a constructor to pass in the instance and annotate the constructor with @Inject.
Now you can place a breakpoint in the constructor. This will show you who is creating the instance. And if somebody is calling new the compiler may already tell you before you execute the code.
By the way: I would always favour constructor injection over field injection
- because it makes writing tests simpler (just call the constructor from your test class)
- an ugly constructor with 5+ arguments smells stronger than 5+ fields with annotation. And this is good because having that many dependency is often a sign that a class has too many responsebilities...
Thomas Broyer
Jun 19, 2018, 4:21:57 AM6/19/18
to google-guice
On Tuesday, June 19, 2018 at 12:44:07 AM UTC+2, scl wrote:
Unless you tell guice that a dependency is optional it will never inject null. It would fail with an exception if it could not fullfil a dependency.
So for me the most likely cause of you seeing null is that the instance you are inspecting is created by calling new, using reflection or by another DI framework (like CDI or Spring).
Best strategy to debug this would be to make the field
_bankAccountProvider final. Then create a constructor to pass in the instance and annotate the constructor with @Inject.
Now you can place a breakpoint in the constructor. This will show you who is creating the instance. And if somebody is calling new the compiler may already tell you before you execute the code.
…and in case something else than Guice has to create the instance, then you can injectMembers on the instance to have the fields (and methods) injected by Guice; either using a MembersInjector (that you could have @Inject⋅ed into your Provider) or Injector#injectMembers (which implies that you have access to the Injector at that point; the Injector can be @Inject⋅ed too into your provider, but I'd recommend using a MembersInjector instead).
By the way: I would always favour constructor injection over field injection
- because it makes writing tests simpler (just call the constructor from your test class)
- an ugly constructor with 5+ arguments smells stronger than 5+ fields with annotation. And this is good because having that many dependency is often a sign that a class has too many responsebilities...
+1
see also https://github.com/google/guice/wiki/MinimizeMutability (and other best practices in the wiki)
Adil Quraish
Jun 22, 2018, 1:21:38 PM6/22/18
to google-guice
Thanks. Based on your suggestion, I have modified BankAccountServiceProvider as follows -
Now I end up getting the following exception -
public class BankAccountServiceProvider implements Provider<BankAccountService> {
@Inject
private MembersInjector<BankAccountService> membersInjector;
@Override
public BankAccountService get() {
BankAccountService bankAccountService = ServiceLocator.locateService(BankAccountService.class);
membersInjector.injectMembers(bankAccountService);
return bankAccountService;
}
}
Now I end up getting the following exception -
Reply all
Reply to author
Forward
0 new messages