DI 注入的三种方式

最近在看spring in action，提到di注入的三种方式，觉得挺有意思。

1. set 注入

2. 构造函数注入

3. 方法注入

相对来说1,2 比较容易，3因为用到反射，有一种偷梁换柱的感觉，很好很强大。

--玩杂技

public interface Juggler {
void perform();
}

--诗人

public interface Poem {
void recite();
}

--会玩杂技的诗人

public class PoeticJuggler implements Juggler {

private Poem poem;

public PoeticJuggler() {
super();
// TODO Auto-generated constructor stub
}

--constructor DI

public PoeticJuggler(Poem poem) {
super();
this.poem = poem;
}

@Override
public void perform() {
DebugLog.log("i am performing");
poem.recite();
}

public Poem getPoem() {
return poem;
}

-- setter DI

public void setPoem(Poem poem) {
this.poem = poem;
}

}

public class PushKin implements Poem {

@Override
public void recite() {
DebugLog.log("love ...love ... love...");
}

}

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
//constructor
Juggler juggler=new PoeticJuggler(new PushKin());
juggler.perform();

//setter
PoeticJuggler poeticJuggler=new PoeticJuggler();
poeticJuggler.setPoem(new PushKin());
poeticJuggler.perform();
}

}

RESULT:

Test.main():11i am performing
PoeticJuggler.perform():22love ...love ... love...
Test.main():16i am performing
PoeticJuggler.perform():22love ...love ... love...

方法注入就不一样了：

我们经常看到魔术师将美女助手变成老虎，现在就用这个为例：

public class DummyMagicBoxImp implements MagicBox {

@Override
public String getContents() {
return "a beautiful assistance";
}

}

public interface MagicBox {
String getContents();
}

public class Magician implements Performer {
private MagicBox magicbox;

public void setMagicbox(MagicBox magicbox) {
this.magicbox = magicbox;
}

public Magician(MagicBox magicbox) {
super();
this.magicbox = magicbox;
}

@Override
public void perform() {

//念魔法
DebugLog.log("magic words");

//美女 or 老虎
DebugLog.log(magicbox.getContents());
}

}

public class MethodReplaceHandler implements InvocationHandler {

private Object dimmytarget;
private Object realTarget;
private static MethodReplaceHandler hander;

public void setRealTarget(Object realTarget) {
this.realTarget = realTarget;
}

private MethodReplaceHandler(Object dpObj) {
this.dimmytarget = dpObj;
}

public static Object factory(Object obj) {
Class cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),
cls.getInterfaces(), getInstance(obj));
}

public static synchronized MethodReplaceHandler getInstance(Object obj) {
if (hander == null) {
hander = new MethodReplaceHandler(obj);
}
return hander;
}

public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
DebugLog.log("start dymanic proxy");
Object obj = null;
if(dimmytarget !=null)
obj = method.invoke(dimmytarget, args);
if(realTarget !=null)
obj = method.invoke(realTarget, args);

DebugLog.log("end dymanic proxy");
return obj;
}

}

public interface Performer {
void perform();
}

public class RealMagicBoxImp implements MagicBox {

@Override
public String getContents() {
return "a ferocious tiger";
}

}

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
//before magic
MagicBox magicbox=new DummyMagicBoxImp();
Magician magician=new Magician(magicbox);
Performer houseProcedure = (Performer)MethodReplaceHandler.factory(magician);
houseProcedure.perform();

//magic
MethodReplaceHandler handler= MethodReplaceHandler.getInstance(magicbox);
magician.setMagicbox(new RealMagicBoxImp());
handler.setRealTarget(magician);
houseProcedure.perform();
}

}

RESULT:

$Proxy0.perform():-1start dymanic proxy
NativeMethodAccessorImpl.invoke0():-2magic words
NativeMethodAccessorImpl.invoke0():-2a beautiful assistance
$Proxy0.perform():-1end dymanic proxy
$Proxy0.perform():-1start dymanic proxy
NativeMethodAccessorImpl.invoke0():-2magic words
NativeMethodAccessorImpl.invoke0():-2a ferocious tiger
NativeMethodAccessorImpl.invoke0():-2magic words
NativeMethodAccessorImpl.invoke0():-2a ferocious tiger
$Proxy0.perform():-1end dymanic proxy