AOP之代理篇

相关文章: X
java 动态代理的一点迷惑
现看静态代理：
Java代码
package proxy.demo2;  
 
public interface Subject {  
    public void request();  
} 

package proxy.demo2;

public interface Subject {
    public void request();
}


Java代码
package proxy.demo2;  
 
public class RealSubject implements Subject{  
 
    public void request() {  
        // TODO Auto-generated method stub  
        System.out.println("invoke request is RealSubject.request");  
    }  
      
} 

package proxy.demo2;

public class RealSubject implements Subject{

public void request() {
// TODO Auto-generated method stub
System.out.println("invoke request is RealSubject.request");
}
   
}

Java代码
package proxy.demo2;  
 
/** 
* @author spark 
* 代理接口：Subject ； 
* 真实的被代理对象:RealSubject（实现那subject接口）； 
* 代理对象：ProxySubjet; 
* 这里的有几点需要注意的 
* 1：RealSubject是存在的。也就是说ProxySubject 
* 事先是知道代理的对象是谁（这里指的是RealSubject）； 
* 故是一种静态代理；而所谓的Dynamic Proxy是事先不知道被代理的对象的存在， 
* 也就是知道被代理的对象是实现了某个接口的；也就是说真正被代理的对象是动态 
* 产生的。 
* 2：所谓的代理对象只不过是被代理对象的加强版对象 
* 说白那就是RealSubject对象有的功能（说到“功能”两字，大家的脑袋应该立马联想到接口（interface））， 
* ProxySubject都具有；故当RealSubject实现那Subject，那么ProxySubject也要实现Subject接口； 
* 并且在ProxySubject实现的request（）方法中其实是调用那RealSubject的request（）方法； 
* 当然ProxySubject的request()方法也可是RealSubject的request（）方法的加强版；可以在 
* RealSubject.request()方法之前或之后做一些事情 
* 3:由1，2二点可以看出 
* “如果要按照上述的方法使用代理模式，那么真实角色（被代理对象）必须是事先已经存在的， 
* 并将其作为代理对象的内部属性。但是实际使用时，一个真实角色（被代理对象）必须对应一个代理角色（代理对象）， 
* 如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？ 
* 这个问题引出了Java了一个很有趣的机制--动态代理。” 
* ----------------上面引用于“http://aladdin.iteye.com/blog/40998” 
* 呵呵，希望大家尊重原创，我也是看了aladdin的文章才有所启发的，谢谢aladdin的精彩文章； 
* 只是aladdin有些话太高深，我翻译成大白话，方便以后自己学习； 
* 希望aladdin不要介意 
*/ 
public class ProxySubject implements Subject {  
    private RealSubject realsubject;  
    public ProxySubject(RealSubject realsubject){  
        this.realsubject=realsubject;  
    }  
    public void request() {  
        // TODO Auto-generated method stub  
         this.beforRequest();  
         realsubject.request();//这句话才是“代理”二字的真实含义，实际上调用的RealSubject类对象的request（）；  
         this.afterRequest();  
    }  
    //在RealSubject.request()调用之前做一些事情  
    private void beforRequest(){  
        System.out.println("befor RealSubject.request()");  
    }  
    //在RealSubject.request()调用之后做一些事情  
    private void afterRequest(){  
        System.out.println("after RealSubject.request()");  
    }  
} 

package proxy.demo2;

/**
* @author spark
* 代理接口：Subject ；
* 真实的被代理对象:RealSubject（实现那subject接口）；
* 代理对象：ProxySubjet;
* 这里的有几点需要注意的
* 1：RealSubject是存在的。也就是说ProxySubject
* 事先是知道代理的对象是谁（这里指的是RealSubject）；
* 故是一种静态代理；而所谓的Dynamic Proxy是事先不知道被代理的对象的存在，
* 也就是知道被代理的对象是实现了某个接口的；也就是说真正被代理的对象是动态
* 产生的。
* 2：所谓的代理对象只不过是被代理对象的加强版对象
* 说白那就是RealSubject对象有的功能（说到“功能”两字，大家的脑袋应该立马联想到接口（interface）），
* ProxySubject都具有；故当RealSubject实现那Subject，那么ProxySubject也要实现Subject接口；
* 并且在ProxySubject实现的request（）方法中其实是调用那RealSubject的request（）方法；
* 当然ProxySubject的request()方法也可是RealSubject的request（）方法的加强版；可以在
* RealSubject.request()方法之前或之后做一些事情
* 3:由1，2二点可以看出
* “如果要按照上述的方法使用代理模式，那么真实角色（被代理对象）必须是事先已经存在的，
* 并将其作为代理对象的内部属性。但是实际使用时，一个真实角色（被代理对象）必须对应一个代理角色（代理对象），
* 如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？
* 这个问题引出了Java了一个很有趣的机制--动态代理。”
* ----------------上面引用于“http://aladdin.iteye.com/blog/40998”
* 呵呵，希望大家尊重原创，我也是看了aladdin的文章才有所启发的，谢谢aladdin的精彩文章；
* 只是aladdin有些话太高深，我翻译成大白话，方便以后自己学习；
* 希望aladdin不要介意
*/
public class ProxySubject implements Subject {
    private RealSubject realsubject;
    public ProxySubject(RealSubject realsubject){
    this.realsubject=realsubject;
    }
public void request() {
// TODO Auto-generated method stub
         this.beforRequest();
         realsubject.request();//这句话才是“代理”二字的真实含义，实际上调用的RealSubject类对象的request（）；
         this.afterRequest();
}
//在RealSubject.request()调用之前做一些事情
    private void beforRequest(){
    System.out.println("befor RealSubject.request()");
    }
    //在RealSubject.request()调用之后做一些事情
    private void afterRequest(){
    System.out.println("after RealSubject.request()");
    }
}


看测试类
Java代码
package proxy.demo2;  
 
public class 测试静态代理 {  
 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
           Subject proxy=new ProxySubject(new RealSubject());  
           //Subject proxy=new ProxySubject(new RealSubject());这行代码  
           //也体现那proxy是静态代理，因为它知道该实例化那个代理对象；  
           proxy.request();  
    }  
 
} 

package proxy.demo2;

public class 测试静态代理 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
           Subject proxy=new ProxySubject(new RealSubject());
           //Subject proxy=new ProxySubject(new RealSubject());这行代码
           //也体现那proxy是静态代理，因为它知道该实例化那个代理对象；
           proxy.request();
}

}

再看动态代理
Java代码
package proxy.demo2;  
 
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
 
public class DynamicProxy implements InvocationHandler {  
    private Subject subject;  
    public DynamicProxy(Subject subject){  
        this.subject=subject;  
    }  
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable {  
        // TODO Auto-generated method stub  
        this.beforRequest();  
        method.invoke(subject, args);  
        this.afterRequest();  
        return null;  
    }  
//  在RealSubject.request()调用之前做一些事情  
    private void beforRequest(){  
        System.out.println("befor RealSubject.request()");  
    }  
    //在RealSubject.request()调用之后做一些事情  
    private void afterRequest(){  
        System.out.println("after RealSubject.request()");  
    }  
} 

package proxy.demo2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {
    private Subject subject;
    public DynamicProxy(Subject subject){
    this.subject=subject;
    }
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
this.beforRequest();
method.invoke(subject, args);
this.afterRequest();
return null;
}
// 在RealSubject.request()调用之前做一些事情
    private void beforRequest(){
    System.out.println("befor RealSubject.request()");
    }
    //在RealSubject.request()调用之后做一些事情
    private void afterRequest(){
    System.out.println("after RealSubject.request()");
    }
}



看测试类：
Java代码
package proxy.demo2;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
 
import proxy.Secretary;  
public class 测试动态代理 {  
 
    /** 
     * @param args 
     *  Subject is Interface 
     *  get Subject instance; 
     *  Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), 
     *        new Class[] { Foo.class }, handler); 
     */ 
      
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
       RealSubject real=new RealSubject();  
       InvocationHandler handler=new DynamicProxy(real);  
       Subject proxy= (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, handler);  
       proxy.request();  
    }  
 
}