什么是动态代理

动态代理就是在不改变源代码的情况下对方法进行增强。比如大明星类。如果不使用动态代理的话，增强sing、dance的话只能去修改源代码。

被代理对象

public class BigStar implements Star {
    private String name;


    public BigStar() {
    }

    public BigStar(String name) {
        this.name = name;
    }

    //唱歌
    @Override
    public String sing(String name){
        System.out.println(this.name + "正在唱" + name);
        return "谢谢";
    }

    //跳舞
    @Override
    public void dance(){
        System.out.println(this.name + "正在跳舞");
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "BigStar{name = " + name + "}";
    }
}

代理接口

我们引入动态代理，首先要创建抽象接口。被代理类BigStar哪些方法需要被增强就将方法的声明写入到这个Star接口。然后BigStar就要去引用实现这个接口。

public interface Star {

    //我们可以把所有想要被代理的方法定义在接口当中

    //唱歌
    public abstract String sing(String name);

    //跳舞
    public abstract void dance();


}

创建代理的工具类

其实没有这个工具类也是可以实现创建动态代理对象的，但是有的话在使用的时候就不用写重复的代码

其实这里的invoke方法写死了，不是很合理，我们可以将InvocationHandler通过参数传过来，这样invoke方法是调用者实现。

public class ProxyUtil {
    //创建一个代理
    public static Star createProxy(BigStar bigStar){
        Star o = (Star) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        //判断是通过代理执行什么方法，增强的操作
                        if ("sing".equals(method.getName())) {
                            System.out.println("准备话筒");
                        } else if ("dance".equals(method.getName())) {

                            System.out.println("打扫场地");
                        }
                        return method.invoke(bigStar, args);//参数1是调用者
                    }
                }
        );
        return o;
    }
}