适配器模式

现实生活中的适配器例子

对于不同国家的电源插口,如果我们想要使用,就需要使用对应的适配器

1. 适配器模式介绍

1. 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。
2. 适配器的别名为包装器(Wrapper)，适配器模式属于结构型模式
3. 主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

适配器模式工作原理

1. 适配器模式：将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容
2. 从用户的角度看不到被适配者，用户与被适配者是解耦的
3. 用户调用适配器转化出来的目标接口方法， 适配器再调用被适配者的相关接口方法
4. 用户收到反馈结果，感觉只是和目标接口交互， 如图

2. 类适配器模式

基本介绍： 核心模块是 Adapter 类(适配者)，Adapter 类，通过继承 src 类（被适配者），实现 dst 类接口（目标类），完成 src --> dst 的适配

应用实例说明

以生活中充电器的例子来讲解适配器，充电器本身相当于Adapter， 220V交流电相当于src (即被适配者)， 我们的dst(即目标)是5V直流电

类图 :

代码实现:

1. src类，输出 220V 的电压

   //被适配的类
   public class Voltage220V {
   	// 输出220V的电压
   	public int output220V() {
   		int src = 220;
   		return src;
   	}
   }
   
   

2. 适配器接口（dst 接口），规定适配器的规范

   //适配接口
   public interface IVoltage5V {
   	public int output5V();
   }
   
   

3. 适配器，继承了 Voltage220V 并实现了 IVoltage5V 接口

   //适配器类
   public class VoltageAdapter extends Voltage220V implements IVoltage5V {
   	@Override
   	public int output5V() {
   		int srcV = output220V(); // 获取到220V电压
   		int dstV = srcV / 44; // 降压转成 5v
   		return dstV;
   	}
   }
   
   

4. 使用者,使用 5V 适配器进行充电

   public class Phone {
   	// 充电
   	public void charging(IVoltage5V iVoltage5V) {
   		if (iVoltage5V.output5V() == 5) {
   			System.out.println("电压为5V, 可以充电~~");
   		} else if (iVoltage5V.output5V() > 5) {
   			System.out.println("电压大于5V, 不能充电~~");
   		}
   	}
   }
   
   

5. 客户端，进行代码测试

   public class Client {
   
   	public static void main(String[] args) {
   		System.out.println(" === 类适配器模式 ====");
   		Phone phone = new Phone();
   		phone.charging(new VoltageAdapter());
   	}
   
   }
   
   

总结:对于原先输出 220v 的类,我们对他进行适配,继承该类,并实现,适配器的规范接口, 在内部进行适配

类适配器模式注意事项和细节

缺点:

Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为Adapter已经继承了src类，这要求dst必须是接口，有一定局限性

src类的方法在Adapter中都会暴露出来，也增加了使用的成本，因为src类中的方法可能很多

优点:

由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了

3. 对象适配器模式

对象适配器模式介绍

1. 基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。
2. 对象适配器模式的核心思想：适配器持有src类，实现dst类接口，完成src --> dst的适配
3. 根据“合成复用原则”，在系统中尽量使用关联关系（聚合、组合）来替代继承关系。
4. 对象适配器模式是适配器模式常用的一种

对上面的案例进行修改

类图:

**代码实现: **

1. 适配器不在继承被适配者,而是改为持有

   //适配器类
   public class VoltageAdapter implements IVoltage5V {
   
   	private Voltage220V voltage220V; // 关联关系-聚合
   
   	// 通过构造器，传入一个 Voltage220V 实例
   	public VoltageAdapter(Voltage220V voltage220v) {
   		this.voltage220V = voltage220v;
   	}
   
   	@Override
   	public int output5V() {
   		int dst = 0;
   		if (null != voltage220V) {
   			int src = voltage220V.output220V();// 获取220V 电压
   			System.out.println("使用对象适配器，进行适配~~");
   			dst = src / 44;
   			System.out.println("适配完成，输出的电压为=" + dst);
   		}
   		return dst;
   	}
   
   }
   
   

2. 测试:

   public class Client {
   
   	public static void main(String[] args) {
   		System.out.println(" === 对象适配器模式 ====");
   		Phone phone = new Phone();
   		phone.charging(new VoltageAdapter(new Voltage220V()));
   	}
   
   }
   
   

总结

与类适配器模式相比，对象适配器模式中，适配器 Adapter 没有使用继承关系，而是使用聚合关系，在适配器 Adapter 中聚合了一个 src 类实例，相同的是 Adapter 实现适配器接口（dst接口），在 Adapter 中实现 dst 接口中的抽象方法，然后使用 src 类实例和完成适配（转换）

对象适配器模式注意事项和细节

对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。根据合成复用原则， 使用组合替代继承， 所以它解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口。对象适配器的使用成本更低，更灵活

4. 接口适配器模式

接口适配器模式介绍

1. 当我们想要使用某一个接口,但是又无需使用全部方法,对此类接口进行适配,只使用需要的方法时
2. 核心思想：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
3. 一些书籍称为：适配器模式(Default Adapter Pattern)或缺省适配器模式
4. 适用于一个接口的实现类不想使用其所有的方法的情况

接口适配器模式应用实例

类图:

1. 待适配的接口适配器，对接口中的抽象方法进行空实现

   public interface Interface4 {
   	public void m1();
   
   	public void m2();
   
   	public void m3();
   
   	public void m4();
   }
   

2. 适配器，对接口中的抽象方法进行空实现

   //在AbsAdapter 我们将 Interface4 的方法进行默认实现
   public abstract class AbsAdapter implements Interface4 {
   	// 默认实现
   	public void m1() {
   
   	}
   
   	public void m2() {
   
   	}
   
   	public void m3() {
   
   	}
   
   	public void m4() {
   
   	}
   }
   
   

3. 客户端 ,使用时只需手动实现我们需要的方法即可

   public class Client {
   	public static void main(String[] args) {
   
   		AbsAdapter absAdapter = new AbsAdapter() {
   			// 只需要去覆盖我们 需要使用 接口方法
   			@Override
   			public void m1() {
   				System.out.println("使用了m1的方法");
   			}
   		};
   
   		absAdapter.m1();
   	}
   }
   
   

Android 代码中的使用

1. AnimatorListener是一个接口，它里面定义了一些抽象方法

   public static interface AnimatorListener {
       void onAnimationStart(Animator animation);
       void onAnimationEnd(Animator animation);
       void onAnimationCancel(Animator animation);
       void onAnimationRepeat(Animator animation);
   }
   
   

2. AnimatorListenerAdapter类就是一个接口适配器，它空实现了Animator.AnimatorListener类(src)的所有方法

   public abstract class AnimatorListenerAdapter implements Animator.AnimatorListener, Animator.AnimatorPauseListener {
       @Override //默认实现
       public void onAnimationCancel(Animator animation) {
       }
       
       @Override
       public void onAnimationEnd(Animator animation) {
       }
       
       @Override
       public void onAnimationRepeat(Animator animation) {
       }
       
       @Override
       public void onAnimationStart(Animator animation) {
       }
       
       @Override
       public void onAnimationPause(Animator animation) {
       }
       
       @Override
       public void onAnimationResume(Animator animation) {
       }
   }
   
   

3. 程序里的匿名内部类就是Listener具体实现类，我们可以选择性地实现想要重写的方法

   new AnimatorListenerAdapter() {
       @Override
       public void onAnimationStart(Animator animation) {
       	//xxxx具体实现
       }
   }
   
   

5. Spring MVC 中的使用

SpringMVC中的HandlerAdapter，就使用了适配器模式，SpringMVC处理请求的流程回顾：

1. 用户发送请求, 由SpringMVC中的dispatcherServlet 的 doDispatch() 方法 统一接收处理
2. 在该方法中,通过HandlerMapping,找到用户请求的路径 对应的Handler处理器(也就是你的Controller方法)
3. 根据获取的Handler的不同, 在获取到此Handler对象的适配器,
4. 再对通过适配器进行调用,实际Handler的处理方法,返回ModelAndView 对象
5. 返回的ModelAndView 通过 InternalResourceViewResolve 进行处理解析,有可能是某个页面,也有可能是一个json字符串, 都会以字符串的形式返回给前端
6. 前端根据接收的字符串进行解析

总结:

在上面的描述中,当我们调用实际的Handler时,使用了适配器模式,这样我们调用不同类型的Handler,在使用方却可以使用同一种方式调用. 使用方和逻辑处理方充分解耦,便于宽展

源码:

1. 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;
   			//通过mapperHandler 获取该请求路径的Handler
   			mappedHandler = getHandler(processedRequest);
   			if (mappedHandler == null || mappedHandler.getHandler() == null) {
   				noHandlerFound(processedRequest, response);
   				return;
   			}
   			//根据此时Handler 的类型 获取对应的适配器
   			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
   
   			//后面就无需知道具体的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()) {
   					String requestUri = urlPathHelper.getRequestUri(request);
   					logger.debug("Last-Modified value for [" + requestUri + "] 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);
   		}
   	}
   }
   
   

2. getHandlerAdapter() 方法

   //此方法是 根据Handler类型去获取对应的 适配器
   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");
   }
   
   

3. HandlerAdapter 上述各个Handler 对应的适配器的规范接口

   public interface HandlerAdapter {
   
   
   	boolean supports(Object handler);
   
   	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
   
   	long getLastModified(HttpServletRequest request, Object handler);
   
   }
   
   

4. 有哪些适配器呢

   

总结:

1. 根据我们请求的路径,获取到相应的Handler
2. 再根据Handler类型的不同,例如 AnnotionMethedHandler ,HttpRequestHandler等
3. 获取到对应的适配器
4. 对适配器进行统一方式的调用,由对应的适配器,对对应的Handler进行处理

模仿 SpringMVC 通过适配器设计模式

类图:

对上述的类图进行说明:

1. 对于Controller 的不同实现方式有: HttpController,SimpleController,AnnotationController
2. 对于不同的Controller,也就是不同的Handler,有其对应的适配器HttpHandlerAdapter,SimpleHandlerAdapter,AnnotationHandlerAdapter,并且统一实现其规范接口HandlerAdapter
3. 在DispatchServlet类中,根据不同的Controller, 获取对应的适配器进行调用

代码实现:

1. Controller 接口及其实现类

   //多种Controller实现  
   public interface Controller {
   
   }
   
   class HttpController implements Controller {
   	public void doHttpHandler() {
   		System.out.println("http...");
   	}
   }
   
   class SimpleController implements Controller {
   	public void doSimplerHandler() {
   		System.out.println("simple...");
   	}
   }
   
   class AnnotationController implements Controller {
   	public void doAnnotationHandler() {
   		System.out.println("annotation...");
   	}
   }
   
   
   

2. 适配器规范接口及其实现

   //定义一个Adapter接口 
   public interface HandlerAdapter {
   	// 当前 HandlerAdapter 对象是否支持 handler（判断 handler 的类型是否为本适配器的目标）
   	public boolean supports(Object handler);
   
   	// 执行目标方法（将 handler 对象强转后，调用对应的方法）
   	public void handle(Object handler);
   }
   
   // 多种适配器类
   class SimpleHandlerAdapter implements HandlerAdapter {
   
   	public void handle(Object handler) {
   		((SimpleController) handler).doSimplerHandler();
   	}
   
   	public boolean supports(Object handler) {
   		return (handler instanceof SimpleController);
   	}
   
   }
   
   class HttpHandlerAdapter implements HandlerAdapter {
   
   	public void handle(Object handler) {
   		((HttpController) handler).doHttpHandler();
   	}
   
   	public boolean supports(Object handler) {
   		return (handler instanceof HttpController);
   	}
   
   }
   
   class AnnotationHandlerAdapter implements HandlerAdapter {
   
   	public void handle(Object handler) {
   		((AnnotationController) handler).doAnnotationHandler();
   	}
   
   	public boolean supports(Object handler) {
   		return (handler instanceof AnnotationController);
   	}
   
   }
   
   

3. 模拟 doDispatch() 方法中获取适配器的流程

   public class DispatchServlet {
   
   	public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();
   
   	// 组合了多个 HandlerAdapter 的实现类
   	public DispatchServlet() {
   		handlerAdapters.add(new AnnotationHandlerAdapter());
   		handlerAdapters.add(new HttpHandlerAdapter());
   		handlerAdapters.add(new SimpleHandlerAdapter());
   	}
   
   	public void doDispatch() {
   
   		// 此处模拟SpringMVC从request取handler的对象，
   		// 适配器可以获取到希望的Controller
   		HttpController controller = new HttpController();
   		// AnnotationController controller = new AnnotationController();
   		// SimpleController controller = new SimpleController();
   		
   		// 得到对应适配器
   		HandlerAdapter adapter = getHandler(controller);
   		// 通过适配器执行对应的controller对应方法
   		adapter.handle(controller);
   
   	}
   
   	public HandlerAdapter getHandler(Controller controller) {
   		// 遍历：根据得到的controller(handler), 返回对应适配器
   		for (HandlerAdapter adapter : this.handlerAdapters) {
   			if (adapter.supports(controller)) {
   				return adapter;
   			}
   		}
   		return null;
   	}
   
   	public static void main(String[] args) {
   		new DispatchServlet().doDispatch(); // http...
   	}
   
   }
   
   

6. 适配器模式的注意事项和细节

对于三种适配器模式的命名方式，是根据src是以怎样的形式给到Adapter（在Adapter里的形式）来命名的。

1. 类适配器：以类给到，在Adapter里，就是将src当做类，继承
2. 对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有
3. 接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作，相当于是个中转封装站

实际开发中，实现起来不拘泥于我们讲解的三种经典形式