结构型设计模式-代理模式

结构型模式主要总结了一些类或者对象组合在一起的经典结构，用于解决特定场景的问题。

代理模式：

在不改变原始类或者被代理类代码的情况下，通过引入代理类来给原始类附加功能。

1、如果被代理类实现了一套接口，那么代理类也同样实现这一套接口，然后内部在实现这套接口的时候，委托给被代理类，还可以附加一些其他的处理；

2、如果被代理类没有定义接口，并且原始类代码并不是我们开发维护的（比如来自一个第三库的类库），并没有办法修改原始类，那么这时候就采用继承的方式来扩展外部类。

综上，很明显代理模式就是类上加了一层壳子，还是蛮好理解的。

代理类中，需要将原始类中的所有方法都重新实现一遍；同时，如果要添加代理的类有很多，那么就需要针对每个类都创建一个代理类。显然，这真的很麻烦，类立刻翻倍了。

针对上述的问题，就可以使用动态代理来解决。不管出现多么糟糕的情况，都有人知道怎么解决，真的很棒棒。

动态代理就说不事先为每个原始类编写代理类，而是在运行的时候，动态的创建原始类对应的代理类，然后在系统中用代理类替换调原始类。来看看如何实现吧。

首先需要明确的就是动态代理依赖反射。上代码吧。

public interface IUserController {

    void say();
    void run();
}

public class UserController implements IUserController{
    @Override
    public void say() {
        System.out.println("say 吧");
    }

    @Override
    public void run() {
        System.out.println("run 啊 瘪犊子");
    }
}

public class DemoProxy {


    public static void main(String[] args) {
        DemoProxy proxy = new DemoProxy();
        IUserController userController = (IUserController) proxy.createProxy(new UserController());
        userController.say();
        userController.run();
    }
    /**
     * 创建代理类对象
     * @param proxyObject
     * @return
     */
    public Object createProxy(Object proxyObject){
        Class<?>[] interfaces = proxyObject.getClass().getInterfaces();
        DynamicProxyHandler proxyHandler = new DynamicProxyHandler(proxyObject);
        return Proxy.newProxyInstance(proxyObject.getClass().getClassLoader(),interfaces,proxyHandler);
    }
private class DynamicProxyHandler implements InvocationHandler{
        private Object mProxyObject;

        public DynamicProxyHandler(Object mProxyObject) {
            this.mProxyObject = mProxyObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result  = method.invoke(mProxyObject,args);
            return result;
        }
    }
}

完事运行就可以得到