简单例子

package com.kfm.jdbc.day0328;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public interface Actor {
    void sing(double money);
    void jump(double money);
}
class Kun implements Actor{
    @Override
    public void sing(double money) {
        System.out.println("收了" + money + "元，唱了一首《只因你太美》");
    }
    @Override
    public void jump(double money) {
        System.out.println("收了" + money + "元，跳了一个舞");
    }
}
class Agent implements Actor{
    private Actor actor;
    public Agent(Actor actor){
        this.actor = actor;
    }
    @Override
    public void sing(double money) {
        this.actor.sing(money * 0.8);
    }
    @Override
    public void jump(double money) {
        this.actor.jump(money * 0.9);
    }
}
class Main {
    public static void main(String[] args) {
        Kun kun = new Kun();
        Actor o = (Actor) Proxy.newProxyInstance(Kun.class.getClassLoader(),
                new Class[]{Actor.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String name = method.getName();
                        if ("sing".equals(name)){
                            System.out.println("请他唱歌先请我吃饭");
                            return method.invoke(kun, args);
                        } else {
                            System.out.println("做其他事得加钱");
                            return method.invoke(kun, args);
                        }
                    }
                }
        );
        o.sing(1.1);
        o.jump(2.2);
//        Agent agent = new Agent(kun);
//        agent.sing(50000);
    }
}

对例子进行分析：

• 有一个actor的接口，有jump和sing两个方法
• ikun实现了此接口
• 但是你能直接见到IKUN吗？？？
• 因此需要一个agent也来实现actor接口，但是，agent需要赚一点差价
• 现在在代码每次运行时，来一个agent，因此就用到代理：

在 Main 类中，首先创建了一个 Kun 对象 kun，然后使用 Java 反射机制，创建了一个代理对象 o，代理的是 Kun 类。在代理对象的创建过程中，传入了 Kun 类的类加载器、Actor 接口的 Class 对象和一个 InvocationHandler 对象。这个 InvocationHandler 对象的作用是拦截代理对象方法的调用，对调用进行增强。在 invoke 方法中，首先判断调用的方法是 sing 还是 jump，如果是 sing 方法，则输出一条信息“请他唱歌先请我吃饭”，然后再调用 kun 对象的 sing 方法。如果是 jump 方法，则输出一条信息“做其他事得加钱”，然后再调用 kun 对象的 jump 方法。最后，通过代理对象 o 调用了 sing 和 jump 方法。在这个示例中，代理对象 o 拦截了 sing 和 jump 方法的调用，对 sing 方法进行了增强，输出了一条信息，而对 jump 方法没有进行增强，只是输出了一条提示信息。

Proxy.newProxyInstance 是 Java 动态代理的一个方法，用于创建代理对象。它有三个参数：

ClassLoader 类加载器，用于加载代理对象的 Class 文件。
Class<?>[] interfaces，被代理对象实现的接口列表，这些接口必须是非 final 类型。
InvocationHandler invocationHandler，实现了 InvocationHandler 接口的对象，用于拦截代理对象的方法调用并进行增强。
在这段代码中，Kun.class.getClassLoader() 表示使用 Kun 类的类加载器来加载代理对象的 Class 文件。new Class[]{Actor.class} 表示要代理的接口列表，这里只有 Actor 接口。new InvocationHandler() 表示实现了 InvocationHandler 接口的对象，这里使用了匿名内部类来实现。在这个匿名内部类中，重写了 invoke 方法，用于拦截代理对象的方法调用并进行增强。

最后，将代理对象强制转换为 Actor 类型，并将其赋值给 o 变量，o 可以调用 Actor 接口中的方法，实际上调用的是被代理对象 Kun 的对应方法，而 InvocationHandler 中的增强操作也会被执行。

invoke() 方法是 InvocationHandler 接口中的一个方法，用于拦截代理对象的方法调用并进行增强。它有三个参数：

Object proxy，代理对象本身，通常在 invoke() 方法中不会使用到。
Method method，代理对象被调用的方法对象。
Object[] args，代理对象被调用的方法的参数列表。
在这段代码中，invoke() 方法首先通过 Method 对象获取被调用方法的名字，然后判断被调用的方法是 sing 还是其他方法。如果是 sing 方法，就输出一句话并调用被代理对象 Kun 的 sing() 方法，并将其返回值作为 invoke() 方法的返回值。如果是其他方法，就输出另一句话并调用被代理对象 Kun 的对应方法，并将其返回值作为 invoke() 方法的返回值。

因此，当代理对象 o 调用 sing() 方法时，实际上会调用 invoke() 方法，并在其中输出一句话，并调用被代理对象 Kun 的 sing() 方法，并将其返回值作为 o.sing() 的返回值。当代理对象 o 调用 jump() 方法时，实际上也会调用 invoke() 方法，并在其中输出另一句话，并调用被代理对象 Kun 的 jump() 方法，并将其返回值作为 o.jump() 的返回值。