01.适配器模式基础适配器模式是一种结构型设计模式用于将不兼容的接口转换为可兼容的接口使原本不能一起工作的类可以协同工作。本文详细介绍了适配器模式的基础、实现方式类适配器和对象适配器、应用场景如封装有缺陷的接口、统一多个类的接口、替换依赖的外部系统等以及优缺点。通过具体案例如读卡器适配、播放器适配和实际开发中的应用如数据库适配器、日志框架适配器帮助读者深入理解和应用适配器模式。1.1 适配器模式由来适配器模式的英文翻译是 Adapter Design Pattern。顾名思义这个模式就是用来做适配的它将不兼容的接口转换为可兼容的接口让原本由于接口不兼容而不能一起工作的类可以一起工作。对于这个模式有一个经常被拿来解释它的例子就是 USB 转接头充当适配器把两种不兼容的接口通过转接变得可以一起工作。主要解决问题主要解决在软件系统中常常要将一些现存的对象放到新的环境中而新环境要求的接口是现对象不能满足的。简单来说用于事后补救措施项目代码后期想让不想关的类变成可以一起工作。1.2 适配器模式定义适配器模式(Adapter Pattern)的定义 将一个接口转换成客户希望的另一个接口适配器模式使接口不兼容的那些类可以一起工作其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式也可以作为对象结构型模式。1.3 适配器模式场景在计算机编程中当我们有两个已有的功能但由于某种原因它们不能直接协同工作时我们使用适配器模式。举个例子1类似USB转接头既可以链接Android手机也可以链接IOS手机。举个例子2欧洲制造的电器但你住在中国。你不能直接将这部电器插入墙上因为插头和插座不兼容。此时你需要一个适配器将欧洲插头转换为中国插座。1.4 适配器模式思考适配器模式应该在真正需要时使用而不是为了强行适配而使用。在设计阶段应该尽量考虑接口的一致性和兼容性以减少对适配器模式的依赖。02.适配器模式原理与实现2.1 罗列一个场景适配器模式在软件开发中有多种应用场景以下是一些常见的应用场景数据库访问适配器模式可以用于将不同数据库供应商的API转换为统一的数据库访问接口以便在不同的数据库之间切换和使用。旧系统升级当需要将旧系统升级为新系统时适配器模式可以用于保留旧系统的功能并将其接口转换为新系统所需的接口。第三方库使用当使用第三方库或组件时其提供的接口可能与当前系统的接口不兼容。适配器模式可以用于将第三方库的接口转换为系统所需的接口。2.2 用例子理解适配器适配器有两种方式类的适配器。通过继承来实现对象的适配器。通过组合来实现具体的代码实现如下所示。其中ITarget 表示要转化成的接口定义。Adaptee 是一组不兼容 ITarget 接口定义的接口Adaptor 将 Adaptee 转化成一组符合 ITarget 接口定义的接口。2.3 适配器模式基本实现类的适配器。通过继承来实现●目标(Target)角色这就是所期待得到的接口。注意由于这里讨论的是类适配器模式因此目标不可以是类。●源(Adapee)角色现在需要适配的接口。●适配器(Adaper)角色适配器类是本模式的核心。适配器把源接口转换成目标接口。显然这一角色不可以是接口而必须是具体类。// 类适配器: 基于继承 public interface ITarget { void f1(); void f2(); void f3(); } public class Adaptee { public void fa() { //... } public void fb() { //... } public void fc() { //... } } public class Adaptor extends Adaptee implements ITarget { public void f1() { super.fa(); System.out.println(调用适配器中方法); } public void f2() { //...重新实现f2()... super.fb(); System.out.println(重新实现f2); } // 这里fc()不需要实现直接继承自Adaptee这是跟对象适配器最大的不同点 Override public void f3() { } }对象的适配器。通过组合来实现// 对象适配器基于组合 public interface ITarget { void f1(); void f2(); void fc(); } public class Adaptee { public void fa() { //... } public void fb() { //... } public void fc() { //... } } public class Adaptor implements ITarget { private final Adaptee adaptee; public Adaptor(Adaptee adaptee) { this.adaptee adaptee; } public void f1() { adaptee.fa(); //委托给Adaptee } public void f2() { //...重新实现f2()... } public void fc() { adaptee.fc(); } }2.4 如何选择适配器针对这两种实现方式在实际的开发中到底该如何选择使用哪一种呢判断的标准主要有两个一个是 Adaptee 接口的个数另一个是 Adaptee 和 ITarget 的契合程度。如果 Adaptee 接口并不多那两种实现方式都可以。如果 Adaptee 接口很多而且 Adaptee 和 ITarget 接口定义大部分都相同那我们推荐使用类适配器因为 Adaptor 复用父类 Adaptee 的接口比起对象适配器的实现方式Adaptor 的代码量要少一些。如果 Adaptee 接口很多而且 Adaptee 和 ITarget 接口定义大部分都不相同那我们推荐使用对象适配器因为组合结构相对于继承更加灵活。03.适配器模式分析3.1 类适配器案例类适配器是一种结构型设计模式它允许将一个类的接口转换为另一个客户端所期望的接口。通过继承原始类和实现目标接口类适配器使得原始类的接口与目标接口兼容。特点 1.使用继承类适配器通过继承源类来实现适配功能。2.单一适配由于 Java 中不支持多重继承类适配器只能适配一个源类。3.2 对象适配器案例对象适配器是适配器模式的一种变体它通过组合而不是继承原始类和目标接口来实现适配器功能。在对象适配器中适配器类持有一个原始类的实例并实现目标接口通过调用原始类的方法来实现目标接口的方法。特点1.适配器通过原始类的实例来实现适配器功能而不是通过继承原始类。2.对象适配器可以重用现有的功能无需修改原始类的代码。3.3 适配器模式结构图包含如下角色Target目标抽象类。定义客户端所期望的接口。适配器将原始类的接口转换为目标接口使得客户端可以通过目标接口来访问原始类的功能。Adapter适配器类。适配器类实现了目标接口并持有原始类的实例。适配器类中的方法通过调用原始类的方法来实现目标接口的方法。适配器充当了目标接口和原始类之间的桥梁。Adaptee适配者类【原始类】。需要被适配的类它定义了不兼容目标接口的方法。适配器模式的目标是使得客户端可以通过目标接口来使用原始类的功能。Client客户类。客户端可以通过目标接口来使用原始类的功能而不需要直接与原始类交互。3.4 适配器模式时序图适配器模式时序图如下所示04.适配器应用解析4.1 读卡器适配案例【类】分析现有一台电脑只能读取SD卡而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器将TF卡中的内容读取出来。首先我们先开发电脑读取SD卡的业务Computer只能使用SD卡所以方法名为readSD()需要SDCard类型的对象。具体做法是主要是SDCard包含两个方法读数据写数据子实现类为SDCardImpl。public interface SDCard { //从SD卡中读取数据 String readSD(); //往SD卡中写数据 void writeSD(String msg); } //具体的SD卡 public class SDCardImpl implements SDCard { Override public String readSD() { String msg SDCard read msg : SD; System.out.println(msg); return msg; } Override public void writeSD(String msg) { System.out.println(SDCard write msg : msg); } } //计算机类 public class Computer { //从SD卡中读取数据 public String readSD(SDCard sdCard) { if (sdCard null) { throw new NullPointerException(sd card is null); } return sdCard.readSD(); } } private void test1() { //计算机读SD卡 Computer computer new Computer(); SDCardImpl sdCard new SDCardImpl(); computer.readSD(sdCard); } //输出结果是 //SDCard read msg : SD然后思想一下如何给TF做适配。第一步定义了一个接口 TFCard 接口有两个方法读取数据写数据。子实现类TFCardImpl重写了接口的两个方法第二步当我们想用Computer去读取TF卡中的内容不能直接读取需要定义适配器类。要让这个适配器类实现目标接口就要重写SDCard中的两个方法同时我们要让它去继承TFCardImpl。第三步最后实现之后这两个方法看似是从SD卡中读数据写数据但是实际上用的是TF卡中的功能//适配者类的接口 public interface TFCard { //从TF卡中读取数据 String readTF(); //往TF卡中写数据 void writeTF(String msg); } //适配者类 public class TFCardImpl implements TFCard { Override public String readTF() { String msg TFCard read msg : TF; System.out.println(msg); return msg; } Override public void writeTF(String msg) { System.out.println(TFCard write msg : msg); } } //适配器类 public class SDAdapterTF extends TFCardImpl implements SDCard { Override public String readSD() { System.out.println(adapter read tf card); return readTF(); } Override public void writeSD(String msg) { System.out.println(adapter wrete tf card); writeTF(msg); } } private void test2() { //计算器适配读卡器去读TF卡中的内容 Computer computer new Computer(); //创建适配器对象完全没有影响之前计算机读SD卡的逻辑 SDAdapterTF sdAdapterTF new SDAdapterTF(); computer.readSD(sdAdapterTF); }通过这个案例可以知道适配器模式是一种强大的设计模式能够有效解决接口不兼容的问题使得不同接口的类能够协同工作。通过合理使用适配器模式可以提高系统的灵活性和复用性但也需要注意其可能带来的复杂性和性能影响。4.2 类适配器优缺点优点简单实现由于类适配器通过继承实现它可以直接访问被适配类Adaptee的所有方法。这使得实现适配器时相对简单不需要额外的委托逻辑。提高代码的可复用性通过继承实现使得子类能够继承父类的所有功能从而提高了代码的复用性。可以重定义被适配类的一些行为通过继承可以在适配器类中重定义被适配类的一些方法实现更加灵活的适配。缺点受限于单继承类适配器模式在Java等单继承语言中有一个显著的缺点即一个类只能继承一个父类。这意味着如果适配器类已经有一个父类就不能再使用类适配器模式来继承另一个类。高耦合适配器类和被适配类之间的耦合度较高因为适配器类直接继承了被适配类的实现。如果被适配类发生变化适配器类可能也需要进行相应的修改。不符合组合原则面向对象设计中组合优于继承的原则提倡使用组合来代替继承以降低类之间的耦合度。类适配器模式违背了这一原则因为它是通过继承来实现适配的。4.3 播放器适配器案例【对象】播放器案例需求分析想象一下我们有一个MediaPlayer接口它可以播放mp3格式的文件。private void test1() { MediaPlayer mp3Player new Mp3Player(); mp3Player.play(mp3,file.mp3); } // MediaPlayer.java public interface MediaPlayer { void play(String audioType, String fileName); } // Mp3Player.java public class Mp3Player implements MediaPlayer { Override public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase(mp3)) { System.out.println(Playing mp3 file. Name: fileName); } else { System.out.println(Invalid media. audioType format not supported); } } }现在我们想扩展这个功能使其也可以播放其他格式的文件比如vlc和mp4。但是我们不希望修改原始的MediaPlayer接口。为了支持更多的格式我们将创建一个新的接口AdvancedMediaPlayerprivate void test2() { AdvancedMediaPlayer vlcPlayer new VlcPlayer(); vlcPlayer.playVlc(vlc); AdvancedMediaPlayer mp4Player new Mp4Player(); mp4Player.playMp4(mp4); } // AdvancedMediaPlayer.java public interface AdvancedMediaPlayer { void playVlc(String fileName); void playMp4(String fileName); } // VlcPlayer.java public class VlcPlayer implements AdvancedMediaPlayer { Override public void playVlc(String fileName) { System.out.println(Playing vlc file. Name: fileName); } Override public void playMp4(String fileName) { // Do nothing } } // Mp4Player.java public class Mp4Player implements AdvancedMediaPlayer { Override public void playVlc(String fileName) { // Do nothing } Override public void playMp4(String fileName) { System.out.println(Playing mp4 file. Name: fileName); } }现在我们已经有了基础的播放器但我们还需要一个适配器以便MediaPlayer可以使用AdvancedMediaPlayer。实现MediaPlayer适配器。为了使MediaPlayer能够使用AdvancedMediaPlayer我们需要创建一个适配器。这个适配器将决定使用哪个AdvancedMediaPlayer的实现。public class MediaAdapter implements MediaPlayer { AdvancedMediaPlayer advancedMusicPlayer; public MediaAdapter(String audioType) { if (audioType.equalsIgnoreCase(vlc)) { advancedMusicPlayer new VlcPlayer(); } else if (audioType.equalsIgnoreCase(mp4)) { advancedMusicPlayer new Mp4Player(); } } Override public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase(vlc)) { advancedMusicPlayer.playVlc(fileName); } else if (audioType.equalsIgnoreCase(mp4)) { advancedMusicPlayer.playMp4(fileName); } } }现在让我们扩展我们的Mp3Player类使其可以使用MediaAdapter来播放其他格式public class AudioPlayer implements MediaPlayer { MediaAdapter mediaAdapter; Override public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase(mp3)) { System.out.println(Playing mp3 file. Name: fileName); } else if (audioType.equalsIgnoreCase(vlc) || audioType.equalsIgnoreCase(mp4)) { mediaAdapter new MediaAdapter(audioType); mediaAdapter.play(audioType, fileName); } else { System.out.println(Invalid media. audioType format not supported); } } }让我们通过一些测试来验证我们的适配器是否正常工作private void test3() { AudioPlayer audioPlayer new AudioPlayer(); audioPlayer.play(mp3, mySong.mp3); audioPlayer.play(mp4, video.mp4); audioPlayer.play(vlc, movie.vlc); audioPlayer.play(avi, doubi.avi); // Not supported }适配器模式是一个非常有用的模式它允许我们整合不兼容的接口而不需要修改原始代码。在本例中我们成功地扩展了MediaPlayer的功能使其可以播放其他格式的文件而不需要改变其原始定义。像上面的MediaPlayer示例一样你可能会在许多真实的应用程序中遇到类似的场景其中一些旧的接口需要与新的接口一起工作但又不希望进行大规模的重写。4.4 对象适配器优缺点对象适配器模式具有以下优点适配器可以重用现有的功能无需修改原始类的代码。适配器通过将原始类的接口转换为目标接口使得客户端可以无缝地使用原始类的功能。对象适配器使用组合来实现适配器功能因此可以适配原始类的子类。这使得对象适配器具有更大的灵活性和可扩展性。对象适配器可以在不修改客户端代码的情况下实现接口转换。客户端只需要通过调用适配器类的方法来使用原始类的功能而不需要直接与原始类交互。对象适配器可以适配多个不同的原始类只需创建相应的适配器类即可。这使得对象适配器具有更高的复用性和可维护性。然而对象适配器模式也有一些缺点和限制对象适配器引入了额外的对象引用可能会增加内存消耗。每个适配器实例都需要持有一个原始类的实例。对象适配器在适配器类中引入了原始类的功能可能会导致接口的冗余和复杂性增加。对象适配器需要通过组合来实现适配器功能这可能需要更多的代码和配置。05.应用场景分析大概有哪些场景封装有缺陷的接口设计统一多个类的接口设计为何用这个一般来说适配器模式可以看作一种“补偿模式”用来补救设计上的缺陷。应用这种模式算是“无奈之举”。如果在设计初期我们就能协调规避接口不兼容的问题那这种模式就没有应用的机会了。5.1 封装有缺陷的接口设计假设我们依赖的外部系统在接口设计方面有缺陷比如包含大量静态方法引入之后会影响到我们自身代码的可测试性。为了隔离设计上的缺陷我们希望对外部系统提供的接口进行二次封装抽象出更好的接口设计这个时候就可以使用适配器模式了。具体我还是举个例子来解释一下你直接看代码应该会更清晰。具体代码如下所示public class CD { //这个类来自外部sdk我们无权修改它的代码 //... public static void staticFunction1() { //... } public void uglyNamingFunction2() { //... } public void tooManyParamsFunction3(int paramA, int paramB, ...) { //... } public void lowPerformanceFunction4() { //... } } // 使用适配器模式进行重构 public class ITarget { void function1(); void function2(); void fucntion3(ParamsWrapperDefinition paramsWrapper); void function4(); //... } // 注意适配器类的命名不一定非得末尾带Adaptor public class CDAdaptor extends CD implements ITarget { //... public void function1() { super.staticFunction1(); } public void function2() { super.uglyNamingFucntion2(); } public void function3(ParamsWrapperDefinition paramsWrapper) { super.tooManyParamsFunction3(paramsWrapper.getParamA(), ...); } public void function4() { //...reimplement it... } }5.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 aFilter; public String filter(String text) { String maskedText aFilter.filterSexyWords(text); maskedText aFilter.filterPoliticalWords(maskedText); return maskedText; } } //...省略BSensitiveWordsFilterAdaptor、CSensitiveWordsFilterAdaptor... // 扩展性更好更加符合开闭原则如果添加一个新的敏感词过滤系统 // 这个类完全不需要改动而且基于接口而非实现编程代码的可测试性更好。 public class RiskManagement { private ListISensitiveWordsFilter 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; } }5.3 替换依赖的外部系统当我们把项目中依赖的一个外部系统替换为另一个外部系统的时候利用适配器模式可以减少对代码的改动。具体的代码示例如下所示// 外部系统A public interface IA { //... void fa(); } public class A implements IA { //... public void fa() { //... } } // 在我们的项目中外部系统A的使用示例 public class Demo { private IA a; public Demo(IA a) { this.a a; } //... } Demo d new Demo(new A()); // 将外部系统A替换成外部系统B public class BAdaptor implemnts IA { private B b; public BAdaptor(B b) { this.b b; } public void fa() { //... b.fb(); } } // 借助BAdaptorDemo的代码中调用IA接口的地方都无需改动 // 只需要将BAdaptor如下注入到Demo即可。 Demo d new Demo(new BAdaptor(new B()));5.4 兼容老版本接口在做版本升级的时候对于一些要废弃的接口我们不直接将其删除而是暂时保留并且标注为 deprecated并将内部实现逻辑委托为新的接口实现。这样做的好处是让使用它的项目有个过渡期而不是强制进行代码修改。这也可以粗略地看作适配器模式的一个应用场景。同样我还是通过一个例子来进一步解释一下。JDK1.0 中包含一个遍历集合容器的类 Enumeration。JDK2.0 对这个类进行了重构将它改名为 Iterator 类并且对它的代码实现做了优化。但是考虑到如果将 Enumeration 直接从 JDK2.0 中删除那使用 JDK1.0 的项目如果切换到 JDK2.0代码就会编译不通过。为了避免这种情况的发生我们必须把项目中所有使用到 Enumeration 的地方都修改为使用 Iterator 才行。单独一个项目做 Enumeration 到 Iterator 的替换勉强还能接受。但是使用 Java 开发的项目太多了一次 JDK 的升级导致所有的项目不做代码修改就会编译报错这显然是不合理的。这就是我们经常所说的不兼容升级。为了做到兼容使用低版本 JDK 的老代码我们可以暂时保留 Enumeration 类并将其实现替换为直接调用 Itertor。代码示例如下所示public class Collections { public static Emueration emumeration(final Collection c) { return new Enumeration() { Iterator i c.iterator(); public boolean hasMoreElments() { return i.hashNext(); } public Object nextElement() { return i.next(): } } } }5.5 适配不同格式的数据前面我们讲到适配器模式主要用于接口的适配实际上它还可以用在不同格式的数据之间的适配。比如把从不同征信系统拉取的不同格式的征信数据统一为相同的格式以方便存储和使用。再比如Java 中的 Arrays.asList() 也可以看作一种数据适配器将数组类型的数据转化为集合容器类型。ListString stooges Arrays.asList(Larry, Moe, Curly);5.6 Java适配器模式使用JDK1.1 之前提供的容器有 Arrays,Vector,Stack,Hashtable,Properties,BitSet其中定义了一种访问群集内各元素的标准方式称为 Enumeration列举器接口。Vector vnew Vector(); for (Enumeration enum v.elements(); enum.hasMoreElements();) { Object o enum.nextElement(); processObject(o); }JDK1.2 版本中引入了 Iterator 接口新版本的集合对HashSet,HashMap,WeakHashMap,ArrayList,TreeSet,TreeMap, LinkedList是通过 Iterator 接口访问集合元素。List listnew ArrayList(); for(Iterator itlist.iterator();it.hasNext();){ System.out.println(it.next()); }这样如果将老版本的程序运行在新的 Java 编译器上就会出错。因为 List 接口中已经没有 elements()而只有 iterator() 了。那么如何将老版本的程序运行在新的 Java 编译器上呢? 如果不加修改是肯定不行的但是修改要遵循“开闭”原则。我们可以用 Java 设计模式中的适配器模式解决这个问题。public class NewEnumeration implements Enumeration { Iterator it; public NewEnumeration(Iterator it) { this.it it; } public boolean hasMoreElements() { return it.hasNext(); } public Object nextElement() { return it.next(); } public static void main(String[] args) { List list new ArrayList(); list.add(a); list.add(b); list.add(C); for (Enumeration e new NewEnumeration(list.iterator()); e.hasMoreElements(); ) { System.out.println(e.nextElement()); } } }NewEnumeration 是一个适配器类通过它实现了从 Iterator 接口到 Enumeration 接口的适配这样我们就可以使用老版本的代码来使用新的集合对象了。5.7 数据库适配器在许多应用程序中需要与多种数据库进行交互。如果每种数据库都有不同的接口那么使用适配器模式可以简化代码并提高代码的可维护性和可扩展性。例如public interface Database { void connect(); void query(String sql); } public class MySqlDatabase implements Database { Override public void connect() { System.out.println(Connecting to MySQL Database); } Override public void query(String sql) { System.out.println(Querying data from MySQL Database: sql); } } public class OracleDatabaseAdapter implements Database { private OracleDatabase oracleDatabase; public OracleDatabaseAdapter(OracleDatabase oracleDatabase) { this.oracleDatabase oracleDatabase; } Override public void connect() { oracleDatabase.open(); } Override public void query(String sql) { oracleDatabase.execute(sql); } } class OracleDatabase { void open() { System.out.println(Opening Oracle Database); } void execute(String sql) { System.out.println(Executing SQL on Oracle Database: sql); } }5.8 日志框架适配器许多Java应用程序使用日志框架来记录应用程序的运行情况。有许多不同的日志框架比如Log4j、SLF4J等它们有着不同的API。通过使用适配器模式我们可以定义一个统一的日志接口然后为每个日志框架实现一个适配器从而让应用程序可以在不同的日志框架之间无缝切换。public interface Logger { void log(String message); } public class Log4jAdapter implements Logger { private org.apache.log4j.Logger logger; public Log4jAdapter(org.apache.log4j.Logger logger) { this.logger logger; } Override public void log(String message) { logger.info(message); } } public class SLF4JAdapter implements Logger { private org.slf4j.Logger logger; public SLF4JAdapter(org.slf4j.Logger logger) { this.logger logger; } Override public void log(String message) { logger.info(message); } }这样我们就可以在应用程序中自由切换使用哪个日志框架而不需要修改大量的代码。5.9 第三方库适配器在实际开发中我们经常会用到第三方库。但是不同的库可能提供了不同的API直接使用会导致代码的耦合度增加。通过适配器模式我们可以为每个库提供一个适配器使它们都符合同一个接口这样在主程序中就可以无缝切换降低了代码的耦合度。06.适配器总结一下6.1 适配器使用环境在以下情况下可以使用适配器模式系统需要使用现有的类而这些类的接口不符合系统的需要。想要建立一个可以重复使用的类用于与一些彼此之间没有太大关联的一些类包括一些可能在将来引进的类一起工作。6.2 适配器模式拓展认适配器模式(Default Adapter Pattern)或缺省适配器模式当不需要全部实现接口提供的方法时可先设计一个抽象类实现接口并为该接口中每个方法提供一个默认实现空方法那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求它适用于一个接口不想使用其所有的方法的情况。因此也称为单接口适配器模式。一般来说适配器模式可以看作一种“补偿模式”用来补救设计上的缺陷。应用这种模式算是“无奈之举”如果在设计初期我们就能协调规避接口不兼容的问题那这种模式就没有应用的机会了。6.3 跟其他模式对比代理、桥接、装饰器、适配器这 4 种模式是比较常用的结构型设计模式。它们的代码结构非常相似。尽管代码结构相似但这4种设计模式的用意完全不同也就是说要解决的问题、应用场景不同这也是它们的主要区别。这里我就简单说一下它们之间的区别。代理模式代理模式在不改变原始类接口的条件下为原始类定义一个代理类主要目的是控制访问而非加强功能这是它跟装饰器模式最大的不同。桥接模式桥接模式的目的是将接口部分和实现部分分离从而让它们可以较为容易、也相对独立地加以改变。装饰器模式装饰者模式在不改变原始类接口的情况下对原始类功能进行增强并且支持多个装饰器的嵌套使用。适配器模式适配器模式是一种事后的补救策略。适配器提供跟原始类不同的接口而代理模式、装饰器模式提供的都是跟原始类相同的接口。07.动态代理总结7.1 总结一下笔记01.适配器模式基础什么叫做适配器模式用来做适配将不兼容的接口转化成兼容的接口例子就是 USB 转接头充当适配器把两种不兼容的接口通过转接变得可以一起工作。简单来说用于事后补救措施项目代码后期想让不想关的类变成可以一起工作。可以作为类结构型模式也可以作为对象结构型模式。适配器模式思考不要强行适配设计前期就要考虑到兼容性以减少对适配器依赖02.适配器模式实现适配器模式两种实现方式类的适配器。通过继承来实现对象的适配器。通过组合来实现03.适配器模式分析类适配器是一种结构型设计模式它允许将一个类的接口转换为另一个客户端所期望的接口。通过继承原始类和实现目标接口类适配器使得原始类的接口与目标接口兼容。对象适配器是适配器模式的一种变体它通过组合而不是继承原始类和目标接口来实现适配器功能。在对象适配器中适配器类持有一个原始类的实例并实现目标接口通过调用原始类的方法来实现目标接口的方法。