设计模式之禅-适配器模式

最新推荐文章于 2024-04-23 18:52:22 发布

gclhaha

最新推荐文章于 2024-04-23 18:52:22 发布

阅读量99

点赞数

分类专栏：设计模式文章标签： java 设计模式

本文链接：https://blog.csdn.net/weixin_43797872/article/details/113881805

版权

设计模式专栏收录该内容

23 篇文章 0 订阅

订阅专栏

适配器模式

例子

项目对接第三方，数据格式不一致。
在这里插入图片描述

本项目实体接口

public interface IUserInfo {
    String getUserName();
    String getMobileNumber();
    String getHomeAddress();
    String getOfficeTelNumber();
    String getJobPosition();
    String getHomeTelNumber();
}

实体实现

public class UserInfo implements IUserInfo {
    /**
     * 获得家庭地址，下属送礼也可以找到地方
     */
    @Override
    public String getHomeAddress() {
        System.out.println("这里是员工的家庭地址...");
        return null;
    }

    /**
     * 获得家庭电话号码
     */
    @Override
    public String getHomeTelNumber() {
        System.out.println("员工的家庭电话是...");
        return null;
    }

    /**
     * 员工的职位，是部门经理还是普通职员
     */
    @Override
    public String getJobPosition() {
        System.out.println("这个人的职位是BOSS...");
        return null;
    }

    /**
     * 手机号码
     */
    @Override
    public String getMobileNumber() {
        System.out.println("这个人的手机号码是0000...");
        return null;
    }

    /**
     * 办公室电话，烦躁的时候最好"不小心"把电话线踢掉
     */
    @Override
    public String getOfficeTelNumber() {
        System.out.println("办公室电话是...");
        return null;
    }

    /**
     * 姓名，这个很重要
     */
    @Override
    public String getUserName() {
        System.out.println("姓名叫做...");
        return null;
    }
}

第三方实体接口

public interface IOuterUser {
    Map getUserBaseInfo();
    Map getUserOfficeInfo();
    Map getUserHomeInfo();
}

第三方实体实现

public class OuterUser implements IOuterUser {
    /**
     * 用户的基本信息
     */
    @Override
    public Map getUserBaseInfo() {
        HashMap baseInfoMap = new HashMap();
        baseInfoMap.put("userName", "这个员工叫混世魔王...");
        baseInfoMap.put("mobileNumber", "这个员工电话是...");
        return baseInfoMap;
    }

    /**
     * 员工的家庭信息
     */
    @Override
    public Map getUserHomeInfo() {
        HashMap homeInfo = new HashMap();
        homeInfo.put("homeTelNumbner", "员工的家庭电话是...");
        homeInfo.put("homeAddress", "员工的家庭地址是...");
        return homeInfo;
    }

    /**
     * 员工的工作信息，比如，职位等
     */
    @Override
    public Map getUserOfficeInfo() {
        HashMap officeInfo = new HashMap();
        officeInfo.put("jobPosition", "这个人的职位是BOSS...");
        officeInfo.put("officeTelNumber", "员工的办公电话是...");
        return officeInfo;
    }
}

适配器

public class OuterUserInfo extends OuterUser implements IUserInfo {
    /**
     * 员工的基本信息
     */
    private final Map baseInfo = super.getUserBaseInfo();
    /**
     * 员工的家庭信息
     */
    private final Map homeInfo = super.getUserHomeInfo();
    /**
     * 工作信息
     */
    private final Map officeInfo = super.getUserOfficeInfo();

    /**
     * 家庭地址
     */
    @Override
    public String getHomeAddress() {
        String homeAddress = (String) this.homeInfo.get("homeAddress");
        System.out.println(homeAddress);
        return homeAddress;
    }

    /**
     * 家庭电话号码
     */
    @Override
    public String getHomeTelNumber() {
        String homeTelNumber = (String) this.homeInfo.get("homeTelNumber");
        System.out.println(homeTelNumber);
        return homeTelNumber;
    }

    /**
     * 职位信息
     */
    @Override
    public String getJobPosition() {
        String jobPosition = (String) this.officeInfo.get("jobPosition");
        System.out.println(jobPosition);
        return jobPosition;
    }

    /**
     * 手机号码
     */
    @Override
    public String getMobileNumber() {
        String mobileNumber = (String) this.baseInfo.get("mobileNumber");
        System.out.println(mobileNumber);
        return mobileNumber;
    }

    /**
     * 办公电话
     */
    @Override
    public String getOfficeTelNumber() {
        String officeTelNumber = (String) this.officeInfo.get("officeTelNumber");
        System.out.println(officeTelNumber);
        return officeTelNumber;
    }

    /**
     * 员工的名称
     */
    @Override
    public String getUserName() {
        String userName = (String) this.baseInfo.get("userName");
        System.out.println(userName);
        return userName;
    }
}

场景类1

public class Client {
    public static void main(String[] args) {
        IUserInfo userInfo = new UserInfo();
        for (int i = 0; i < 101; i++) {
            userInfo.getMobileNumber();
        }
    }
}

场景类2

public class OuterClient {
    public static void main(String[] args) {
        IUserInfo userInfo = new OuterUserInfo();
        for (int i = 0; i < 101; i++) {
            userInfo.getMobileNumber();
        }
    }
}

使用了适配器模式只修改了一句话，其他的业务逻辑都不用修改就解决了系统对接的问题，而且在我们实际系统中只是增加了一个业务类的继承，就实现了可以查本公司的员工信息，也可以查人力资源公司的员工信息，尽量少的修改，通过扩展的方式解决了该问题。这就是适配模式。

定义

将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
在这里插入图片描述
A、B两个图框代表已经塑模成型的物体A和物体B，那现在要求把A和B安装在一起使用，如何安装？两者的接口不一致，是不可能安装在一起使用的，那怎么办？引入一个物体 C，如图19-6所示。

引入物体C后，C适应了物体A的接口，同时也适应了物体B的接口，然后三者就可以组合成一个完整的物体，如图19-7所示。
在这里插入图片描述

Target目标角色
该角色定义把其他类转换为何种接口，也就是我们的期望接口，例子中的IUserInfo接口就是目标角色。
Adaptee源角色
你想把谁转换成目标角色，这个“谁”就是源角色，它是已经存在的、运行良好的类或对象，经过适配器角色的包装，它会成为一个崭新、靓丽的角色。
Adapter适配器角色
适配器模式的核心角色，其他两个角色都是已经存在的角色，而适配器角色是需要新建立的，它的职责非常简单：把源角色转换为目标角色，怎么转换？通过继承或是类关联的方式。

public interface Target {
    void request();
}

public class ConcreteTarget implements Target {

    @Override
    public void request() {
        System.out.println("if you need any help,pls call me!");
    }
}

public class Adaptee {
    public void doSomething(){
        System.out.println("I'm kind of busy,leave me alone,pls!");
    }
}

public class Adapter extends Adaptee implements Target{
    @Override
    public void request() { super.doSomething(); }
}

public class Client {
    public static void main(String[] args) {
        //原有的业务逻辑
        Target target = new ConcreteTarget();
        target.request();
        //现在增加了适配器角色后的业务逻辑
        Target target2 = new Adapter();
        target2.request();
    }
}

优点

适配器模式可以让两个没有任何关系的类在一起运行，只要适配器这个角色能够搞定他们就成。
增加了类的透明性
想想看，我们访问的Target目标角色，但是具体的实现都委托给了源角色，而这些对高层次模块是透明的，也是它不需要关心的。
提高了类的复用度
当然了，源角色在原有的系统中还是可以正常使用，而在目标角色中也可以充当新的演员。
灵活性非常好
某一天，突然不想要适配器，没问题，删除掉这个适配器就可以了，其他的代码都不用修改，基本上就类似一个灵活的构件，想用就用，不想就卸载。

使用场景

适配器应用的场景只要记住一点就足够了：你有动机修改一个已经投产中的接口时，适配器模式可能是最适合你的模式。比如系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统的接口，怎么办？使用适配器模式。

注意

适配器模式最好在详细设计阶段不要考虑它，它不是为了解决还处在开发阶段的问题，而是解决正在服役的项目问题，没有一个系统分析师会在做详细设计的时候考虑使用适配器模式，这个模式使用的主要场景是扩展应用中，就像我们上面的那个例子一样，系统扩展了，不符合原有设计的时候才考虑通过适配器模式减少代码修改带来的风险。
项目一定要遵守依赖倒置原则和里氏替换原则，否则即使在适合使用适配器的场合下，也会带来非常大的改造。

扩展

如果劳动服务公司提供的人员接口不止一个，也就是说，用户基本信息是一个接口，工作信息是一个接口，家庭信息是一个接口，总共有三个接口三个实现类。声明一个 OuterUserInfo实现类，实现IUserInfo接口，通过再关联其他三个实现类不就可以解决这个问题。
OuterUserInfo通过关联的方式与外界的三个实现类通讯，当然也可以理解为是聚合关系。
在这里插入图片描述

public interface IOuterUserBaseInfo {
    Map getUserBaseInfo();
}

public interface IOuterUserHomeInfo {
    Map getUserHomeInfo();
}

public interface IOuterUserOfficeInfo {
    Map getUserOfficeInfo();
}

public class OuterUserBaseInfo implements IOuterUserBaseInfo {
    /**
     * 用户的基本信息
     */
    @Override
    public Map getUserBaseInfo() {
        HashMap baseInfoMap = new HashMap();
        baseInfoMap.put("userName", "这个员工叫混世魔王...");
        baseInfoMap.put("mobileNumber", "这个员工电话是...");
        return baseInfoMap;
    }
}

public class OuterUserHomeInfo implements IOuterUserHomeInfo {
    /**
     * 员工的家庭信息
     */
    @Override
    public Map getUserHomeInfo() {
        HashMap homeInfo = new HashMap();
        homeInfo.put("homeTelNumbner", "员工的家庭电话是...");
        homeInfo.put("homeAddress", "员工的家庭地址是...");
        return homeInfo;
    }
}

public class OuterUserOfficeInfo implements IOuterUserOfficeInfo {
    /**
     * 员工的工作信息，比如，职位等
     */
    @Override
    public Map getUserOfficeInfo() {
        HashMap officeInfo = new HashMap();
        officeInfo.put("jobPosition", "这个人的职位是BOSS...");
        officeInfo.put("officeTelNumber", "员工的办公电话是...");
        return officeInfo;
    }
}

public class OuterUserInfo implements IUserInfo {
    //源目标对象
    private IOuterUserBaseInfo baseInfo = null;

    private IOuterUserHomeInfo homeInfo = null;

    private IOuterUserOfficeInfo officeInfo = null;
    //数据处理
    private Map baseMap = null;
    private Map homeMap = null;
    private Map officeMap = null;

    public OuterUserInfo(IOuterUserBaseInfo _baseInfo, IOuterUserHomeInfo _homeInfo,
                         IOuterUserOfficeInfo _officeInfo) {
        this.baseInfo = _baseInfo;
        this.homeInfo = _homeInfo;
        this.officeInfo = _officeInfo;
        //数据处理
        this.baseMap = this.baseInfo.getUserBaseInfo();
        this.homeMap = this.homeInfo.getUserHomeInfo();
        this.officeMap = this.officeInfo.getUserOfficeInfo();
    }

    @Override
    public String getHomeAddress() {
        String homeAddress = (String) this.homeMap.get("homeAddress");
        System.out.println(homeAddress);
        return homeAddress;
    }

    @Override
    public String getHomeTelNumber() {
        String homeTelNumber = (String) this.homeMap.get("homeTelNumber");
        System.out.println(homeTelNumber);
        return homeTelNumber;
    }

    @Override
    public String getJobPosition() {
        String jobPosition = (String) this.officeMap.get("jobPosition");
        System.out.println(jobPosition);
        return jobPosition;
    }

    @Override
    public String getMobileNumber() {
        String mobileNumber = (String) this.baseMap.get("mobileNumber");
        System.out.println(mobileNumber);
        return mobileNumber;
    }

    @Override
    public String getOfficeTelNumber() {
        String officeTelNumber = (String) this.officeMap.get("officeTelNumber");
        System.out.println(officeTelNumber);
        return officeTelNumber;
    }

    @Override
    public String getUserName() {
        String userName = (String) this.baseMap.get("userName");
        System.out.println(userName);
        return userName;
    }
}

public class Client {
    public static void main(String[] args) {
        IOuterUserBaseInfo baseInfo = new OuterUserBaseInfo();
        IOuterUserHomeInfo homeInfo = new OuterUserHomeInfo();
        IOuterUserOfficeInfo officeInfo = new OuterUserOfficeInfo();
        IUserInfo userInfo = new OuterUserInfo(baseInfo,homeInfo,officeInfo);
        for (int i = 0; i < 101; i++) {
            userInfo.getMobileNumber();
        }
    }
}

在这里插入图片描述
适配器的通用代码也比较简单，把原有的继承关系变更为关联关系就可以了，不再赘述。对象适配器和类适配器的区别是：类适配器是类间继承，对象适配器是对象的合成关系，也可以说是类的关联关系，这是两者的根本区别。二者在实际项目中都会经常用到，由于对象适配器是通过类间的关联关系进行耦合的，因此在设计时就可以做到比较灵活，比如修补源角色的隐形缺陷，关联其他对象等，而类适配器就只能通过覆写源角色的方法进行扩展，在实际项目中，对象适配器使用到场景相对较多。

总结

适配器模式是一个补偿模式，或者说是一个“补救”模式，通常用来解决接口不相容的问题，它在需求巨变、业务飞速而导致你极度郁闷、烦躁、崩溃的时候横空出世，它通过把非本系统接口的对象包装成本系统可以接受的对象，从而简化了系统大规模变更风险的存在。

gclhaha

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式之禅-适配器模式

适配器模式例子项目对接第三方，数据格式不一致。本项目实体接口public interface IUserInfo { String getUserName(); String getMobileNumber(); String getHomeAddress(); String getOfficeTelNumber(); String getJobPosition(); String getHomeTelNumber();}实体实现publ
复制链接

扫一扫