Use of TypeLiteral in java

Question

Please provide some basic information of how TypeLiteral in Google Guice or Java EE is used, It will be very helpful if it would be explained using a simple code, thanks in

Answer 1

Like anything in Guice - modularity, reusability, and removal of boilerplate are core concepts of all utilities.

Of course, anything you do in Guice can be mimicked in Java - at the cost of lots of boilerplate So... the real question is :

How can we USE TypeLiterals to write more modular/reusable components ?

The power of TypeLiterals in Guice is that it allows you to refernce implementations of a service without defining what that service is.

Lets start with a simple list in a program where we have many types of lists that are processed differntly :

List myStringList = new ArrayList();

Now, how should I process these Strings ? At runtime, there is no way to "know" that its a String list. So, often times I might create a factory, like so , that gets processing objects for me :

ProcessorFactory.get(String.class).process(myStringList); 

Thus, I might use a factory (with a bunch of if/else or case statements) to define processors for different data types. My constructor, for the object which uses these processors, and which needs access to various Processor Implementations, might look like this :

public MyClass(Processor strProcessor, Processor intProcessor)P
{
    //Simple enough, but alot of boiler plate is required to launch this constructor.
}

//and to invoke 
new MyClass(PRocessorFactory.get(....), ProcessorFactory.get(...)); 

All good so far... Until we realize that there is a better way :

In the Guice world, I can forget about writing this factory - rather, I can explicitly BIND classes to processors. The advantage of this is that there are no static dependencies - the class which needs to USE processor implementations DOES NOT need any static dependency on a factory -rather, the classes are directly injected. Thus, I can easily define a class which uses complex dependencies, without having to build a factory aware class builder... Thus, I have far less boilerplate :

@Inject
public MyClass(Processor implStr, Processor implInt)
{
   //Now , this method will work magically, because Guice is capable of  
   //Using the loaded modules, which define bindings between generics and their implementations
}

//Elsewhere I simply define a single guice module that does the binding, and make sure to load it before my application launches. 

There is a good tutorial on this with interface implementations and binding examples, here : http://thejavablog.wordpress.com/2008/11/17/how-to-inject-a-generic-interface-using-guice/