设计模式-适配器模式及应用

 生活中经常出现两个“事物”不能直接匹配，需要中间加一层转换层实现原本不兼容的接口或者规范变得通用。例如我们使用的各种电源适配器，还例如我前段时间更换电脑的SSD，应因新的SSD与老的不兼容，中间加了个转换头等等。

 在程序软件世界中，同样存在着此问题。我们需要使用某些成熟的组件，但是接口或者方法定义又使得我们无法直接使用，而又不能去修改运行稳定的代码。重新开发的话成本和代价都很高，这可以通过中间加一层适配层来转换组件与新使用方的关系，从而达到复用组件的目的。这就是今天所要说到的适配器模式在软件设计领域的使用，很多开源框架中也经常能够看到。

模式的定义与特点

 适配器模式（Adapter）的定义如下：将一个接口转换为使用者希望得到的另外一个接口，使得原来不能适配的不能一起工作的
类能够一起工作。

 适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，使用继承或者实现的方式，后者使用关联的方式解耦。

 另外还有一种是缺省适配器模式（Default Adapter Pattern），当无需实现一个接口的所有方法时，可能通过抽象类实现空方法的方式，让具体实现的子类去覆盖抽象类中的方法，来实现自定义方法的实现。
缺省适配器模式是适配器模式的一种变体，其应用也较为广泛。在JDK类库的事件处理包java.awt.event中广泛使用了缺省适配器模式，如WindowAdapter、KeyAdapter、MouseAdapter等。

模式的结构与实现

 适配器模式的结构在Java中可以定义一个适配器来实现当前系统的接口，同时又继承现有组件库中的组件。在适配器中完成现有组件和目标接口的适配。

1.适配器模式结构对象

• 目标（Target）接口：当前系统所需要的接口，可以是抽象类或者接口
• 适配者（Adaptee）类：已有组件或者接口，被适配者角色
• 适配器类（adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

适配器模式的结构图如下：
1.类结构模式（继承或者实现方式）

2.对象适配（引用）

3.缺省模式

示例代码：
1.类结构模式（继承或者实现方式）
模拟电源适配，220v标准电压，转手机充电所需5v电压。

• 适配者（标准电压）

public class Adaptee {
	//电压
	private Integer voltage = 220;

	public Integer standardVoltage() {
		System.out.println("被适配标准电压" +voltage + "V");
		return voltage;
	}
}

• 目标接口

public interface Target {
	/**
	 * 所需电压
	 * @return
	 */
   Integer needVoltage();
}

• 适配器(继承适配者，实现目标接口)

public class Adapter extends Adaptee implements Target{

	@Override
	public Integer needVoltage() {
		//标准电压
		Integer standarVoltage =  standardVoltage();
		// 转为5v电压
		Integer mobileVoltage = standarVoltage / 44 ; 
		return mobileVoltage;
	}
}

• 使用方

public class Client {

	public static void main(String[] args) {
		Target adapter = new Adapter();
		Integer voltage = adapter.needVoltage();
		System.out.println("适配目标电压："+voltage);
	}
}

执行结果：

 被适配标准电压:220V
 适配目标电压：5V

类结构模式案例类图：

2.对象适配

• 适配者 （标准电压）

public class Adaptee {
	//电压
	private Integer voltage = 220;

	public Integer standardVoltage() {
		System.out.println("被适配标准电压" +voltage + "V");
		return voltage;
	}
}

• 目标接口

public interface Target {
	/**
	 * 所需电压
	 * @return
	 */
   Integer needVoltage();
}

• 适配器（引用适配者）

public class Adapter implements Target{
	//被适配对象
	private Adaptee adaptee;
	
	public Adapter(Adaptee adaptee) {
		this.adaptee = adaptee;
	}

	@Override
	public Integer needVoltage() {
		//标准电压
		Integer standarVoltage =  adaptee.standardVoltage();
		// 转为5v电压
		Integer mobileVoltage = standarVoltage / 44 ; 
		return mobileVoltage;
	}
}

• client 使用方

public class Client {

	public static void main(String[] args) {
		// 被适配对象
		Adaptee adaptee = new Adaptee();

		// 目标适配
		Target adapter = new Adapter(adaptee);
		Integer voltage = adapter.needVoltage();
		System.out.println("适配目标电压：" + voltage + "V");
	}
}

执行结果：

 被适配标准电压220V
 适配目标电压：5V

对象适配案例类图：

3.缺省模式

• 目标接口

public interface Target {
	public void method1();
	
	public void method2();

	public void method3();
}

• 适配器（抽象类，模式空实现）

public abstract class AbstractAdapter implements Target{
	/**
	 * 模式所有方法都是空实现，具体实现逻辑，通过子类去覆盖。
	 */
	@Override
	public void method1() {
		
	}
	
	@Override
	public void method2() {
		
	}
	
	@Override
	public void method3() {
		
	}
}

• 使用方 client, 子类覆盖需要使用的方法

public class Client {

	public static void main(String[] args) {
		AbstractAdapter abstractAdapter = new AbstractAdapter() {
			
			@Override
			public void method1() {
				System.out.println("this method m1");
			}
		};
		abstractAdapter.method1();
	}	
}

执行结果：

 this method m1

缺省模式案例结构图：

适配器模式应用场景

适配器模式（Adapter）通常适用于以下场景。

• 已有老的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
• 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

适配器模式的优缺点

优点如下：

• 客户端通过适配器可以透明地调用目标接口。
• 复用了现存的类，现有系统不需要修改原有代码而重用现有的适配者类。
• 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
• 在很多业务场景中符合开闭原则。

其缺点是：

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

适配器模式在源码中的使用

1.SpringMVC中的适配器
SpringMVC中使用到适配器模式的地方，是我们的调用核心派发类DispatcherServlet中的doDispatch()方法；不妨先看下SpringMVC一个请求进来的数据流转流程：

这张图的流程，应该不用详细赘述，SpringMVC框架的请求处理流程就是图示中所显示。
回到这篇文章的主题，适配器模式是如何运用到这个流程中的，这里先看下HandlerMapping这里的HandlerMapping可以简单理解为的Controller,他是通过请求的Url来映射具体的Controller，不同的Cotroller实现方式的不同，对应的Controller处理类也不同,常用的例如@controller注解的方式，或者实现Controller的方式；而HandlerAdapter是如何通过Hander知道我们调用的是哪个处理器。
首先看下HandlerAdapter接口

public interface HandlerAdapter {
    boolean supports(Object var1);

    @Nullable
    ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;

    long getLastModified(HttpServletRequest var1, Object var2);
}

他的实现类及子类的结构图：

这里不同实现的适配器，就决定我们前面说的适配不同方式实现的Controller,拿常用的注解方式来说，对应的适配器为RequestMappingHandlerAdapter,继承抽象的AbstractHandlerMethodAdapter,HandlerAdapter接口中，两个方法比较重要supports(object o),判断适配器是否满足当前请求，handle(HttpServletRequest var1, HttpServletResponse var2, Object var3),调用Controller方法，返回ModelAndView对象。
具体的结构类图：

回到主干看下DispatcherServlet类的doDispatch()方法。篇幅限制，删减部分代码

try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    // 根据请求，获取具体的mapperHadler对象,取得处理当前请求的Controller，这里也称为Handler，即处理器这里并不是直接返回Controller，而是返回 HandlerExecutionChain 请求处理链对象该对象封装了Handler和Inteceptor
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
  //获取具体的适配器对象，根据MappedHandler
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if (this.logger.isDebugEnabled()) {
                            this.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;
                    }
//通过适配器调用controller的方法并返回ModelAndView
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                    //略。。。。 

getHandlerAdapter（）获取适配器

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		//略
	}

从源码中可以看到，获取适配器的过程就是通过遍历系统中所有适配器，通过supports，方法找到指定的适配器。而这个适配器是何时注册进去的。
可以发现handlerAdapters其实就是List集合。通过初始化方法注册

	/** List of HandlerAdapters used by this servlet. */
	@Nullable
	private List<HandlerAdapter> handlerAdapters;
   
//初始化方法   initHandlerAdapters（）
protected void initStrategies(ApplicationContext context) {
		// 多文件上传的组件
		initMultipartResolver(context);
		// 初始化本地语言环境
		initLocaleResolver(context);
		// 初始化模板处理器
		initThemeResolver(context);
		// 初始化HandlerMapping
		initHandlerMappings(context);
		// 初始化参数适配器
		initHandlerAdapters(context);
		// 初始化异常拦截器
		initHandlerExceptionResolvers(context);
		// 初始化视图预处理器
		initRequestToViewNameTranslator(context);
		// 初始化视图转换器
		initViewResolvers(context);
		// 初始化 FlashMap 管理器
		initFlashMapManager(context);
	}    

initHandlerAdapters（context）从容器中获取适配器中对象。
通过源码分析SpringMVC中适配器的使用，HandlerAdapter接口为我们的目标接口，不同的实现类为具体的适配器角色，而不同请求类型的Controller为具体的适配者角色，这里宽泛的认为HandlerMapping为Controller角色，当然Controller到HandlerMapping子类的实现，如何通过注解或者继承的方式来实现这里不做叙述，具体细节查看源码。

✨✨ 欢迎🔔订阅个人的微信公众号 享及时博文更新