最近在看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