结构型模式之代理模式

GitHub地址：https://github.com/zhangboqing/design-mode/tree/master/src/main/java/com/zbq

 

一.定义

　　代理模式(Proxy Pattern) ：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy或Surrogate，它是一种对象结构型模式。

 

二、模式结构成员构成

• Subject: 抽象主题角色

• Proxy: 代理主题角色

• RealSubject: 真实主题角色

 

三.代码示例

1）静态代理

/**
 * Subject
 * 抽象角色
 */
public abstract class Subject {
    public abstract void request();
}


/**
 * RealSubject
 * 真实的角色
 */
public class RealSubject extends Subject {

    @Override
    public void request() {
        // TODO Auto-generated method stub

    }
}
 

/**
 * Proxy
 * 静态代理，对具体真实对象直接引用
 * 代理角色，代理角色需要有对真实角色的引用，
 * 代理做真实角色想做的事情
 */
public class ProxySubject extends Subject {

    private RealSubject realSubject = null;
    
    /**
     * 除了代理真实角色做该做的事情，代理角色也可以提供附加操作，
     * 如：preRequest()和postRequest()
     */
    @Override
    public void request() {
        preRequest();  //真实角色操作前的附加操作
        
        if(realSubject == null){
            realSubject =  new RealSubject();
        }
        realSubject.request();
        
        postRequest();  //真实角色操作后的附加操作
    }
 
    /**
     *    真实角色操作前的附加操作
     */
    private void postRequest() {
        // TODO Auto-generated method stub
        
    }
 
    /**
     *    真实角色操作后的附加操作
     */
    private void preRequest() {
        // TODO Auto-generated method stub
        
    }
 
}

/**
 * client
 */
public class Client {


    public static void main(String[] args) {
        Subject subject = new ProxySubject();
        subject.request();  //代理者代替真实者做事情
    }

}

2) 动态代理

/**
 * Subject
 * 抽象角色
 */
public abstract class Subject {
    public abstract void request();
}

/**
 * RealSubject
 * 真实的角色
 */
public class RealSubject extends Subject {

    @Override
    public void request() {
        // TODO Auto-generated method stub

    }
}
 
/**
 * proxy
 * 动态代理， 它是在运行时生成的class，在生成它时你必须提供一组interface给它， 然后该class就宣称它实现了这些interface。
 * 你当然可以把该class的实例当作这些interface中的任何一个来用。 当然啦，这个Dynamic
 * Proxy其实就是一个Proxy，它不会替你作实质性的工作， 在生成它的实例时你必须提供一个handler，由它接管实际的工作。
 */
public class DynamicSubject implements InvocationHandler {

    private Object sub; // 真实对象的引用

    public DynamicSubject(Object sub) {
        this.sub = sub;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before calling " + method);
        method.invoke(sub, args);
        System.out.println("after calling " + method);
        return null;
    }

}

/**
 * client
 */
public class Client {

    public static void main(String[] args) throws Throwable {
        RealSubject rs = new RealSubject();
        InvocationHandler handler = new DynamicSubject(rs);
        Class cls = rs.getClass();
        //以下是分解步骤
        /*
        Class c = Proxy.getProxyClass(cls.getClassLoader(), cls.getInterfaces());
        Constructor ct = c.getConstructor(new Class[]{InvocationHandler.class});
        Subject subject =(Subject) ct.newInstance(new Object[]{handler});
        */

        //以下是一次性生成
        Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), handler);
        subject.request();
    }
}

 

 

四.优点和缺点分析

优点：

> 代理模式能够协调调用者和被调用者，在一定程度上降低了系 统的耦合度。

> 代理模式能够增强被调用者的功能，让被调用者在原有功能上，增加其他额外的功能。

 

缺点：

>实现代理模式需要额外的工作，有些代理模式的实现 非常复杂。

 

五.应用场景

>为某个对象提供额外的操作的时候