java 设计模式之四-代理模式 java静态代理和动态代理

拿魔兽世界的拍卖行来比喻，假设最早的版本的拍卖行只有最两个基本的功能，买东西和卖东西。而在后续的版本中慢慢添加一些判断或者条件限制等功能，比如要先判断你是否有足够的钱来买这个商品、这个商品是否还存在、这个商品是否过期等等一些前置处理或者后置处理功能。你有这么几个选择：

1.修改原来的拍卖行这个类。

2.新建一个子类，来重写这个方法。

3.新写一个代理类来实现。

这三个方法都可以使用，不过如果之前的代码不是你写的，或者是第三方提供的jar包，那第一个方法就不合适了。

这里首先使用静态代理的方法：有一个拍卖行类，功能单一。然后有个拍卖行代理类，可以处理做一些前置和后置处理，最后测试类通过代理类来使用拍卖行

package auction;

/**
 * DOC 拍卖行类
 */
public class AuctionShop {

    /**
     * 卖东西
     */
    public void sellGoods() {
        System.out.println("您拍卖了XXX东西");
    }

    /**
     * 买东西
     */
    public void buyGoods() {
        System.out.println("您购买了XXX东西");
    }

}

package auction;

/**
 * DOC 拍卖行代理类
 */
public class AuctionShopProxy {

    private AuctionShop auctionShop = new AuctionShop();

    /**
     * 卖东西
     */
    public void sellGoods() {
        System.out.println("卖东西之前...");
        auctionShop.sellGoods();
        System.out.println("卖东西之后...");
    }

    /**
     * 买东西
     */
    public void buyGoods() {
        System.out.println("买东西之前...");
        auctionShop.buyGoods();
        System.out.println("买东西之后...");
    }

}

测试类：

package test;

import auction.AuctionShopProxy;

public class StaticProxyTest {

    public static void main(String[] args) {
        AuctionShopProxy proxy = new AuctionShopProxy();
        System.out.println("-----------买东西----------");
        proxy.buyGoods();
        System.out.println("-----------卖东西----------");
        proxy.sellGoods();
    }

}

测试结果：

-----------买东西----------
买东西之前...
您购买了XXX东西
买东西之后...
-----------卖东西----------
卖东西之前...
您拍卖了XXX东西
卖东西之后...

从代码看出，每个代理类只能为一个接口或者一个类服务，代码很多，文件很多，效果不好。因此java提供了一种动态代理机制，可以动态生成一个代理类来完成代理的任务。

package auction;

public interface IAuctionShop {

    /**
     * 卖东西
     */
    public void sellGoods();

    /**
     * 买东西
     */
    public void buyGoods();
}

package auction;

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

public class DynamicProxy implements InvocationHandler {

    private Object target;

    /**
     * DOC 通过反射动态生成一个代理对象.调用该对象的任何一个方法，都会进入invoke方法里
     * 
     * @param target
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        System.out.println("方法执行之前...");
        result = method.invoke(target, args);
        System.out.println("方法执行之后...");
        return result;
    }

}

package auction;

/**
 * DOC 拍卖行类
 */
public class AuctionShop implements IAuctionShop {

    /**
     * 卖东西
     */
    public void sellGoods() {
        System.out.println("您拍卖了XXX东西");
    }

    /**
     * 买东西
     */
    public void buyGoods() {
        System.out.println("您购买了XXX东西");
    }

}

测试类：

package test;

import auction.AuctionShop;
import auction.DynamicProxy;
import auction.IAuctionShop;

public class DynamicProxyTest {

    public static void main(String[] args) {
        DynamicProxy proxy = new DynamicProxy();
        IAuctionShop auctionShop = (IAuctionShop) proxy.bind(new AuctionShop());
        auctionShop.buyGoods();
    }

}

测试结果：

方法执行之前...
您购买了XXX东西
方法执行之后