Dependency Injection with Guice

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

It uses power of Java 5 Annotations to replace new with @Inject.

Before delving into the new framework, lets recapture "Dependency Injection"

Before starting a surgery, the surgeon makes sure, whatever required to complete the surgery procedure are readily available.

The surgery assistant does the prep work and manages everything available before calling the surgeon to start. Imagine how horrible it would be for a surgeon to do the prep work during the surgery itself. It would leave enormous amount of risk on critical operation.

Similarly for a TransactionMananger to act on a transaction,it may depend on - Source Account, Receiver Account, Transaction modes etc.

If the transaction manager works on gathering the dependencies during the transaction, it will not only affect the transaction time , but can also impact on quality which can lead to errors.

If an assistant makes sure, TransactionManager gets everything it requires before starting the transaction, the TM can just focus and ensure smoother transaction. If at all there is any error, it will be very easy to find out as responsibilities are way clear off.

This is what called as "Dependency Injection". In other words "Dont call me. I will call you".

public class TransactionManager{

Account sourceAccount;
Account receiverAccount;
Double amount;

void transfer(){
this.sourceAccount.debit(this.amount) ;
this.receiverAccount.credit(this.amount);
}

}

public class Account{

long accountNo;
String name;

void debit(int a){
}

void credit(int a){

}

}

The dependencies of TransactionManager are sourceAccount and receiverAccount. All these dependencies are injected by an assistant - called - Inversion of Control Engine. [IoC Engine]

The IoC engine just requires following configuration to perform this.

< bean name="transactionManager" class="TransactionManager" >
< property name="sourceAccount" ref="sourceAccount"/>
< property name="receiverAccount" ref="receiverAccount"/>
< property name="amount" value="100"/>
</bean >

< bean name="sourceAccount" class="Account" >
< property name="accountNo" value="123" />
< property name="accountName" value="first last" />
</ bean >

< bean name="receiverAccount" class="Account" >
< property name="accountNo" value="89234" />
< property name="accountName" value="xyz man" />
</ bean >



Without dependency injection the transfer() would have been like this

void transfer(){
Account sourceAccount=new Account();
sourceAccount.setAccountNo(123);
sourceAccount.setName("first last");

Account receiverAccount=new Account();
receiverAccount.setAccountNo("89234");
receiverAccount.setName("xyz man");

sourceAccount.debit(100);
receiverAccount.credit(100);

}


Instead of tying the dependencies too tightly and mixing with core functionality, the assistant [IoC - Inversion of Control or Dependency Injection Engine] makes sure all the dependencies are readily available when required.

This not only makes the surgeon [TransactionManager] job easier, but also ensures testability and maintenance. If the amount or Account implementation changes in future, its very easy to update the code. Just change the configuration and you all done. The IOC will keep you updated and will deliver you all dependencies at required time


Refer for more info.
http://code.google.com/p/google-guice/