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东西

方法执行之后