java的反射机制之静态代理和动态代理的对比

一、静态代理

//接口
interface All{  
    public void method1();  
} 
 //被代理類
class A implements All{  
//重寫接口中的方法
    public void method1(){  
        System.out.println("method");  
    }  
} 
//代理類
class B implements All{  
	All obj；//被代理類的聲明，也是代理類B的成員變量
public B(All obj){//構造器
	this.obj = obj;
}

//重寫接口中的方法
    public void method1(){  
        System.out.println("method");  
        obj.method1();//調用被代理類中的方法
    } 
     
} 

public class TestRflection{  
    public static void main(String args[]){  
    //1、創建一個被代理類的對象
    A a = new A();
    //2、創建代理類的對象
    B b = new B(a);
    //3、調用的是代理類的方法，但實際上調用的被代理類的方法
    b.method1();
    
}

 二、动态代理

  
//接口  
interface All{  
    public void method1();  
}  
//被代理類
class A implements All{  
//重寫接口中的方法
    public void method1(){  
        System.out.println("method");  
    }  
}  
//通過實現InvocationHandler接口的類，創建代理類的對象並且實現對被代理類中方法的調用
class B implements InvocationHandler{  
   Object obj;//被代理類對象的聲明
   public Object setObject(Object obj){
   this.obj = obj;	//實例化被代理類
   //通過Proxy類的靜態方法newProxyInstance動態的創建被代理類的對象，并返回
   return Proxy.newProxyInstance(obj.getClass().getClassLoder(),obj.getClass().getInterfaces(),this);
   }
   @Override // 重寫InvocationHandler接口中的抽象方法，相當于是轉換成了對被代理類對象中方法的調用
   public Object invoke(Object proxy,Method method,Object[] args)  throws Throwable{
   	Object returnVal = method.invoke(obj,args);
   	return returnVal;//返回的是被代理類中被調用的方法的返回值，若返回的是null，則說明調用的是void類型
   }
}  
public class TestRflection{  
    public static void main(String args[]){  
    //1、創建一個被代理類的對象
    A a = new A();
    //2、創建一個實現了InvocationHandler接口的類的對象
    B b = new B();
    //3、調用setObject()方法，動態的創建一個Object類型的代理類的對象
    Object c = b.setObject(a);
    //4、在創建代理類的那個方法也實現了All接口
    (All)d = All(c);
    //5、此時就可以掉用被代理類的方法了
    d.method1();
    
}

 总结：

静态代理，其实就是静态的创建某一个代理类，只适合代理这一个被代理的类，如果想要代理其他的类，就必须再显示的写一个其他类的代理类；

而动态代理，其实就是动态的创建一个代理类，可代理多个被代理的类，能够创建任何一个被代理类的代理类。这样就减少了代码量，提高了开发效率

 

PS：AOP(面向切面的编程)，会用到动态代理，即在invoke()方法的前面和后面可能是其他类的方法，invoke本身就是一个动态的方法，它会应调用的对象的不同，而实现不同的方法。