代理模式与动态代理

什么是代理模式？

代理，在生活中很常见，比如我不想去做一些复杂的，多重选择的事情，或者以不同的方式回应不同的事件，这个时候我们就可以找一个代理，让他帮我做这些事，只需要给他需要的东西，他就能自动匹配我想让他做的事情，不需要我亲自去不同的地方做不同的事情。

代理分为静态代理和动态代理

静态代理

静态代理，在编译期间就确定了代理关系的代理类叫静态代理。即需要手动实现代理，为每个业务类抽象一个接口，对应的创建代理类

写一个传菜的服务员

//定义一个厨师接口
public interface Cook {
    String send(String food);
}

//厨师出菜
public class CookImpl implements cook {
    public String send(String food) {
        System.out.println("send food:" + food);
        return food;
    }
}

//服务员(代理)代替厨师传菜
public class Waiter implements Cook {

    private final Cook cook;

    public CookProxy(Cook cook) {
        this.cook = cook;
    }

    //增强了厨师出菜的方法
    @Override
    public String send(String food) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("接收到麻辣香锅");
        smsService.send(food);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("将麻辣香锅传给客人");
        return null;
    }
}

我们每多出一个厨子，就要多出一个服务员传菜，厨子和服务员一对一，很不实用，我们想要很多厨师，但只需要一个服务员传菜，这时候就需要动态代理出马了。

静态代理的缺点：

• 1、重复性：即使有多个基础业务需要代理，也不需要编写过多重复的模板代码；

• 2、脆弱性：当基础接口变更时，同步改动代理并不是必须的。

动态代理

动态代理是指在运行时才确定代理类和被代理类的关系，即我的服务员要对接哪个厨子，这个是由用户选择的，用户传入什么参数，调用什么方法，返回值类型，来确定到底需要用到哪些方法。其实现有JDK动态代理、Javassist 动态代理和 ASM 动态代理等。

在动态代理中最核心的方法就是Proxy类中的newProxyInstance方法和InvocationHandler 方法

就拿JDK动态代理举例：

public static Object newProxyInstance(ClassLoader loader,//类加载器，用于加载代理对象。
                                          Class<?>[] interfaces,//被代理类实现的一些接口
                                          InvocationHandler h)//实现了 InvocationHandler 接口的对象
        throws IllegalArgumentException
    {
        ......
    }

要实现动态代理就要实现InvocationHandler中的invoke方法

public interface InvocationHandler {

    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

invoke对象的三个参数是，proxy动态生成的代理类，method代理类调用的方法，args是method方法的参数

通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情，对实际想调用的方法进行增强。

实例

 HWSale saleProxy = (HWSale) Proxy.newProxyInstance(
                hwSale.getClass().getClassLoader(), // 通过真实对象获取对应的类加载器
                hwSale.getClass().getInterfaces(),  // 通过真实对象获取对应的接口 Class 数组
                   //匿名内部类实现了InvocationHandler方法，对方法的增强
                 new InvocationHandler() {
                    @Override        //这里可以实现方法的动态选择，即在运行时才确定代理对象
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String s1 = null;
                        // 发现当前执行的方法是 sale 方法
                        if (method.getName().equals("salePhone")) {
                            // 获取当前方法执行的实际参数，关注方法的参数真实数据类型和个数
                            Float proxyPrice = (Float) args[0];

                            // 真实对象依然执行目标方法，但是方法的参数是修改之后的代理价格【增强参数】
                            // 得到了原本的返回值类型
                            s1 = hwSale.salePhone(proxyPrice * 0.9F);

                            // 【增强返回值】
                            s1 += "华为手机打九折啦";

                            return s1;
                        } else {
                            return null;
                        }
                    }
                });

        System.out.println("代理售出");
        String s1 = saleProxy.salePhone(10000F);
        System.out.println(s1);
    }

输出结果为

9000.00华为手机打九折啦
//或者
代理售出
10000.0

输出结果取决于方法名是否为salePhone

总结

静态代理在设计模式中随处可见，但静态代理有重复性和脆弱性 动态代理是用来给方法实现增强并且让方法选择更为多样的，即在用户调用一个代理类中的方法就能够执行相对应的方法，甚至通过返回值类型来确定执行哪一个重载的方法。

如有不足，私信或者评论指正，肥肠感激。🙋