精华内容
下载资源
问答
  • 适配器模式应用场景Traditionally, structural patterns are described as the thing that helps simplify the process of object composition. Its purpose is to help identify the relationship between ...

    适配器模式应用场景

    Traditionally, structural patterns are described as the thing that helps simplify the process of object composition. Its purpose is to help identify the relationship between different objects, making sure that if something changes within the system, it doesn’t force the entire system to change with it.

    传统上,结构模式被描述为有助于简化对象组成过程的事物。 其目的是帮助识别不同对象之间的关系,确保如果系统中发生某些更改,则不会强制整个系统随之更改。

    Let’s begin with the adapter pattern.

    让我们从适配器模式开始。

    适配器图案 (Adapter Pattern)

    Imagine you have to build another cart solution for your boss. But there’s a caveat — you’re not allowed to change the original code that spits out the cart data. Why? Because no one knows how that change will impact the rest of the application. It’s a fragile piece of art that no one wants to touch, not yet, or ever. The situation is one of those moments where you just don’t have the time or mental space to question it. You’ll just have to accept that it’s going to be like this until you fully transition out of your legacy systems.

    想象一下,您必须为老板构建另一个购物车解决方案。 但是需要注意的是-您不能更改用于吐出购物车数据的原始代码。 为什么? 因为没有人知道这一更改将如何影响应用程序的其余部分。 这是一件易碎的艺术品,没人愿意,现在甚至永远都不想碰。 这种情况就是您没有时间或精力去质疑它的时刻之一。 您只需要接受这种情况就可以了,直到您完全退出旧系统为止。

    But the process of transitioning is going to take a long time and you don’t want your code to be too intertwined with the old code. What do you do?

    但是过渡过程将花费很长时间,并且您不希望您的代码与旧代码过于纠结。 你是做什么?

    In situations like these, the adapter pattern comes in handy.

    在这种情况下,可以使用适配器模式。

    The adapter pattern introduces an intermediary piece of code that makes two parts of a system compatible with one another. It also injects an element of lose coupling by keeping the two pieces of code separate. It means that you can write your code however you want without the need to take the other piece of code into consideration. Your adapter code will do the necessary translation and give you what you need and in whatever format you want.

    适配器模式引入了一段中间代码,使系统的两个部分相互兼容。 它还通过使两段代码分开来注入失去耦合的元素。 这意味着您可以根据需要编写代码,而无需考虑其他代码。 您的适配器代码将进行必要的翻译,并为您提供所需的内容以及所需的任何格式。

    When one side of the code changes, you only need to change the adapter for that particular part rather than both sides of the application.

    当代码的一侧发生更改时,您只需要更改该特定部分的适配器,而无需更改应用程序的两侧。

    那么,您到底如何用JavaScript编写适配器模式呢? (So how exactly do you write an adapter pattern in JavaScript?)

    There’s no actual way to write it as such. It’s more a conceptual idea and the code itself is dependent on the situation you’re trying to bridge. It’s a process of abstracting the data you need from an external or 3rd party object. To do this, we often create an interface to represent our adapter and create the connections required between the two parts.

    没有实际的方式可以这样写。 这更多是一个概念性想法,代码本身取决于您要弥合的情况。 这是从外部或第三方对象中提取所需数据的过程。 为此,我们经常创建一个接口来表示我们的适配器,并在两个部分之间创建所需的连接。

    One thing to take note is that the adapter only has a single direction of dependency. The adapter only consumes what it aims to translates. In most cases, it’s the legacy API or 3rd party libraries. It doesn’t do anything else other than form a connection between two sides of an application. It should not contain any business logic.

    需要注意的一件事是,适配器仅具有单个方向的依赖性。 适配器仅消耗其要翻译的内容。 在大多数情况下,它是旧版API或第三方库。 除了在应用程序的两侧之间建立连接之外,它没有做任何其他事情。 它不应包含任何业务逻辑。

    Conventionally, an adapter sits in a utils folder and then imported into a file when it's needed. However, it can also be a stand alone function.

    按照惯例,适配器位于utils文件夹中,然后在需要时导入到文件中。 但是,它也可以是独立功能。

    Let’s take a look at the exported class version first.

    让我们首先看一下导出的class版本。

    //your original cart data service
    //this is just a hypothetical name
    import { v4 as cart } from "cartServiceV4"

    class CartServiceAdapter {
    getCart(){
    //some cart code
    //using data from the imported cart service
    //can transform the original output to suit your needs
    return cart;
    }
    removeItemFromCart(){
    //some cart code
    return cart;
    }
    //etc
    }

    export default new CartService();

    import brings in the thing you want to translate. export makes your CartServiceAdapter available for usage by anything that imports it.

    import会带来您要翻译的内容。 export使CartServiceAdapter可供导入它的任何对象使用。

    When you need the cart data, you just need to import your adapter into your code using import.

    当你需要的cart的数据,你只需要使用导入你的适配器插入你的代码import

    import cart from "./utils/CartServiceAdapter"

    console.log(cart.getCart());

    What this hypothetical code looks like in diagram form:

    该假设代码以图表形式显示:

    Image for post
    diagram by Aphinya Dechalert
    图由Aphinya Dechalert撰写

    This means that rather than forcing your new cart code to conform to the needs of the mysterious original code, you can just write an adapter that translates the original to fit with the new code. As a result, you’re free to construct your code however you want.

    这意味着您不必编写新的购物车代码来满足神秘原始代码的需求,而只需编写一个适配器即可转换原始代码以使其适合新代码。 结果,您可以随意构建自己的代码。

    You can also write your adapters as normal functions rather than a class. There are no restrictions on how you write it. Here’s an example of what a possible interface can look like as a function:

    您也可以将适配器编写为普通函数,而不是类。 编写方式没有任何限制。 这是一个可能的界面作为函数的示例:

    //original cart data that cannot be changed at source
    //let's pretend this is from a mysterious data service
    //we have no direct access to this
    var cart = [
    {item: "vintage clock", sku: 9284, value: 15.99},
    {item: "motivate carts", sku: 9232, value: 19.99}
    ]

    //old interface pulls in data from mysterious data service
    //we're not allowed to touch this
    function Cart(){
    return this.cart;
    }

    //our adapter code to translate the data
    //prevents us from consuming the Cart() directly
    function CartAdapter(){
    var originalCart = Cart();
    var adapterCart = originalCart.map(function(obj){
    return {
    item: obj.item,
    productId: obj.sku,
    price:obj.value
    }
    });
    return adapterCart;
    }

    //now we can use the result of the CartAdapter() however we want
    //changes in Cart() will result in only a change in the adapter
    //the rest of the code remains unimpacted once the adapter is fixed
    console.log(CartAdapter());

    In the example above, we’re pretending that the cart data format cannot be changed that it's being pulled into the application via the Cart() function. Cart() can be seen as the old interface that we don't want to touch. CartAdapter() as the intermediary piece of code that prevents us from consuming Cart() directly. When something changes in Cart(), we only need to change CartAdapter() rather than the family of functions that may be consuming the data from Cart() directly.

    在上面的示例中,我们假装无法将cart数据格式更改为通过Cart()函数将其拖入应用程序。 Cart()可以看作是我们不想触摸的旧界面。 CartAdapter()作为中间代码段,可防止我们直接使用Cart() 。 当Cart()某些内容发生变化时,我们只需要更改CartAdapter()而无需更改可能直接使用Cart()的数据的函数族。

    The adapter pattern comes in handy for when you’re working across multiple platforms, data sources, libraries and frameworks. It fills in the gaps that are caused by the various requirements and differences in environments. The context of the original code may make sense, but not in the use case that it needs to be consumed. The adapter pattern makes this possible by bridging the different sources together.

    当您跨多个平台,数据源,库和框架工作时,适配器模式非常有用。 它填补了各种要求和环境差异所造成的空白。 原始代码的上下文可能有意义,但在用例中不需要使用它。 适配器模式通过将不同的源桥接在一起使之成为可能。

    翻译自: https://medium.com/madhash/adapter-pattern-in-a-nutshell-2aafb4099a23

    适配器模式应用场景

    展开全文
  • Java 适配器模式应用场景适配器模式的思想和我们现实世界中的接口转接器的模式很相似,我只需要花较少的代价买个适配器就行,而不用花大价钱把原有设备也给换掉,比较典型的例子,就是不同的苹果的耳机接口;...

    Java 适配器模式应用场景

    适配器模式的思想和我们现实世界中的接口转接器的模式很相似,我只需要花较少的代价买个适配器就行,而不用花大价钱把原有设备也给换掉,比较典型的例子,就是不同的苹果的耳机接口;

    主要用途:

    通常用于对旧系统进行改造升级的时候

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

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

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

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

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

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

    3.替换依赖的外部系统

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

    4.兼容老版本接口

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

    5.适配不同格式的数据

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

    展开全文
  • 适配器模式应用场景总结

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

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

    1. 封装有缺陷的接口设计
      假设我们依赖的外部系统在接口设计方面有缺陷(比如包含大量静态方法),引入之后会影响到我们自身代码的可测试性。为了隔离设计上的缺陷,我们希望对外部系统提供的接口进行二次封装,抽象出更好的接口设计,这个时候就可以使用适配器模式了。
    2. 统一多个类的接口设计
      某个功能的实现依赖多个外部系统(或者说类)。通过适配器模式,将它们的接口适配为统一的接口定义,然后我们就可以使用多态的特性来复用代码逻辑。
    3. 替换依赖的外部系统
      当我们把项目中依赖的一个外部系统替换为另一个外部系统的时候,利用适配器模式,可以减少对代码的改动。
    4. 兼容老版本接口
      在做版本升级的时候,对于一些要废弃的接口,我们不直接将其删除,而是暂时保留,并且标注为 deprecated,并将内部实现逻辑委托为新的接口实现。这样做的好处是,让使用它的项目有个过渡期,而不是强制进行代码修改。这也可以粗略地看作适配器模式的一个应用场景。
    5. 适配不同格式的数据
      适配器模式主要用于接口的适配,实际上,它还可以用在不同格式的数据之间的适配。比如,把从不同征信系统拉取的不同格式的征信数据,统一为相同的格式,以方便存储和使用。再比如,Java 中的 Arrays.asList() 也可以看作一种数据适配器,将数组类型的数据转化为集合容器类型。
    展开全文
  • 适配器模式属于结构性设计模式,它也是一种常用的设计模式。适配器模式适配器模式很容易理解,从字面意思就知道是用来做适配的。他的作用是将原本不兼容的接口转换为客户期望的接口,使得原本由于接口不兼容而不能...
  • 适配器模式有两种:类适配器、对象适配器、接口适配器前二者在实现上有些许区别,作用一样,第三个接口适配器差别较大。1、类适配器模式:原理:通过继承来实现适配器功能。当我们要访问的接口A中没有我们想要的方法...
  • 适配器模式有两种:类适配器、对象适配器、接口适配器前二者在实现上有些许区别,作用一样,第三个接口适配器差别较大。1、类适配器模式:原理:通过继承来实现适配器功能。当我们要访问的接口A中没有我们想要的方法...
  • 适配器模式 概念:将一个接口转换为客户希望的另一个接口,使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。 适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。 在适配器模式中,我们...
  •  适配器模式有两种:类适配器、对象适配器、接口适配器  前二者在实现上有些许区别,作用一样,第三个接口适配器差别较大。 1、类适配器模式:  原理:通过继承来实现适配器功能。  当我们要访问的接口A中...
  • 适配器模式应用场景: 适配器模式(Adapter Pattern)是指将一个类的接口转换成客户期望的另一个接口,使原本的接口不兼容的类可以一起工作,属于结构型设计模式。 适配器适用于以下几种业务场景: 1、已经存在的...
  • 适配器模式有两种:类适配器、对象适配器、接口适配器前二者在实现上有些许区别,作用一样,第三个接口适配器差别较大。1、类适配器模式:原理:通过继承来实现适配器功能。当我们要访问的接口A中没有我们想要的方法...
  • 适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式,它结合了两个独立接口的功能。 这种模式涉及到一个单一的类,该类负责加入独立的或不兼容的接口功能。举个真实...
  • Java设计模式之《适配器模式》及应用场景  原创作品,可以转载,但是请标注出处地址http://www.cnblogs.com/V1haoge/p/6479118.html  适配器就是一种适配中间件,它存在于不匹配的二者之间,用于连接二者,将不...
  • 适配器模式

    2020-08-30 23:18:55
    适配器模式适配器模式实现类的适配器模式对象适配器模式应用场景 适配器模式 适配器模式将一个类的接口适配成客户所希望的另一个接口。适配器使得原本由于接口不兼容而不能一起工作的类可以一起工作。 适配器模式是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 650
精华内容 260
关键字:

适配器模式应用场景