Spring源码学习笔记：经典设计模式之适配器模式

1、博客内容均出自于咕泡学院架构师第三期
2、架构师系列内容：架构师学习笔记（持续更新）

0、适配器模式（Adapter Pattern）

指将一个类的接口转换成客户期望的另外一个接口，使原本的接口不兼容的类可以一起工作。属于结构型设计模式。

适用场景：

1. 已经存在的类，它的方法和需求不匹配（方法结果相同或相似）的情况。
2. 适配器模式不是软件设计阶段考虑的设计模式，是随着软件维护，由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。有点亡羊补牢的感觉。生活中也非常的应用场景，例如电源插转换头、手机充电转换头、显示器转接头。
   在中国民用电都是 220V 交流电，但我们手机使用的锂电池使用的 5V 直流电。因此，我们给手机充电时就需要使用电源适配器来进行转换。

优缺点：
优点：

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

缺点：

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

1、简单实现

简单实现电源适配器的场景 220V转 5V

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

package com.jarvisy.demo.pattern.adapter.poweradapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:41
* @description ：
*/
public class AC220 {


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

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

package com.jarvisy.demo.pattern.adapter.poweradapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:43
* @description ：
*/
public interface DC5 {


    int outputDC5V();
}

创建电源适配器 PowerAdapter 类：

package com.jarvisy.demo.pattern.adapter.poweradapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:44
* @description ：
*/
public class PowerAdapter implements DC5 {


    private AC220 ac220;

    public PowerAdapter(AC220 ac220) {
        this.ac220 = ac220;
    }


    @Override
    public int outputDC5V() {
        int adapterInput = ac220.outputAC220V();
        int adapterOutput = adapterInput / 44;
        System.out.println("使用PowerAdapter输入AC：" + adapterInput + "V 输出DC" + adapterInput);
        return adapterOutput;
    }
}

测试代码：

package com.jarvisy.demo.pattern.adapter.poweradapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:47
* @description ：
*/
public class PowerAdapterTest {
    public static void main(String[] args) {
        DC5 dc5 = new PowerAdapter(new AC220());
        dc5.outputDC5V();
    }
}

此时就是通过增加了PowerAdapter电源适配器，实现了输出220V转换成输出5V。

2、适用适配器模式重构第三方登录自由适配的业务场景

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

首先创建ResultMsg 类：

package com.jarvisy.demo.pattern.adapter.loginadapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:56
* @description ：
*/
public class ResultMsg {


    private int code;
    private String msg;
    private Object data;


    public ResultMsg(int code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }


    public int getCode() {
        return code;
    }


    public void setCode(int code) {
        this.code = code;
    }


    public String getMsg() {
        return msg;
    }


    public void setMsg(String msg) {
        this.msg = msg;
    }


    public Object getData() {
        return data;
    }


    public void setData(Object data) {
        this.data = data;
    }
}

假设老系统的登录逻辑 SignService：

package com.jarvisy.demo.pattern.adapter.loginadapter.v1.service;




import com.jarvisy.demo.pattern.adapter.loginadapter.Member;
import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:57
* @description ：
*/
public class SignService {


    /**
     * 注册方法
     *
     * @param username
     * @param password
     * @return
     */
    public ResultMsg register(String username, String password) {
        return new ResultMsg(200, "注册成功", new Member());
    }




    /**
     * 登录的方法
     *
     * @param username
     * @param password
     * @return
     */
    public ResultMsg login(String username, String password) {
        return null;
    }


}

为了遵循开闭原则，老系统的代码不会去修改。那么下面开启代码重构之路，
先创建 Member 类：

package com.jarvisy.demo.pattern.adapter.loginadapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:56
* @description ：
*/
public class Member {


    private String username;
    private String password;
    private String mid;
    private String info;


    public String getUsername() {
        return username;
    }


    public void setUsername(String username) {
        this.username = username;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getMid() {
        return mid;
    }


    public void setMid(String mid) {
        this.mid = mid;
    }


    public String getInfo() {
        return info;
    }


    public void setInfo(String info) {
        this.info = info;
    }
}

创建一个新的类继承原来的逻辑，运行非常稳定的代码不去改动，然后新增新的登录方式：

package com.jarvisy.demo.pattern.adapter.loginadapter.v1.service;




import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 0:58
* @description ：
*/
public class SignForThirdService extends SignService {


    public ResultMsg loginForQQ(String openId) {
        //1、openId是全局唯一，我们可以把它当做是一个用户名(加长)
        //2、密码默认为QQ_EMPTY
        //3、注册（在原有系统里面创建一个用户）


        //4、调用原来的登录方法


        return loginForRegister(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 loginForRegister(String username, String password) {
        super.register(username, null);
        return super.login(username, null);
    }
}

测试代码：

package com.jarvisy.demo.pattern.adapter.loginadapter.v1;


import com.jarvisy.demo.pattern.adapter.loginadapter.v1.service.SignForThirdService;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:00
* @description ：
*/
public class SignForThirdServiceTest {
    public static void main(String[] args) {
        SignForThirdService service = new SignForThirdService();
        service.login("", "123456");
        service.loginForQQ("asdfsfadsdfsdf");
        service.loginForWeChat("sdfasdadfeff");
    }
}

这样一个简单的适配就完成了代码的兼容

更优雅的代码，根据不同登录方式，创建不同的Adapter。
首先创建LoginAdapter接口；

package com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters;


import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:15
* @description ：在适配器里面，这个接口是可有可无，不要跟模板模式混淆
* 模板模式一定是抽象类，而这里仅仅只是一个接口
*/
public interface LoginAdapter {
    boolean support(Object adapter);


    ResultMsg login(String id, Object adapter);


}

分别实现不同的登录适配 LoginForQQAdapter，LoginForTelAdapter，LoginForWeChatAdapter:

package com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters;




import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;
/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:17
* @description ：
*/
public class LoginForQQAdapter implements LoginAdapter {
    public boolean support(Object adapter) {
        return adapter instanceof LoginForQQAdapter;
    }


    public ResultMsg login(String id, Object adapter) {
        //具体实现逻辑
        return null;
    }
}

package com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters;




import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:16
* @description ：
*/
public class LoginForTelAdapter implements LoginAdapter {
    public boolean support(Object adapter) {
        return adapter instanceof LoginForTelAdapter;
    }
    public ResultMsg login(String id, Object adapter) {
        //具体实现逻辑
        return null;
    }
}

package com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters;


import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:17
* @description ：
*/
public class LoginForWeChatAdapter implements LoginAdapter {
    public boolean support(Object adapter) {
        return adapter instanceof LoginForWeChatAdapter;
    }


    public ResultMsg login(String id, Object adapter) {
        return null;
    }
}

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

package com.jarvisy.demo.pattern.adapter.loginadapter.v2;


import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:18
* @description ：只扩展
*/
public interface IPassportForThird {


    /**
     * QQ登录
     *
     * @param id
     * @return
     */
    ResultMsg loginForQQ(String id);

    /**
     * 微信登录
     *
     * @param id
     * @return
     */
    ResultMsg loginForWeChat(String id);
    /**
     * 手机号登录
     *
     * @param tel
     * @param code
     * @return
     */
    ResultMsg loginForTel(String tel, String code);

    /**
     * 注册后自动登录
     *
     * @param username
     * @param passport
     * @return
     */
    ResultMsg loginForRegister(String username, String passport);
}

实现兼容 PassportForThirdAdapter：

package com.jarvisy.demo.pattern.adapter.loginadapter.v2;




import com.jarvisy.demo.pattern.adapter.loginadapter.ResultMsg;
import com.jarvisy.demo.pattern.adapter.loginadapter.v1.service.SignService;
import com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters.LoginAdapter;
import com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters.LoginForQQAdapter;
import com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters.LoginForTelAdapter;
import com.jarvisy.demo.pattern.adapter.loginadapter.v2.adapters.LoginForWeChatAdapter;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:22
* @description ：结合策略模式、工厂模式、适配器模式
*/
public class PassportForThirdAdapter extends SignService implements IPassportForThird {


    public ResultMsg loginForQQ(String id) {
        //策略模式，根据不同类型执行不同逻辑，也是工厂模式，根据类型创建特定的类
        return processLogin(id, LoginForQQAdapter.class);
    }


    public ResultMsg loginForWeChat(String id) {
        return processLogin(id, LoginForWeChatAdapter.class);
    }

    public ResultMsg loginForTel(String tel, String code) {
        return processLogin(tel, LoginForTelAdapter.class);
    }


    public ResultMsg loginForRegister(String username, String passport) {
        super.register(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;
    }
}

测试代码:

package com.jarvisy.demo.pattern.adapter.loginadapter.v2;


/**
* @author ：Jarvisy
* @date ：Created in 2020/9/20 1:18
* @description ：
*/
public class PassportTest {

    public static void main(String[] args) {

        IPassportForThird passportForThird = new PassportForThirdAdapter();

        passportForThird.loginForQQ("");

    }
}

附上类图：

至此，我们在遵循开闭原则的前提下，完整地实现了一个兼容多平台登录的业务场景。目前的这个设计也并不完美，例如适配器中的参数目前是写死为 String，改为 Object[]应该更合理。

问题：适配器模式跟策略模式好像区别不大？
答：适配器模式主要解决的是功能兼容问题，单场景适配大家可能不会和策略模式有对比。但多场景适配大家产生联想和混淆了。其实，代码中适配器都加上了一个 support()方法，用来判断是否兼容，support()方法的参数也是 Object 的，而 supoort()来自于接口。适配器的实现逻辑并不依赖于接口，我们完全可以将 LoginAdapter 接口去掉。而加上接口，只是为了代码规范。上面的代码可以说是策略模式、简单工厂模式和适配器模式的综合运用。

3、适配器在源码中的体现

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);
    }
}

ThrowsAdviceAdapter类：

class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {
    ThrowsAdviceAdapter() {
    }


    public boolean supportsAdvice(Advice advice) {
        return advice instanceof ThrowsAdvice;
    }


    public MethodInterceptor getInterceptor(Advisor advisor) {
        return new ThrowsAdviceInterceptor(advisor.getAdvice());
    }
}

Spring 会根据不同的 AOP 配置来确定使用对应的 Advice，跟策略模式不同的一个方法可以同时拥有多个 Advice。

再看 SpringMVC 中的 HandlerAdapter 类，它也有多个子类，类图如下：

其适配调用的关键代码还是在 DispatcherServlet 的 doDispatch()方法中：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   HttpServletRequest processedRequest = request;
   HandlerExecutionChain mappedHandler = null;
   boolean multipartRequestParsed = false;


   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);


   try {
      ModelAndView mv = null;
      Exception dispatchException = null;


      try {
         processedRequest = checkMultipart(request);
         multipartRequestParsed = (processedRequest != request);


         // Determine handler for the current request.
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
            return;
         }


         // Determine handler adapter for the current request.
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());


         // Process last-modified header, if supported by the handler.
         String method = request.getMethod();
         boolean isGet = "GET".equals(method);
         if (isGet || "HEAD".equals(method)) {
            long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
            if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
               return;
            }
         }


         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }


         // Actually invoke the handler.
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());


         if (asyncManager.isConcurrentHandlingStarted()) {
            return;
         }


         applyDefaultViewName(processedRequest, mv);
         mappedHandler.applyPostHandle(processedRequest, response, mv);
      }
      catch (Exception ex) {
         dispatchException = ex;
      }
      catch (Throwable err) {
         // As of 4.3, we're processing Errors thrown from handler methods as well,
         // making them available for @ExceptionHandler methods and other scenarios.
         dispatchException = new NestedServletException("Handler dispatch failed", err);
      }
      processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   catch (Exception ex) {
      triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
   }
   catch (Throwable err) {
      triggerAfterCompletion(processedRequest, response, mappedHandler,
            new NestedServletException("Handler processing failed", err));
   }
   finally {
      if (asyncManager.isConcurrentHandlingStarted()) {
         // Instead of postHandle and afterCompletion
         if (mappedHandler != null) {
            mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
         }
      }
      else {
         // Clean up any resources used by a multipart request.
         if (multipartRequestParsed) {
            cleanupMultipart(processedRequest);
         }
      }
   }
}

在 doDispatch()方法中调用了 getHandlerAdapter()方法:

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
   if (this.handlerAdapters != null) {
      for (HandlerAdapter adapter : this.handlerAdapters) {
         if (adapter.supports(handler)) {
            return adapter;
         }
      }
   }
   throw new ServletException("No adapter for handler [" + handler +
         "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

在getHandlerAdapter()方法中循环调用了 supports()方法判断是否兼容，循环迭代集合中的 Adapter 又是在初始化时早已赋值。