侧边栏壁纸
博主头像
qingtian博主等级

喜欢是一件细水流长的事,是永不疲惫的双向奔赴~!

  • 累计撰写 85 篇文章
  • 累计创建 40 个标签
  • 累计收到 0 条评论

再谈适配器模式

qingtian
2022-04-17 / 0 评论 / 0 点赞 / 35 阅读 / 5,841 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-04-17,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

适配器模式

适配器模式的原理和实现

适配器模式Adapter Design Pattern

用来做适配的,它将不兼容的接口转换为可兼容的接口,让原本由于接口不兼容而不能一起工作的类可以一起工作。

适配器模式有两种实现方式:类适配器和对象适配器。其中,类适配器使用继承关系来实现,对象适配器使用组合关系来实现。具体的代码实现如下所示。其中,ITarget 表示要转化成的接口定义。Adaptee是一组不兼容 ITarget接口定义的接口,Adaptor 将 Adaptee 转化成一组符合 ITarget 接口定义的接口。

类适配器:基于继承
---------------------------------------------------------------
public interface ITarget {
    void f1();
    void f2();
    void fc();
}

public class Adaptee {
    public void fa() {}
    public void fb() {}
    public void fc() {}
}

public class Adaptor extends Adaptee implements ITarget{
    @Override
    public void f1() {
        super.fa();
    }

    @Override
    public void f2() {
        //重新实现f2()
    }

    /**
     * 这里fc()不需要实现,直接可以继承Adaptee ,这是和对象适配器最大的不同
     */
    @Override
    public void fc() {}

}

---------------------------------------------------------------------
对象适配器:基于组合
public interface ITarget {
    void f1();
    void f2();
    void fc();
}

public class Adaptee {
    public void fa() {}
    public void fb() {}
    public void fc() {}
}

public class Adaptor2 implements ITarget{

    //基于组合
    private Adaptee adaptee;
    public Adaptor2(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void f1() {
        adaptee.fa();   //委托给adaptee
    }

    @Override
    public void f2() {
        //重新实现f2()
    }

    @Override
    public void fc() {
        adaptee.fc();   //委托给adaptee
    }
}

针对两种实现方式,在实际开发中该如何选择使用哪种模式呢

主要的判断标准:

  • 一个是 Adaptee 接口的个数,另一个是 Adaptee 和 ITarget 的契合程度。
  • 如果 Adaptee 接口并不多,那两种实现方式都可以。
  • 如果 Adaptee 接口很多,而且 Adaptee 和 ITarget 接口定义大部分都相同,那我们推荐使用类适配器,因为 Adaptor 复用父类 Adaptee 的接口,比起对象适配器的实现方式,Adaptor 的代码量要少一些。
  • 如果 Adaptee 接口很多,而且 Adaptee 和 ITarget 接口定义大部分都不相同,那我们推荐使用对象适配器,因为组合结构相对于继承更加灵活。

适配器模式使用场景总结

一般来说,适配器模式可以看作一种“补偿模式”,用来补救设计上的缺陷。应用这种模式算是“无奈之举”。如果在设计初期,我们就能协调规避接口不兼容的问题,那这种模式就没有应用的机会了。

实际开发中什么情况下才会遇到接口不兼容呢?

1. 封装有缺陷的接口设计

假设我们依赖的外部系统在接口设计方面有缺陷(比如包含大量静态方法),引入之后会影响到我们自身代码的可测试性。为了隔离设计上的缺陷,我们希望对外部系统提供的接口进行二次封装,抽象出更好的接口设计,这个时候就可以使用适配器模式了。

例子代码如下:

public class CD {   //这个类来自外部sdk,我们无权修改它的代码
    public static void staticFunction1(){}

    public void uglyNamingFunction2(){}

    public void  tooManyParamsFunctions(int paramA, int paramB){}

    public void lowPerFormanceFunction4(){}
}

//使用适配器模式重构
public interface ITarget2 {
    void function1();
    void function2();
    void function3(ParamsWrapperDefinition paramsWrapper);
    void function4();
}

public class CDAdaptor extends CD implements ITarget2{
    @Override
    public void function1() {
        staticFunction1();
    }

    @Override
    public void function2() {
        super.uglyNamingFunction2();
    }

    @Override
    public void function3(ParamsWrapperDefinition paramsWrapper) {
        super.tooManyParamsFunctions(paramsWrapper.getParamA(),.....);
    }

    @Override
    public void function4() {
        super.lowPerFormanceFunction4();
    }
}

2. 同一多个类的接口设计

某个功能的实现依赖多个外部系统(或者说类)。通过适配器模式,将它们的接口适配为统一的接口定义,然后我们就可以使用多态的特性来复用代码逻辑。

假设我们的系统要对用户输入的文本内容做敏感词过滤,为了提高过滤的召回率,我们引入了多款第三方敏感词过滤系统,依次对用户输入的内容进行过滤,过滤掉尽可能多的敏感词。但是,每个系统提供的过滤接口都是不同的。这就意味着我们没法复用一套逻辑来调用各个系统。这个时候,我们就可以使用适配器模式,将所有系统的接口适配为统一的接口定义,这样我们可以复用调用敏感词过滤的代码。

public class ASensitiveWordsFilter {    //A敏感词过滤系统提供的接口
    //text是原始文本,函数输出用****代替敏感词之后的文本
    public String filterSexyWords(String text) {}

    public String filterPoliticalWords(String text){};
}

public class BSensitiveWordsFilter {    //B敏感词过滤系统提供的接口
    public String filter(String text){}
}

public class CSensitiveWordsFilter {    //C过滤系统提供的接口
    public String filter(String text, String mask){}
}

//未使用适配器模式之前的代码
public class RiskManagement {
    private ASensitiveWordsFilter aFilter = new ASensitiveWordsFilter();
    private BSensitiveWordsFilter bFilter = new BSensitiveWordsFilter();
    private CSensitiveWordsFilter cFilter = new CSensitiveWordsFilter();

    public String filterSensitiveWords(String text) {
        String maskedText = aFilter.filterSexyWords(text);
        maskedText = aFilter.filterPoliticalWords(maskedText);
        maskedText = bFilter.filter(maskedText);
        maskedText = cFilter.filter(maskedText,"***");
        return maskedText;
    }
}

----------------------------------------------------------------------
//使用适配器模式进行改造
public interface ISensitiveWordsFilter {    //统一定义接口
    String filter(String text);
}

public class ASensitiveWordsFilterAdaptor implements ISensitiveWordsFilter{
    private ASensitiveWordsFilter filter;
    @Override
    public String filter(String text) {
        String maskedText = filter.filterSexyWords(text);
        maskedText = filter.filterPoliticalWords(maskedText);
        return maskedText;
    }
}

//...省略BSensitiveWordsFilterAdaptor、CSensitiveWordsFilterAdaptor...

//扩展性更好,更加符合开闭原则,如果添加一个新的过滤词系统
//这个类完全不需要改动;而且基于接口而非实现编程
public class RiskManagement {
    private List<ISensitiveWordsFilter> filters = new ArrayList<>();
    
    public void addSensitiveWordsFilter(ISensitiveWordsFilter filter) {
        filters.add(filter);
    }
    
    public String filterSensitiveWords(String text) {
        String maskedText = text;
        for (ISensitiveWordsFilter filter : filters) {
            maskedText = filter.filter(maskedText);
        }
        return maskedText;
    }
}

3. 替换依赖的外部系统

当我们把项目中依赖的一个外部系统替换为另一个外部系统的时候,利用适配器模式,可以减少对代码的改动。具体的代码示例如下所示:

//外部系统A
public interface IA {
    void fa();
}

public class A implements IA{
    @Override
    public void fa() {

    }
}

//在自己系统中使用外部系统A的实例
public class Demo {
    private IA a;
    public Demo(IA a) {
        this.a = a;
    }

    //如何使用A系统
    public static void main(String[] args) {
        Demo demo = new Demo(new A());
    }
}
--------------------------------------------------------------------
//将外部系统A替换成外部系统B
public class BAdaptor implements IA{
    private B b;
    public BAdaptor(B b) {
        this.b = b;
    }
    @Override
    public void fa() {
        //...
        b.fb();
    }
}

//借助BAdaptor,Demo中的代码调用IA接口的地方都无需改动
//只需要将BAdaptor如下注入Demo即可
Demo demo1 = new Demo(new BAdaptor(new B()));

4.兼容老版本的接口

在做版本升级的时候,对于一些要废弃的接口,我们不直接将其删除,而是暂时保留,并且标注为 deprecated,并将内部实现逻辑委托为新的接口实现。这样做的好处是,让使用它的项目有个过渡期,而不是强制进行代码修改。

看下面这段代码

public class Collections {
	public static Emueration emueration(final Collection c) {
		return new Emueration() {
			Iterator i = c.iterator();
			
			public boolean hasMoreElments() {
				return i.hasNext();
			}
			
			public Object nextElement() {
				return i.next();
			}
		}
	}
}

5. 适配不同格式的数据

适配器模式主要用于接口的适配,实际上,它还可以用在不同格式的数据之间的适配。比如,把从不同征信系统拉取的不同格式的征信数据,统一为相同的格式,以方便存储和使用。再比如,Java 中的 Arrays.asList() 也可以看作一种数据适配器,将数组类型的数据转化为集合容器类型。

List<String> stringList = Arrays.asList("a", "b", "c");

代理、桥接、装饰器、适配器4种设计模式的区别

代理、桥接、装饰器、适配器,这 4 种模式是比较常用的结构型设计模式。它们的代码结构非常相似。笼统来说,它们都可以称为 Wrapper 模式,也就是通过 Wrapper 类二次封装原始类。

尽管代码结构相似,但这 4 种设计模式的用意完全不同,也就是说要解决的问题、应用场景不同,这也是它们的主要区别。这里我就简单说一下它们之间的区别。

代理模式:代理模式在不改变原始类接口的条件下,为原始类定义一个代理类,主要目的是控制访问,而非加强功能,这是它跟装饰器模式最大的不同。

桥接模式:桥接模式的目是将接口部分和实现部分分离,从而让它们可以较为容易、也相对独立地加以改变。

装饰器模式:装饰者模式在不改变原始类接口的情况下,对原始类功能进行增强,并且支持多个装饰器的嵌套使用。

适配器模式:适配器模式是一种事后的补救策略。适配器提供跟原始类不同的接口,而代理模式、装饰器模式提供的都是跟原始类相同的接口。

0

评论区