动态代理

代理模式的应用场景：

1、例如要给某个方法加上监控，记录方法开始时候的时间，方法结束时的时间。

静态代理：

静态代理缺点：接口与代理类是1对1的，有多个接口需要代理，就需要新建多个代理类，繁琐，类爆炸。

    public interface IPerson {
        void say();
    }

    public static class Man implements IPerson{
        @Override
        public void say() {
        }
    }

    /**
     * 静态代理缺点：接口与代理类是1对1的，有多个接口需要代理，就需要新建多个代理类，繁琐，类爆炸。
     * 所以有了动态代理
     */
    public class ManProxy implements IPerson{

        private IPerson target;

        public IPerson getTarget() {
            return target;
        }

        public ManProxy setTarget(IPerson target) {
            this.target = target;
            return this;
        }

        @Override
        public void say() {
            if (target != null) {
                //例如监控say方法的开始时间
                target.say();
                //例如监控say方法的结束时间
            }
        }
    }

复制

动态代理：

    /**
     * 动态代理
     */
    public static class NormalHandler implements InvocationHandler {

        private Object target;

        public NormalHandler(Object target) {
            this.target = target;
        }

        //第一个参数是代理对象，第二个参数是被调用的方法对象，第三个方法是调用参数。
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //例如监控target方法的开始时间
            method.invoke(target, args);
            //例如监控target方法的结束时间
            return null;
        }
    }

    /**
     * 动态代理的调用
     */
    public static void main(String[] args) {
        Man man = new Man();
        IPerson iPerson = (IPerson) Proxy.newProxyInstance(
                man.getClass().getClassLoader(),   //ClassLoader
                man.getClass().getInterfaces(),    //interfaces
                new NormalHandler(man));           //InvocationHandler
        iPerson.say();
    }

复制