设计模式-适配器模式_设计模式适配器模式-优快云博客

//被适配类 220v电压
public class Voltage220V {

    public int output220V() {
        //源电压 220伏
        int src = 220;
        System.out.println("电压 src = " + src);
        return src;
    }
}

//输出类 输出 5v 电压
public interface IVoltage5V {

    //输出 5v 电压
    public int output5v();
}

//转换器 继承 被适配者 和实现 转换的接口
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

    @Override
    public int output5v() {
        //获取到 源数据 中的 220v 电压
        int srcV = super.output220V();
        //转换逻辑 转换成5V
        int dstV = srcV / 44;
        System.out.println("转换器 转换成 dstV = " + dstV + " v 电压");
        return dstV;
    }
}

//使用类
public class Phone {

    //充电方法
    public void charging(IVoltage5V iVoltage5V) {

        int output5v = iVoltage5V.output5v();
        if (output5v == 5) {
            System.out.println("电压是 " + output5v + "v 充电开始");
        } else {
            System.out.println("电压不是 5v 充电失败");
        }

    }
}

//客户端
public class Client {
    public static void main(String[] args) {

        System.out.println("== 类适配器模式 ==");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

结果:

4、总结

类适配器注意事项和细节

Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性;
src类的方法在Adapter中都会暴露出来，也增加了使用的成本。
由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了。

三、对象适配器模式

1、介绍

基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性的问题。即:持有src类，实现 dst 类接口，完成src->dst的适配
根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系。
对象适配器模式是适配器模式常用的一种

2、类图

3、代码实现

//被适配类 220v电压
public class Voltage220V {

    public int output220V() {
        //源电压 220伏
        int src = 220;
        System.out.println("电压 src = " + src);
        return src;
    }
}

//输出 5v 电压 结果
public interface IVoltage5V {

    //输出 5v 电压
    public int output5v();
}

//转换器 聚合 被适配者 和实现 转换的接口
public class VoltageAdapter implements IVoltage5V {


    private Voltage220V voltage220V;

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

    @Override
    public int output5v() {
        int dstV = 0;
        if (null != this.voltage220V) {
            //获取到 源数据 中的 220v 电压
            int srcV = this.voltage220V.output220V();
            //转换逻辑 转换成5V
            dstV = srcV / 44;
            System.out.println("转换器 转换成 dstV = " + dstV + " v 电压");
        }
        return dstV;
    }
}

public class Phone {

    //充电方法
    public void charging(IVoltage5V iVoltage5V) {

        int output5v = iVoltage5V.output5v();
        if (output5v == 5) {
            System.out.println("电压是 " + output5v + "v 充电开始");
        } else {
            System.out.println("电压不是 5v 充电失败");
        }

    }
}

public class Client {
    public static void main(String[] args) {

        System.out.println("== 对象适配器模式 ==");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

结果：

3、总结

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

四、接口适配器模式

1、介绍

一些书籍称为:适配器模式(Default Adapter Pattern)或缺省适配器模式。
当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现(空方法)，那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
适用于一个接口不想使用其所有的方法的情况。

2、类图

3、代码实现

//接口
public interface Interface4 {
    public void method1();
    public void method2();
    public void method3();
    public void method4();
}

//适配器抽象类 默认实现接口中的所有方法
public abstract class AbsAdapter implements Interface4{

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }
}

//客户端类 使用适配器 去重写对应的具体方法
public class Client {


    public static void main(String[] args) {

        Interface4  interface4  = new AbsAdapter() {
            @Override
            public void method1() {
                //现在我只需要用到 方法1 重写这个方法即可
                System.out.println(" method1 ");
            }
        };

        //执行目标方法
        interface4.method1();
    }

运行结果

四、spring中用到的适配器模式

在Spring框架中，DispatcherServlet是前端控制器，负责接收所有的HTTP请求并分发这些请求到相应的处理器（Controller）。为了实现这种分发机制，Spring使用了适配器模式（Adapter Pattern）。

适配器模式是一种结构型设计模式，它允许接口不兼容的类一起工作。在Spring MVC中，适配器模式主要体现在HandlerAdapter接口及其实现类上。

1、工作原理

DispatcherServlet：
- 作为前端控制器，DispatcherServlet接收所有的HTTP请求。
- 根据请求的URL和请求方法，DispatcherServlet从HandlerMapping中找到相应的处理器（Controller）。
HandlerMapping：
- HandlerMapping是一个接口，它负责根据请求找到对应的处理器（Controller）。
- 常见的实现类有RequestMappingHandlerMapping，它根据注解（如@RequestMapping）来匹配请求。
HandlerAdapter：
- HandlerAdapter是一个接口，它负责将DispatcherServlet找到的处理器（Controller）适配为能够调用的形式。
- HandlerAdapter的实现类会处理不同类型的处理器（如基于注解的控制器、基于实现Controller接口的控制器等）。
- DispatcherServlet通过HandlerAdapter调用处理器的具体方法。

2、核心接口和类

HandlerAdapter：
```
public interface HandlerAdapter {
boolean supports(Object handler);


ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception;
}
```
- supports(Object handler)：检查该适配器是否支持给定的处理器。
- handle(HttpServletRequest request, HttpServletResponse response, Object handler)：处理请求并返回ModelAndView。
RequestMappingHandlerAdapter：
- 处理基于注解的控制器（如@Controller和@RequestMapping）。
- 它是HandlerAdapter的一个实现类，负责调用注解控制器的方法。

3、示例

假设你有一个基于注解的控制器：

@Controller
public class MyController {
@RequestMapping("/hello")
public String hello(Model model) {
model.addAttribute("message", "Hello, World!");
return "hello";
}
}

当请求/hello时，RequestMappingHandlerMapping会找到MyController的hello方法，然后RequestMappingHandlerAdapter会调用这个方法并处理结果。

4、总结

Spring MVC通过适配器模式（Adapter Pattern）将不同类型的处理器（Controller）适配为DispatcherServlet可以调用的形式。这种设计使得Spring MVC能够灵活地支持多种类型的控制器，如基于注解的控制器、基于接口的控制器等。

5、简单版实现SpringMVC

类图

代码实现

//适配器接口
public interface HandlerAdapter {

    //判断 当前对象是否是需要的Controller
    public boolean supports(Controller controller);

    //执行 controller 中的方法
    public void handle(Controller controller);
}

//http 处理器适配器
public class HttpHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Controller controller) {
        return controller instanceof HttpController;
    }

    @Override
    public void handle(Controller controller) {
        ((HttpController) controller).doHttpHandler();
    }
}

//Annotation 处理器适配器
public class AnnotationHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Controller controller) {
        return controller instanceof AnnotationController;
    }

    @Override
    public void handle(Controller controller) {
        ((AnnotationController) controller).doAnnotationHandler();
    }
}

//简单处理器适配器类
public class SimpleHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Controller controller) {
        return controller instanceof SimpleController;
    }

    @Override
    public void handle(Controller controller) {
        ((SimpleController) controller).doSimpleHandler();
    }
}

//处理器接口
public interface Controller {
}

//http处理器
public class HttpController implements Controller {

    public void doHttpHandler() {
        System.out.println("doHttpHandler..........★");
    }
}

// Annotation处理器
public class AnnotationController implements Controller {

    public void doAnnotationHandler() {
        System.out.println("doAnnotationHandler.....⚪");
    }
}

//简单处理器
public class SimpleController implements Controller {

    public void doSimpleHandler() {
        System.out.println("Simple handler.....❤");
    }
}

public class DispatchServlet {

    private final List<HandlerAdapter> handlerAdapterList = new ArrayList<>();

    //组合不同的 适配器
    public DispatchServlet() {
        this.handlerAdapterList.add(new AnnotationHandlerAdapter());
        this.handlerAdapterList.add(new HttpHandlerAdapter());
        this.handlerAdapterList.add(new SimpleHandlerAdapter());
    }

    //获取适配器 从而获得对应的 controller 执行controller中的方法
    public void doDispatch(Controller controller) {
        HandlerAdapter adapter = getHandlerAdapter(controller);
        if (adapter != null) {
            adapter.handle(controller);
        }
    }


    private HandlerAdapter getHandlerAdapter(Controller controller) {
        for (HandlerAdapter adapter : this.handlerAdapterList) {
            if (adapter.supports(controller)) {
                return adapter;
            }
        }
        return null;
    }
}


//客户端
public class Client {
    public static void main(String[] args) {

        //根据不同的处理器 获取不同的适配器 执行处理器中的方法
        DispatchServlet dispatchServlet = new DispatchServlet();

        System.out.println("------ httpController ------ ");
        dispatchServlet.doDispatch(new HttpController());

        System.out.println("\n\n\n------ SimpleController ------ ");
        dispatchServlet.doDispatch(new SimpleController());

        System.out.println("\n\n\n------ AnnotationController ------ ");
        dispatchServlet.doDispatch(new AnnotationController());
    }
}

client执行结果