Java设计模式——Proxy代理模式

Proxy代理模式分为静态代理和动态代理，简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。
举一个很简单的例子，比如有个歌手对象叫SunZi，这个对象有一个唱歌方法叫sing()。

public class Sunzi{
    public void sing() {
        System.out.println("我会唱唐人");
    }
}

假如现在你希望，这个歌手对象，在唱歌前后还要想观众问好和答谢，也即对目标对象Singer的sing方法进行功能扩展，代码如下：

public void sing() {
        System.out.println("向观众问好");
        System.out.println("我会唱唐人");
        System.out.println("答谢观众");
    }

但是你现在又不能直接对源代码进行修改，这时就需要用到java的代理模式了。

/**  静态代理  **/
public interface ISinger {
    void sing();
}

/**
 *  目标对象实现了某一接口
 */
public class SunZi implements ISinger{
    public void sing(){
        System.out.println("我会唱唐人");
    }  
}

/**
 *  代理对象和目标对象实现相同的接口
 */
public class SingerProxy implements ISinger{
    // 接收目标对象，以便调用sing方法
    private ISinger target;
    public UserDaoProxy(ISinger target){
        this.target=target;
    }
    // 对目标对象的sing方法进行功能扩展
    public void sing() {
        System.out.println("向观众问好");
        target.sing();
        System.out.println("答谢观众");
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        //目标对象
        ISinger target = new SunZi();
        //代理对象
        ISinger proxy = new SingerProxy(target);
        //执行的是代理的方法
        proxy.sing();
    }
}

总结：静态代理其实就是创建一个代理类SingerProxy，继承了ISinger接口并实现了其中的方法，只不过这种实现特意包含了目标对象的方法，正是这种特征使得看起来像是“扩展”了目标对象的方法。假使代理对象中只是简单地对sing方法做了另一种实现而没有包含目标对象的方法，也就不能算作代理模式了，所以这里的包含是关键。

缺点：代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。

/** 动态代理（也叫JDK代理） **/
public interface ISinger {
    void sing();
}

/**
 *  目标对象实现了某一接口
 */
public class SunZi implements ISinger{
    public void sing(){
        System.out.println("我会唱唐人");
    }  
}

public class Test {
    public static void main(String[] args) {
        Singer target = new Singer();
        ISinger proxy = (ISinger) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("向观众问好");
                        // 执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("答谢观众");
                        return returnValue;
                    }
                });
        proxy.sing();
    }
}

java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便。

缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，假如没有，则可以使用Cglib代理。

/** Cglib代理 **/
/**
前提条件：

需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core-3.2.5.jar
目标类不能为final
目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
**/
/**
 * 目标对象,没有实现任何接口
 */
public class Singer{

    public void sing() {
        System.out.println("我会唱唐人");
    }
}

/**
 * Cglib子类代理工厂
 */
public class ProxyFactory implements MethodInterceptor{
    // 维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("向观众问好");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("答谢观众");
        return returnValue;
    }
}

/**
 * 测试类
 */
public class Test{
    public static void main(String[] args){
        //目标对象
        Singer target = new Singer();
        //代理对象
        Singer proxy = (Singer)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy.sing();
    }
}

总结：三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例，在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理