What is Google Guice

Google Guice is a light java dependency inversion framework using annotations. It is developed by Google(Bob Lee and Kevin Bourrillion) and it is used internally by Google for their applications. Google Guice is sometimes considered an Inversion of Control Container but as their authors state it’s not a container, it’s just an Dependency Injector, being too light to be considered a container. Beside Dependency injection Google Guice does some more AOP stuff. However in this tutorial we are going to talk only about the Dependency Injection part. In order to use Google Guice download it and add the jar from the downloaded zip to the classpath of your application.

First of all let’s take a look on what Google Guice does, then we’ll check how it’s doing it. Let’s take the following sample composed of a few classes:

Customer – contains the customer data – email address, …
Notifier – the interface used to notify a recipient. The customer object contains a reference to the Notifier object.
SendMail – an implementation of the Notify interface which notifies a client about the occurred changes by sending an email.
SendSMS – another implementation of the Notify interface notifying a client by sending an SMS.

Let’s see the code when we don’t use any dependency injection framework:

public class Customer {
      private Notifier notifier;

      public Notifier getNotifier() {
            return notifier;
      }

      public void setNotifier(Notifier notifier) {
            this.notifier = notifier;
      }

      public void changeSomething(){
            this.notifier.sendNotification("This Customer");
      }
}

public interface Notifier {

      public void sendNotification(String to);

}

public class SendMail implements Notifier{

      public void sendNotification(String to){

            System.out.println("Notifying " + to);
      }
}

public class SendSMS implements Notifier{
      public void sendNotification(String to){
            System.out.println("Notifying " + to);
      }
}

public class Main {

      public static void main(String[] args) {

            Customer customer = new Customer();
            Notifier notifier = new SendMail();
            customer.setNotifier(notifier);
            customer.changeSomething();
      }
}

Using Google Guice injector with default bindings defined through annotations.

Now lets use Guice as a dependency injector. First of all we can communicate to Guice the default implementation for the Notifier interface, by using annotations:

@ImplementedBy(SendMail.class)
public interface Notifier {
    public void sendNotification(String to);
}

Then we have to change the “application” code. Instead of using new keyword to create a new object we use the getInstance method of the injector Guice creates for us:

public static void main(String[] args) {
    Injector injector = Guice.createInjector();
    Customer customer = injector.getInstance(Customer.class);
    customer.changeSomething(); // the customer must be notified about the change
}

Then the last step, we must to tell Guice what to inject in the Customer object. We have here 3 options: Field Injection, Method Injection, Constructor Injection:

1. Field Injector – Guice will create an object of type Notifier (Guice already knows from the first step that the default implementation for Notifier is SendMail) and inject it in the field “Notifier” of the Customer object. Guice is using reflection here and the interesting part here is that it can inject into private and protected fields as well, breaking the encapsulation:

@Inject
private Notifier notifier;

2. Method Injector:

@Inject
public void setNotifier(Notifier notifier) {
    this.notifier = notifier;
}

3. Constructor Injector:

public class Customer {
…
      @Inject
      public Customer(Notifier notifier) {
            this.notifier = notifier;
      }
…
}

Defining new bindings

Well done until now, it seems we have everything in place, but what happens if we want to add another notifier class and change the default behavior? Of course we don’t want to change the annotations in the interfaces changing the default implementation. What we need is to define new bindings. To do this Guice provide a mechanism which assume the creation of another class called Module, that overwrite the bindings. Let’s say we have another Notifier class, SendSMS and we want to use it. We need to create a module class:

public class MyModule implements Module{

    public void configure(Binder binder) {
        binder.bind(Notifier.class).to(SendSMS.class);
    }
}

Now we have the class where we defined the bindings. All we have to do is to tell to the injector to use those bindings. This is how the main method looks:

public static void main(String[] args) {
    MyModule module = new  MyModule();
    Injector anotherInjector = Guice.createInjector(module);

    Customer customer = anotherInjector.getInstance(Customer.class);
    customer.changeSomething();
}

Conclusion

We’ve seen 3 main Google Guice classes in action in this tutorial. Google Guice mainly consists of those classes along with a few other classes which we haven’t seen in action yet:
Binder, Binding – classes responsible for keeping the mapping between interfaces and the implementations that has to be used.
Injector – Fulfills requests for the object instances that make up your application, always ensuring that these instances are properly injected before they are returned.
Module – defines sets of bindings. Modules classes can be used to create injectors (passing a reference to the injector constructor) so the injector uses the binding defined in this.
Provider – provides instances of the applications and can encapsulate some logic to provide one type of implementation or another depending on a context
Scope – helps defining the scope of different injected instances. By scoping Guice offer the option to reuse object instances inside a defined scope (for example reusing objects inside the scope of a session).

In a next part of the tutorial I’ll try to check in more depth what Google Guice is capable of.

Related Posts

• Guice Servlets Integration
• Multimap in Google Collections Library
• Google Guice Starts a New Google Age?
• How To Use Ant

Before giving a few examples about it, a few words about Google Collections. This is a really light java framework, build in one jar of about 300 kb. Currently only the Alpha version is released, but it doesn’t mean it’s not tested. In the Google Collection FAQ on Google Code the authors explain what 0.5 Alpha means” “We already use this library extensively in production for services like GMail, Reader, Blogger, Docs & Spreadsheets, AdWords, AdSense and dozens more. We consider it to be pretty safe. However, during the alpha period, we do reserve the right to make changes of any kind to it at any time.”

All you have to do is to download the latest Google Snapshot, unzip google-collect-snapshot-20080321.jar and then add it to your classpath. In our sample we are going to use one class and one interface (classes link to javadocs): com.google.common.collect.HashMultimap, com.google.common.collect.Multimap. Here is an example of Google Collection in action:

Multimap multimap = new HashMultimap();
multimap.put("key1", "value1A");
multimap.put("key2", "value1A");
multimap.put("key1", "value1B");
System.out.println(multimap.get("key1").toString());

Something similar using Generics:

Multimap> peoples = new HashMultimap>();

Multimap vehicles = new HashMultimap();
vehicles.put("Ferrari", "Silver Ferrari");
vehicles.put("Ferrari", "Red Ferrari");
vehicles.put("Car", "Honda Civic");
vehicles.put("Bycicle", "33 Gears Bycicle");
peoples.put("Kevin S.", vehicles);

System.out.println(peoples);

And the final snippet using some classes created by us. We use Google Collection to keep some existing ‘has’ relations:

Multimap> samepeoples = new HashMultimap>();
Multimap newvehicles = new HashMultimap();
newvehicles.put("Porsche", new Car("Silver Porsche"));
newvehicles.put("Porsche", new Car("Red Porsche"));
newvehicles.put("Car", new Car("Honda Civic"));
newvehicles.put("Bycicle", new Bycicle("33 Gears Bycicle"));
samepeoples.put(new Person("Kevin S."), newvehicles);

System.out.println(samepeoples);

The result of the test program printed to the console:

[value1B, value1A]
{Kevin S.=[{Car=[Honda Civic], Ferrari=[Red Ferrari, Silver Ferrari], Bycicle=[33 Gears Bycicle]}]}
{Kevin S.=[{Car=[Honda Civic], Porsche=[Silver Porsche, Red Porsche], Bycicle=[33 Gears Bycicle]}]}

Here are the classes I created to for the previous snippet:

class Person {
	private String name;
	public Person(String name)
	{
		this.name = name;
	}
	public String toString()
	{
		return name;
	}
}
class Vehicle {
	private String name;
	public Vehicle(String name)
	{
		this.name = name;
	}
	public String toString()
	{
		return name;
	}
}
class Car extends Vehicle {
	public Car(String name)
	{
		super(name);
	}
}
class Bycicle extends Vehicle {
	public Bycicle(String name)
	{
		super(name);
	}
}

Many situations occurred in the past when I had to organize some data in some hierarchical structures. I didn’t want to create some classes keep hierarchical structures so I used hashmaps, hashtables or even sets or lists, storing Set or some other collection as values. Some sort of sets of sets, maps of lists and so on. The Multimap comes to fulfill this need and opens the way for a multitude of uses of collections. Until now, when I thought how I used the collections I felt a little bit that I’m doing something wrong since is not something that Java Collection was providing. Now, that I know that Google has this class I feel better.

Just think to the coupling degree if we modify the classes to keep association relations. For example a Person class should be enhanced to keep collection of Vehicles so the person class will be coupled with the Vehicle interface. If we just want to add some 1-to-many relations between some existing classes, changing them might not be the best way of doing it.

Related Posts

• How to Read/Write Java Properties Files
• Google Guice Tutorial
• How To Use Ant
• How to write an Ant xml build file to Generate JAXB Code and Compile and Build it to a Jar