The main purpose is to record the implementation of java Dynamic agent and pave the way for rpc learning.

What is a dynamic agent?
Dynamic proxy is to generate a proxy for a class when Java is running, that is, in the code phase, there is no actual java file corresponding to it.

The class that java implements dynamic Proxy is the Proxy class in the reflection package.
Let's look at the example of dynamic agent

public class TestProxy {
    public static void main(String[] args) {
        PaoTui paoTuiProxy = (PaoTui)Proxy.newProxyInstance(
                PaoTui.class.getClassLoader(), 
                new Class[]{PaoTui.class},
                new InvocationHandler() {
                    Flan flan = new Flan();
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        return method.invoke(flan, args);
                    }}
                );

        paoTuiProxy.buySomething("an apple");
        System.out.println(paoTuiProxy.toString());
    }
}

interface PaoTui {
    void buySomething(String something);
}

class Flan implements PaoTui {
    @Override
    public void buySomething(String something) {
        System.out.println("Flan buys "+something+" for Remi");
    }
}

Save the proxy class and check the source code:

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

public final class $Proxy0 extends Proxy implements PaoTui {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void buySomething(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("PaoTui").getMethod("buySomething", new Class[]{Class.forName("java.lang.String")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}