Java学习------静态、动态代理

前言

代理模式是一种常见的设计模式，其中分为静态代理和动态代理，最近这两天简单总结了一下代理的使用，发现网上大部分教程都不太好理解，然后我总结了一下，由一个简单的需求去说明。

静态代理

代理这个词就有很多人不理解，我们身边就有很多代理，比如微商，他们并不生产任何东西，只是一个代理，那么咱们就从微商的模式来理解代理。

下面我们这里有个卖面膜的微商代理（代理了水面膜和植物面膜），首先他不生产面膜，是相应面膜工厂生产面膜，微商代理实际只负责发朋友圈宣传和交货后的收款，工厂只负责生产交付，下面就开始实例化出这个模式

定义面膜工厂接口（使用代理必须使用接口，后面代码中解释）

public interface Mask {
    void getMask();
}

实现水面膜的交付

public class WaterMask implements Mask {
    @Override
    public void getMask() {
        System.out.println("交付一个水面膜");
    }
}

实现植物面膜的交付

public class PlantMask implements Mask {
    @Override
    public void getMask() {
        System.out.println("交付一个植物面膜");
    }
}

实现面膜代理

import factory.Mask;
import factory.impl.PlantMask;
import factory.impl.WaterMask;
//面膜静态代理
public class MaskStaticProxy implements Mask {
    //创建一个私有的交付对象，因为会交付不同对象，这就是必须使用接口的原因
    private Mask mask;

    //通过构造参数得到相应交付对象
    public MaskStaticProxy(Mask mask) {
        this.mask = mask;
    }

    @Override
    public void getMask() {
        System.out.println("发朋友圈推销:"+mask.getClass().getSimpleName());  //交付前操作
        mask.getMask();       //交付
        System.out.println("收钱");  //交付后操作
    }
}

测试整个流程

public static void main(String[] args) {
    //实例化交付对象
    Mask waterMask = new WaterMask();
    Mask plantMask = new PlantMask();
    //实例化不同交付对象代理
    MaskStaticProxy waterStaticProxy = new MaskStaticProxy(waterMask);
    MaskStaticProxy plantStaticProxy = new MaskStaticProxy(plantMask);
    //代理交付
    waterStaticProxy.getMask();
    plantStaticProxy.getMask();
}

测试结果

发朋友圈推销:WaterMask
交付一个水面膜
收钱
发朋友圈推销:PlantMask
交付一个植物面膜
收钱

为什么要使用代理？推销过程直接在水面膜工厂和植物面膜工厂实现不好吗？

答：不够优雅，代码冗余，后期不好修改

上面就是一个静态代理的构建过程，相信大家都很好理解

动态代理

咱们微商故事继续，随着业务的不断发展壮大，我不光要卖假面膜，我还准备拓展业务，做假鞋代理

首先再来个制鞋接口

public interface Shoes {
    void getShoses();
}

我们通过制鞋接口生产耐克运动鞋

public class NikeShoes implements Shoes {
    @Override
    public void getShoses() {
        System.out.println("交付一双耐克鞋");
    }
}

问题来了

现在发现我现在代理，只会代理面膜，我们可以再写一个卖鞋的代理，但是那样就会有两个代理，怎样才能一个代理实现所有业务的销售呢？

解决思路

如果有一个东西，可以生产代理，我们给他面膜他就给我面膜代理，给他鞋他就给我鞋代理就好了，这个java已经给我们实现好了，就是动态代理，我们要做的只是编写我们的业务代码，使用java提供好的动态代理绑定即可，那么我们下面去实现一个动态代理

import factory.Mask;
import factory.Shoes;
import factory.impl.NikeShoes;
import factory.impl.WaterMask;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理
public class DynamicProxy implements InvocationHandler {

    private Object target;

    /**
     * 绑定委托对象并返回一个相应的代理
     *
     * @param target 真实对象
     * @return 代理对象【占位】
     */
    public Object bind(Object target, Class[] interfaces) {
        this.target = target;
        //第一个参数是类加载器，第二个参数是或者对象的接口（代理对象挂在那个接口下），第三个参数this代表当前Proxy类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), interfaces, this);
    }

    /**
     * 同过代理对象调用方法首先进入这个方法.
     *
     * @param proxy  --代理对象
     * @param method -- 方法,被调用方法.
     * @param args   -- 方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;

        System.out.println("发朋友圈推销:" + proxy.getClass().getName());  //交付前操作
        result = method.invoke(target, args);       //交付
        System.out.println("收钱");  //交付后操作
        return result;
    }
}

这里的bind方法里面有句：

Proxy.newProxyInstance(target.getClass().getClassLoader(), interfaces, this)

他的意思就是生成一个代理对象，绑定this(DynamicProxy )，即使用DynamicProxy 作为对象的代理。

一旦这样绑定后，那么在进入代理对象方法调用的时候就会到DynamicProxy 的invoke方法上，invoke方法有三个参数：第一个proxy是代理对象，第二个是当前调用那个方法，第三个是方法的参数。

举例，现在WaterMask对象用bind方法绑定后，返回其【占位】(proxy)，我们在调用waterMask.getMask()，那么它就会进入到DynamicProxy 的invoke()方法。而invoke参数中第一个便是代理对象proxy，方法便是getMask。那么我们就可以通过反射技术调度真实对象的方法。

测试动态代理

public static void main(String[] args) {
    Mask waterMask = new WaterMask();
    Shoes nikeShoes = new NikeShoes();
    DynamicProxy dynamicProxy = new DynamicProxy();
    //绑定代理对象
    waterMask = (Mask) dynamicProxy.bind(waterMask, new Class[]{Mask.class});
    //经过绑定，再次调用就会进入invoke方法
    waterMask.getMask();

    //卖鞋
    nikeShoes = (Shoes) dynamicProxy.bind(nikeShoes, new Class[]{Shoes.class});
    nikeShoes.getShoses();
}

测试结果

发朋友圈推销:com.sun.proxy.$Proxy0
交付一个水面膜
收钱
发朋友圈推销:com.sun.proxy.$Proxy1
交付一双耐克鞋
收钱

最后这个代理又给我们卖面膜，又卖鞋，完美。

遗留问题

发现使用动态代理测试结果打印推向内容为com.sun.proxy.$Proxy0，为什么proxy.getClass().getName()打印出的并不是类型名？

提示：动态代理的代理对象并不是真正的代理对象，是一个占位，大家感兴趣，可以去探究一下，深入研究动态代理实现机理。

如果我们调用nikeShoes对象的toString()方法，发现也会被代理，但是我们并不想这个方法被代理，怎么实现？