设计模式系列：适配器与代理模式

场景

前不久CBA北京队，现有成员：孙悦、吉喆、段江鹏、张玉。现教练说为增强目前后卫防守的能力，引入一名外籍篮球员：马布里（不懂中文）。在讨论战术的时候，外籍篮球员需要一名翻译着在场，将中国教练说的战术翻译给马布里听。请用代码实现教练、篮球员、外籍篮球员、翻译者沟通战术的场景。

分析

当前总共分为四种角色：教练、中国篮球员、外籍篮球员、翻译者。但是，翻译者是外籍篮球员的替代品(仅战术沟通而言)，也就是充当了一名中国篮球员的角色。并在获取到教练传递的指令之后，翻译成外籍篮球员可理解的方式，告诉给他。

代码

public interface IChinesePlayer {
    void 安排(String coachMessage);
}

public class ChinesePlayer implements IChinesePlayer {
    private String name;
    public ChinesePlayer(String name) {
        this.name = name;
    }
    public void 安排(String coachMessage) {
        String message = String.format("%s获得到教练的安排：%s", this.name, coachMessage);
        System.out.println(message);
    }
}

public interface IUsPlayer {
    public void arrangement(String coachMessage);
}

public class UsPlayer implements  IUsPlayer {
    private String name;
    public UsPlayer(String name) {
        this.name = name;
    }
    public void arrangement(String coachMessage) {
        String message = String.format("%s，get coach message:"+ coachMessage);
        System.out.println(message);
    }
}

public class PlayerAdapter implements IChinesePlayer {
    private IUsPlayer usPlayer;
    public PlayerAdapter(IUsPlayer usPlayer) {
        this.usPlayer = usPlayer;
    }
    public void 安排(String coachMessage) {
      String translateMessage = transMessage(coachMessage);
      usPlayer.arrangement(translateMessage);
    }
    private String transMessage(String coachMessage) {
        if(StringUtils.equals(coachMessage, "进攻")) {
            return "attack";
        }
        if(StringUtils.equals(coachMessage, "防守")) {
            return "defense";
        }
        return "not know message";
    }

}

public class AdapteTest {
    public static void main(String[] args) {
        UsPlayer mblUsPlayer = new UsPlayer("Stephon Marbury");
        ChinesePlayer sunyChinesePlayer = new ChinesePlayer("sun yue");
        ChinesePlayer jizChinesePlayer = new ChinesePlayer("ji ze");
        ChinesePlayer duanjpChinesePlayer = new ChinesePlayer("duan jiang peng");
        ChinesePlayer zhangyChinesePlayer = new ChinesePlayer("zhang yu");
        PlayerAdapter playerTranslater = new PlayerAdapter(mblUsPlayer);
        String message = "进攻";
        sunyChinesePlayer.安排(message);
        jizChinesePlayer.安排(message);
        duanjpChinesePlayer.安排(message);
        zhangyChinesePlayer.安排(message);
        playerTranslater.安排(message);
    }
}

定义

将一个类的接口转换成另一个接口。使得原本由于接口不兼容问题解决。

类图

屏幕快照 2017-07-28 下午7.46.14.png

---

场景

现在互联网发达的今天，千千万万的人使用58同城或水木论坛找房东直租的房子，或直接找链家、麦田房产中介。请使用代码实现此场景。

分析

目前涉及的角色：房东、中介、房屋、租客。其中比较有争执的一点就是，中介有关联关系的是房东，而不是房屋。房子是属于房东的。租客联系的要么是房东，要么是中介

第一版代码

public class Hourse {
    private String area;
    private String decorationtate;
    private String floor;
    private long price;
    public Hourse(String area, String decorationtate, String floor, long price) {
        this.area = area;
        this.decorationtate = decorationtate;
        this.floor = floor;
        this.price = price;
    }
    public long getPrice() {
        return price;
    }
    public void setPrice(long price) {
        this.price = price;
    }
    public String getArea() {
        return area;
    }
    public void setArea(String area) {
        this.area = area;
    }
    public String getDecorationtate() {
        return decorationtate;
    }
    public void setDecorationtate(String decorationtate) {
        this.decorationtate = decorationtate;
    }
    public String getFloor() {
        return floor;
    }
    public void setFloor(String floor) {
        this.floor = floor;
    }
}

public interface IHourseSell {
    public String description();
    public Hourse lease();
    public long money();
}

public class Landlady implements IHourser {
    private Hourse hourse;
    public Landlady(Hourse hourse){
       this.hourse = hourse;
    }
    public String description(){
      return String.format("area:%s, price:%s", hourse.getArea(), hourse.getPrice());
    }
    public Hourse lease() {
        return hourse;
    }
    public long money() {
      return 100000000L;
    }
    public Hourse getHourse() {
        return hourse;
    }
}

public class Medium implements IHourser {
    private Landlady landlady;
    public Medium(Landlady realHourseSell) {
        this.landlady = realHourseSell;
    }
    public String description() {
        Hourse hourse = landlady.getHourse();
        String description = String.format("过来看过来瞧，这里房子临近地铁，这个房子在%s层" +
                "，这里的房子装修是%s，并且这里的房子相当的大，多大呢？有这么%s大哦。",
                hourse.getFloor(), hourse.getDecorationtate(), hourse.getArea());
        return description;
    }
    public Hourse lease() {
        return landlady.getHourse();
    }
    public long money() {
        return landlady.getHourse().getPrice()+100000;
    }
}

public class ProxyText {
    public static void main(String[] args) {
        Hourse hourse = new Hourse("134平方米", "精装修", "3层", 4000000);
        Landlady fangzhu = new Landlady(hourse);
        Medium medium = new Medium(fangzhu);
        System.out.println(medium.description());
        System.out.println(medium.lease());
        System.out.println(medium.money());
    }
}

第二版代码

public class Dynstic implements InvocationHandler {
    private Landlady landLady = new Landlady(new Hourse("100平米", "挺好的房子", "5层", 5000000));

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(method.getName().contains("description")) {
            Hourse hourse = landLady.getHourse();
            String description = String.format("过来看过来瞧，这里房子临近地铁，这个房子在%s层" +
                            "，这里的房子装修是%s，并且这里的房子相当的大，多大呢？有这么%s大哦。",
                    hourse.getFloor(), hourse.getDecorationtate(), hourse.getArea());
            return description;
        }
        return null;
    }
}

public class DynsticTest {
    public static void main(String[] args) {
        Dynstic stic = new Dynstic();
        IHourser hourseSell = (IHourser) Proxy.newProxyInstance(DynsticTest.class.getClassLoader(), new Class[]{IHourser.class}, stic);
        hourseSell.description();
    }
}

定义

为其他对象提供一种代理以控制对这个对象的访问

类图

屏幕快照 2017-07-28 下午7.50.16.png

常见场景

• 代理的种类？
  • 远程代理(remote proxy):为一个位于不同的地址空间的对象提供一个本地的代理对象，这个不同的地址空间可以是在同一台主机中，也可是在另一台主机中，远程代理又称为大使（Ambassador）。
  • 虚拟代理(virtual proxy):如果需要创建一个资源消耗较大的对象，先创建一个消耗相对较小的对象来表示，真实对象只在需要时才会被真正创建。
  • 保护代理(protect proxy):控制对象的访问，可以为单独的角色设定权限。
  • 缓冲代理(cache proxy):为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。
  • 智能引用代理(smart reference proxy):当一个对象被引用时，提供一些额外的操作，例如将对象被调用的次数记录下来等。
• 代理实现的分类？
  • 动态代理:代理类是在运行时生成的。也就是说编译完Java之后并没有实际的class文件存在，而是在运行时动态生成的类字节码，并加载到JVM中。
  • 静态代理:代理类是在编译时就实现好的。也就是说编译完Java之后代理类是一个实际的class文件。

注意

永远不要在InvocationHandler的invoke里面调用第一个参数proxy的任何方法，因为这样会导致invoke循环无数次调用，最终stackoverflow。