设计模式之——代理模式（Proxy）

笔者今天被问到了一个问题，那就是：你是怎么理解Java中的代理模式的？当时我回答的模模糊糊的，只说了有两种一种是静态代理一种是动态代理，然后这两种代理具体有啥用，各有什么优缺点就讲的很模糊了。之后笔者查了一些资料，然后写下了这篇博文。

---

一、代理模式具体是什么？它有什么作用？

代理模式提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
核心思想：代理人跟被代理人都能做同一件事，只不过被代理人把执行权限交给了代理人，外部只能通过代理人来联系被代理人，通过代理人来增强被代理人的一些功能

二、Java中有几种代理模式？

Java中主要有两种代理模式：静态代理和动态代理

1、静态代理

静态代理的意思是：在程序运行前就已经存在代理类的字节码文件（代理类和委托类的关系在运行前就已经确定了），它需要和代理对象继承同一个接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能；
缺点：

• 1、冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
• 2、不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。
• 3、由于增加了代理对象，因此可能会造成请求的处理速度变慢；

• 需要被代理的任务接口

package com.muyichen.weibo.dplusservice.proxy;
/**
 * 需要被代理的任务接口
 */
public interface SellService {

    void SellHouse();

}

• 目标对象

package com.muyichen.weibo.dplusservice.proxy;
/**
 * 目标对象
 */
public class SellServiceImpl implements SellService {

    @Override
    public void SellHouse() {
        System.out.println("卖出了一栋房子！");
    }

}

• 静态代理类

package com.muyichen.weibo.dplusservice.proxy;

/**
 * 静态代理类
 */
public class SellStaticProxy implements SellService {

    @Override
    public void SellHouse() {
        ad();
        //目标对象
        SellService target = new SellServiceImpl();
        target.SellHouse();
        backAd();
    }

    private void ad() {
        System.out.println("广告：xxx街道售卖房子了！");
    }

    private void backAd() {
        System.out.println("房子已经卖出，需要撤回广告！");
    }

}

• 静态代理测试

package com.muyichen.weibo.dplusservice.proxy;

/**
 * 代理测试
 */
public class testProxy {

    public static void main(String[] args) {
        //代理对象
        SellStaticProxy sellStaticProxy = new SellStaticProxy();
        //执行代理任务
        sellStaticProxy.SellHouse();
    }

}

• 输出结果

广告：xxx街道售卖房子了！
卖出了一栋房子！
房子已经卖出，需要撤回广告！

2、动态代理

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能，动态代理又被称为JDK代理或接口代理。
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中。
注意：动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

优点：动态代理弥补了静态代理中的一些不足之处，通过反射机制可以降低冗余，增强了代码的可维护性；
缺点：由于增加了代理对象，因此可能会造成请求的处理速度变慢；

• 目标对象

package com.muyichen.weibo.dplusservice.proxy;

/**
 * 需要被代理的任务接口
 */
public interface SellService {

    void SellHouse();

    class SellServiceA implements SellService {
        @Override
        public void SellHouse() {
            System.out.println("我是房子主人A，我要卖房子");
        }
    }

    class SellServiceB implements SellService {
        @Override
        public void SellHouse() {
            System.out.println("我是房子主人B，我要卖房子");
        }
    }

}

• 动态代理类

package com.muyichen.weibo.dplusservice.proxy;

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

/**
 * 动态代理类
 */
public class SellDynamicProxy implements InvocationHandler {

    //代理对象
    private Object proxyObject;

    public Object newProxyInstance(Object proxyObject) {
        this.proxyObject = proxyObject;
        return Proxy.newProxyInstance(
                //指定生成代理类对象的类加载器
                proxyObject.getClass().getClassLoader(),
                //指定目标对象的实现接口
                proxyObject.getClass().getInterfaces(),
                //指定InvocationHandler对象
                this
        );
    }

    /**
     * 动态代理每次为房屋主人卖房子的时候都会调用该方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        ad();
        Object invoke = method.invoke(proxyObject, args);
        backAd();
        return invoke;
    }

    private void ad() {
        System.out.println("动态代理广告：xxx街道售卖房子了！");
    }

    private void backAd() {
        System.out.println("动态代理已经将房子卖出，需要撤回广告！");
    }

}

• 动态代理测试

package com.muyichen.weibo.dplusservice.proxy;

/**
 * 代理测试
 */
public class testProxy {

    public static void main(String[] args) {
        //静态代理对象
        //SellStaticProxy sellStaticProxy = new SellStaticProxy();
        //执行静态代理任务
        //sellStaticProxy.SellHouse();

        //创建两个被代理对象
        SellService.SellServiceA sellServiceA = new SellService.SellServiceA();
        SellService.SellServiceB sellServiceB = new SellService.SellServiceB();

        new Thread(() -> {
            //动态代理对象A
            SellDynamicProxy sellDynamicProxy = new SellDynamicProxy();
            SellService proxyInstance = (SellService) sellDynamicProxy.newProxyInstance(sellServiceA);
            proxyInstance.SellHouse();
        }).start();

        new Thread(() -> {
            //动态代理对象B
            SellDynamicProxy sellDynamicProxy = new SellDynamicProxy();
            SellService proxyInstance = (SellService) sellDynamicProxy.newProxyInstance(sellServiceB);
            proxyInstance.SellHouse();
        }).start();

    }

}

• 输出结果

动态代理广告：xxx街道售卖房子了！
我是房子主人A，我要卖房子
动态代理已经将房子卖出，需要撤回广告！
动态代理广告：xxx街道售卖房子了！
我是房子主人B，我要卖房子
动态代理已经将房子卖出，需要撤回广告！

三、代理模式的应用场景

（1）当我们想要隐藏某个类时，可以为其提供代理类。
（2）当一个类需要对不同的调用者提供不同的调用权限时，可以使用代理类来实现（代理类不一定只有一个，我们可以建立多个代理类来实现，也可以在一个代理类中进行权限判断来进行不同权限的功能调用）。
（3）当我们要扩展某个类的某个功能时，可以使用代理模式，在代理类中进行简单扩展（只针对简单扩展，可在引用委托类的语句之前与之后进行）。

四、总结一下动态代理和静态代理的区别

• 静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
• JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
• 静态代理在编译时产生class字节码文件，可以直接使用，效率高。
  动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。