现实生活中，存在着各种代理，比如海外代购，律师，游戏代练等等，映射到Java中，也存在着代理，汇总实际场景中的使用，将代理分为了静态代理和动态代理两种模式。

StaticProxy

静态代理拆开来，静态指的是在程序运行前就已经存在了代理类的字节码文件，也就是这个代理类是程序员手动编写的，代理类和被代理类的关系就已经确定了的，代理指的就是编写的代理类对被代理类的增强效果。

场景一：

张三看上了海外一家公司CompanyA制造的一款包，如果他自己想要买这款包，他就需要出国购买，出国前办理签证，坐飞机，买包，坐飞机，回家。但他并不像这么麻烦，于是他便找了一家代购店，于是张三所做的事情就是给钱，拿包完事，至于中间代购店如何出的国，如何坐的飞机，跟张三毫无关系，因为张三的目的就是要这个包，抽象如下：

业务接口BusinessA（制造包）

/**
 * Description: 制造包的业务接口
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public interface BusinessA {

    void createBag();

}

生产包的厂商CompanyA：

/**
 * Description: 国外生产包的厂商A，但不限于A，可能还有B，C 。。。
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public class CompanyA implements BusinessA {

    @Override
    public void createBag() {
        System.out.println("CompanyA公司生产的包。");
    }

}

代理类ProxyStore：

/**
 * Description: 代理商店，它对外宣称有卖包的业务
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public class ProxyStore implements BusinessA {

    private CompanyA companyA;

    @Override
    public void createBag() {
        // 1. 在购买前做的事
        doBefore();
        // 2. 从厂商购买
        companyA.createBag();
        // 3. 运回国内
        doAfter();
    }

    private void doBefore() {
        System.out.println("办理签证，坐飞机去国外。");
    }

    private void doAfter() {
        System.out.println("从国外运回国内。");
    }

    public CompanyA getCompanyA() {
        return companyA;
    }

    public void setCompanyA(CompanyA companyA) {
        this.companyA = companyA;
    }
}

测试：

/**
 * Description:
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public class Test01 {

    @Test
    public void m1() {
        // 创建代理类
        ProxyStore proxyStore = new ProxyStore();
        // 让代理有买包的权利
        proxyStore.setCompanyA(new CompanyA());
        // 由代理去购买
        proxyStore.createBag();
    }
}

静态代理的优缺点：

• 优点：业务类只需要关注业务本身，无需关心业务前后所做的增强处理，这些都交给代理来处理。
• 缺点：代理类代理的业务单一，假如业务接口扩展了，还需要改动代理类的代码，增加维护的成本。

DynamicProxy

动态代理拆开，动态指的是代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

• Proxy类，它是所有动态代理的父类，其中利用静态方法newProxyInstance()来创建代理类。
• InvocationHandler接口，其中invoke方法的作用就是在代理类中调用目标方法，并返回结果。
• invoke方法的三个参数
  • proxy：代理对象的实例
  • method：通过它可以调用真实方法
  • args：传过来的参数

还是上面静态代理的例子(以下为JDK动态代理，只能代理接口)：

业务接口BusinessA：

/**
 * Description: 制造包的业务接口
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public interface BusinessA {

    void createBag();

}

业务接口BusinessB：

/**
 * Description: 制造手表的业务接口
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public interface BusinessB {

    void createWatch();

}

生产包的厂商CompanyA：

/**
 * Description: 国外生产包的厂商A，但不限于A，可能还有B，C 。。。
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public class CompanyA implements BusinessA {

    @Override
    public void createBag() {
        System.out.println("CompanyA公司生产的包。");
    }

}

生产手表的厂商CompanyB：

/**
 * Description: 国外生产手表的厂商CompanyB
 *
 * @Author 70KG
 * @Date 2019/3/12
 * @Since v1.0
 */
public class CompanyB implements BusinessB {

    @Override
    public void createWatch() {
        System.out.println("CompanyB公司生产的手表。");
    }

}

代理类：

需要实现InvocationHandler接口，并且重写invoke方法，还需要一个获取代理对象的方法getProxyInstance。

/**
 * description 实现InvocationHandler接口的动态代理类
 *
 * @author 70KG
 * @date 2019/3/12
 */
public class ProxyClassBeans implements InvocationHandler {

    /**
     * 被代理的对象
     **/
    private Object tar;

    /**
     * 利用反射来调用目标方法
     **/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 调用目标方法之前
        doBefore();
        // 2. 调用目标方法
        Object invoke = method.invoke(tar, args);
        // 3. 调用目标方法之后
        doAfter();
        return invoke;
    }

    /** 绑定该类实现的所有接口，取得代理类 **/
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(tar.getClass().getClassLoader(), tar.getClass().getInterfaces(), this);
    }

    // ===================动态代理类中的增强方法========================

    public void doBefore() {
        System.out.println("在国外寻找优质的货源。");
    }

    public void doAfter() {
        System.out.println("精包装安全邮寄回国内。");
    }

    // ===========================get/set=============================


    public Object getTar() {
        return tar;
    }

    public void setTar(Object tar) {
        this.tar = tar;
    }
}

测试：

/**
 * description
 *
 * @author 70KG
 * @date 2019/3/12
 */
public class MainTest {
    public static void main(String[] args) {
        // 获取动态代理类
        ProxyClassBeans proxyClassBeans = new ProxyClassBeans();
        IBusinessA companyA = new CompanyA();
        // 将目标类交给代理类
        proxyClassBeans.setTar(companyA);
        // 拿到代理对象
        IBusinessA instance1 = (IBusinessA) proxyClassBeans.getProxyInstance();
        instance1.createBag();

        System.out.println("=================================");

        IBusinessB companyB = new CompanyB();
        proxyClassBeans.setTar(companyB);
        IBusinessB instance2 = (IBusinessB) proxyClassBeans.getProxyInstance();
        instance2.saleWatch();
    }
}

运行结果：

在国外寻找优质的货源。
CompanyA公司生产的包。
精包装安全邮寄回国内。
=================================
在国外寻找优质的货源。
CompanyB公司生产的手表。
精包装安全邮寄回国内。

由运行结果可知，动态代理在增添业务的时候(增添了卖手表的业务)，只需要调用者传入不同的接口就好了，代理类不需要改动。

动态代理的优缺点：

• 优点：同样，我们只关注业务类的逻辑即可，并且如果新增业务类，代理类的代码根本不需要动，因为代理对象是根据传入的接口类型生成的，方便扩展。
• 缺点：JDK动态代理，在生成代理对象的时候必须传入业务类的接口类型，也就是只能够代理接口。能够代理类的动态代理是CGLIB动态代理。