# Guice integration

Guice (pronounced 'juice') is a lightweight dependency injection framework for Java 5 and above, brought to you by Google.

We've written a piece of integration code that bridges the two IoC frameworks together. You can inject Guice defined beans into the Microcontainer and/or the other way around. See the examples for more details.

In this example we will define a Guice module, binding a simple Singleton class to one of its instances. We will then do a contextual lookup for the Singleton instance in the SingletonHolder class.

          AbstractBeanMetaData guicePlugin =
                new AbstractBeanMetaData(
                    "GuicePlugin", GuiceKernelRegistryEntryPlugin.class.getName());
          AbstractConstructorMetaData constructor =
            new AbstractConstructorMetaData();
          AbstractArrayMetaData arrayMetaData = new AbstractArrayMetaData();
          final Singleton singleton = new Singleton();
          Module module = new AbstractModule()
          {
             protected void configure()
             {
                bind(Singleton.class).toInstance(singleton);
             }
          };
          arrayMetaData.add(new AbstractValueMetaData(module));
          constructor.setParameters(
             Collections.singletonList(
                 (ParameterMetaData)new AbstractParameterMetaData(arrayMetaData)));
          guicePlugin.setConstructor(constructor);

          public class SingletonHolder
          {
             private Singleton singleton;

             @Constructor
             public SingletonHolder(@Inject Singleton singleton)
             {
                this.singleton = singleton;
             }

             public Singleton getSingleton()
             {
                return singleton;
             }
          }

          ControllerContext holderContext = controller.getInstalledContext("holder");
          assertNotNull(holderContext);
          SingletonHolder holder = (SingletonHolder)holderContext.getTarget();
          assertNotNull(holder);
          assertEquals(singleton, holder.getSingleton());

The detail that is hidden is in GuiceKernelRegistryEntryPlugin, which acts as a intermediate between the Microcontainer's registry and the Guice Injector. But all you need to do is register GuiceKernelRegistryEntryPlugin as a POJO into Microcontainer, providing Guice Modules with its constructor.

We can also go the other way around. Injecting named beans into the Guice Injector. There are a couple of ways to achieve that. Lets look at them.

          Injector injector = Guice.createInjector(new AbstractModule()
          {
             protected void configure()
             {
                bind(Controller.class).toInstance(controller);
                bind(Singleton.class).toProvider(
                   GuiceIntegration.fromMicrocontainer(
                      Singleton.class, "singleton"));
                bind(Prototype.class).toProvider(
                   GuiceIntegration.fromMicrocontainer(
                      Prototype.class, "prototype"));
             }
          });

         AbstractBeanMetaData injectorBean =
            new AbstractBeanMetaData(
                "injector", GuiceInjectorFactory.class.getName());
         AbstractConstructorMetaData constructor = new AbstractConstructorMetaData();
         constructor.setFactoryClass(GuiceInjectorFactory.class.getName());
         constructor.setFactoryMethod("createInjector");
         List<ParameterMetaData> parameters = new ArrayList<ParameterMetaData>();
         parameters.add(new AbstractParameterMetaData(
                new AbstractDependencyValueMetaData(KernelConstants.KERNEL_NAME)));
         AbstractArrayMetaData array = new AbstractArrayMetaData();
         array.add(new AbstractValueMetaData(GuiceObject.ALL));
         parameters.add(new AbstractParameterMetaData(array));
         constructor.setParameters(parameters);
         injectorBean.setConstructor(constructor);
         controller.install(injectorBean);

         ControllerContext injectorContext =
            controller.getInstalledContext("injector");
         assertNotNull(injectorContext);
         Injector injector = (Injector)injectorContext.getTarget();

          <bean name="injector" class="org.jboss.guice.plugins.GuiceInjectorFactory">
             <constructor
                    factoryClass="org.jboss.guice.plugins.GuiceInjectorFactory"
                    factoryMethod="createInjector">
                <parameter>jboss.kernel:service=Kernel</parameter>
                <parameter>
                   <array>
                      <bean name="BindAll"
                            class="org.jboss.guice.plugins.AllGuiceObject">
                         <constructor
                                factoryClass="org.jboss.guice.plugins.AllGuiceObject"
                                factoryMethod="getInstance"/>
                      </bean>
                   </array>
                </parameter>
             </constructor>
          </bean>

Here we saw three ways of using Microcontainer beans to do wiring in Guice. The first and second examples are purely programmatic and you need to provide a Controller instance. The third one is how you would bind all existing installed beans into the Guice Injector via a -beans.xml. Or you can provide a ControllerContextBindFilter instance to the binding methods to filter the beans you want to bind. See the API docs for more details.