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

旧城等待， 2022-11-06 11:56 160阅读 0赞

### 目录 ###

*  第一章 适配器模式介绍
 *  第二章 适配器模式实现（类适配器）
 *   *  2.1、关系依赖图
     *  2.2、创建交流电
     *  2.3、定义直流电
     *  2.4、创建充电器
     *  2.5、创建手机类
     *  2.6、测试充电器
     *  2.7、点评该模式
 *  第三章 适配器模式实现（对象适配器）
 *   *  3.1、关系依赖图
     *  3.2、创建交流电
     *  3.3、定义直流电
     *  3.4、创建充电器
     *  3.5、创建手机类
     *  3.6、测试充电器
     *  3.7、点评该模式
 *  第四章 适配器模式实现（接口适配器）
 *   *  4.1、关系依赖图
     *  4.2、创建动画接口
     *  4.3、接口的适配器
     *  4.4、适配器的子类
     *  4.5、客户端测试类
     *  4.6、该模式的实践
 *  第五章 适配器模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 适配器模式介绍 #

适配器模式的介绍：

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

适配器模式的优点：

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

适配器模式的缺点：

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

适配器模式的场景：

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

适配器模式的角色：

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

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

## 2.1、关系依赖图 ##

![edaddc94facb1f06606042d0c0902a93.png][]

## 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`类的实例，以解决兼容性的问题。

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

![e02fd6111e5114ee05f357a9e299835b.png][]

## 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

## 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、关系依赖图 ##

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

![5798c346503292a676c583e8eae2db32.png][]

## 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`

![f5088ab46e71098a98cceb109a72f270.png][]

# 第五章 适配器模式应用 #

最佳实践：`适配器模式在 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);
    }

![397dc4a6627997b18a9aff3b6dcd6c29.png][]

`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;
    	}
    }

[edaddc94facb1f06606042d0c0902a93.png]: /images/20221023/14ba33ff012d458ca711c75ac4d6b8a4.png
[e02fd6111e5114ee05f357a9e299835b.png]: /images/20221023/3fef9bbbf1d6449c9edb253b86c52db7.png
[5798c346503292a676c583e8eae2db32.png]: /images/20221023/05deb037ee614922bf304f0ca565a4e7.png
[f5088ab46e71098a98cceb109a72f270.png]: /images/20221023/09d5340d3bd04355a8da9a8e4e999cad.png
[397dc4a6627997b18a9aff3b6dcd6c29.png]: /images/20221023/1ee9ddd7a5ba4911861e2cc80496a4e7.png