设计模式之动态代理模式

代理是一种模式，提供了对目标对象的间接访问方式，即通过代理访问目标对象。如此便于在目标实现的基础上增加额外的功能操作，前拦截，后拦截等，以满足自身的业务需求，同时代理模式便于扩展目标对象功能的特点也为多人所用。

静态代理

　　静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法，并实现前拦截，后拦截等所需的业务功能。

public interface Star {
    /**
     * 面谈
     */
    void confer();

    /**
     * 签合同
     */
    void signContract();

    /**
     * 订票
     */
    void bookTicket();

    /**
     * 唱歌
     */
    void sing();

    /**
     * 收尾款
     */
    void collectMoney();

public class RealStar implements Star{
    /**
     * 面谈
     */
    public void confer() {
        System.out.println("RealStar confer");
    }

    /**
     * 签合同
     */
    public void signContract() {
        System.out.println("RealStar signContract");
    }

    /**
     * 订票
     */
    public void bookTicket() {
        System.out.println("RealStar bookTicket");
    }

    /**
     * 唱歌
     */
    public void sing() {
        System.out.println("明星唱歌");
    }

    /**
     * 收尾款
     */
    public void collectMoney() {
        System.out.println("RealStar collectMoney");
    }
}

public class Proxy implements Star{

    private Star star;

    public Proxy(Star star){
        this.star = star;
    }

    /**
     * 面谈
     */
    public void confer() {
        System.out.println("Proxy confer");
    }

    /**
     * 签合同
     */
    public void signContract() {
        System.out.println("Proxy signContract");
    }

    /**
     * 订票
     */
    public void bookTicket() {
        System.out.println("Proxy bookTicket");
    }

    /**
     * 唱歌
     */
    public void sing() {
        star.sing();
    }

    /**
     * 收尾款
     */
    public void collectMoney() {
        System.out.println("Proxy collectMoney");
    }
}

public class TestStaticProxy {
    @Test
    public void test(){
        Proxy proxy = new Proxy(new RealStar());
        proxy.sing();
    }
}

静态代理的总结
　　优点：可以做到不对目标对象进行修改的前提下，对目标对象进行功能的扩展和拦截。
　　缺点：因为代理对象，需要实现与目标对象一样的接口，会导致代理类十分繁多，不易维护，同时一旦接口增加方法，则目标对象和代理类都需要维护。

动态代理

　　动态代理是指动态的在内存中构建代理对象（需要我们制定要代理的目标对象实现的接口类型），即利用JDK的API生成指定接口的对象，也称之为JDK代理或者接口代理。

/**

　*　动态代理对象，无需实现任何接口

* 通过传入任何类型的目标对象并指定接口

* 调用JDK接口动态创建代理对象

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

/**
 * Created by chengbx 
 */
public class StartHandler implements InvocationHandler{

    private Star star;

    public StartHandler(Star star) {
        this.star = star;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object obj = null;
        System.out.println("真正的方法执行前");
        System.out.println("面谈，签合同，预付款，订机票");
        if (method.getName().equals("sing")) {
            method.invoke(star,args);
        }
        System.out.println("真正的方法执行后");
        System.out.println("收尾款");
        return  obj;
    }
}

public class TestDynamicProxy {

    @Test
    public void test(){
        StartHandler startHandler = new StartHandler(new RealStar());

        Star  star = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, startHandler);
        star.sing();
    }
}

输出：

　　真正的方法执行前
　　面谈，签合同，预付款，订机票
　　明星唱歌
　　真正的方法执行后
　　收尾款

　动态代理的总结

　　优点：代理对象无需实现接口，免去了编写很多代理类的烦恼，同时接口增加方法也无需再维护目标对象和代理对象，只需在事件处理器中添加对方法的判断即可。

　　缺点：代理对象不需要实现接口，但是目标对象一定要实现接口，否则无法使用JDK动态代理。

设计模式之动态代理模式

猜你喜欢