Java设计模式 --适配器模式【Adapter Pattern】

前言

今天讲适配器模式，这个模式也很简单，你笔记本上的那个拖在外面的黑盒子就是个适配器，一般你在中国能用，在日本也能用，虽然两个国家的的电源电压不同，中国是 220V，日本是 110V，但是这个适配器能够把这些不同的电压转换为你需要的 36V 电压，保证你的笔记本能够正常运行，那我们在设计模式中引入这个适配器模式是不是也是这个意思呢？是的，一样的作用，两个不同接口，有不同的实现，但是某一天突然上帝命令你把 B 接口转换为 A 接口，怎么办？继承，能解决，但是比较傻，而且还违背了 OCP 原则，怎么办？好在我们还有适配器模式。
适配器的通用类图是这个样子滴：


这两个对象都不在一个系统中，你如何使用呢？简单！RMI 已经帮我们做了这件事情，只要有接口，就可以把远程的对象当成本地的对象使用，这个大家有时间可以去看一下 RMI 文档，不多说了。通过适配器，把 OuterUser 伪装成我们系统中一个 IUserInfo 对象，这样，我们的系统基本不用修改什么程序，所有的人员查询、调用跟本地一样样的。

我方对象接口信息

package inter;

/**
 * @author qiyq
 * @create 2022-10-09 11:32
 * 用户信息对象
 */
public interface IUserInfo {
    //获取用户姓名
    public String getUserName();

    //获取家庭地址
    public String getHomeAddress();

    //获取手机号码
    public String getMobileNumber();

    //获取办公电话
    public String getOfficeTelNumber();

    //获取职位
    public String getJobPosition();

    //获取家庭电话
    public String getHomeTelNumber();
}

impl

package impl;

import inter.IUserInfo;

/**
 * @author qiyq
 * @create 2022-10-09 11:41
 */
public class UserInfo implements IUserInfo {

    @Override
    public String getUserName() {
        System.out.println("姓名叫做...");
        return null;
    }

    @Override
    public String getHomeAddress() {
        System.out.println("这里是员工的家庭地址....");
        return null;
    }

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

    @Override
    public String getOfficeTelNumber() {
        System.out.println("办公室电话是....");
        return null;
    }

    @Override
    public String getJobPosition() {
        System.out.println("这个人的职位是BOSS....");
        return null;
    }

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

客户端

import impl.UserInfo;
import inter.IUserInfo;

/**
 * @author qiyq
 * @create 2022-10-09 11:49
 * 这就是我们具体的应用了，比如老板要查所有的20-30的女性信息
 */
public class AppClient {
    public static void main(String[] args) {
        //没有与外系统连接的时候，是这样写的
        IUserInfo iUserInfo = new UserInfo();

        //从数据库中查到101个
        for (int i = 0; i < 101; i++) {
            iUserInfo.getMobileNumber();
        }
    }
}

对方对象接口信息

package inter;

import java.util.Map;

/**
 * @author qiyq
 * @create 2022-10-09 11:53
 * 外系统的人员信息
 */
public interface IOuterUser {
    //基本信息，比如名称，性别，手机号码等
    public Map getUserBaseInfo();

    //工作区域信息
    public Map getUserOfficeInfo();

    //用户的家庭信息
    public Map getUserHomeInfo();
}

impl

package impl;

import inter.IOuterUser;

import java.util.HashMap;
import java.util.Map;

/**
 * @author qiyq
 * @create 2022-10-09 16:39
 * 外系统的用户信息的实现类
 */
public class OuterUser implements IOuterUser {
    /**
     *  用户的基本信息
     * @return Map
     */
    @Override
    public Map getUserBaseInfo() {
        Map baseInfoMap = new HashMap();
        baseInfoMap.put("userName", "混世魔王");
        baseInfoMap.put("mobileNumber", "混世魔王电话是...");
        return baseInfoMap;
    }

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

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

适配器

那怎么把外系统的用户信息包装成我们公司的人员信息呢？看下面的 OuterUserInfo 类源码，也就是我们的适配器：

import impl.OuterUser;
import inter.IUserInfo;

import java.util.Map;

/**
 * @author qiyq
 * @create 2022-10-09 17:09
 */
public class OuterUserInfo extends OuterUser implements IUserInfo {
    private Map baseInfo = super.getUserBaseInfo(); //员工的基本信息
    private Map homeInfo = super.getUserHomeInfo(); //员工的家庭信息
    private Map officeInfo = super.getUserOfficeInfo();//工作信息

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

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

    @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 getJobPosition() {
        String jobPosition = (String) this.officeInfo.get("jobPosition");
        System.out.println(jobPosition);
        return jobPosition;
    }

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

大家看到没？这里有很多的强制类型转换，就是(String)这个东西，如果使用泛型的话，完全就可以避免这个转化，这节课啰嗦的太多就不再讲了，下次找个时间再讲。这个适配器的作用就是做接口的转换，那然后我们再来看看我们的业务是怎么调用的：

客户端适配器模式

import impl.UserInfo;
import inter.IUserInfo;

/**
 * @author qiyq
 * @create 2022-10-09 11:49
 * 这就是我们具体的应用了，比如老板要查所有的20-30的女性信息
 */
public class AppClient {
    public static void main(String[] args) {
        //没有与外系统连接的时候，是这样写的
        //IUserInfo iUserInfo = new UserInfo();

        IUserInfo iUserInfo = new OuterUserInfo();

        //从数据库中查到101个
        for (int i = 0; i < 101; i++) {
            iUserInfo.getMobileNumber();
        }
    }
}

大家看，使用了适配器模式只修改了一句话，其他的业务逻辑都不用修改就解决了系统对接的问题，而且在我们实际系统中只是增加了一个业务类的继承，就实现了可以查本公司的员工信息，也可以查人力资源公司的员工信息，尽量少的修改，通过扩展的方式解决了该问题。
适配器模式分为类适配器和对象适配器，这个区别不大，上边的例子就是类适配器，那对象适配器是什么样子呢？对象适配器的类图是这个样子滴：

最后

看到没？和上边的类图就一个箭头的图形的差异，一个是继承，一个是关联，就这么多区别，只要把我们上面的程序稍微修改一下就成了 类适配器，这个大家自己考虑一下，简单的很。
适配器模式不适合在系统设计阶段采用，没有一个系统分析师会在做详设的时候考虑使用适配器模式，这个模式使用的主要场景是扩展应用中，就像我们上面的那个例子一样，系统扩展了，不符合原有设计的时候才考虑通过适配器模式减少代码修改带来的风险。