JDK Proxy动态代理的底层实现

/*
* JDK动态代理的底层原理：返回实现了接口的匿名内部类。匿名内部类的方法的功能
* 是通过InvokeHandler接口实现类的invoke方法实现*/

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Adder{
    public Integer add(Integer a, Integer b);
}

class Myproxy{
    public static Adder getNewInstance(ClassLoader classLoader, final Class<?> clazz, InvocationHandler handler){
        //返回实现Adder接口的匿名内部类
        return new Adder() {
            @Override
            public Integer add(Integer a, Integer b) {
                try {

                    Method add = clazz.getMethod("add",Integer.class,Integer.class);
                    Object[] args = {a,b};
                    Object invoke = handler.invoke(this, add, args);
                    return (Integer) invoke;
                } catch (Exception e) {
                    e.printStackTrace();
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }

                return null;
            }
        };
    }
}

public class JDKProxy_Source {
        public static void main(String[] args){

            Adder adder = Myproxy.getNewInstance(Adder.class.getClassLoader(), Adder.class, new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if ("add".equals(method.getName())) {
                        Integer a = (Integer) args[0];
                        Integer b = (Integer) args[1];
                        return a + b;
                    }
                    return null;
                }
            });
            System.out.println(adder.add(1,1));
        }
}