{"id":926,"date":"2012-02-13T19:36:00","date_gmt":"2012-02-13T19:36:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/play-framework-google-guice.html"},"modified":"2012-10-21T23:02:17","modified_gmt":"2012-10-21T23:02:17","slug":"play-framework-google-guice","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2012\/02\/play-framework-google-guice.html","title":{"rendered":"Play! Framework + Google Guice"},"content":{"rendered":"
In the project I\u2019m currently working, we started to use Google Guice. For those who don\u2019t know, Google Guice<\/a> is a dependency injection framework. The basic idea behind dependency injection is to provide a class it\u2019s dependencies, instead of making the dependent class responsible of instantiating the objects on which it depends.<\/p>\n

Play has a module for integrating Guice:
\nhttp:\/\/www.playframework.org\/modules\/guice-1.2\/home<\/a><\/p>\n

In addition to the module documentation, this post from @_felipera<\/a> can help you get started.
\nhttp:\/\/geeks.aretotally.in\/dependency-injection-with-play-framework-and-google-guice<\/a><\/p>\n

How to use the Guice module<\/span><\/strong><\/p>\n

Add the dependency<\/strong><\/p>\n

require:\r\n  - play\r\n  - play -> guice 1.2\r\n<\/pre>\n
Download the dependencies<\/strong><\/p>\n
play deps\r\n<\/pre>\n
Create a new class that will be injected in the controller<\/strong>
\nservices.MyService<\/p>\n
package services;\r\npublic interface MyService {\r\n   public void sayHello();\r\n}\r\n<\/pre>\n
services.MyServiceImpl<\/p>\n
package services;\r\npublic class MyServiceImpl implements MyService {\r\n    public MyServiceImpl(){\r\n        play.Logger.info(\"constructor!\");\r\n    }\r\n\r\n    @Override\r\n    public void sayHello() {\r\n        play.Logger.info(\"hello\");\r\n    }\r\n}\r\n<\/pre>\n
Configure the injector<\/strong><\/p>\n
package config;\r\npublic class GuiceConfig extends GuiceSupport {\r\n    @Override\r\n    protected Injector configure() {\r\n        return Guice.createInjector(new AbstractModule() {\r\n            @Override\r\n            protected void configure() {\r\n                bind(MyService.class).to(MyServiceImpl.class).in(Singleton.class);\r\n            }\r\n        });\r\n    }\r\n}\r\n<\/pre>\n
This will setup the class as a singleton. Each time a class has the dependency of MyService, the injector will inject the same instance of MyServiceImpl.<\/p>\n
Inject the dependency using the @Inject annotation<\/strong><\/p>\n
package controllers;\r\npublic class Application extends Controller {\r\n\r\n    @Inject\r\n    static MyService myService;\r\n\r\n    public static void index() {\r\n        myService.sayHello();\r\n        render();\r\n    }\r\n}\r\n<\/pre>\n
Testing<\/span><\/strong>
\nMy next step was to create a test and here came the first problem<\/p>\n
play test\r\n<\/pre>\n
http:\/\/localhost:9000\/@tests<\/a>
\nCompilation error! The problem is that the module has a folder called \u2018test\u2019. This folder should have some unit or functional test, but instead it has three sample applications. The convention in play modules is to have these kind of applications in the \u2018samples-and-test\u2019 folder.<\/p>\n
I made a fork of the project to rename this folder:
\nhttps:\/\/github.com\/axelhzf\/play-guice-module<\/a>
\nI also did a pull-request but I didn\u2019t get any response so far :
\nhttps:\/\/github.com\/pk11\/play-guice-module\/pull\/5<\/a>
\nRenaming the folder \u2018test\u2019 was enough to run this test:<\/p>\n
@InjectSupport\r\npublic class InjectTest extends UnitTest {\r\n    @Inject\r\n    static MyService myService;\r\n\r\n    @Test\r\n    public void injectOk(){\r\n        assertNotNull(myService);\r\n    }\r\n}\r\n<\/pre>\n
Adding more dependencies<\/span><\/strong>
\nBy default, Play automatically detects the @Inject annotation on classes than inherit from Controller, Job and Mail. If you want to inject dependencies on other classes you must use the @InjectSupport.
\nTypically our services are not as simple as MyService. It is common to have dependencies between services. Guice solves this problem analyzing the dependencies and instantiating the objects in the proper order.
\nservices.MyDependentService
 
<\/div> <\/div><\/p>\n
package services;\r\n\r\npublic interface MyDependentService {\r\n    public void sayHelloWorld();\r\n}\r\n<\/pre>\n
service.MyDependentServiceImpl<\/p>\n
package services;\r\n\r\n@InjectSupport\r\npublic class MyDependentServiceImpl implements MyDependentService {\r\n    @Inject\r\n    static MyService myService;\r\n\r\n    public MyDependentServiceImpl(){\r\n        play.Logger.info(\"Init MyDependentServiceImpl\");\r\n    }\r\n\r\n    public void sayHelloWorld(){\r\n        myService.sayHello();\r\n        play.Logger.info(\"world\");\r\n    }\r\n}\r\n<\/pre>\n
InjectTest<\/p>\n
@InjectSupport\r\npublic class InjectTest extends UnitTest {\r\n\r\n@Inject\r\nstatic MyDependentService myDependentService;\r\n\r\n@Test\r\npublic void injectOk(){\r\n    assertNotNull(myDependentService);\r\n    myDependentService.sayHelloWorld();\r\n}\r\n\r\n}\r\n<\/pre>\n
Binding in GuiceConfig<\/p>\n
bind(MyDependentService.class).to(MyDependentServiceImpl.class).in(Singleton.class);\r\n<\/pre>\n
And this is the console output<\/p>\n
20:34:39,090 INFO ~ Init MyServiceImpl\r\n20:34:39,095 INFO ~ Init MyDependentServiceImpl\r\n20:34:39,095 INFO ~ Application 'lazySingleton' is now started !\r\n20:34:39,136 INFO ~ hello\r\n20:34:39,136 INFO ~ world\r\n<\/pre>\n
Constructor injection<\/span><\/strong>
\nOne of the things I don\u2019t like about the module is that the fields you are allowed to inject must be static. I would prefer to declare the dependencies as constructor parameters. This way, it would be more obvious that to create an instance of MyDependentServiceImpl you need a MyService instance. Moreover, when working on units test, it\u2019s easier to pass a mock objects as a parameter than to configure an injector.
\nIn the module documentation I didn\u2019t found any reference to how to do it. Nevertheless, I found an article explaining how to do this using a Provider:
\nhttp:\/\/ericlefevre.net\/wordpress\/2011\/05\/08\/play-framework-and-guice-use-providers-in-guice-modules\/<\/a>
\nLater, I found a question on StackOverflow that gave me another clue:
\nhttp:\/\/stackoverflow.com\/questions\/8435686\/does-injector-getinstance-always-call-a-constructor<\/a>
\nIn the Edit<\/em> he says that he forgot to put the @Inject annotation in the constructor. I tried to do the same thing and finally it worked:<\/p>\n
public class MyDependentServiceImpl implements MyDependentService {\r\n\r\n    private final MyService myService;\r\n    @Inject\r\n\r\n    public MyDependentServiceImpl(MyService myService){\r\n        this.myService = myService;\r\n        play.Logger.info(\"Inicializando MyDependentServiceImpl\");\r\n    }\r\n\r\n    ...\r\n<\/pre>\n
Lazy Singletons<\/span><\/strong>
\nIt still remains one last detail to have a perfect google guice configuration.
\nThe services are initialized when the application starts.<\/p>\n
21:38:11,801 INFO ~ Inicializando MyServiceImpl\r\n21:38:11,805 INFO ~ Inicializando MyDependentServiceImpl\r\n21:38:11,805 INFO ~ Application 'lazySingleton' is now started !\r\n<\/pre>\n
When the application is in production mode this is the correct behavior. But in development mode I prefer that Singletons are intialized on demand. There may be services that take their time to start and I want the application startup to be as fast as possible.<\/p>\n
With Google Guice you can achieve this using Scopes:
\nhttp:\/\/code.google.com\/p\/google-guice\/wiki\/Scopes<\/a>
\nAll you have to do is to set the Stage parameter:<\/p>\n
Stage stage = Play.mode.isDev() ? Stage.DEVELOPMENT : Stage.PRODUCTION;\r\nreturn Guice.createInjector(stage, new AbstractModule() {\u2026..\r\n<\/pre>\n
Rerunning the test<\/p>\n
22:00:03,353 WARN ~ You're running Play! in DEV mode\r\n22:00:04,615 INFO ~ Connected to jdbc:h2:mem:play;MODE=MYSQL;LOCK_MODE=0\r\n22:00:04,811 INFO ~ Guice injector created: config.GuiceConfig\r\n22:00:04,819 INFO ~ Init MyServiceImpl\r\n22:00:04,824 INFO ~ Init MyDependentServiceImpl\r\n22:00:04,824 INFO ~ Application 'lazySingleton' is now started !\r\n<\/pre>\n
Ooops! The Singleton are initialized before application starts. Perhaps that\u2019s not the correct use for the stage variable. Let\u2019s try a test:<\/p>\n
public class StageTest {\r\n\r\n    @Test\r\n    public void testDevelopment(){\r\n        Injector injector = createInjector(Stage.DEVELOPMENT);\r\n        System.out.println(\"development - before getInstance\");\r\n        MyService instance = injector.getInstance(MyService.class);\r\n        System.out.println(\"development - after getInstance\");\r\n    }\r\n\r\n    @Test\r\n    public void testProduction(){\r\n        Injector injector = createInjector(Stage.PRODUCTION);\r\n        System.out.println(\"production - before getInstance\");\r\n        MyService instance = injector.getInstance(MyService.class);\r\n        System.out.println(\"production - after getInstance\");\r\n    }\r\n\r\n    public Injector createInjector(Stage stage){\r\n        Injector injector = Guice.createInjector(stage, new AbstractModule(){\r\n            @Override\r\n            protected void configure() {\r\n                bind(MyService.class).to(MyServiceImpl.class);\r\n            }\r\n        });\r\n        return injector;\r\n    }\r\n}\r\n<\/pre>\n
And the result is:<\/p>\n
INFO: development - before getInstance\r\nINFO: Inicializando MyServiceImpl\r\nINFO: development - after getInstance\r\n\r\nINFO: Inicializando MyServiceImpl\r\nINFO: production - before getInstance\r\nINFO: production - after getInstance\r\n<\/pre>\n
Just like it says on the documentation, in development mode Singletons are initialized lazily.
\nIf this works, when I tried using the play module why didn\u2019t it work?<\/p>\n
Reviewing the code:
\nhttps:\/\/github.com\/pk11\/play-guice-module\/blob\/master\/src\/play\/modules\/guice\/GuicePlugin.java<\/a>
\n@OnApplicationStart the module finds all classes annotated with @InjectSupport and inject it\u2019s dependencies. To inject the dependencies the module calls the getBean() method. And here we find the problem: when calling getBean() the class is instantiated.<\/p>\n
I found a solution to this problem:
\nhttps:\/\/groups.google.com\/d\/msg\/google-guice\/405HVgnCzsQ\/fBUuueP6NfsJ<\/a>
\nThis is the code:<\/p>\n