不学无数——Java代理模式

1. 代理

Provide a surrogate or placeholder for another object to control access to it（为其余对象提供一种代理以控制对这个对象的访问）

1.1 什么是代理

代理是基本的设计模式之一，它是你为了提供额外或者不一样的行为，而插入的用来代替”实际对象“的对象。这些操做一般是涉及到与”实际对象“的通讯。

举个现实中和的例子：假设你有一套房子要出租，一种方法是你直接去网上发布出租信息，而后直接带要租房子的人来看房子，可是可能你很忙，你没有时间去处理这些事情，因此你能够去找中介，让中介帮你处理这些琐碎事情，中介实际上就是你的代理。原本是你要作的事情，如今中介帮助你一一处理。当咱们须要租房子时，只能找房屋中介，而不能找房东了，由于房东已经和房屋中介签定了协议。因此房屋中介代理的存在就是为了拦截咱们对于房东的直接访问。

下面在代码中体现出上面的例子

如今有一个House，有价格和颜色两个属性。

class Home{
    Integer price;
    String color;
    -----get.set方法
}

复制代码

有个房主的接口，每一个房主都具备出租的功能。

interface Homeowner{
    public void LeaseHouse(Home home);
}

复制代码

如今有一个真实的房主实现了这个接口

class RealHomeowner implements Homeowner{
    @Override
    public void LeaseHouse(Home home) {
        System.out.println("房价是 "+ home.price);
        System.out.println("房子颜色是 "+ home.color);
    }
}

复制代码

如今有一个房屋代理，房屋代理也具有出租的功能，可是他出租的是和他签定协议房主的房子。在和房主签定协议以后他会对房子进行处理，而且将价格提升。

class HomeProxy implements Homeowner{

    private Homeowner homeowner;

    public HomeProxy(Homeowner homeowner){
        this.homeowner = homeowner;
    }
    @Override
    public void LeaseHouse(Home home) {
        System.out.println("装修房子");
        home.color="red";
        System.out.println("提高价格");
        home.price=home.price+1000;
        homeowner.LeaseHouse(home);
    }
}

复制代码

当房屋代理将房子整理好了之后，就将房源信息放入到网上供人们选择

public static void consume(Homeowner homeowner,Home home){
    if (homeowner instanceof HomeProxy){
        homeowner.LeaseHouse(home);
    }
    else {
        System.out.println("请找房屋代理");
    }
}

复制代码

在主方法中调用consume()方法

public class ProxyDemo {
    public static void main(String[] args) {
        consume(new HomeProxy(new RealHomeowner()),new Home(1000,"black"));
        System.out.println("--------------------");
        consume(new RealHomeowner(),new Home(1000,"black"));
    }
}

复制代码

发现直接和房东直租已经被拒绝了，只能经过代理进行租房。打印信息以下：

装修房子
提高价格
房价是 2000
房子颜色是 red
--------------------
请找房屋代理

复制代码

从上面能够看出代理其实分为三个角色：

1. 抽象的主题角色：只是业务类型的定义。

2. 具体的主题角色：也叫作被代理角色，是业务逻辑的真正执行者。

3. 代理主题角色： 也叫作委托类、代理类。它负责对真实角色的应用，把全部抽象主题类定义的方法限制委托给真实主题角色实现，而且在真实主题角色处理完毕先后作预处理和蔼后处理工做。

1.2 何时使用代理

在任什么时候候，只要你想要从额外的操做从“实际的对象”分离到不一样的地方，特别是当你但愿可以很容易的作出修改，从没有使用额外操做转为使用这些操做，或者反过来时，代理就显得颇有用。

仍是刚才的现实的例子，咱们为何要把房子给房屋代理？

• 例如你在美国有一套房，而你在北京居住和上班，这时候你没时间去和租房的人打交道。因此将房子交给房屋代理。

为其余对象提供一种代理以控制对这个对象的访问。在某些状况下，一个客户不想或者不能直接引用另外一个对象，而代理对象能够在客户端和目标对象之间起到中介的做用

对应到代码中的意思就是：若是你在北京要处理美国的房子，每次有人想租房子，或者你租的房子出现了问题，你都得坐飞机回去和房客进行交涉或者维修。代码中最多见的就是Web Service的工做原理,即你只是想和另外一台机器进行通讯，你不想管中间的通讯原理，例如网络打包、通讯、解包等一系列复杂的问题，因此咱们使用代理将这一系列通讯的问题进行了包装，再由代理进行通讯的功能。

• 对于房屋的维修或者和房租打交道嫌麻烦，只想把房子租出去收钱就行，因此直接交给房屋代理进行打理。

对应到代码中的意思就是：一个类的单一职能原则，对于房东来讲，只会租房的功能，可是若是不装修，不打理的话是很难租出去的，因此交给了房屋代理，房屋代理进行装修，后期整理在进行出租。代码中常见的实现就是对于权限的过滤，一个类有一个功能，而这个功能只适合一部分的用户使用，因此利用代理进行权限的过滤。

代理体现了一个类的单一职能原则，就是一个类只作本身的功能，不掺杂其余东西，这样这个类被修改的概率才会最小。

1.3 代理的优势

• 职责清晰：真实的角色就是现实实际的业务逻辑，不用关系其余非本职的东西，经过后期的代理完成一件事务，附带的结果就是变成简洁清晰

• 高扩展性：具体主题角色是随时发生变化的，只要它实现了接口，因此它不管怎么变化，都逃不脱如来佛的手掌（接口）的控制，那咱们的代理类彻底能够在不作任何修改的状况下使用。

• 智能化：在动态代理中能够体现出具体的智能化，关于动态代理在下一节中进行讲解。

1.4 强制代理

强制代理是代理模式的一种延伸，代理模式是经过代理找到实际的角色动做，可是强制代理要求经过实际角色得到代理，否则不让访问。在现实中体现就是，房主和房屋代理签定了合同，若是有房客想要租这个房就只能找这个固定的房屋代理，不能找其余的。不论是new出来一个房屋代理也好，仍是直接找房主也好，都是租不了房的。

强制代理接口以下，只是增长了一个getProxy()方法，得到指定的代理:

interface Homeowner{
    public void LeaseHouse(Home home);
    public Homeowner getProxy();
}

复制代码

实现类也做了一些的修改，先看房主角色

class RealHomeowner implements Homeowner{
    private Homeowner proxy;
    @Override
    public void LeaseHouse(Home home) {
        if (isProxy()){
            System.out.println("房价是 "+ home.price);
            System.out.println("房子颜色是 "+ home.color);
        }else {
            System.out.println("请找房屋代理");
        }
    }
    // 得到本身的代理
    @Override
    public Homeowner getProxy() {
        this.proxy=new HomeProxy(this);
        return this.proxy;
    }
    // 校验是不是代理访问
    private Boolean isProxy(){
        if (this.proxy == null){
            return false;
        }else {
            return true;
        }
    }
}

复制代码

强制代理的代理类

class HomeProxy implements Homeowner{

    private Homeowner homeowner;

    public HomeProxy(Homeowner homeowner){
        this.homeowner = homeowner;
    }
    @Override
    public void LeaseHouse(Home home) {
        System.out.println("装修房子");
        home.color="red";
        System.out.println("提高价格");
        home.price=home.price+1000;
        homeowner.LeaseHouse(home);
    }
	// 由于代理上面没有代理就返回本身
    @Override
    public Homeowner getProxy() {
        return this;
    }
}

复制代码

若是此时代理又被代理了，能够继续延伸下去。

此时若是按照正常的代理模式进行访问的话，

public static void main(String[] args) {
		RealHomeowner realHomeowner=new RealHomeowner();
		Home home=new Home(1000,"red");
		realHomeowner.LeaseHouse(home);
		HomeProxy homeProxy = new HomeProxy(realHomeowner);
		homeProxy.LeaseHouse(home);
}

复制代码

发如今进行出租房子的时候，进行了拒绝出租。这个代理对象是你new出来的，因此真是对象固然不认，这就比如你和A代理公司签定了合同，可是房客去B代理公司租你的房子，确定是不行的。

装修房子
提高价格
请找房屋代理
复制代码

此时若是更改为以下：

public static void main(String[] args) {
    RealHomeowner realHomeowner=new RealHomeowner();
    Home home=new Home(1000,"red");
    Homeowner homeProxy = realHomeowner.getProxy();
    homeProxy.LeaseHouse(home);
}

复制代码

就会发现房子被租出去了

装修房子
提高价格
房价是 2000
房子颜色是 red

复制代码

强制代理的概念就是要从真是对象查找代理角色，不容许直接访问真实角色

1.5 代理实现多个接口

一个类能够实现多个接口，完成不一样的任务的整合，也就说代理类不只能够实现主题接口，也能够实现其余接口完成不一样的任务，并且代理的目的就是在目标对象方法的基础上做加强，这种增长本质上就是对目标对象的方法进行拦截过滤。好比如今房屋中介不想本身进行装修房子了，因而把装修单独拆出来做为一个接口，在内部进行实现。

interface RenovationInterface{
    public void Renovation(Home home,String color);
}

复制代码

代理类

class HomeProxy implements Homeowner , RenovationInterface{
    private Homeowner homeowner;
    public HomeProxy (Homeowner homeowner){
        this.homeowner = homeowner;
    }
    @Override
    public void LeaseHouse(Home home) {
        System.out.println("装修房子");
        this.Renovation(home,"red");
        System.out.println("提高价格");
        home.price=home.price+1000;
        homeowner.LeaseHouse(home);
    }

    @Override
    public Homeowner getProxy() {
        return this;
    }

    @Override
    public void Renovation(Home home, String color) {
        home.color = color;
    }
}

复制代码

一个代理类能够代理多个真实的角色，而且真实角色之间能够有耦合关系，能够自行的进行扩展。