Possible Java Implementations

Traditional simple way

    public class Singleton {
        private static final Singleton INSTANCE = new Singleton();

        // Private constructor prevents instantiation from other classes
        private Singleton() {}

        public static Singleton getInstance() {
            return INSTANCE;
        }
    }

The solution of Bill Pugh

    public class Singleton {
        // Private constructor prevents instantiation from other classes
        private Singleton() {}

        /**
        * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
        * or the first access to SingletonHolder.INSTANCE, not before.
        */
        private static class SingletonHolder { 
            private static final Singleton INSTANCE = new Singleton();
        }

        public static Singleton getInstance() {
            return SingletonHolder.INSTANCE;
        }
    }    

Java 5 Way! a.k.a Joshua Bloch way.

    public enum Singleton {
        INSTANCE;
        public void myUsefulMethod1(){...}
        ...
    } 
    
    Usage: Singleton.INSTANCE.myUsefulMethod1();

Typical implementation

    // Correct but possibly expensive multithreaded version    class Foo {         private Helper helper = null;        public synchronized Helper getHelper() {            if (helper == null)                helper = new Helper();            return helper;        }

        // other functions and members...    }

Notes: The overhead of acquiring and releasing a lock every time this method is called seems unnecessary. Once the initialization has been completed, acquiring and releasing the locks would appear unnecessary.

DCL using Java 5 Memory Model

    // Works with acquire/release semantics for volatile    // Broken under Java 1.4 and earlier semantics for volatile    class Foo {        private volatile Helper helper = null;        public Helper getHelper() {            if (helper == null) {                synchronized(this) {                    if (helper == null)                        helper = new Helper();                }            }            return helper;        }

        // other functions and members...    }

Notes: Java 5 and later extends the semantics for volatile so that the system will not allow a write of a volatile to be reordered with respect to any previous read or write, and a read of a volatile cannot be reordered with respect to any following read or write.

DCL using Thread Local Storage

    class Foo {        /**          *  If perThreadInstance.get() returns a non-null value, this thread         *  has done synchronization needed to see initialization         *  of helper          */        private final ThreadLocal perThreadInstance = new ThreadLocal();        private Helper helper = null;        public Helper getHelper() {            if (perThreadInstance.get() == null)                 createHelper();            return helper;        }        private final void createHelper() {            synchronized(this) {                if (helper == null)                    helper = new Helper();            }            // Any non-null value would do as the argument here            perThreadInstance.set(perThreadInstance);        }    }    

Notes: Each thread keeps a thread local flag to determine whether that thread has done the required synchronization.

Credits: Wiki

Creating a simple DI application

//Service Receiver.
public class Chef {
    private final FortuneService fortuneService;

    @Inject
    public Chef(FortuneService fortuneService) {
        this.fortuneService = fortuneService;
    }

    public void makeFortuneCookie() {
        new FortuneCookie(fortuneService.randomFortune());
    }
}

//Service Provider -- Implementation 1
public class FortuneServiceImpl implements FortuneService {
    private static final List<string> MESSAGES =
        Arrays.asList(
         "Today you will have some refreshing juice.",
         "Larry just bought your company."
    );

    public String randomFortune() {
        return MESSAGES.get(new Random().nextInt(MESSAGES.size()));
    }
}

//Configuration Module
public class ChefModule implements Module {  //can 'implements Module' or 'extends AbstractModule'
    public void configure(Binder binder) {
        binder.bind(FortuneService.class)
        .to(FortuneServiceImpl.class)
        .in(Scopes.SINGLETON);
    }
}

//Bootstraping 
public class FortuneApplication {   
    public static void main(String[] args) {
        Injector i = Guice.createInjector(new ChefModule());   // Can also be Injector i = Guice.createInjector(Stage.PRODUCTION, new ChefModule(),...); i.e 1 or more modules
        Chef chef = i.getInstance(Chef.class); //which is same as i.getInstance(Key.get(Chef.class));
        chef.makeFortuneCookie();
    }
}

Here is the sequence diagram of the above code snippet at runtime.

Guice.createInjector(new ChefModule());

ChefModule.configure(Binder binder);

The following is the Guice Runtime Model

Note: The above code snippet uses Key.Type. It does not use any annotation

DI with annotations — ‘choosing between implementations’

Using the above Interface (i.e FortuneService) & Implemementation (i.e FortuneServiceImpl)

//Service Provider -- Implementation 2
public class MegaFortuneService implements FortuneService {
 private static final List<fortuneservice> SERVICES =
     Arrays.<fortuneservice>asList(
         new FunnyFortuneService(),
        new QuoteFortuneService()
     );

 public String randomFortune() {
     int index = new Random().nextInt(SERVICES.size());
     return SERVICES.get(index).randomFortune();
 }
}

//Configuration Module
public class CommonSenseModule extends AbstractModule {
 protected void configure() {
     bind(FortuneService.class).to(FortuneServiceImpl.class);
     bind(FortuneService.class).to(MegaFortuneService.class); //ERROR!!!
 }
}

Hence, we need a better means to tell Guice to use MegaFortuneService. Using 'Binding Annotations' would resolve this problem.

//Service Receiver.
public class Chef {
 private final FortuneService fortuneService;

 @Inject
 public Chef(@Mega FortuneService fortuneService) {  //Updated Usage!
     this.fortuneService = fortuneService;
 }

 public String randomFortune() {
     return MESSAGES.get(new Random().nextInt(MESSAGES.size()));
 }
}

//Module class.
public class ChefModule extends AbstractModule {
 protected void configure() {
     bind(FortuneService.class).to(FortuneServiceImpl.class);
     bind(FortuneService.class)
         .annotatedWith(Mega.class)        //Add annotation key!
         .to(MegaFortuneService.class);
 }
}

//Annotation class.
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@BindingAnnotation
public @interface Mega {}


//Bootstraping
public class FortuneApplication {   //Main class
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new ChefModule());   // Can also be Injector i = Guice.createInjector(Stage.PRODUCTION, new ChefModule());
     Chef chef = i.getInstance(Key.get(FortuneService.class, Mega.class));  //Refer: http://docs.google.com/File?id=dd2fhx4z_30f3dppc
     chef.makeFortuneCookie();
 }
}

Implicit Binding – @ImplementedBy

//Service Provider
@ImplementedBy(FortuneServiceImpl.class)  //Implicit binding. Note: Module configuration i.e bind(FortuneService.class).to(FortuneServiceImpl.class) would still take precidence over this.
public interface FortuneService {
 String randomFortune();
}

//Service Receiver.
public class Chef {
 private final FortuneService fortuneService;

 @Inject
 public Chef(FortuneService fortuneService) {
     this.fortuneService = fortuneService;
 }

 public void makeFortuneCookie() {
     new FortuneCookie(fortuneService.randomFortune());
 }
}

//Service Provider -- Implementation 1
public class FortuneServiceImpl implements FortuneService {
 private static final List<string> MESSAGES =
     Arrays.asList(
         "Today you will have some refreshing juice.",
         "Larry just bought your company."
     );

 public String randomFortune() {
     return MESSAGES.get(new Random().nextInt(MESSAGES.size()));
 }
}

Notice that, 'ChefModule' is not required for default configuration.
</string></pre>

<span style=";font-family:verdana;font-size:130%;"  >Scoping</span>
[sourcecode language='java']
public class ChefModule extends AbstractModule {
 protected void configure() {
     bind(FortuneService.class)
         .to(FortuneServiceImpl.class)
         .in(Singleton.class);  //Either Singleton.class or Scopes.SINGLETON
     bind(FortuneService.class)
         .annotatedWith(Mega.class)
         .to(MegaFortuneService.class)
         .asEagerSingleton(); //Do singletons load lazily or eagerly?

 }
}

Guice Provider

A Provider implementation is basically a small factory class that Guice will invoke whenever it needs an instance of the given type.

public class Gum {}

public class GumballMachine {
 @Inject
 private Provider<gum> gumProvider;

 public Gum dispense() {
     return gumProvider.get();
 }
}

public class GumProvider implements Provider<gum> {
 public Gum get() {
     return new Gum();
 }
}

public class GumModule extends AbstractModule {
 protected void configure() {
     bind(Gum.class).toProvider(GumProvider.class);
 }
}

public class GumballExample {
 public static void main(String[] args) {
     Injector injector = Guice.createInjector(new GumModule());
     GumballMachine m = injector.getInstance(GumballMachine.class);
     System.out.println(m.dispense());  // Gum@10f11b8
     System.out.println(m.dispense());  // Gum@544ec1
 }
}

Injecting into Provider:
public class BlueGumProvider implements Provider<gum> {
 @Inject Color color;
 public Gum get() {
     return new Gum(color);
 }
}

Implict Binding – @ProvidedBy

Similar to @ImplementedBy</pre>

<span style=";font-family:verdana;font-size:130%;"  >Using @Named</span>
[sourcecode language='java']
@Named is a OOTB annotation, that uses string identifier to differentiate among different bindings.

//Service Consumer
public class ActionMovie {
 @Inject @Named("stallone")
 private Actor actor;
}

Module code snippet:
 bind(Actor.class).annotatedWith(Names.named("stallone")).to(...); //Note: The usual way of using annotations, 'bind(Actor.class).annotatedWith(Named.class).to(...);' will NOT work.
</pre>

<span style=";font-family:verdana;font-size:130%;"  >Binding Constants</span>
[sourcecode language='java']
//Service Consumer
public class ConcertHall {
 @Inject @Named("capacity")
 private int capacity;

 @Inject @Named("stage")
 private Class stageType;

 @Inject @Named("setting")
 private Setting setting;

 public String toString() {
     return String.format("%s[capacity=%s, stageType=%s, setting=%s]",
                          getClass().getName(), capacity, stageType, setting);
 }
}

//Another service provider with package "somepackage"
public class BigStage {}

//Service Configuration
public class ConcertModule extends AbstractModule {
 protected void configure() {
     bindConstant()
         .annotatedWith(Names.named("capacity"))
         .to("322");
     bindConstant()
         .annotatedWith(Names.named("stage"))
         .to("somepackage.BigStage");
     bindConstant()
         .annotatedWith(Names.named("setting"))
         .to("INDOOR");
 }
}

//Bootstraping
public class ConcertExample {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new ConcertModule());
     ConcertHall hall = i.getInstance(ConcertHall.class);
     System.out.println(hall);  //Outputs, ConcertHall[capacity=322, stageType=class somepackage.BigStage, setting=INDOOR]
 }
}

A better way of binding, especially while using generic types.
//Service Consumer
public class LongHolder {
 @Inject @Named("long")
 @Inject @Named("list") List<string> strings;
 @Inject @Named("list") List<integer> integers;
 private Long theLong;
}

//Service Configuration
public class LongModule extends AbstractModule {
 protected void configure() {
     bind(Long.class)
     .annotatedWith(Names.named("long"))
     .toInstance(123L); 
 bind(new TypeLiteral<list><string>>(){})
         .annotatedWith(Names.named("list"))
         .to(new TypeLiteral<arraylist><string>>(){});
     bind(new TypeLiteral<list><integer>>(){})
         .annotatedWith(Names.named("list"))
         .to(new TypeLiteral<arraylist><integer>>(){});

 }
}

//Bootstraping
public class LongHolderExample {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new LongModule());
     i.getInstance(LongHolder.class);
 }
}

//A more readable Service Configuration that can deal with types. --- Essentially the same functionality.
public class TypeLiteralModule extends AbstractModule {
 protected void configure() {
     bind(listOf(String.class))
         .annotatedWith(Names.named("list"))
         .to(arrayListOf(String.class));
     bind(listOf(Integer.class))
         .annotatedWith(Names.named("list"))
         .to(arrayListOf(Integer.class));
 }

 @SuppressWarnings("unchecked")
 static <t> TypeLiteral<list><t>> listOf(final Class<t> parameterType) {
     return (TypeLiteral<list><t>>) TypeLiteral.get(new ParameterizedType() {
         public Type[] getActualTypeArguments(){return new Type[] {parameterType};}
         public Type getRawType() { return List.class; }
         public Type getOwnerType() { return null; }
     }
 );
 }

 @SuppressWarnings("unchecked")
 static <t> TypeLiteral<arraylist><t>> arrayListOf(final Class<t> parameterType) {
     return (TypeLiteral<arraylist><t>>) TypeLiteral.get(new ParameterizedType() {
         public Type[] getActualTypeArguments(){return new Type[] {parameterType};}
         public Type getRawType() { return ArrayList.class; }
 }
 );
 }
}

Properties

Sample property file: db.properties
db.url = jdbc:mysql://localhost/test
db.driver = com.mysql.jdbc.Driver
db.user = test
db.password = test

public class PropertiesModule extends AbstractModule {
 protected void configure() {
     try {
         Properties databaseProperties = loadProperties("db.properties");
         Names.bindProperties(binder(), databaseProperties);
     } catch (RuntimeException e) {
         addError("Could not configure database properties", e);
   }
 }

 private static Properties loadProperties(String name) { //loads file as java.util.Properties
     Properties properties = new Properties();
     InputStream is = new Object(){}
                         .getClass()
                         .getEnclosingClass()
                         .getResourceAsStream(name);
     try {
      properties.load(is);
     } catch(IOException e) {
         throw new RuntimeException(e);
     } finally {
         if (is != null) {
            try {
                is.close();
            } catch (IOException dontCare) {}
         }
     }
     return properties;
 }
}

public class PropertiesExample {
 @Inject
 public void databaseURL(@Named("db.url") String url) {
     System.out.println(url);
 }

 public static void main(String[] args) {
     Injector i = Guice.createInjector(new PropertiesModule());
     i.getInstance(PropertiesExample.class);  //Output: jdbc:mysql://localhost/test.
 }
}

Static Injection

public class StaticModule extends AbstractModule {
 protected void configure() {
     bindConstant().annotatedWith(Names.named("s")).to("D'OH!");
     requestStaticInjection(StaticInjection.class);
 }
}

public class StaticInjection {
 @Inject
 public static void staticMethod(@Named("s") String str) {
     System.out.println(str); //Output: D'OH!
 }

 public static void main(String[] args) {
     Guice.createInjector(new StaticModule());
 }
}

Custom Scope

public class CustomScopes {
 public static final Scope DEFAULT = new Scope() {
     public <t> Provider<t> scope(Key<t> key, Provider<t> creator) {
         System.out.println("Scoping "+key);
         return creator;
     }
     public String toString() {
         return CustomScopes.class.getSimpleName()+".DEFAULT";
     }
 };
}

public class Person {
 public Person() {
     System.out.printf("Hi, I'm a Person. With hashCode '%s', I'm unique!%n", super.hashCode());
 }
}

public class CustomScopeModule extends AbstractModule {
 protected void configure() {
     bind(Person.class).in(CustomScopes.DEFAULT);
 }
}

public class UseCustomScope {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new CustomScopeModule());
     i.getInstance(Person.class);  //Output: Hi, I'm a Person. With hashCode '7841785', I'm unique!
     i.getInstance(Person.class);  //Output: Hi, I'm a Person. With hashCode '1847634', I'm unique!
 }
}

Using custom scope as an annotation,

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@ScopeAnnotation
public @interface DefaultScoped {}

@DefaultScoped
public class Person {
 public Person() {
     System.out.printf("Hi, I'm a Person. With hashCode '%s', I'm unique!%n", super.hashCode());
 }
}

public class CustomScopeModule extends AbstractModule {
 protected void configure() {
     bindScope(DefaultScoped.class, CustomScopes.DEFAULT);  //CustomScopes.DEFAULT is defined in the previous example.
 }
}

public class UseCustomScope {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new CustomScopeModule());
     i.getInstance(Person.class);  //Output: Hi, I'm a Person. With hashCode '7841785', I'm unique!
     i.getInstance(Person.class);  //Output: Hi, I'm a Person. With hashCode '1847634', I'm unique!
 }
}

Organizing Modules

If a project has more than a module (i.e service configurations), then...

public class ApplicationModule extends AbstractModule {
 protected void configure() {
     install(new DefaultScopeModule());  //Install all the modules in the order of depedency?
     install(new BindingsModule());
 }
}

public class UseCustomScopeWithApplicationModule {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new ApplicationModule());
     i.getInstance(Person.class);
     i.getInstance(Person.class);
 }
}

AOP (using) Guice

//The class that would be intercepted.
public class Phone {
 private static final Map<number, receiver=""> RECEIVERS =
     new HashMap<number, receiver="">();

 static {
     RECEIVERS.put(123456789, new Receiver("Aunt Jane"));
 }

 public Receiver call(Number number) {
     return RECEIVERS.get(number);
 }
}

public class Receiver {
 private final String name;
 public Receiver(String name) {
     this.name = name;
 }
 public String toString() {
     return String.format("%s[name=%s]", getClass().getName(), name);
 }
}


import static com.google.inject.matcher.Matchers.*;
public class PhoneModule extends AbstractModule {
 protected void configure() {
     bindInterceptor(
         subclassesOf(Phone.class),       //Class Constraint   //any(), not(...), annotatedWith(...), subclassesOf(...), only(...), identicalTo(...), inPackage(...)
         returns(only(Receiver.class)),   //Method Constraint  //any(), not(...), annotatedWith(...), only(...), identicalTo(...), returns(...)
         new PhoneLoggerInterceptor(),
     new PhoneRedirectInterceptor()
   );
 }
}


public class PhoneLoggerInterceptor implements MethodInterceptor {
 public Object invoke(MethodInvocation invocation) throws Throwable {
     for (Object arg : invocation.getArguments())
         if (arg instanceof Number)
            System.out.println("CALL: "+arg);

     return invocation.proceed();
 }
}

public class PhoneRedirectInterceptor implements MethodInterceptor {
 public Object invoke(MethodInvocation invocation) throws Throwable {
     return new Receiver("Alberto's Pizza Place");
 }
}

//Bootstrap...
public class MakePhoneCall {
 public static void main(String[] args) {
     Injector i = Guice.createInjector(new PhoneModule());
 Phone phone = i.getInstance(Phone.class);
     Receiver auntJane = phone.call(123456789); //Output:  CALL: 123456789 Receiver[name=Alberto's Pizza Place]
 }
}

Credits: APRESS – Google Guice: Agile Lightweight Dependency Injection Framework, Guice User’s Guice