拿魔兽世界的拍卖行来比喻，假设最早的版本的拍卖行只有最两个基本的功能，买东西和卖东西。而在后续的版本中慢慢添加一些判断或者条件限制等功能，比如要先判断你是否有足够的钱来买这个商品、这个商品是否还存在、这个商品是否过期等等一些前置处理或者后置处理功能。你有这么几个选择：
1.修改原来的拍卖行这个类。
2.新建一个子类，来重写这个方法。
3.新写一个代理类来实现。
这三个方法都可以使用，不过如果之前的代码不是你写的，或者是第三方提供的jar包，那第一个方法就不合适了。
这里首先使用静态代理的方法：有一个拍卖行类，功能单一。然后有个拍卖行代理类，可以处理做一些前置和后置处理，最后测试类通过代理类来使用拍卖行
[
java] 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 AuctionShop {
/**
* 卖东西
*/
public void sellGoods() {
System.out.println("您拍卖了XXX东西");
}
/**
* 买东西
*/
public void buyGoods() {
System.out.println("您购买了XXX东西");
}
}
[
java] 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 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("买东西之后...");
}
}
测试类：
[
java] 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();
}
}
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提供了一种动态代理机制，可以动态生成一个代理类来完成代理的任务。
[
java] package auction;
public
interface IAuctionShop {
/**
* 卖东西
*/
public void sellGoods();
/**
* 买东西
www.atcpu.com */
public void buyGoods();
}
package auction;
public interface IAuctionShop {
/**
* 卖东西
*/
public void sellGoods();
/**
* 买东西
*/
public void buyGoods();
}
[
java] 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;
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;
}
}
[
java] package auction;
/**
* DOC 拍卖行类
*/
public class AuctionShop implements IAuctionShop {
/**
* 卖东西
*/
public void sellGoods() {
System.out.println("您拍卖了XXX东西");
}
/**
* 买东西
*/
public void buyGoods() {
System.out.println("您购买了XXX东西");
}
}
package auction;
/**
* DOC 拍卖行类
*/
public class AuctionShop implements IAuctionShop {
/**
* 卖东西
*/
public void sellGoods() {
System.out.println("您拍卖了XXX东西");
}
/**
* 买东西
*/
public void buyGoods() {
System.out.println("您购买了XXX东西");
}
}
测试类：
[
java] 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();
}
}
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东西
方法执行之后
