关于动态代理的使用流程及举例理解

有一位同学（Host）拥有一套房子，他想把他的房子租赁出去，但又忙于学业无法亲自办理，于是他选择了找房屋中介代理去出租房子。为了实现这个目的，他需要表示他有这个需求，于是他需要实现租房接口（Rent）。

public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东：有房出租！！");
    }
}

public interface Rent {
    public void rent();
}

现在，他需要去租房平台寻找一个中介。

租房平台如下：

public class ProxyInvocationHandler implements InvocationHandler {

    //需要代理哪个接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成并得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制进行实现
        Object result = method.invoke(rent, args);
        return result;
    }
}

寻找中介如下：

找到中介之后，中介需要接受委托，并与房东先生订立委托契约。

与中介建立委托之后，中介需要拿到房东的钥匙，或者说，对房东房子的管理权。

然后，房东开始工作。

总的执行流程为：

public class Client {
    public static void main(String[] args) {
        //现在有一个房东，他想要出租自己的房子
        Host host = new Host();

        //他选择去某平台找一个专门代理租房事务的中介，来替他租赁自己的房子
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        //中介接受委托，与这位房东订立代理契约
        handler.setRent(host);
        //中介接管房东的房屋钥匙
        Rent proxy = (Rent) handler.getProxy();
        //中介开始工作
        proxy.rent();

    }
}

效果如下：

在这里插入图片描述

进阶版：

public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房东：有房出租！！");
    }

    @Override
    public void seeHouse() {

    }

    @Override
    public void hetong() {

    }

    @Override
    public void fare() {

    }
}

public interface Rent {
    public void rent();
    //看房
    public void seeHouse();
    //签合同
    public void hetong();
    //收费
    public void fare();
}

现在，他去了一个某大型网络平台。

public class ProxyInvocationHandler implements InvocationHandler {

    //需要代理哪个接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成并得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质，就是使用反射机制进行实现
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg) {
        System.out.println("[DEBUG] 执行了 "+msg+"  方法");
    }
}

现在他登录了这个平台。

在这个平台上，他找到了房屋出租分区，在这里，他挑了一个愿意为他代理出租房子的房屋中介。

public class MyProxy implements Rent {
    private Host host;

    public MyProxy() {
    }

    public MyProxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        host.rent();
    }

    @Override
    public void seeHouse() {
        System.out.println("中介：看房！！");
    }

    @Override
    public void hetong() {
        System.out.println("中介：签合同！！");
    }

    @Override
    public void fare() {
        System.out.println("中介：收钱！！");
    }


}

他选择了这个中介。

中介接受了他的委托，并与他签订房屋代理租赁契约。

中介表示需要拿到他的钥匙，或者说，房屋的管理权。

中介开始工作。

proxy.rent();//中介出租房子
proxy.seeHouse();//中介看房
proxy.hetong();//中介带你签合同
proxy.fare();//中介找你收钱

完整流程代码如下：

public class Client {
    public static void main(String[] args) throws NoSuchMethodException {
        //现在有一个房东，他想要出租自己的房子(即实现Rent接口)
        Host host = new Host();

        //他选择去平台找一个中介，来替他租赁自己的房子
        ProxyInvocationHandler handler = new ProxyInvocationHandler();

        //在平台上挑了一个专门负责租房业务的中介
        MyProxy myProxy = new MyProxy(host);

        //中介接受委托，与这位房东订立代理契约
        handler.setTarget(myProxy);
        //中介接管房东的房屋钥匙
        Rent proxy = (Rent) handler.getProxy();
        //中介开始工作
        proxy.rent();//中介出租房子
        proxy.seeHouse();//中介看房
        proxy.hetong();//中介带你签合同
        proxy.fare();//中介找你收钱
    }
}