1. 首页
  2. 文章中心
  3. springboot

05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc 不同controller实现模拟api多版本控制适配器优缺点相关代码

121 阅读 0 评论
我是靠谱客的博主 温柔世界，这篇文章主要介绍05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc 不同controller实现模拟api多版本控制适配器优缺点相关代码，现在分享给大家，希望可以做个参考。

1.什么是适配器？
2.适配器设计原理
3.springmvc 、mybatis哪些场景使用到适配器？
4.企业级多api版本如何采用适配器重构

什么是适配器

1.适配器模式是一种结构型设计模式。适配器模式的思想是：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

苹果手机是否可以插入 圆孔耳机，（圆孔）转接头（接入苹果口子）

2.用电器来打个比喻：有一个电器的插头是三脚的，而现有的插座是两孔的，要使插头插上插座，我们需要一个插头转换器，这个转换器即是适配器。

3.适配器模式涉及3个角色：

源（Adaptee）：需要被适配的对象或类型，相当于插头。

适配器（Adapter）：连接目标和源的中间对象，相当于插头转换器。

目标（Target）：期待得到的目标，相当于插座。

适配器模式包括3种形式：类适配器模式、对象适配器模式、接口适配器模式（或又称作缺省适配器模式）。

适配器模式原理图

适配器模式应用场景

1.springmvc多个不同controller实现;

2.API多版本控制;

适用场景

1. 系统需要使用现有的类，而这些类的接口不符合系统的接口。

​ 2. 想要建立一个可以重用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。

​ 3.类所做的事情相同或相似，但是具有不同接口的时候。

4.旧的系统开发的类已经实现了一些功能，但是客户端却只能以另外接口的形式访问，但我们不希望手动更改原有类的时候。

5.使用第三方组件，组件接口定义和自己定义的不同，不希望修改自己的接口，但是要使用第三方组件接口的功能。

springmvc适配器原理分析

方式一：@Controller/@RequestMapping

方式二：实现HttpRequestHandler接口

方式三：实现Controller接口

适配器模式就是把一个类的接口替换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

springmvc 定义controller方式

方式一：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.mayikt.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@RestController
public class MayiktController {
    /**
    * 访问  mayikt
    *
    * @return
    */
    @RequestMapping("/getMayikt")
    public String getMayikt() {
        return "mayikt";
    }
}

方式二：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.mayikt.controller;

import org.springframework.stereotype.Component;
import org.springframework.web.HttpRequestHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Component("/mayiktHttpRequestHandler")
public class MayiktHttpRequestHandler implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
        PrintWriter writer = httpServletResponse.getWriter();
        writer.print("mayiktHttpRequestHandler");
        writer.close();
    }
}

方式三：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.mayikt.controller;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import org.springframework.web.servlet.view.json.MappingJackson2JsonView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Component("/implController")
public class MayiktImplController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        PrintWriter writer = response.getWriter();
        writer.print("mayikt--MayiktImplController");
        writer.close();
        return null;
    }
}

springmvc适配器原理分析

源码解读：

1.springmvc接受请求入口 servlet DispatcherServlet

​ 三种不同方式定义url映射？

用户选择方式2

方式1：

方式2：

方式3：

如何调试源码呢？idea版本

由于Controller的类型不同，有多重实现方式，那么调用方式就不是确定的，如果需要直接调用Controller方法，需要在代码中写成如下形式

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.mayikt.adapter;

import com.mayikt.adapter.impl.AnnotationController;
import com.mayikt.adapter.impl.ImplController;
import com.mayikt.adapter.impl.RequestHandlerController;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class AdapterInvok {
    public static void invok(Controller controller) {
        if (controller instanceof AnnotationController) {
            AnnotationController annotationController = (AnnotationController) controller;
            annotationController.requestMapping();
            return;
        }
        if (controller instanceof ImplController) {
            ImplController implController = (ImplController) controller;
            implController.handleRequest();
        }
        if (controller instanceof RequestHandlerController) {
            RequestHandlerController requestHandlerController = (RequestHandlerController) controller;
            requestHandlerController.requestHandler();
        }
        
    }

    public static void main(String[] args) {
        AdapterInvok.invok(new ImplController());
    }
}

如果是这样写代码的话， 后期增加了一种controller的实现方式的话，我们就需要在方法中增加一个if else,这种形式就使得代码非常不好维护，并且也违反了设计模式中的开闭原则。

因此SpringMVC中 定义了一个适配器接口，使得每一种controller都对应一个 适配器类，让适配器代替controller执行对应的方法，这样我们在扩展controller的时候，只需要增加一个对应的适配器类就可以了。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
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");
}

核心组件

1.目标接口（Target）：客户端所期待的接口，目标可以使具体的或抽象类， 也可以是接口

2.需要适配的类（Adaptee）：需要适配的类或者适配者类

3.适配器（Adapter）:通过包装一个需要适配的对象，把原有接口转换成目标接口

模拟springmvc 不同controller实现

目标接口（Target）

复制代码
1
2
3
4
5
6
7
8
9
10
11
package com.mayikt.adapter.controller;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public interface Controller {
    
}

需要适配的类（Adaptee）

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com.mayikt.adapter.controller.impl;

import com.mayikt.adapter.controller.Controller;
import lombok.extern.slf4j.Slf4j;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Slf4j
public class AnnotationController implements Controller {
    public String requestMapping() {
        log.info("<使用注解@Controller>");
        return "ok";
    }
}

package com.mayikt.adapter.controller.impl;

import com.mayikt.adapter.controller.Controller;
import lombok.extern.slf4j.Slf4j;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Slf4j
public class ImplController implements Controller {
    public void handleRequest() {
        log.info("<handleRequest>");
    }
}

package com.mayikt.adapter.controller.impl;

import com.mayikt.adapter.controller.Controller;
import lombok.extern.slf4j.Slf4j;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Slf4j
public class RequestHandlerController implements Controller {
    public void requestHandler() {
        log.info("<requestHandler>");
    }
}

适配器（Adapter）

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package com.mayikt.adapter;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public interface HandlerAdapter {

    boolean supports(Object controller);

    /**
     * 调用到具体的方法
     *
     * @param handler
     */
    void handle(Object handler);
}

package com.mayikt.adapter.impl;

import com.mayikt.adapter.HandlerAdapter;
import com.mayikt.adapter.controller.impl.AnnotationController;
import com.mayikt.adapter.controller.impl.RequestHandlerController;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class RequestHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object controller) {
        return controller instanceof RequestHandlerController;
    }

    @Override
    public void handle(Object handler) {
        RequestHandlerController requestHandlerController = (RequestHandlerController) handler;
        requestHandlerController.requestHandler();
    }
}

package com.mayikt.adapter.impl;

import com.mayikt.adapter.HandlerAdapter;
import com.mayikt.adapter.controller.impl.ImplController;
import com.mayikt.adapter.controller.impl.RequestHandlerController;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class ImplHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object controller) {
        return controller instanceof ImplController;
    }

    @Override
    public void handle(Object handler) {
        ImplController implController = (ImplController) handler;
        implController.handleRequest();
    }
}

package com.mayikt.adapter.impl;

import com.mayikt.adapter.HandlerAdapter;
import com.mayikt.adapter.controller.impl.AnnotationController;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class AnnotationHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object controller) {
        return controller instanceof AnnotationController;
    }

    @Override
    public void handle(Object handler) {
        AnnotationController annotationController = (AnnotationController) handler;
        annotationController.requestMapping();
    }
}


package com.mayikt.adapter;

import com.mayikt.adapter.controller.Controller;
import com.mayikt.adapter.controller.impl.AnnotationController;
import com.mayikt.adapter.controller.impl.ImplController;
import com.mayikt.adapter.impl.AnnotationHandlerAdapter;
import com.mayikt.adapter.impl.ImplHandlerAdapter;
import com.mayikt.adapter.impl.RequestHandlerAdapter;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class DispatchServlet {
    private List<HandlerAdapter> handlerAdapters = new ArrayList<>();

    public DispatchServlet() {
        handlerAdapters.add(new AnnotationHandlerAdapter());
        handlerAdapters.add(new ImplHandlerAdapter());
        handlerAdapters.add(new RequestHandlerAdapter());
    }

    public void doDispatch() {
        AnnotationController implController = new AnnotationController();
        HandlerAdapter handlerAdapter = getHandler(implController);
        if (handlerAdapter == null) {
            return;
        }
        handlerAdapter.handle(implController);
    }

    public HandlerAdapter getHandler(Controller controller) {
        for (HandlerAdapter handlerAdapter :
                handlerAdapters) {
            if (handlerAdapter.supports(controller)) {
                return handlerAdapter;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        new DispatchServlet().doDispatch();
    }
}

模拟api多版本控制

企业中编写了开放接口 MayiktServiceV1. addUser(String userName)；

企业中编写了开放接口 MayiktServiceV2. addUserJson(User user)；

if(“1”==v){

MayiktServiceV1. addUser(String userName)；

return ;

}

if(“2”==v){

MayiktServiceV2. addUserJson(User user)；

return ;

}

if(“3”==v){

MayiktServiceV2. addUserJson(User user)；

return ;

}

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package com.mayikt.adapter2;

import lombok.extern.slf4j.Slf4j;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/

@Slf4j
public class MayiktApiServiceV1 {
    public String addUser(String userName, Integer age) {
        log.info("<v1版本>");
        return "ok";
    }
}

package com.mayikt.adapter2;

import lombok.extern.slf4j.Slf4j;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
@Slf4j
public class MayiktApiServiceV2 {
    public String addUserObject(MayiktUserEntity mayiktUserEntity) {
        log.info("<v2版本>");
        return "ok";
    }
}

package com.mayikt.adapter2;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class MayiktUserEntity {
    private String userName;
    private Integer age;

    public MayiktUserEntity(String userName, Integer age) {
        this.userName = userName;
        this.age = age;
    }
}

package com.mayikt.adapter2;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public interface MayiktApiAdapter {
    boolean supports(Object api);
    void invok(Object api);
}

package com.mayikt.adapter2.impl;

import com.mayikt.adapter2.MayiktApiAdapter;
import com.mayikt.adapter2.MayiktApiServiceV1;
import com.mayikt.adapter2.MayiktApiServiceV2;
import com.mayikt.adapter2.MayiktUserEntity;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class ApiV2Adapter implements MayiktApiAdapter {
    @Override
    public boolean supports(Object api) {
        return api instanceof MayiktApiServiceV2;
    }

    @Override
    public void invok(Object api) {
        MayiktApiServiceV2 mayiktApiServiceV2 = (MayiktApiServiceV2) api;
        mayiktApiServiceV2.addUserObject(new MayiktUserEntity("mayikt", 22));
    }
}

package com.mayikt.adapter2.impl;

import com.mayikt.adapter2.MayiktApiAdapter;
import com.mayikt.adapter2.MayiktApiServiceV1;

/**
* @author songchuanfu
* @qq 1802284273
* 微信:wx-suagcf
*/
public class ApiV1Adapter implements MayiktApiAdapter {
    @Override
    public boolean supports(Object api) {
        return api instanceof MayiktApiServiceV1;
    }

    @Override
    public void invok(Object api) {
        MayiktApiServiceV1 mayiktApiServiceV1 = (MayiktApiServiceV1) api;
        mayiktApiServiceV1.addUser("mayikt", 22);
    }
}

适配器优缺点

优点

更好的复用性：系统需要使用现有的类，而此类的接口不符合系统的需要。那么通过适配器模式就可以让这些功能得到更好的复用。

更好的扩展性：在实现适配器功能的时候，可以扩展自己源的行为（增加方法），从而自然地扩展系统的功能。

缺点

会导致系统紊乱：滥用适配器，会让系统变得非常零乱。例如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。

[

](https://blog.csdn.net/weixin_44688301/article/details/115748540)

相关代码

最后

以上就是温柔世界最近收集整理的关于05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc 不同controller实现模拟api多版本控制适配器优缺点相关代码的全部内容，更多相关05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(80)

相关文章

if/else简化之策略模式（了解）if/else
if/else简化之策略模式（了解）if/else
SpringMVC使用CommonsMultipartResolver实现文件上传
SpringMVC使用CommonsMultipartResolver实现文件上传
设计模式(五)之适配器模式
设计模式(五)之适配器模式
适配器模式：不要你觉得，我要我觉得
适配器模式：不要你觉得，我要我觉得
05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc 不同controller实现模拟api多版本控制适配器优缺点相关代码
05.设计模式之适配器模式什么是适配器适配器模式原理图适配器模式应用场景springmvc适配器原理分析核心组件模拟springmvc 不同controller实现模拟api多版本控制适配器优缺点相关代码
设计模式七：结构型-适配器模式
设计模式七：结构型-适配器模式
SpringBoot 中的 ServletInitializer类-----------SpringBootServletInitializer
SpringBoot 中的 ServletInitializer类-----------SpringBootServletInitializer
SpringBootServletInitializer的作用
SpringBootServletInitializer的作用

评论列表共有 0 条评论

立即
投稿
返回
顶部