适配器模式

适配器模式

基本介绍

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

类适配器模式

介绍

Adapter类，通过继承src类，实现dest接口，完成src -> dest的适配。
应用实例

• 1.以手机充电为例，充电器本身相当于Adapter类，220V的交流电相当于src(被适配者)，我们的dest(目标)是5V直流电。
  
• 2.类图
  
  
  
  

代码

案例只是展示这种思想，无实际意义。

1. public class Voltage220V {
3.     public int output220V(){
4.         int voltage = 220;
5.         System.out.println("电压" + voltage + "V");
6.         return voltage;
7.     }
8. }
9. public interface Voltage5V {
10.     public int output5V();
11. }
12. public class Adapter extends Voltage220V implements Voltage5V{
13.     @Override
14.     public int output5V() {
15.         int src = this.output220V();
16.         int dest = src / 44;//转成5v
17.         return dest;
18.     }
19. }
20. public class Phone {
22.     public void charging(Voltage5V v){
23.         if(v.output5V() == 5){
24.             System.out.println("电压为5V，可以充电");
25.         }else if(v.output5V() > 5){
26.             System.out.println("电压大于5V，不能充电");
27.         }
28.     }
29. }
30. //测试
31. public class Client {
32.     public static void main(String[] args) {
33.         System.out.println("类适配器模式");
34.         new Phone().charging(new Adapter());
35.     }
36. }

复制代码

注意事项和细节

• 1.Java是单继承机制，所以类适配器需要继承src类这一点是一个缺点，还要求dest必须是接口，有一定局限性。
  
• 2.Adapter类，会继承src类的所有方法，增加了使用成本。
  
• 3.由于继承了src类，所以它可以根据需求重写src类的方法，使得Adapter类的灵活性增强了。
  

对象适配器模式

介绍

• 1.基本思路和类的适配器模式相同，只是将Adapter类做修改，不是继承src类，而是持有src类的实例，解决兼容性的问题。即持有src类，实现dest接口，完成src -> dest的适配。
  
• 2.根据合成复用原则，尽量使用关联关系替代继承关系。
  
• 3.对象适配器模式是适配器模式常用的一种。
  

应用实例

用对象适配器模式，完成手机充电案例

1. public class Voltage220V {
2.     public int output220V(){
3.         int voltage = 220;
4.         System.out.println("输出电压" + voltage + "V");
5.         return voltage;
6.     }
7. }
8. public interface Voltage5V {
9.     public int output5V();
10. }
11. public class Phone {
12.     public void charging(Voltage5V v){
13.         if(v.output5V() == 5){
14.             System.out.println("电压为5V，可以充电");
15.         }else if(v.output5V() > 5){
16.             System.out.println("电压大于5V，不能充电");
17.         }
18.     }
19. }
20. public class Adapter implements Voltage5V {
22.     private Voltage220V voltage220V;
24.     public Adapter(){}
26.     public Adapter(Voltage220V voltage220V){
27.         this.voltage220V = voltage220V;
28.     }
30.     public void setVoltage220V(Voltage220V voltage220V) {
31.         this.voltage220V = voltage220V;
32.     }
34.     @Override
35.     public int output5V() {
36.         int src = voltage220V.output220V();
37.         int dest = src / 44;
38.         System.out.println("进行电压适配" + src + "->" + dest);
39.         return dest;
40.     }
41. }
42. public class Client {
43.     public static void main(String[] args) {
44.         System.out.println("对象适配器模式");
45.         Phone phone = new Phone();
46.         Adapter adapter = new Adapter(new Voltage220V());
47.         phone.charging(adapter);
48.     }
49. }

复制代码

注意事项和细节

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

接口适配器模式

介绍

• 1.当不需要全部实现接口提供的方法时，可以设计一个抽象类实现接口，并为该接口中每个方法提供一个默认的实现(空方法)，那么该抽象类的子类可以有选择性的重写某些方法。
  
• 2.适用于一个接口不想使用其所有方法的情况
  
• 3.接口适配器模式，也被称为默认适配器模式。
  

应用实例

• 1.Android中的属性动画ValueAnimator类可以通过addListener(AnimatorListener listener)方法添加监听器，常规方法如下右图。
  
• 2.不想实现Animator.AnimatorListener接口的全部方法，我们只想监听onAnimationStart 如下 下图写。
  
  
  
  
• 3.AnimatorListenerAdapter类，就是一个接口适配器，代码如下 右图。
  
• 4.AnimatorListener是一个接口。
  
  
  
  
• 5.程序里的匿名内部类就是AnimatorListener的具体实现类。
  Java中的匿名内部类，类似接口适配器模式。
  

适配器模式在SpringMVC中的源码分析

• 1.SpringMVC中的HandlerAdapter，就是用了适配器模式。
  
• 2.使用HandlerAdapter的原因分析。Handler(controller,处理器)的类型不同，有多重实现方式，那么调用方式就不是确定的，如果需要直接调用Controller方法，需要调用时，就要使用很多的if else分支语句，进行判断，哪一种子类执行。这样的写法，如果要扩展controller，就要修改原来的代码，违背了ocp。
  
• 3.代码分析
  

1. //DispatchServlet类中得doDispatch(HttpServletRequest request, HttpServletResponse response)方法 部分源码
2. HttpServletRequest processedRequest = request;
3. HandlerExecutionChain mappedHandler = null;//参数定义
4. // Determine handler for the current request.
5. mappedHandler = getHandler(processedRequest);//根据请求获取 对应的HandlerExecutionChain
6. if (mappedHandler == null) {
7.    noHandlerFound(processedRequest, response);
8.    return;
9. }
11. // Determine handler adapter for the current request.
12. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());//根据handler获取对应的HandlerAdapter
14. //getHandlerAdapter源码 遍历所有的HandlerAdapter 判断是否支持当前handler,支持返回对应的HandlerAdapter
15. protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
16.                 if (this.handlerAdapters != null) {
17.                         for (HandlerAdapter ha : this.handlerAdapters) {
18.                                 if (logger.isTraceEnabled()) {
19.                                         logger.trace("Testing handler adapter [" + ha + "]");
20.                                 }
21.                                 if (ha.supports(handler)) {
22.                                         return ha;
23.                                 }
24.                         }
25.                 }
26.                 throw new ServletException("No adapter for handler [" + handler +
27.                                 "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
28. }

复制代码

• 4.HandlerAdapter接口中的方法
  

1. boolean supports(Object handler);//判断是否支持当前handler
2. //执行handler
3. @Nullable
4. ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
5. long getLastModified(HttpServletRequest request, Object handler);

复制代码

• 5.HandlerAdapter及其子类
  
  
  
  
• 6.简单模拟写一下适配器模式，及其对应的controller源码
  

1. /**
2. * @author 长名06
3. * @version 1.0
4. * Controller接口
5. */
6. public interface Controller {
8. }
10. class HttpController implements Controller{
11.     public void doHttpController(){
12.         System.out.println("http...");
13.     }
14. }
16. class SimpleController implements Controller{
17.     public void doSimpleController(){
18.         System.out.println("simple...");
19.     }
20. }
22. class AnnotationController implements Controller{
23.     public void doAnnotationController(){
24.         System.out.println("annotation...");
25.     }
26. }
27. /**
28. * @author 长名06
29. * @version 1.0
30. * 适配器接口
31. * 一个controller对应一个handlerAdapter
32. */
33. public interface HandlerAdapter {
35.     //判断handler是否是当前适配器对应的controller
36.     boolean supports(Object handler);
38.     void handle(Object handler);
39. }
41. class HttpHandlerAdapter implements HandlerAdapter{
42.     @Override
43.     public boolean supports(Object handler) {
44.         return (handler instanceof HttpController);
45.     }
47.     @Override
48.     public void handle(Object handler) {
49.         ((HttpController) handler).doHttpController();
50.     }
51. }
53. class SimpleHandlerAdapter implements HandlerAdapter{
54.     @Override
55.     public boolean supports(Object handler) {
56.         return (handler instanceof SimpleController);
57.     }
59.     @Override
60.     public void handle(Object handler) {
61.         ((SimpleController) handler).doSimpleController();
62.     }
63. }
65. class AnnotationHandlerAdapter implements HandlerAdapter{
66.     @Override
67.     public boolean supports(Object handler) {
68.         return (handler instanceof AnnotationController);
69.     }
71.     @Override
72.     public void handle(Object handler) {
73.         ((AnnotationController) handler).doAnnotationController();
74.     }
75. }
76. /**
77. * @author 长名06
78. * @version 1.0
79. * 适配器模式
80. */
81. public class Dispatch {
83.     public static final List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();
85.     public Dispatch(){
86.         handlerAdapters.add(new HttpHandlerAdapter());
87.         handlerAdapters.add(new AnnotationHandlerAdapter());
88.         handlerAdapters.add(new SimpleHandlerAdapter());
89.     }
91.     public void doDispatch(){
92. //        HttpController controller = new HttpController();
93. //        SimpleController controller = new SimpleController();
94.         AnnotationController controller = new AnnotationController();
95.         HandlerAdapter adapter = getHandler(controller);
96.         adapter.handle(controller);
97.     }
99.     public HandlerAdapter getHandler(Controller controller){
100.         for(HandlerAdapter ha : this.handlerAdapters){
101.             if(ha.supports(controller)){
102.                 return ha;
103.             }
104.         }
105.         return null;
106.     }
108.     public static void main(String[] args) {
109.         new Dispatch().doDispatch();
110.     }
111. }

复制代码

注意事项和细节

• 1.三种形式，按照src以怎样的方式给到Adapter(在Adapter里的形式)命名的
  
• 2.类适配器：以类给到，在Adapter里，就是将src当作类，继承；对象适配器：以对象给到 ，在Adapter里，将src作为一个对象持有；接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现。
  
• 3.Adapter模式最大的作用就是将原本不兼容的接口融合在一起工作。
  
• 4.实际开发中，不一定非要按照这三种要求，重要的是其思想
  

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！