通俗易懂的注释，让你一看就懂的java动态代理

package com.jun.music.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.nio.file.attribute.AclEntry;

public class ProxyTest {
    public static void main(String[] args) {
        Message message = (Message) new MessageProxy().bind(new MessageImpl());
        /**
         * 通过传入委托对象，利用反射去调用委托对象方法。
         */
        message.send();
    }
}

interface Message{
    public boolean send();
}

class MessageImpl implements Message{

    @Override
    public boolean send() {
        System.out.println("发送成功");
        return true;
    }
}




class MessageProxy implements InvocationHandler {
    private Object object;  // 委托对象

    //    public MessageProxy(Object object){
//        this.object = object;
//    }
    public boolean connect() {
        System.out.println("链接成功");
        return true;
    }

    public void close() {
        System.out.println("成功关闭");
    }

    public Object bind(Object object) {
        this.object = object;
        return Proxy.newProxyInstance(this.object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
        /*
            上面产生代理对象， 传入委托对象的classloader， 还有interfaces，就可以通过反射去调用委托对象方法，
            委托对象再调用invoke方法，将反射获取到的委托对象方法再次传入到该类this实例中的invoke方法
            然后再通过用户实现InvocationHandler自定义的代理类中的委托对象， 去动态的调用

         */
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnData = null;
        if (connect()) {
            returnData = method.invoke(object, args);
            this.close();
        }
        System.out.println(returnData);
        return returnData;
    }
}