适配器模式

现实生活中的适配器例子

1608392748146

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

1. 适配器模式介绍

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

适配器模式工作原理

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

1608392869782

2. 类适配器模式

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

应用实例说明

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

1608451153206

类图 :

1608452455632

代码实现:

  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. 对象适配器模式是适配器模式常用的一种

对上面的案例进行修改

类图:

1608460581832

**代码实现: **

  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. 适用于一个接口的实现类不想使用其所有的方法的情况

接口适配器模式应用实例

类图:

1608463089318

  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. 有哪些适配器呢

    1608466282624

总结:

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

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

类图:

1608466552174

对上述的类图进行说明:

  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模式最大的作用还是将原本不兼容的接口融合在一起工作，相当于是个中转封装站

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

posted @ 2021-01-09 23:57  哈哈丶丶  阅读(52)  评论(0)  编辑  收藏  举报