Dependency/Code Injection mit Google Guice!
Den Anfang macht das Bean. Angefangen mit dem Interface
package guicedemo;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public interface Config {
public String getValue(String key);
public void setValue(String key, String value);
}
Hier die ConfigImpl:
package guicedemo;
import java.util.Map;
import java.util.HashMap;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class ConfingImpl implements Config {
private Map<String, String> prefs = new HashMap<>();
public ConfingImpl() {
super();
}
public String getValue(String key) {
return this.prefs.get(key);
}
public void setValue(String key, String value) {
this.prefs.put(key, value);
}
}
ReadController:
package guicedemo;
import com.google.inject.Inject;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class ReadController
{
private Config conf;
@Inject
public ReadController(Config conf)
{
super();
this.conf = conf;
}
public void printConfig()
{
System.out.println("Konfiguration: Test=" + this.conf.getValue("Test"));
}
}
Wie man hier sieht, hat man hier mehr keinen leeren (oder Standard) Konstruktor sondern einen mit dem Bean als Namen. Desweiteren ist das @Inject sehr wichtig (ohne dem funktioniert der ganze Zauber auch nicht).
WriteController:
package guicedemo;
import com.google.inject.Inject;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class WriteController {
private Config conf;
@Inject
public WriteController(Config conf) {
super();
this.conf = conf;
}
public void doConfig() {
this.conf.setValue("Test", "42");
}
}
Auch hier hat man wieder einen Konstruktor mit dem Interface, sowie das @Inject nicht vergessen.
Bei Google Guice hat man keine XML-Datei, was angibt welches Interface wohingebunden wird. Stattdessen macht man das in einem Interface (Module) oder einer abstrakten Klasse (AbstractModule).
Ich habe diese Konfiguration in meiner main Klasse gemacht. Indem sie von AbstractModule abgeleitet ist und die Methode configure überschreibt. Man könnte es auch über eine anonyme Klasse übergeben (so mache ich es im 2ten Bsp!).
package guicedemo;
import com.google.inject.AbstractModule;
import com.google.inject.Scopes;
import com.google.inject.Injector;
import com.google.inject.Guice;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class Main extends AbstractModule
{
public Main()
{
super();
}
@Override
protected void configure()
{
//hier wird es zugewiesen
bind(Config.class)
.to(ConfingImpl.class)
.in(Scopes.SINGLETON);
}
public static void main(String args[])
{
Injector injector = Guice.createInjector(new Main()); //holt den Injector
ReadController reader = injector.getInstance(ReadController.class); //instanziert die Klasse
reader.printConfig();
WriteController writer = injector.getInstance(WriteController.class); //nochmals die Klasse
writer.doConfig();
reader.printConfig();
}
}
Wie man sieht, MUSS man sich den Injector über eine statische Methode holen. Diesen gibt man ein Module oder ein AbstractModule an, welches ungefähr die gleiche Arbeit verrichtet, wie unter spring die XML-Datei. Es gibt an, worauf unsere Bean/Interface gebunden werden soll.
Ausgabe:
Konfiguration: Test=null Konfiguration: Test=42
Hier noch ein Bsp wie man 2 Beans konfigurieren kann. Es ist nicht zwingend notwendig, dass alle Klassen diese Beans im Konstruktor haben.
Hier das neue Interface:
package guicedemo;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public interface Demo {
public int getDemoWert();
}
Die Impl dazu:
package guicedemo;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class DemoImpl implements Demo {
private static int var = 0; // um zu sehen wie oft es instanziert wird
public DemoImpl() {
super();
var++;
}
public int getDemoWert() {
return var;
}
}
Der WriteController ist UNVERÄNDERT (also der Konstruktor hat weiterhin nur 1 Parameter).
Neuer ReadController:
package guicedemo;
import com.google.inject.Inject;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class ReadController {
private Config conf;
private Demo demo;
@Inject
public ReadController(Config conf, Demo demo) // zusätzlicher parameter
{
super();
this.conf = conf;
this.demo = demo;
}
public void printConfig() {
System.out.println("Konfiguration: Test=" + this.conf.getValue("Test") + " DEMO WERT: " + demo.getDemoWert());
}
}
Wie man sieht, hat man hier einen zusätzlichen Parameter, aber das stellt kein Problem dar.
Neue Main:
package guicedemo;
import com.google.inject.AbstractModule;
import com.google.inject.Scopes;
import com.google.inject.Injector;
import com.google.inject.Guice;
/**
* Title:
*
* Description:
*
* Copyright: Copyright (c) 2009
*
* Company:
*
* @author Taschek Joerg
* @version 1.0
*/
public class Main {
public static void main(String args[]) {
// mit anonamyer Klasse instanzieren
Injector injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
// hier wird es zugewiesen
bind(Config.class).to(ConfingImpl.class).in(Scopes.SINGLETON);
bind(Demo.class).to(DemoImpl.class).in(Scopes.SINGLETON);
}
});
ReadController reader = injector.getInstance(ReadController.class);
reader.printConfig();
WriteController writer = injector.getInstance(WriteController.class);
writer.doConfig();
reader.printConfig();
}
}
Habe den Injector auf eine anonyme Klasse umgebaut und die Ausgabe ist wiefolgt:
Konfiguration: Test=null DEMO WERT: 1 Konfiguration: Test=42 DEMO WERT: 1
Wie man sieht, geht Code Injection mit Google Guice recht leicht.
Links: Google Guice
--thE_29 17:07, 24. Marz 2009 (CET)
