/**
 * 抽象主题（Subject）角色：定义代理角色和真是角色的公共对外方法
 */
public interface Star {
    //面谈
    void confer();
    //签合同
    void signContract();
    //订票
    void bookTicket();
    //唱歌
    void sing();
    //收尾款
    void collectMoney();
}

/**
 * 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑
 *          供代理角色调用（依赖）
 */
public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("RealStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket");
    }

    @Override
    public void sing() {
        System.out.println("RealStar（周杰伦）.sing");
    }

    @Override
    public void collectMoney() {

    }
}

/**
 * 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，
 *          并可以附加自己的操作
 * 【将统一的流程控制放到代理角色中处理】
 */
public class ProxyStar implements Star {
    public Star star = null;

    public ProxyStar(Star star){
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("ProxyStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket");
    }

    /**
     * sing代理做不了，只能由明星本人来做
     * 所以需要调用Star接口（或者引用/依赖RealStar）
     */
    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney");
    }
}

/**
 *  静态代理总结：
 *         优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
 *         缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。
 */
public class Client {
    public static void main(String[] args) {

        RealStar realStar = new RealStar();
        ProxyStar proxyStar = new ProxyStar(realStar);

        proxyStar.confer();
        proxyStar.signContract();
        proxyStar.bookTicket();
        proxyStar.sing();   //调用RealStar中的方法
        proxyStar.collectMoney();
    }
}

/**
 * 抽象主题（Subject）角色：定义代理角色和真是角色的公共对外方法
 */
public interface Star {
    //面谈
    void confer();
    //签合同
    void signContract();
    //订票
    void bookTicket();
    //唱歌
    void sing();
    //收尾款
    void collectMoney();
}

/**
 * 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑
 *          供代理角色调用（依赖）
 */
public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("RealStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket");
    }

    @Override
    public void sing() {
        System.out.println("RealStar（周杰伦）.sing");
    }

    @Override
    public void collectMoney() {

    }
}

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

/**
 * 在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。
   真正的代理对象由JDK在运行时为我们动态的来创建,实现invoke方法。
 */
public class StarHandler implements InvocationHandler{

    public Star realStar;

    public StarHandler(Star realStar){
        this.realStar = realStar;
    }

    /**
     * 只要调用了代理类的方法，全部进入这里启动
     * 所以可以进入这里进行流程控制 —— 这样可以把和新方法之外的方法（需要代理的）进行流程控制
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object invoke_obj = null;
        System.out.println("----真正的方法执行前----");
        System.out.println("面谈，签合同，订票");

        if(method.getName().equals("sing")){
            invoke_obj = method.invoke(realStar, args);
        }

        System.out.println("----真正的方法执行后----");
        System.out.println("收尾款");
        return invoke_obj;
    }
}

import java.lang.reflect.Proxy;

/**
 * Proxy 实现动态代理（代理有接口的类）: JDK实现动态代理需要实现类通过接口定义业务方法
 *
 * Proxy.newProxyInstance()方法接受三个参数：
        ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
        Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型
        InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法
 *
 */

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

        Star realStar = new RealStar();
        StarHandler starHandler = new StarHandler(realStar);

        Star proxy  = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, starHandler);

        /**
         * 调用proxy代理对象执行方法，全部执行的是真实对象的方法
         * 只要调用peoxy代理对象，全部进入public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
         */
//        proxy.confer();
//        proxy.signContract();
//        proxy.bookTicket();
//        proxy.sing();
//        proxy.collectMoney();

        //在starHandler中做了流程控制后，只需要调用核心方法即可
        proxy.sing();

    }
}