(转载)代理模式

代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用.

代理,指的就是一个角色代表另一个角色采取行动,就象生活中,一个红酒厂商,是不会直接把红酒零售客户的,都是

通过代理来完成他的销售业务的.而客户,也不用为了喝红酒而到处找工厂,他只要找到厂商在当地的代理就行了,具体红酒工厂在那里,客户不用关心,代理会帮他处理.

代理模式涉及的角色:
1:抽象主题角色.声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替.

2:代理主题角色.含有真实主题的引用,从而可以在任何时候操作真实主题,代理主题功过提供和真实主题相同的接口,使它可以随时代替真实主题.代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作.

3:真实代理对象.定义了代理角色所代表的具体对象.

下面是代理模式的实现类图:


根据上图的关系,我们可以用客户买红酒来模拟代理模式的实现,

红酒代理商和红酒厂商都有销售红酒的只能,我们可以为他们定义一个共同的抽象主题角色,
Java代码

/**  
*抽象主题角色,定义了真实角色和代理角色的公共接口  
*/  
public interface SellInterface{   
     public Object sell();   
}  




接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的.
Java代码
/** 
*真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口 
*/ 
public class RedWineFactory implements SellInterface{  
     public Object sell(){  
         System.out.println("真实主题角色RedWineFactory 被调用了");  
         return new Object();  
     }  


/**
*真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口
*/
public class RedWineFactory implements SellInterface{
     public Object sell(){
         System.out.println("真实主题角色RedWineFactory 被调用了");
         return new Object();
     }
}


下面是代理主题角色(这里指红酒代理商),同样,代理主题也必须实现SellInterface接口.
Java代码
/** 
*代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒 
*厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理. 
*/ 
public class RedWineProxy implements SellInterface{  
     //持有一个RedWineFactory对象的引用  
      private RedWineFactory redWineFactory;  
 
     //销售总量  
      private static int sell_count = 0;  
 
     public Object sell(){  
         if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情  
             Object obj = redWineFactory.sell();  
             count ++;//同样,在调用后我们也可以执行一些额外的动作.  
             return obj ;  
         }else{  
             throw new RuntimeException();  
         }  
     }  
 
     protected boolean checkUser(){  
            //do something  
            return true;  
     }  


/**
*代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒
*厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理.
*/
public class RedWineProxy implements SellInterface{
     //持有一个RedWineFactory对象的引用
      private RedWineFactory redWineFactory;

     //销售总量
      private static int sell_count = 0;

     public Object sell(){
         if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情
             Object obj = redWineFactory.sell();
             count ++;//同样,在调用后我们也可以执行一些额外的动作.
             return obj ;
         }else{
             throw new RuntimeException();
         }
     }

     protected boolean checkUser(){
            //do something
            return true;
     }
}


接下来看看调用代理对象的代码
Java代码
public static void main(String agr[])  
{  
     SellInterface sell = new RedWineProxy();  
     sell.sell();  


public static void main(String agr[])
{
     SellInterface sell = new RedWineProxy();
     sell.sell();
}


从上面的例子可以看出代理模式的工作方式,首先,因为代理主题和真实主题都实现了共同的接口,这使我们可以在不改变原来接口的情况下,只要用真实主题对象的地方,都可以用代理主题来代替.其次,代理主题在客户和真实主题之间起了一个中介作用,利用这个中介平台,我们可以在把客户请求传递给真实主题之前,做一些必要的预处理.

java对代理模式的支持 ---动态代理
上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface.这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类.幸好,java为代理模式提供了支持.
java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的.
下面用java的代理机制来实现上面的例子
Java代码
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
/** 
*代理类一定要实现了InvocationHandler接口 
*/ 
public class ProxyObject implements InvocationHandler{  
    private Object proxy_obj;  
 
    ProxyObject(Object obj){  
        this.proxy_obj = obj;  
    }  
 
    public static Object factory(Object obj){  
        Class cls = obj.getClass();  
        //通过Proxy类的newProxyInstance方法来返回代理对象  
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));  
    }  
 
/** 
*实现InvocationHandler接口的invoke 
*/ 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        System.out.println("函数调用前被拦截了:   " + method);  
        if(args != null){  
            //打印参数列表  
            System.out.println("方法有  " + args.length + "    个参数");  
            for(int i = 0; i < args.length; i ++){  
                System.out.println(args[i]);  
            }  
        }  
        //利用反射机制动态调用原对象的方法  
         Object mo = method.invoke(proxy_obj, args);  
        System.out.println("函数调用后进行处理 :   " + method);  
        return mo;  
    }  
 
    //测试代码      
    public static void main(String agr[]){  
        SellInterface si = (SellInterface)factory(new RedWineFactory());  
        si.sell();  
    }  


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
*代理类一定要实现了InvocationHandler接口
*/
public class ProxyObject implements InvocationHandler{
    private Object proxy_obj;

    ProxyObject(Object obj){
        this.proxy_obj = obj;
    }

    public static Object factory(Object obj){
        Class cls = obj.getClass();
        //通过Proxy类的newProxyInstance方法来返回代理对象
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),new ProxyObject(obj));
    }

/**
*实现InvocationHandler接口的invoke
*/
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("函数调用前被拦截了:   " + method);
        if(args != null){
            //打印参数列表
            System.out.println("方法有  " + args.length + "    个参数");
            for(int i = 0; i < args.length; i ++){
                System.out.println(args[i]);
            }
        }
        //利用反射机制动态调用原对象的方法
         Object mo = method.invoke(proxy_obj, args);
        System.out.println("函数调用后进行处理 :   " + method);
        return mo;
    }

    //测试代码   
    public static void main(String agr[]){
        SellInterface si = (SellInterface)factory(new RedWineFactory());
        si.sell();
    }
}

通过上面的代码可以看出,代理主题ProxyObject类并没有实现我们定义的SellInterface借口,
而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口.
其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧

接着,用代理模式实现一个超级简单的aop拦截机制
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理
Java代码
/** 
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理 
*/ 
public interface AopInterface {  
   public void before(Object obj);//调用的处理  
   public void end(Object obj);//调用后的处理  


/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
   public void before(Object obj);//调用的处理
   public void end(Object obj);//调用后的处理
}


这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑
Java代码
public class AopInterfaceImp implements AopInterface{  
 
    public void before(Object obj) {  
        System.out.println("调用前拦截");  
    }  
 
    public void end(Object obj) {  
        System.out.println("调用调用后处理");  
    }  
 


public class AopInterfaceImp implements AopInterface{

    public void before(Object obj) {
        System.out.println("调用前拦截");
    }

    public void end(Object obj) {
        System.out.println("调用调用后处理");
    }

}


接着是代理类
Java代码
public class PeoxyObject implements InvocationHandler {  
    private AopInterface aop;//定义了切入时调用的方法  
    private Object proxy_obj;  
    private String methodName;//指定要切入的方法名  
 
    PeoxyObject(){}  
 
    public Object factory(Object obj){  
        proxy_obj = obj;  
        Class cls = obj.getClass();  
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);  
    }  
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        if(this.aop == null)throw new NullPointerException("aop is null");  
        if(method == null)throw new NullPointerException("method is null");  
 
        Object o;  
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理  
//否则当正常方法处理  
        if(methodName != null && method.toString().indexOf(methodName) != -1){  
            aop.before(proxy_obj);//指定方法调用前的处理  
            o = method.invoke(proxy_obj, args);  
            aop.end(proxy_obj);//指定方法调用后的处理  
        }else{  
            //没有指定的方法,以正常方法调用  
            o = method.invoke(proxy_obj, args);  
        }  
        return o;  
    }  
 
    public AopInterface getAop() {  
        return aop;  
    }  
 
    public void setAop(AopInterface aop) {  
        this.aop = aop;  
    }  
 
    public String getMethodName() {  
        return methodName;  
    }  
 
    public void setMethodName(String methodName) {  
        this.methodName = methodName;  
    }  


public class PeoxyObject implements InvocationHandler {
    private AopInterface aop;//定义了切入时调用的方法
    private Object proxy_obj;
    private String methodName;//指定要切入的方法名

    PeoxyObject(){}

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(this.aop == null)throw new NullPointerException("aop is null");
        if(method == null)throw new NullPointerException("method is null");

        Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
        if(methodName != null && method.toString().indexOf(methodName) != -1){
            aop.before(proxy_obj);//指定方法调用前的处理
            o = method.invoke(proxy_obj, args);
            aop.end(proxy_obj);//指定方法调用后的处理
        }else{
            //没有指定的方法,以正常方法调用
            o = method.invoke(proxy_obj, args);
        }
        return o;
    }

    public AopInterface getAop() {
        return aop;
    }

    public void setAop(AopInterface aop) {
        this.aop = aop;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
}


这里定义一个用来测试用的类
Java代码
public interface SubInterface {  
    public void add(String value1,String value2);  
    public void acc(String value1);  
}  
 
public class ImpObject implements SubInterface{  
 
    public void add(String value1,String value2) {  
        System.out.println("ImpObject add(String value1,String value2)");  
    }  
 
    public void acc(String value1){  
        System.out.println("ImpObject acc(String value1)");  
    }  
 


public interface SubInterface {
    public void add(String value1,String value2);
    public void acc(String value1);
}

public class ImpObject implements SubInterface{

    public void add(String value1,String value2) {
        System.out.println("ImpObject add(String value1,String value2)");
    }

    public void acc(String value1){
        System.out.println("ImpObject acc(String value1)");
    }

}


这里是测试代码
Java代码
public static void main(String agr[]){  
     PeoxyObject po = new PeoxyObject();  
 
     po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象  
      po.setMethodName("acc");//指定要拦截的函数  
       
      SubInterface si = (SubInterface)po.factory(new ImpObject());  
   //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行  
      si.add("tt","dd");     
 
   //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp  
    //对象的两个方法  
      si.acc("tt");  


   public static void main(String agr[]){
        PeoxyObject po = new PeoxyObject();

        po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
         po.setMethodName("acc");//指定要拦截的函数
       
         SubInterface si = (SubInterface)po.factory(new ImpObject());
      //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
         si.add("tt","dd");  

      //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
       //对象的两个方法
         si.acc("tt");
    }


通过上面可以看出,拦截机制是代理模式的重要使用方式之一,
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限.

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值