0、适配器模式(Adapter Pattern)
指将一个类的接口转换成客户期望的另外一个接口,使原本的接口不兼容的类可以一起工作。属于结构型设计模式。
适用场景:
- 已经存在的类,它的方法和需求不匹配(方法结果相同或相似)的情况。
- 适配器模式不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。有点亡羊补牢的感觉。生活中也非常的应用场景,例如电源插转换头、手机充电转换头、显示器转接头。
在中国民用电都是 220V 交流电,但我们手机使用的锂电池使用的 5V 直流电。因此,我们给手机充电时就需要使用电源适配器来进行转换。
优缺点:
优点:
- 能提高类的透明性和复用,现有的类复用但不需要改变。
- 目标类和适配器类解耦,提高程序的扩展性。
- 在很多业务场景中符合开闭原则。
缺点:
- 适配器编写过程需要全面考虑,可能会增加系统的复杂性。
- 增加代码阅读难度,降低代码可读性,过多使用适配器会使系统代码变得凌乱。
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 又是在初始化时早已赋值。