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

╰半夏微凉° 2022-08-06 07:22 243阅读 0赞

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

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.2cto.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东西  
方法执行之后

欢迎大家收看我的在线Java全套免费教学超清视频：

http://v.youku.com/v\_show/id\_XODQ1NjU0NDc2.html   这是其中的一个视频连接，大家可以拖动到优酷视频下方，订阅我的账号，因为以后我会有更多视频免费提供

百度搜索：输入Fcs\_D调的码农 ，或者输入"胡博君"就能看到我的很多视频

或者加我的微信号：fcsboy     我可以及时通过微信通知你们

QQ学习群：237053693

[www.2cto.com]: http://www.2cto.com/