【设计模式】结构型：适配器模式

心已赠人 2023-01-17 04:42 129阅读 0赞

适配器模式的英文翻译是 Adapter Design Pattern。顾名思义，这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。属于**结构型**设计模式。

适配器适用于以下几种业务场景：

*  已经存在的类，它的方法和需求不匹配（方法结果相同或相似）的情况
 *  适配器模式不是软件设计阶段考虑的设计模式，是随着软件维护，由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。有点亡羊补牢的感觉

生活中也有非常多的应用场景，例如电源插转换头、手机充电转换头、显示器转接头。在中国民用电都是 220V 交流电，但我们手机使用的锂电池使用的 5V 直流电。因此，我们给手机充电时就需要使用电源适配器来进行转换。

### 1.代码示例 ###

下面我们有代码来还原上面说的这个生活场景，

创建 AC220 类，表示 220V 交流电：

public class AC220 {
        
    
        public int outputAC220V(){
        
            int output = 220;
            System.out.println("输出电流" + output + "V");
            return output;
        }
    }

创建 DC5 接口，表示 5V 直流电的标

public interface DC5 {
        
        int outoupDC5V();
    }

创建电源适配器 PowerAdapter 类

public class PowerAdapter implements DC5 {
        
    	// 组合目标类
       private AC220 ac220;
    	
        public PowerAdapter(AC220 ac220) {
        
            this.ac220 = ac220;
        }
    	
        public int outoupDC5V() {
        
        	// 调用被适配类的方法
            int adapterInput = ac220.outputAC220V();
            int adapterOutput = adapterInput / 44;
            System.out.println("使用PowerAdapter输入AC:" + adapterInput + "V,输出DC：" + adapterOutput + "V");
            return adapterOutput;
        }
    }

客户端测试代码:

public class PowerAdapterTest {
        
        public static void main(String[] args) {
        
        	// 多态
            DC5 dc5 = new PowerAdapter(new AC220());
            dc5.outoupDC5V();
        }
    }

上面的案例中，通过增加 PowerAdapter 电源适配器，实现了二者的兼容…

### 2.源码应用 ###

**适配器模式在源码中的体现**

Spring 中适配器模式也应用得非常广泛，例如：SpringAOP 中的 AdvisorAdapter 类， 它有三个实现类 MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter 和 ThrowsAdviceAdapter。

先来看顶层接口 AdvisorAdapter 的源代码：

public interface AdvisorAdapter {
        
    	boolean supportsAdvice(Advice var1);
    	MethodInterceptor getInterceptor(Advisor var1);
    }

再看 MethodBeforeAdviceAdapter 类：

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
        
        MethodBeforeAdviceAdapter() {
        
        }
        public boolean supportsAdvice(Advice advice) {
        
        	return advice instanceof MethodBeforeAdvice;
        }
        public MethodInterceptor getInterceptor(Advisor advisor) {
        
            MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
            return new MethodBeforeAdviceInterceptor(advice);
        }
    }

其它两个类我这里就不把代码贴出来了。Spring 会根据不同的 AOP 配置来确定应的 Advice，跟策略模式不同的一个方法可以同时拥有多个 Advice。

### 3.总结 ###

适配器模式是用来做适配，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。

> PS：适配器模式有两种实现方式：类适配器和对象适配器。类适配器使用继承关系来实现，对象适配器使用组合关系来实现（上面的示例）。

一般来说，适配器模式可以看作一种“**补偿模式**”，用来补救设计上的缺陷。应用这种模式算是“无奈之举”，如果在设计初期，我们就能协调规避接口不兼容的问题，那这种模式就没有应用的机会了。

优点：

*  能提高类的透明性和复用，现有的类复用但不需要改变。
 *  目标类和适配器类解耦，提高程序的扩展性。
 *  在很多业务场景中符合开闭原则。

缺点：

*  适配器编写过程需要全面考虑，可能会增加系统的复杂性。
 *  增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱。

### 4.实际应用场景示例 ###

很早以前开发的老系统应该都有登录接口，但是随着业务的发展和社会的进步，单纯地依赖用户名密码登录显然不能满足用户需求了。现在，我们大部分系统都已经支持多种登录方式，如 QQ 登录、微信登录、手机登录、微博登录等等，同时保留用户名密码的登录方式。虽然登录形式丰富了，但是登录后的处理逻辑可以不必改，同样是将登录状态保存到 session，遵循开闭原则。

**老系统**

假设老系统的登录逻辑 SiginService

public class SiginService {
        
    
        /**
         * 注册方法
         * @param username
         * @param password
         * @return
         */
        public ResultMsg regist(String username, String password){
        
            return  new ResultMsg(200,"注册成功",new Member());
        }
    
    
        /**
         * 登录的方法
         * @param username
         * @param password
         * @return
         */
        public ResultMsg login(String username,String password){
        
            return null;
        }
    
    }

为了遵循开闭原则，老系统的代码我们不会去修改。创建一个新的类继承原来的逻辑，运行非常稳定的代码我们不去改动：

public class SinginForThirdService extends SiginService {
        
    
        public ResultMsg loginForQQ(String openId){
        
            // 1、openId是全局唯一，我们可以把它当做是一个用户名(加长)
            // 2、密码默认为QQ_EMPTY
            // 3、注册（在原有系统里面创建一个用户）
    
            // 4、调用原来的登录方法
    
            return loginForRegist(openId,null);
        }
    
        public ResultMsg loginForWechat(String openId){
        
            return null;
        }
    
        public ResultMsg loginForToken(String token){
        
            // 通过token拿到用户信息，然后再重新登陆了一次
            return  null;
        }
    
        public ResultMsg loginForTelphone(String telphone,String code){
        
    
            return null;
        }
    
        public ResultMsg loginForRegist(String username,String password){
        
            super.regist(username,null);
            return super.login(username,null);
        }
    }

客户端测试代码：

public class SiginForThirdServiceTest {
        
        public static void main(String[] args) {
        
            SinginForThirdService service = new SinginForThirdService();
            service.login("Jack","123456");
            // 不改变原来的代码，也要能够兼容新的需求
    	    // 还可以再加一层策略模式
            service.loginForQQ("abcdefgh");
            service.loginForWechat("sdfasfsa");
        }
    }

通过这么一个简单的适配，完成了代码兼容。当然，我们代码还可以更加优雅，根据不同的登录方式，创建不同的 Adapter。

**适配器模式改造**

首先，创建 LoginAdapter 接口：

/**
     * 在适配器里面，这个接口是可有可无，不要跟模板模式混淆
     * 模板模式一定是抽象类，而这里仅仅只是一个接口
     */
    public interface LoginAdapter {
        
        boolean support(Object adapter);
        ResultMsg login(String id, Object adapter);
    
    }

分别实现不同的登录适配，QQ 登录 LoginForQQAdapter：

public class LoginForQQAdapter implements LoginAdapter {
        
        public boolean support(Object adapter) {
        
            return adapter instanceof LoginForQQAdapter;
        }
    
        public ResultMsg login(String id, Object adapter) {
        
            return null;
        }
    }

新浪微博登录 LoginForSinaAdapter：

public class LoginForSinaAdapter implements LoginAdapter {
        
        public boolean support(Object adapter) {
        
            return adapter instanceof LoginForSinaAdapter;
        }
        public ResultMsg login(String id, Object adapter) {
        
            return null;
        }
    }

手机号登录 LoginForTelAdapter：

public class LoginForTelAdapter implements LoginAdapter {
        
        public boolean support(Object adapter) {
        
            return adapter instanceof LoginForTelAdapter;
        }
        public ResultMsg login(String id, Object adapter) {
        
            return null;
        }
    }

Token 自动登录 LoginForTokenAdapter：

public class LoginForTokenAdapter implements LoginAdapter {
        
        public boolean support(Object adapter) {
        
            return adapter instanceof LoginForTokenAdapter;
        }
        public ResultMsg login(String id, Object adapter) {
        
            return null;
        }
    }

微信登录 LoginForWechatAdapter：

public class LoginForWechatAdapter implements LoginAdapter {
        
        public boolean support(Object adapter) {
        
            return adapter instanceof LoginForWechatAdapter;
        }
        public ResultMsg login(String id, Object adapter) {
        
            return null;
        }
    }

然后，创建第三方登录兼容接口 IPassportForThird

/**
     * 只扩展
     * Created by Tom on 2019/3/16.
     */
    public interface IPassportForThird {
        
    
        /**
         * QQ登录
         * @param id
         * @return
         */
        ResultMsg loginForQQ(String id);
    
        /**
         * 微信登录
         * @param id
         * @return
         */
        ResultMsg loginForWechat(String id);
    
        /**
         * 记住登录状态后自动登录
         * @param token
         * @return
         */
        ResultMsg loginForToken(String token);
    
        /**
         * 手机号登录
         * @param telphone
         * @param code
         * @return
         */
        ResultMsg loginForTelphone(String telphone, String code);
    
        /**
         * 注册后自动登录
         * @param username
         * @param passport
         * @return
         */
        ResultMsg loginForRegist(String username, String passport);
    }

实现兼容 PassportForThirdAdapter：

public class PassportForThirdAdapter extends SiginService implements IPassportForThird {
        
    
        public ResultMsg loginForQQ(String id) {
        
    //        return processLogin(id,RegistForQQAdapter.class);
            return processLogin(id, LoginForQQAdapter.class);
        }
    
        public ResultMsg loginForWechat(String id) {
        
            return processLogin(id, LoginForWechatAdapter.class);
        }
    
        public ResultMsg loginForToken(String token) {
        
            return processLogin(token, LoginForTokenAdapter.class);
        }
    
        public ResultMsg loginForTelphone(String telphone, String code) {
        
            return processLogin(telphone, LoginForTelAdapter.class);
        }
    
        public ResultMsg loginForRegist(String username, String passport) {
        
            super.regist(username,passport);
            return super.login(username,passport);
        }
    
        private ResultMsg processLogin(String key,Class<? extends LoginAdapter> clazz){
        
            try{
        
                // 适配器不一定要实现接口
                LoginAdapter adapter = clazz.newInstance();
    
                // 判断传过来的适配器是否能处理指定的逻辑
                if(adapter.support(adapter)){
        
                    return adapter.login(key,adapter);
                }
            }catch (Exception e){
        
                e.printStackTrace();
            }
            return null;
        }
        // 类图的快捷键  Ctrl + Alt + Shift + U
    }

客户端测试代码

public class PassportTest {
        
    
        public static void main(String[] args) {
        
    
            IPassportForThird passportForThird = new PassportForThirdAdapter();
            passportForThird.loginForQQ("");
    
        }
    }

最后，来看一下类图:  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center][]

至此，我们在遵循开闭原则的前提下，实现了一个兼容多平台登录的业务场景。

当然，目前的这个设计也并不完美，仅供参考，感兴趣的小伙伴可以继续完善这段代码。例如适配器中的参数目前是写死为 String，改为 Object\[\] 应该更合理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/967aba309e094fe1bfa27125b9938641.png