设计模式：结构型-适配器模式

---

第一章 适配器模式介绍

适配器模式的介绍：

适配器模式（Adapter Pattern）是作为两个不兼容接口之间的桥梁，这种类型的设计模式属于结构型模式。一些书籍也称适配器模式为缺省适配器模式（Default Adapter Pattern）。适配器模式主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。以生活中手机充电为例来讲解适配器模式，手机本身并不能直接用220V交流电，需要将220V的交流电转换为5V的直流电，在这个过程中，充电器本身相当于Adapter（适配器），220V交流电相当于Adaptee (适配者)，5V直流电则是我们的Target（目标）。

适配器模式的优点：

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

适配器模式的缺点：

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

适配器模式的应用：

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

适配器模式的角色：

• 目标（Target）：当前系统业务所期待的接口，它可以是抽象类或接口。就好比上述例子中的5V直流电。
• 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。就好比上述例子中的220V交流电。
• 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口/抽象类的格式访问适配者。

第二章 适配器模式实现（类适配器）

2.1、关系依赖图

2.2、创建交流电

Voltage220V

public class Voltage220V {
     
    public int output220V() {
     
        System.out.println("Voltage220V output220V ...");
        return 220;
    }
}

2.3、定义直流电

Voltage5V

public interface Voltage5V {
     
    //定义一个标准，充电器来实现
    public int output5V();
}

2.4、创建充电器

VoltageAdapter

public class VoltageAdapter extends Voltage220V implements Voltage5V {
     
    @Override
    public int output5V() {
     
        //获取220V交流电
        int output220V = output220V();
        //转换为5V直流电
        int output5V = output220V / 44;

        System.out.println("VoltageAdapter output5V ...");
        return output5V;
    }
}

2.5、创建手机类

Phone

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

2.6、测试充电器

PhoneTest

public class PhoneTest {
     
    public static void main(String[] args) {
     
        //创建一部手机
        Phone phone = new Phone();
        //用充电器充电
        phone.charging(new VoltageAdapter());
    }
}

Voltage220V output220V ...
VoltageAdapter output5V ...
电压刚好5V, 可以充电

2.7、点评该模式

• Java是单继承机制，所以类适配器需要继承适配者（Adaptee，指Voltage220V）类，这点算是一个缺点，除此之外还必须要求目标（Target，指Voltage5V）必须是接口，有一定局限性；
• 适配者Voltage220V类的方法在适配器VoltageAdapter类中都会暴露出来，也增加了使用的成本。但是由于其继承了适配者Voltage220V类，所以它可以根据需求重写该类的方法，使得适配器VoltageAdapter类的灵活性增强了。

第三章 适配器模式实现（对象适配器）

3.1、关系依赖图

基本思路和类适配器模式相同，只是将VoltageAdapter类作修改，不是继承Voltage220V类，而是持有Voltage220V类的实例，以解决兼容性的问题。

根据“合成复用原则”，在系统中尽量使用关联关系（聚合）来替代继承关系。

3.2、创建交流电

Voltage220V

public class Voltage220V {
     
    public int output220V() {
     
        System.out.println("Voltage220V output220V ...");
        return 220;
    }
}

3.3、定义直流电

Voltage5V

public interface Voltage5V {
     
    //定义一个标准，充电器来实现
    public int output5V();
}

3.4、创建充电器

VoltageAdapter

public class VoltageAdapter implements Voltage5V {
     
    private Voltage220V voltage220V;

    public VoltageAdapter(Voltage220V voltage220V) {
     
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
     
        //获取220V交流电
        int output220V = voltage220V.output220V();
        //转换为5V直流电
        int output5V = output220V / 44;

        System.out.println("VoltageAdapter output5V ...");
        return output5V;
    }
}

3.5、创建手机类

Phone

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

3.6、测试充电器

PhoneTest

public class PhoneTest {
     
    public static void main(String[] args) {
     
        //创建一部手机
        Phone phone = new Phone();
        //用充电器充电（传入220V交流电，传出5V直流电）
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

Voltage220V output220V ...
VoltageAdapter output5V ...
电压刚好5V, 可以充电

3.7、点评该模式

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

第四章 适配器模式实现（接口适配器）

4.1、关系依赖图

接口适配器介绍：当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供 一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求。

4.2、创建动画接口

Animation

public interface Animation {
     
    public void fadeIn();
    public void fadeInUp();
    public void fadeInDown();
    public void fadeInLeft();
    public void fadeInRight();
    public void fadeOut();
    public void fadeOutUp();
    public void fadeOutDown();
    public void fadeOutLeft();
    public void fadeOutRight();
}

4.3、接口的适配器

AnimationAdapter

public class AnimationAdapter implements Animation {
     
    @Override
    public void fadeIn() {
     }
    @Override
    public void fadeInUp() {
     }
    @Override
    public void fadeInDown() {
     }
    @Override
    public void fadeInLeft() {
     }
    @Override
    public void fadeInRight() {
     }
    @Override
    public void fadeOut() {
     }
    @Override
    public void fadeOutUp() {
     }
    @Override
    public void fadeOutDown() {
     }
    @Override
    public void fadeOutLeft() {
     }
    @Override
    public void fadeOutRight() {
     }
}

4.4、适配器的子类

JFrameAnimation

public class JFrameAnimation extends AnimationAdapter {
     
    @Override
    public void fadeIn() {
     
        System.out.println("JFrameAnimation fadeIn ...");
    }

    @Override
    public void fadeOut() {
     
        System.out.println("JFrameAnimation fadeOut ...");
    }
}

4.5、客户端测试类

Client

public class Client {
     
    public static void main(String[] args) {
     
        Animation animation = new JFrameAnimation();
        animation.fadeIn();
        animation.fadeOut();
    }
}

JFrameAnimation fadeIn ...
JFrameAnimation fadeOut ...

4.6、该模式的实践

javax.servlet.http.HttpServlet继承javax.servlet.GenericServlet空实现于javax.servlet.Servlet

第五章 适配器模式应用

最佳实践：适配器模式在 SpringMVC 框架应用

由于Controller的类型不同，有多重实现方式，那么调用方式就不是确定的，如果需要直接调用Controller方法，需要调用的时候就得不断是使用if else来进行判断是哪一种子类然后执行。那么如果后面要扩展Controller，就得修改原来的代码，这样违背了 OCP 原则。

因此SpringMVC定义了一个适配接口HandlerAdapter，使得每一种Controller有一种对应的适配器实现类， 让适配器代替Controller执行相应的方法。这样在扩展Controller时，只需要增加一个适配器类就完成了SpringMVC的扩展了。

org.springframework.web.servlet.HandlerAdapter，相当于适配器模式中的目标（Target）

public interface HandlerAdapter {
     
	boolean supports(Object handler);

	@Nullable
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

	long getLastModified(HttpServletRequest request, Object handler);
}

org.springframework.web.servlet.DispatcherServlet

public class DispatcherServlet extends FrameworkServlet {
     
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     
        //通过request可以得到请求对应的控制器handler
        mappedHandler = getHandler(processedRequest);
        //根据handler得到对应的适配器 
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        //通过适配器去调用对应controller的方法，并返回ModelAndView
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    }
}

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");
}

我们随便找一个HandlerAdapter的实现类，相当于适配器模式中的适配器（Adapter），其中Object handler为适配者（Adaptee）

public class HttpRequestHandlerAdapter implements HandlerAdapter {
     
	@Override
	public boolean supports(Object handler) {
     
		return (handler instanceof HttpRequestHandler);
	}

	@Override
	@Nullable
	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;
	}
}