靜態：
首先需要一個接口
public interface Neting {
public void netting();
public String playGame(String name);
}
然后需要一個實例去繼承：
public class NetImpl implements Neting {
@Override
public void netting() {
System.out.println("上網中....");
}
@Override
public String playGame(String name) {
System.out.println("游戲中....");
return "game over";
}
}
最后需要一個同樣實現了相同接口的類來做代理，并在每個方法中加入需要的操作：
public class NetingImplProxy implements Neting {
private Neting neting;
public NetingImplProxy(Neting neting){
this.neting=neting;
}
@Override
public void netting() {
this.up();
neting.netting();
this.down();
}
@Override
public String playGame(String name) {
this.up();
String str=neting.playGame(name);
this.down();
return str;
}
private void up(){
System.out.println("撥號中");
}
private void down(){
System.out.println("斷開中");
}
}
這樣產生的結果是每次更改方法中固定的操作時，都需要更改類的源代碼，帶來很多不便，由此產生動態代理。
動態代理需要一個Proxy類和invocationhandle接口來支持：
同樣，上述的接口和實現類都不變，不再需要代理類，而是由下面這個類動態產生：
public class NetHandle implements InvocationHandler {
//首先需要傳一個目標對象的引用
private Object targetObject;
//設置構造方法時，直接將目標對象作為參數傳入
public NetHandle(Object targetObject){
this.targetObject=targetObject;
}
//這是至關重要的，由此類實例的本方法產生一個$...代理對象：
public Object createProxyInstance(){
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),
this);
}
//代理對象會自動調用復寫后的invoke方法，類似filter中的dofilter；
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
up(); //在此加入需要增加的操作
Object ret=method.invoke(targetObject, args);
down();//在此加入需要增加的操作
return ret;// 如果沒有返回值，則返回null。
}
private void up(){
System.out.println("撥號中");
}
private void down(){
System.out.println("斷開中");
}
}
測試：
public static void main(String[] args) {
NetHandle n=new NetHandle(new NetImpl());
Neting net=(Neting) n.createProxyInstance();
net.netting();
System.out.println(net.playGame(""));
}
運行結果：
撥號中
上網中....
斷開中
撥號中
游戲中....
斷開中
game over