#108 Consistent package naming throughout the examples

dependency-injection/src/main/java/com/iluwatar/dependency/injection/AdvancedWizard.java

@@ -0,0 +1,22 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * AdvancedWizard implements inversion of control.
+ * It depends on abstraction that can be injected through
+ * its constructor.
+ *
+ */
+public class AdvancedWizard implements Wizard {
+	
+	private Tobacco tobacco;
+
+	public AdvancedWizard(Tobacco tobacco) {
+		this.tobacco = tobacco;
+	}
+
+	@Override
+	public void smoke() {
+		tobacco.smoke(this);
+	}
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/App.java

@@ -0,0 +1,40 @@
+package com.iluwatar.dependency.injection;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
+/**
+ * 
+ * Dependency Injection pattern deals with how objects handle their dependencies. The pattern 
+ * implements so called inversion of control principle. Inversion of control has two specific rules:
+ *  - High-level modules should not depend on low-level modules. Both should depend on abstractions.
+ *  - Abstractions should not depend on details. Details should depend on abstractions.
+ *  
+ *  In this example we show you three different wizards. The first one (SimpleWizard) is a naive 
+ *  implementation violating the inversion of control principle. It depends directly on a concrete
+ *  implementation which cannot be changed.
+ *  
+ *  The second wizard (AdvancedWizard) is more flexible. It does not depend on any concrete implementation 
+ *  but abstraction. It utilizes Dependency Injection pattern allowing its Tobacco dependency to be
+ *  injected through its constructor. This way, handling the dependency is no longer the wizard's
+ *  responsibility. It is resolved outside the wizard class.
+ *  
+ *  The third example takes the pattern a step further. It uses Guice framework for Dependency Injection.
+ *  TobaccoModule binds a concrete implementation to abstraction. Injector is then used to create
+ *  GuiceWizard object with correct dependencies.
+ *
+ */
+public class App {
+	
+    public static void main( String[] args ) {
+    	SimpleWizard simpleWizard = new SimpleWizard();
+    	simpleWizard.smoke();
+    	
+    	AdvancedWizard advancedWizard = new AdvancedWizard(new SecondBreakfastTobacco());
+    	advancedWizard.smoke();
+    	
+    	Injector injector = Guice.createInjector(new TobaccoModule());
+    	GuiceWizard guiceWizard = injector.getInstance(GuiceWizard.class);
+    	guiceWizard.smoke();
+    }
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/GuiceWizard.java

@@ -0,0 +1,25 @@
+package com.iluwatar.dependency.injection;
+
+import javax.inject.Inject;
+
+/**
+ * 
+ * GuiceWizard implements inversion of control.
+ * Its dependencies are injected through its constructor
+ * by Guice framework.
+ *
+ */
+public class GuiceWizard implements Wizard {
+	
+	private Tobacco tobacco;
+	
+	@Inject
+	public GuiceWizard(Tobacco tobacco) {
+		this.tobacco = tobacco;
+	}
+
+	@Override
+	public void smoke() {
+		tobacco.smoke(this);
+	}
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/OldTobyTobacco.java

@@ -0,0 +1,9 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * OldTobyTobacco concrete Tobacco implementation
+ *
+ */
+public class OldTobyTobacco extends Tobacco {
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/RivendellTobacco.java

@@ -0,0 +1,9 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * RivendellTobacco concrete Tobacco implementation
+ *
+ */
+public class RivendellTobacco extends Tobacco {
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/SecondBreakfastTobacco.java

@@ -0,0 +1,9 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * SecondBreakfastTobacco concrete Tobacco implementation
+ *
+ */
+public class SecondBreakfastTobacco extends Tobacco {
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/SimpleWizard.java

@@ -0,0 +1,16 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * Naive Wizard implementation violating the inversion of control principle.
+ * It should depend on abstraction instead.
+ *
+ */
+public class SimpleWizard implements Wizard {
+	
+	private OldTobyTobacco tobacco = new OldTobyTobacco();
+	
+	public void smoke() {
+		tobacco.smoke(this);
+	}
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/Tobacco.java

@@ -0,0 +1,13 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * Tobacco abstraction
+ *
+ */
+public abstract class Tobacco {
+	
+	public void smoke(Wizard wizard) {
+		System.out.println(String.format("%s smoking %s", wizard.getClass().getSimpleName(), this.getClass().getSimpleName()));
+	}
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/TobaccoModule.java

@@ -0,0 +1,16 @@
+package com.iluwatar.dependency.injection;
+
+import com.google.inject.AbstractModule;
+
+/**
+ * 
+ * Guice module for binding certain concrete Tobacco implementation.
+ *
+ */
+public class TobaccoModule extends AbstractModule {
+
+	@Override
+	protected void configure() {
+		bind(Tobacco.class).to(RivendellTobacco.class);
+	}
+}

dependency-injection/src/main/java/com/iluwatar/dependency/injection/Wizard.java

@@ -0,0 +1,12 @@
+package com.iluwatar.dependency.injection;
+
+/**
+ * 
+ * Wizard interface
+ *
+ */
+public interface Wizard {
+	
+	void smoke();
+
+}