Adapter Design Pattern (Structural)

Intent

Adapter is a structural design pattern that allows objects with incompatible interfaces to collaborate.

Problem

Imagine that you’re creating a stock market monitoring app. The app downloads the stock data from multiple sources in XML format and then displays nice-looking charts and diagrams for the user.

At some point, you decide to improve the app by integrating a smart 3rd-party analytics library. But there’s a catch: the analytics library only works with data in JSON format.

You could change the library to support XML. However, this might break some existing code that relies on the library. And worse, you might not have access to the library’s source code in the first place, making this approach impossible.

Solution

You can create an adapter. This is a special object that converts the interface of one object so that another object can understand it.

An adapter wraps one of the objects to hide the complexity of conversion happening behind the scenes. The wrapped object isn’t even aware of the adapter. For example, you can wrap an object that operates in meters and kilometers with an adapter that converts all of the data to imperial units such as feet and miles.

Adapters can not only convert data into various formats but can also help objects with different interfaces collaborate. Here’s how it works:

The adapter gets an interface, compatible with one of the existing objects.
Using this interface, the existing object can safely call the adapter’s methods.
Upon receiving a call, the adapter passes the request to the second object, but in a format and order that the second object expects.

Sometimes it’s even possible to create a two-way adapter that can convert the calls in both directions.

Real-World Analogy

When you travel from Europe to the US for the first time, you might get a surprise when trying to charge your laptop. The power plug and sockets standards are different in different countries. That’s why your European plug won’t fit a US socket. The problem can be solved by using a power plug adapter that has the American-style socket and the European-style plug.

Structure (Class Diagram)

classDiagram
    class Client {
    }
    class ClientInterface {
        <<interface>>
        +method(data)
    }
    class Adapter {
        -adaptee: Adaptee
        +method(data)
    }
    class Adaptee {
        +specificRequest(specialData)
    }

    Client --> ClientInterface
    Adapter ..|> ClientInterface
    Adapter --> Adaptee : wraps/delegates

Pseudocode

# The Client Interface describes a protocol that other
# classes must follow to be able to work with the client code.
interface RoundPeg:
    method getRadius(): int

# A class that you want to make compatible with your code.
class SquarePeg:
    field width: int
    constructor SquarePeg(width):
        this.width = width
    method getWidth(): int
        return this.width

# The Adapter allows using square pegs in round holes.
class SquarePegAdapter implements RoundPeg:
    private peg: SquarePeg

    constructor SquarePegAdapter(peg: SquarePeg):
        this.peg = peg

    method getRadius(): int
        # The adapter pretends that it's a round peg with a
        # radius that can fit the square peg that the adapter
        # actually wraps.
        return this.peg.getWidth() * sqrt(2) / 2

Applicability

Use the Adapter class when you want to use some existing class, but its interface isn’t compatible with the rest of your code.
Use the pattern when you want to reuse several existing subclasses that lack some common functionality that can’t be added to the superclass.

How to Implement

Ensure that you have at least two classes with incompatible interfaces:
- A useful Service (usually 3rd-party or legacy) which you can’t change.
- A Client that would benefit from using the service class.
Declare the client interface and describe how the client communicates with the service.
Create the adapter class and make it follow the client interface. Leave all methods empty for now.
Add a field to the adapter class to store a reference to the service object.
One by one, implement all methods of the client interface in the adapter class. The adapter should delegate most of the real work to the service object, handling only the interface or data format conversion.
Clients should use the adapter via the client interface. This will let you change or extend the adapters without affecting the client code.

Pros and Cons

Pros:

Single Responsibility Principle. You can separate the interface or data conversion code from the primary business logic of the program.
Open/Closed Principle. You can introduce new types of adapters into the program without breaking the existing client code, as long as they work with the client interface.

Cons:

The overall complexity of the code increases because you need to introduce a set of new interfaces and classes. Sometimes it’s simpler just to change the service class so that it fits the rest of your code.

Relations with other Design Patterns

Adapter changes the interface of an existing object, while Decorator enhances an object without changing its interface.
Adapter provides a different interface to its subject. Proxy provides it with the same interface. Decorator provides it with an enhanced interface.
Bridge is usually designed up-front, letting you develop parts of an application independently of each other. Adapter is commonly used with an existing app to make some otherwise-incompatible classes work together nicely.

Code Examples

Code Examples (C#)

// Interface expected by the client
public interface ITarget
{
    void Request();
}

// Existing class with incompatible interface.
public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Call for the specific Adaptee method.");
    }
}

// Adapter
public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request()
    {
        _adaptee.SpecificRequest();
    }
}

// Usage
class Program
{
    static void Main()
    {
        var adaptee = new Adaptee();
        ITarget target = new Adapter(adaptee);

        target.Request();
    }
}

Code Examples (Python)

class Target:
    """
    The Target defines the domain-specific interface used by the client code.
    """
    def request(self) -> str:
        return "Target: The default target's behavior."

class Adaptee:
    """
    The Adaptee contains some useful behavior, but its interface is
    incompatible with the existing client code.
    """
    def specific_request(self) -> str:
        return ".eetpadA eht fo roivaheb laicepS"

class Adapter(Target):
    """
    The Adapter makes the Adaptee's interface compatible with the Target's
    interface.
    """
    def __init__(self, adaptee: Adaptee) -> None:
        self.adaptee = adaptee

    def request(self) -> str:
        return f"Adapter: (TRANSLATED) {self.adaptee.specific_request()[::-1]}"

def client_code(target: Target) -> None:
    """
    The client code supports all classes that follow the Target interface.
    """
    print(target.request(), end="")

if __name__ == "__main__":
    print("Client: I can work just fine with the Target objects:")
    target = Target()
    client_code(target)
    print("\\n")

    adaptee = Adaptee()
    print("Client: The Adaptee class has a weird interface. See, I don't understand it:")
    print(f"Adaptee: {adaptee.specific_request()}", end="\\n\\n")

    print("Client: But I can work with it via the Adapter:")
    adapter = Adapter(adaptee)
    client_code(adapter)

Code Examples (C++)

#include <iostream>

// Interface expected by the client
class ITarget {
public:
    virtual ~ITarget() = default;
    virtual void Request() = 0;
};

// Existing class with incompatible interface
class Adaptee {
public:
    void SpecificRequest() {
        std::cout << "Call for the specific Adaptee method." << std::endl;
    }
};

// Adapter
class Adapter : public ITarget {
private:
    Adaptee& adaptee;

public:
    Adapter(Adaptee& a) : adaptee(a) {}

    void Request() override {
        adaptee.SpecificRequest();
    }
};

// Usage
int main() {
    Adaptee adaptee;
    ITarget* target = new Adapter(adaptee);

    target->Request();

    delete target;
    return 0;
}

Code Examples (Java)

// Target Interface
public interface ITarget {
    void request();
}

// Adaptee (Existing Incompatible Class)
public class Adaptee {
    public void specificRequest() {
        System.out.println("Call for the specific Adaptee method.");
    }
}

// Adapter
public class Adapter implements ITarget {

    private final Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// Usage
public class Program {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        ITarget target = new Adapter(adaptee);

        target.request();
    }
}

Code Examples (JavaScript)

// Target Interface (simulated)
class ITarget {
    request() {
        throw new Error("request() must be implemented");
    }
}

// Adaptee (existing incompatible class)
class Adaptee {
    specificRequest() {
        console.log("Call for the specific Adaptee method.");
    }
}

// Adapter
class Adapter extends ITarget {
    constructor(adaptee) {
        super();
        this.adaptee = adaptee;
    }

    request() {
        this.adaptee.specificRequest();
    }
}

// Usage
const adaptee = new Adaptee();
const target = new Adapter(adaptee);

target.request();

Code Examples (Visual Basic)

' ============================
' Interface expected by the client
' ============================
Public Interface ITarget
    Sub Request()
End Interface

' ============================
' Existing class with incompatible interface
' ============================
Public Class Adaptee
    Public Sub SpecificRequest()
        Console.WriteLine("Call for the specific Adaptee method.")
    End Sub
End Class

' ============================
' Adapter
' ============================
Public Class Adapter
    Implements ITarget

    Private ReadOnly _adaptee As Adaptee

    Public Sub New(adaptee As Adaptee)
        _adaptee = adaptee
    End Sub

    Public Sub Request() Implements ITarget.Request
        _adaptee.SpecificRequest()
    End Sub
End Class

' ============================
' Usage
' ============================
Module Program
    Sub Main()
        Dim adaptee As New Adaptee()
        Dim target As ITarget = New Adapter(adaptee)

        target.Request()
    End Sub
End Module

Code Examples (Rust)

// Interface expected by the client
trait Target {
    fn request(&self);
}

// Existing class with incompatible interface
struct Adaptee;

impl Adaptee {
    fn specific_request(&self) {
        println!("Call for the specific Adaptee method.");
    }
}

// Adapter
struct Adapter {
    adaptee: Adaptee,
}

impl Adapter {
    fn new(adaptee: Adaptee) -> Self {
        Self { adaptee }
    }
}

impl Target for Adapter {
    fn request(&self) {
        self.adaptee.specific_request();
    }
}

// Usage
fn main() {
    let adaptee = Adaptee;
    let target: Box<dyn Target> = Box::new(Adapter::new(adaptee));

    target.request();
}

Code Examples (PHP)

<?php

// Interface expected by the client
interface ITarget
{
    public function request(): void;
}

// Existing class with incompatible interface
class Adaptee
{
    public function specificRequest(): void
    {
        echo "Call for the specific Adaptee method.\n";
    }
}

// Adapter
class Adapter implements ITarget
{
    private Adaptee $adaptee;

    public function __construct(Adaptee $adaptee)
    {
        $this->adaptee = $adaptee;
    }

    public function request(): void
    {
        $this->adaptee->specificRequest();
    }
}

// Usage
$adaptee = new Adaptee();
$target = new Adapter($adaptee);

$target->request();

Code Examples (Go)

package main

import (
    "fmt"
)

// Interface expected by the client
type Target interface {
    Request()
}

// Existing class with incompatible interface
type Adaptee struct{}

func (Adaptee) SpecificRequest() {
    fmt.Println("Call for the specific Adaptee method.")
}

// Adapter
type Adapter struct {
    adaptee Adaptee
}

func NewAdapter(a Adaptee) *Adapter {
    return &Adapter{adaptee: a}
}

func (ad *Adapter) Request() {
    ad.adaptee.SpecificRequest()
}

// Usage
func main() {
    adaptee := Adaptee{}
    var target Target = NewAdapter(adaptee)

    target.Request()
}

Code Examples (Ruby)

# Interface expected by the client
class Target
def request
    raise NotImplementedError, "Subclasses must implement request"
end
end

# Existing class with incompatible interface
class Adaptee
def specific_request
    puts "Call for the specific Adaptee method."
end
end

# Adapter
class Adapter < Target
def initialize(adaptee)
    @adaptee = adaptee
end

def request
    @adaptee.specific_request
end
end

# Usage
adaptee = Adaptee.new
target = Adapter.new(adaptee)

target.request

Code Examples (Perl)

#!/usr/bin/perl
use strict;
use warnings;

############################
# Target (Interface-like)
############################
package Target;

sub request {
    die "request() must be implemented by subclass";
}

############################
# Adaptee (Existing class)
############################
package Adaptee;

sub new { bless {}, shift }

sub specific_request {
    print "Call for the specific Adaptee method.\n";
}

############################
# Adapter
############################
package Adapter;
our @ISA = ('Target');

sub new {
    my ($class, $adaptee) = @_;
    return bless { adaptee => $adaptee }, $class;
}

sub request {
    my ($self) = @_;
    $self->{adaptee}->specific_request();
}

############################
# Usage
############################
package main;

my $adaptee = Adaptee->new();
my $target  = Adapter->new($adaptee);

$target->request();

Code Examples (TypeScript)

// Target Interface
interface ITarget {
    request(): void;
}

// Adaptee (existing incompatible class)
class Adaptee {
    specificRequest(): void {
        console.log("Call for the specific Adaptee method.");
    }
}

// Adapter
class Adapter implements ITarget {
    private adaptee: Adaptee;

    constructor(adaptee: Adaptee) {
        this.adaptee = adaptee;
    }

    request(): void {
        this.adaptee.specificRequest();
    }
}

// Usage
const adaptee = new Adaptee();
const target: ITarget = new Adapter(adaptee);

target.request();