The adapter pattern is a useful design pattern that allows you to connect incompatible interfaces and reuse existing code. In this article, you will learn how to use the adapter pattern with UML diagrams and examples.
The adapter pattern is a structural design pattern that converts the interface of one class into another interface that is expected by the client. This way, you can use two classes that have different interfaces and make them work together. The adapter pattern is also known as the wrapper pattern because it wraps one class with another.
The adapter pattern can be a powerful tool in software development, as it allows two incompatible interfaces to work together and can save time and effort by reusing existing code. It can improve the maintainability and extensibility of software systems, as new functionality can be integrated without requiring major modifications to existing code. However, the use of adapters can add complexity to a system and result in decreased performance, which may be a critical issue in some cases. moreover, if the two interfaces are fundamentally incompatible, using the adapter pattern may not be feasible, and alternative approaches may need to be considered.
The adapter pattern can help you solve a variety of problems, such as reusing a class that has useful functionality but does not match the interface you need, creating a reusable class that can cooperate with classes that have different or incompatible interfaces, and decoupling your system from external libraries or frameworks that may change their interfaces over time. Additionally, this pattern can improve the readability and maintainability of your code by concealing the complexity and details of the adapted class.
A lot of time this is used as a way of using existing code to meet a deadline with the long term goal of later writing something that is more specific to the functionality that you need. An example of this is the extension of the WebSecurityConfigurerAdapter, which was deprecated in Spring Boot 2.7 and later. It was replaced by an annotated configuration object.
To apply the adapter pattern, you need to identify four roles: the target, the client, the adaptee, and the adapter. The adapter can be implemented in two ways - class adapter and object adapter. The class adapter uses inheritance to extend the adaptee and implement the target interface, while the object adapter uses composition to hold a reference to the adaptee and implement the target interface.
The adapter pattern can be modeled with UML class diagrams that show the relationships between the classes involved. Here is an example of a class diagram for the object adapter:
[Image: A UML class diagram for the object adapter pattern. It shows four classes: Target, Adapter, Adaptee, and Client. Target has an operation called request(). Adapter implements Target and has an attribute called adaptee of type Adaptee. Adapter also has an operation called request() that calls adaptee.specificRequest(). Adaptee has an operation called specificRequest(). Client uses Target to invoke request().]
The class diagram for the class adapter is similar, except that Adapter inherits from both Target and Adaptee, instead of having an attribute of type Adaptee.
The adapter pattern can be implemented with any programming language that supports inheritance or composition. Here is an example of a Java code for the object adapter:
// The target interface
public interface Target {
void request();
}
// The adaptee class
public class Adaptee {
public void specificRequest() {
System.out.println("Adaptee: Doing something specific");
}
}
// The adapter class
public class Adapter implements Target {
private Adaptee adaptee;
// Constructor that takes an adaptee as an argument
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
// Implement the target interface by delegating to the adaptee
public void request() {
System.out.println("Adapter: Converting request");
adaptee.specificRequest();
}
}
// The client class
public class Client {
public static void main(String[] args) {
// Create an adaptee object
Adaptee adaptee = new Adaptee();
// Create an adapter object that wraps the adaptee
Target target = new Adapter(adaptee);
// Use the target interface to invoke the request
target.request();
}
}