设计模式十之适配器模式
在现实生活中,经常出现两个对象因接口不兼容而不能在一起工作的实例,这时需要第三者进行适配。例如,讲中文的人同讲英文的人对话时需要一个翻译,用直流电的笔记本电脑接交流电源时需要一个电源适配器,用计算机访问照相机的 SD 内存卡时需要一个读卡器等。
在软件设计中也可能出现:需要开发的具有某种业务功能的组件在现有的组件库中已经存在,但它们与当前系统的接口规范不兼容,如果重新开发这些组件成本又很高,这时用适配器模式能很好地解决这些问题。
1. 模式的定义与特点
1.1 模式的定义
适配器模式(Adapter):将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的哪些类能一起工作。适配器模式分为类适配器模式和对象适配器模式,前者由继承实现,后者由组合实现。
1.2 模式的特点
适配器模式的优点有:
1. 能提高类的透明性和复用性,现有类复用但不需要改变;
2. 目标类和适配器类解耦,提高程序扩展性;
2. 符合开闭原则。
适配器模式的缺点有:
1. 适配器编写过程需要全面考虑,可能会增加系统的复杂性;
2. 增加系统代码可读的难度。
1.3 模式的使用场景
1. 已经存在的类,他的方法和需求不匹配;
2. 不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品,不同厂家造成功能类似而接口不相同情况下的解决方案。
2. 模式的结构与实现
类的适配器模式可以采用多重继承的方式实现,但是由于 Java 不支持多继承,因此可以定义一个适配器类来实现当前系统的业务接口,同时又继承现有组件库中以ing存在的组件。
对象的适配器模式可以采用将已有组件库中已实现的组件引入适配器中,该类同时实现当前系统的业务接口。
2.1 模式的结构
适配器模式的主要角色如下:
1. 目标接口(Target):当前系统业务所期待的接口,可以是抽象类或是接口;
2. 适配者类(Adaptee):是被访问和等待适配的现存组件库中的组件接口;
3. 适配器类(Adapter):是一个转换器,通过继承或引用适配者的对象,把适配者接口转换成目标接口,让客户按目标接口的格式访问适配者。
下图分别是类的适配器模式和对象适配器模式的UML
2.2 模式的实现
类的适配器模式
/**
* 目标类 - 接口
*/
public interface Target {
void request();
}
/**
* 具体目标类
*/
public class ConcreteTarget implements Target {
@Override
public void request() {
System.out.println("ConcreteTarget 具体目标类的请求方法");
}
}
/**
* 适配者类
*/
public class Adaptee {
public void adapteeRequest() {
System.out.println("Adaptee 适配者类的请求方法");
}
}
/**
* 适配器类
*/
public class Adapter extends Adaptee implements Target {
@Override
public void request() {
// ...
super.adapteeRequest();
// ...
}
}
public class Client {
public static void main(String[] args) {
Target target = new ConcreteTarget();
target.request();
Target adapterTarget = new Adapter();
adapterTarget.request();
}
}
# 运行结果如下:
ConcreteTarget 集体目标类的请求方法
Adaptee 适配者的请求方法
对象适配器模式
/**
* 目标类 - 接口
*/
public interface Target {
void request();
}
/**
* 具体目标类
*/
public class ConcreteTarget implements Target {
@Override
public void request() {
System.out.println("ConcreteTarget 具体目标类的请求方法");
}
}
/**
* 适配者类
*/
public class Adaptee {
public void adapteeRequest() {
System.out.println("Adaptee 适配者类的请求方法");
}
}
/**
* 适配器类
*/
public class Adapter implements Target {
private Adaptee adaptee = new Adaptee();
@Override
public void request() {
// ...
adaptee.adapteeRequest();
// ...
}
}
public class Client {
public static void main(String[] args) {
Target target = new ConcreteTarget();
target.request();
Target adapterTarget = new Adapter();
adapterTarget.request();
}
}
# 运行结果如下:
ConcreteTarget 集体目标类的请求方法
Adaptee 适配者的请求方法
其实类的适配器模式的实现与对象的适配器模式的实现的唯一区别就是到底是继承适配者还是引入适配者而已。
3. 模式在开源软件中的应用
3.1 org.springframework.web.*.HandlerAdapter 类
public interface HandlerAdapter {
boolean supports(Object handler);
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
long getLastModified(HttpServletRequest request, Object handler);
}
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof Controller);
}
@Override
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return ((Controller) handler).handleRequest(request, response);
}
@Override
public long getLastModified(HttpServletRequest request, Object handler) {
if (handler instanceof LastModified) {
return ((LastModified) handler).getLastModified(request);
}
return -1L;
}
}
public class HttpRequestHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof HttpRequestHandler);
}
@Override
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
((HttpRequestHandler) handler).handleRequest(request, response);
return null;
}
@Override
public long getLastModified(HttpServletRequest request, Object handler) {
if (handler instanceof LastModified) {
return ((LastModified) handler).getLastModified(request);
}
return -1L;
}
}
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 || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
// Determine handler adapter for the current request.
// 根据 mappedHandler 获取相应的 handler
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 (logger.isDebugEnabled()) {
logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
try {
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
}
applyDefaultViewName(request, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Error err) {
triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
return;
}
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
/**
* Return the HandlerAdapter for this handler object.
* @param handler the handler object to find an adapter for
* @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
*/
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
for (HandlerAdapter ha : this.handlerAdapters) {
if (logger.isTraceEnabled()) {
logger.trace("Testing handler adapter [" + ha + "]");
}
if (ha.supports(handler)) {
return ha;
}
}
throw new ServletException("No adapter for handler [" + handler +
"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}
SpringMVC 中的适配器 HandlerAdapter,就是根据 Handler 规则执行不同的 Handler。
DispatcherServlet 根据 HandlerMapping 返回的 handler,向 HandlerAdapter 发起请求,处理 handler。HandlerAdapter 根据规则找到对应的 handler 并让其执行,执行完毕后 Handler 会向 HandlerAdapter 返回一个 ModelAndView,最后由 HandlerAdapter 向 DispatcherServlet 返回一个 ModelAndView。
HandlerAdapter 使得 Handler 的扩展变得容易,只需要增加一个新的 Handler 和一个对应的 HandlerAdapter 即可。因此 Spring 定义了一个适配接口,使得每一种 Controller 有一种对应的适配器实现类,让适配器代替 controller 执行相应的方法。这样在扩展 controller 时,只需要增加一个适配器类就完成了 Spring MVC 的扩展了。