代理模式

通过代理，控制对对象的访问。

抽象角色：定义代理角色和真实角色公共对外方法，一个接口
真实角色：实现抽象角色接口，关注真正的业务逻辑
代理角色：实现与代理角色一样的接口，内部有真实角色的引用，并且可以添加自己的操作

静态代理例子：自定义代理类
先定义一个接口：

public interface Star {
    void sing();//表演
}

代理类与真实类继承一个接口：

public class RealStar implements Star {//被代理的真实类
    private String name;

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

    @Override
    public void sing() {
        System.out.println("歌手表演");
    }
}

public class ProxyStar implements Star{
    private  RealStar realStar;//内部有真实类

    public ProxyStar(RealStar realStar) {
        this.realStar = realStar;
    }

    public   void confer(){
        System.out.println("经纪人面谈");}
    public void signContract(){
        System.out.println("经纪人签合同");}
    @Override
    public void sing() {
          realStar.sing();
    }
    public void collectmoney() {
        System.out.println("经纪人收钱");
    }
}

实现静态代理模式

public class client {
    public static void main(String[] args) {
        RealStar realStar=new RealStar("Bibber");
        ProxyStar proxyStar=new ProxyStar(realStar);
        proxyStar.confer();
        proxyStar.collectmoney();
        proxyStar.sing();
    }
}

动态代理：程序动态生成代理类
JDK自带的动态代理：
java.lang.reflect.Proxy:作用是动态生成代理类和对象

java.lang.reflect.InvocationHandler（处理器接口）：
可以通过invoke方法实现对真实角色代理访问
每次通过Proxy生成代理类对象时都要指定对应的处理器对象

首先定义一个处理类继承InvocationHandler接口：

public class StarHandler implements InvocationHandler {
    Star realstar;

    public StarHandler(Star realstar) {
        this.realstar = realstar;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//代理类，调用的方法，方法的参数
        System.out.println("签合约");
     if(method.getName().equals("sing")) { method.invoke(realstar);}//代理类实现真实类的方法是通过invoke方法完成的
        System.out.println("收尾款");
        return null;
    }
}

Star接口：

public interface Star {
    void sing();//表演
}

被代理的真实类：

public class RealStar implements Star {
    private String name;

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

    @Override
    public void sing() {
        System.out.println("歌手表演");
    }
}

重点😀客户端实现动态代理：

public class client {
    public static void main(String[] args) {
        Star realstar=  new RealStar("Jay");
        StarHandler handler=new StarHandler(realstar);//处理器handler，处理真实类realstar
         Star proxy=(Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class},handler);
        //newProxyInstance方法产生代理类对象proxy，该类实现了Star.class的接口，代理类对象proxy对真实对象realstar进行代理操作
        proxy.sing();

    }
}

面向切面编程AOP使用了动态代理原理：
例子里 客户找歌手表演，经过的流程，可以将这些流程点看作一个面。
客户点到流程面到歌手点！