JAVA 设计模式五之设配器模式

最新推荐文章于 2023-12-28 09:57:05 发布

君为红颜舞

最新推荐文章于 2023-12-28 09:57:05 发布

阅读量150

点赞数

分类专栏：设计模式 java 文章标签： java 设计模式

本文链接：https://blog.csdn.net/cx17521000200/article/details/112858702

版权

java 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

设计模式

5 篇文章 0 订阅

订阅专栏

6. 适配器模式在springmvc框架应用的源码分析

7. 适配器模式的注意事项和细节

1.基本介绍

生活例子：插座，每个国家不一样，买个多功能转换器，就能使用

1）适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器

2）适配器模式属于结构型模式

3）主要分类：类适配器模式、对象适配器模式、接口适配器模式

2.工作原理

1）适配器模式：将一个类的接口转换成另一个接口，让原本接口不兼容的类可以兼容

2）从用户的角度看不到被适配者，是解耦的

3）用户调用适配器转换出来的目标接口方法，适配器再调用被适配者的相关接口方法

4）用户收到反馈结果，感觉只是和目标接口交互

3.类适配器模式介绍

基本介绍：Adapter类，通过继承src类，实现dst类接口，完成src->dst的适配

3.1类适配器模式应用实例

1）生活实例

充电器相当于Adapter,220v交流电相当于src(即被适配者)，我们的目的dst是5V直流电

2）代码实现

package com.cx.adapter.classadapter;
//被适配的类
public class Voltage220V {
    //输出220v电压
    public int output220v(){
        int src = 220;
        System.out.println("电压=" +src +"伏");
        return src;
    }
}

package com.cx.adapter.classadapter;
//适配接口
public interface IVoltage5V {
    public int output5V();
}

package com.cx.adapter.classadapter;

public class VoltageAdapter extends Voltage220V implements IVoltage5V{


    @Override
    public int output5V() {
        //获取到220v电压
        int srcV = output220v();
        //转成5v
        int dstV = srcV/44;
        return dstV;
    }
}

package com.cx.adapter.classadapter;

public class Phone {
    //充电
    public void charging(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V() ==5){
            System.out.println("电压为5v,可以充电");
        }else if(iVoltage5V.output5V() >5){
            System.out.println("电压大于5v,不能充电");
        }
    }
}

package com.cx.adapter.classadapter;

public class Client {
    public static void main(String[] args) {
        System.out.println("类适配器模式");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter());
    }
}

3）类适配器注意事项

（1）java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性

（2）src类的方法在Adapter中都会暴露出来，也增加了使用成本

（3）由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵活性增强了

4. 对象适配器

1）基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而是持有src类的实例，以解决兼容性问题。即：持有src类，实现dst类接口，完成src->dst的适配

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

3）对象适配器模式是适配器模式常见的一种

对象适配器模式应用

1）以生活充电器例子来讲，充电器本身相当于Adapter,220V交流电相当于src(即被适配者)，我们的目的dst(即目标)是5v直流电

2）只需修改适配器即可

public class VoltageAdapter2 implements Voltage5{
    private Voltage220 voltage220;//持有Voltage220对象，不是继承了
}

package com.cx.objectadapter;
//适配接口
public interface IVoltage5V {
    public int output5V();
}

package com.cx.objectadapter;
//被适配的类
public class Voltage220V {
    //输出220v电压
    public int output220v(){
        int src = 220;
        System.out.println("电压=" +src +"伏");
        return src;
    }
}

package com.cx.objectadapter;

public class VoltageAdapter  implements IVoltage5V {

    private Voltage220V voltage220V;

    //通过构造器，传入一个Voltage220v 实例
    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
       int dst = 0;
       if(null != voltage220V){
           int src = voltage220V.output220v();
           System.out.println("使用对象适配器，进行适配");
           dst = src /44;
           System.out.println("适配完成，输出电压为=" +dst);
       }
        return dst;
    }
}

package com.cx.objectadapter;

public class Phone {
    //充电
    public void charging(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V() ==5){
            System.out.println("电压为5v,可以充电");
        }else if(iVoltage5V.output5V() >5){
            System.out.println("电压大于5v,不能充电");
        }
    }
}

package com.cx.objectadapter;

public class Client {
    public static void main(String[] args) {
        System.out.println("对象适配器模式");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}

对象适配器模式注意事项和细节

1）对象适配器和类适配器其实算同一种思想，只不过实现方式不同

根据合成复用原则，使用组合替代继承，所以它解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口

2）使用成本更低，更灵活

5 接口适配器模式

1）一些书籍称为：适配器模式或缺省适配器模式

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

3）适用于一个接口不想使用其所有的方法的情况

package com.cx.adapter.interfaceadapter;

public interface Interface4 {
    public void m1();
    public void m2();
    public void m3();
    public void m4();
}

package com.cx.adapter.interfaceadapter;

//在AbsAdapter 我们将Interface4 的方法进行默认实现
public abstract class AbsAdapter implements  Interface4{
    public AbsAdapter() {
        super();
    }

    @Override
    public void m1() {

    }

    @Override
    public void m2() {

    }

    @Override
    public void m3() {

    }

    @Override
    public void m4() {

    }
}

package com.cx.adapter.interfaceadapter;

public class Client {
    public static void main(String[] args) {
       AbsAdapter absAdapter = new AbsAdapter(){
          //只需要去覆盖我们需要使用接口方法

            @Override
            public void m1() {
                System.out.println("使用了m1的方法");
            }
        };
        absAdapter.m1();

    }
}

6. 适配器模式在springmvc框架应用的源码分析

1）springmvc中的HandlerAdapter就使用了适配器模式

public interface Controller{
    
}
class HttpController implements Controller{
    public void doHttpHandler(){
        System.out.println("Http...");
    }
}

class SimpleController implements Controller{
    public void doSimplerHandler(){
        System.out.println("simple...");
    }
}

class AnnotationController implements Controller{
    public void doAnnotationHandler(){
        System.out.println("annotation...");
    }
}

//定义一个Adapter接口
public interface HandlerAdapter{
    public boolean supports(Object handler);

    public void handle(Object handler);
}

//多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter{
    public void handle(Object handler){
        ((SimpleController) handler).doSimplerHandler();
    }

    public boolean supports(Object handler){
        return (handler instanceof SimpleController);
    }
}

class HttpHandlerAdapter implements HandlerAdapter{
    public void handle(Object handler){
        ((HttpController) handler).doHttpHandler();
    }

    public boolean supports(Object handler){
        return (handler instanceof HttpController);
    }
}

class AnnotationHandlerAdapter implements HandlerAdapter{
    public void handle(Object handler){
        ((AnnotationController) handler).doAnnotationHandler();
    }

    public boolean supports(Object handler){
        return (handler instanceof AnnotationController);
    }
}

public class DispatchServlet{
    public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();
    
    public DispatchServlet(){
        handlerAdapters.add(new AnnotationHandlerAdapter());
        handlerAdapters.add(new HttpHandlerAdapter());
        handlerAdapters.add(new SimpleHandlerAdapter ());
        
    }
    
    public void doDispatch(){
        //此处模拟SpringMvc从request取handler对象
        //适配器可以获取到希望的Controller
        //HttpController controller = new HttpController();
        AnnotationController controller = new AnnotationController();
        //得到对应适配器
        HandlerAdapter adapter = getHandler(controller);
        adapter.handle(controller);
    }
    public HandlerAdapter getHandler(Controller controller){
        for(HandlerAdapter adapter: this.handlerAdapters){
            if(adapter.supports(controller)){
                return adapter;
            }
        }
        return null;
    }
    
    public static void main(String[] args){
        new DispatchServlet().doDispatch();
    }
}

7. 适配器模式的注意事项和细节

1)三种命名方式，是根据src是以怎样的形式给到Adapter来命名的

2）类适配器：以类给到，在Adapter里，就是将src当作类，继承

3）对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有

4）接口适配器，以接口给到，在Adapter里，将src作为一个接口，实现

5）Adapter模式的最大的作用还是将原本不兼容的接口融合在一起工作

君为红颜舞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA 设计模式五之设配器模式

目录1.基本介绍2.工作原理3.类适配器模式介绍3.1类适配器模式应用实例4. 对象适配器对象适配器模式应用对象适配器模式注意事项和细节5 接口适配器模式6. 适配器模式在springmvc框架应用的源码分析7. 适配器模式的注意事项和细节1.基本介绍生活例子：插座，每个国家不一样，买个多功能转换器，就能使用1）适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配不能一起工作.
复制链接

扫一扫