代理模式

代理模式：

                      一.静态代理                二.动态代理

静态代理思想：

        主要理解抽象角色，真实角色，代理角色，客户端。

        假如我去租房子，方式为找中介。真正租房子的是房东给你租的，但你接触的是中介，中介不会租房子给你。但除了租房子外所有的事情都是中介来处理，这就是代理模式思想。根据这段话编写代码：

        事情是什么？房东和中介一直在关注什么事。那就是租房子。所以我们可以编写他俩共同关注的事件，可以为接口，也可以为抽象类。     抽象角色

public interface House {
    public void rent();
}

       租房子事件出来了，谁去真真正正的给你租房子，应该是房东。所以房东为真实角色。编写代码让房东去租房子。

public class LandlordImpl implements House {
    
    @Override
    public void rent() {
        System.out.println("房东进行租房子");    
    }
}

      上面说的，我们需要通过中介来租房子，所以中介这时候需要把房东拉来，告诉房东有客户了。房子谈成功后就要签订手续，办理合同，这些一系列操作都可以通过中介未来完成。这系列操作称为公共业务。这样中介成为代理角色。

public class ProxyLandlord implements House {
    private LandlordImpl landlord;
    public void setLandlord(LandlordImpl landlord) {
        this.landlord = landlord;
    }
    @Override
    public void rent() {
        //中介签合同
        contract();
        //房东租房子
        landlord.rent();
    }
    public void contract(){
        System.out.println("中介签合同");
    }
}

     我进行租房子时，需要房东与中介，房东是真正租房子给我，中介完成了签合同，协商，沟通等操作。

public class Main {
    public static void main(String[] args) {
        //new出来一个真实角色，房东。
        LandlordImpl landlord =new LandlordImpl();
        //new出来一个代理角色，中介。
        ProxyLandlord proxyLandlord = new ProxyLandlord();
        //中介把房东找来
        proxyLandlord.setLandlord(landlord);
        //进行租房子事件
        proxyLandlord.rent();
    }
}

测试结果：

代理模式好处：

        可以使真实角色的操作更加纯粹，不用关注公共的业务，公共的业务交给了代理角色，实现了业务的分工。

        公共业务发生扩展时，方便集中管理

        缺点：

        一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率低。

动态代理思想：

        动态代理和静态代理角色一样。

        动态代理的代理类是动态生成的，不是我们直接写好的。

        理解俩大类：

        1.proxy:生成动态代理实例  

        2.InvocationHandler: 调用处理程序，并返回结果。

1.抽象角色，事件为租房子.

public interface House {
    public void rent();
}

2.真实角色，事件为真正租房子

public class LandlordImpl implements House {
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

3.写一个InvocationHandler实现类，它的作用是1.通过客户端获取到真实角色，真正获取的是接口对象。根据接口对象可自动生成代理实例，并返回。2.利用反射机制invoke方法处理代理实例，并返回结果。

//自动生成代理类
public class InvocationHandlerImpl 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 {
        //动态代理的本质，就是使用反射机制实现的！
        Object invoke = method.invoke(target, args);
        return invoke;
    }
}

客户端执行：

public class Main {
    public static void main(String[] args) {
        //new出来一个真实角色，房东。
        LandlordImpl landlord =new LandlordImpl();
        InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl();
        //通过invocationHandler实现类调用真实角色来处理我们要调用的接口对象！
        invocationHandler.setTarget(landlord);
        //获得代理类
        House proxy = (House) invocationHandler.getproxy();
        //这里的proxy代理类是我们动态生成的
        proxy.rent();
    }
}

结果示例：

代理模式好处：

        可以使真实角色的操作更加纯粹，不用关注公共的业务，公共的业务交给了代理角色，实现了业务的分工。

        公共业务发生扩展时，方便集中管理。

        一个动态代理类代理的是一个接口，一般就是对应的一类业务。

        一个动态代理类可以代理多个类，只要是实现了同一个接口。

举例：张三租房，他是房东，属于真实角色。抽象角色也为租房。生成代理类可以代理张三去租房子。

           而李四也租房，他是房东，属于真实角色。抽象角色也为租房。生成代理类可以代理李四去租房子。

           共同点：实现了同一接口。