Паттерн Адаптер в Python

Паттерн Адаптер — это структурный паттерн проектирования, который позволяет взаимодействовать несовместимым интерфейсам. Подобно тому как электрический адаптер в реальной жизни позволяет вилкам из разных стран подключаться к местным розеткам, в программировании паттерн Адаптер служит мостом между двумя несовместимыми интерфейсами.

Основные концепции

Паттерн Адаптер в основном решает проблему несовместимости интерфейсов. Когда нам нужно использовать существующий класс, но его интерфейс не соответствует нашим требованиям, паттерн Адаптер оказывается кстати. Он преобразует интерфейс, создавая промежуточный слой (адаптер), что позволяет изначально несовместимым классам работать вместе.

Структура паттерна

Паттерн Адаптер состоит из трёх основных ролей:

  • Целевой интерфейс (Target): Интерфейс, ожидаемый клиентом
  • Адаптер (Adapter): Реализует целевой интерфейс и оборачивает адаптируемый объект
  • Адаптируемый (Adaptee): Существующий класс, который нужно адаптировать

Зачем нужен паттерн «Адаптер»?

Сценарий проблемы из реального мира

Представьте, что у вас есть существующая система логирования, которая использует определённый метод для записи логов:

Пример

class LegacyLogger:
    def write_log(self, message):
        print(f"[LEGACY] {message}")

Но теперь вы хотите использовать новый интерфейс логирования:

Пример

class NewLogger:
    def log(self, level, message):
        print(f"[{level.upper()}] {message}")

Без адаптера вам пришлось бы изменить весь код, который вызывает старую систему логирования, что отнимает много времени и чревато ошибками.

Преимущества адаптера

  1. Повторное использование кода: повторное использование существующих классов без изменения исходного кода
  2. Разделение связей: отделение логики преобразования интерфейса от бизнес-логики
  3. Гибкость: лёгкое переключение между различными реализациями
  4. Соблюдает принцип открытости/закрытости: открыт для расширения, закрыт для изменения

Подходы к реализации паттерна Адаптер

Классовый адаптер (с использованием наследования)

Классовый адаптер реализует адаптацию интерфейса через множественное наследование:

Пример

class LegacyLogger:
    """Устаревший класс логирования, который адаптируется"""
    def write_log(self, message):
        print(f"[LEGACY] {message}")

class NewLoggerInterface:
    """Целевой интерфейс"""
    def log(self, level, message):
        pass

class LoggerAdapter(NewLoggerInterface, LegacyLogger):
    """Адаптер класса — реализован через наследование"""
    def log(self, level, message):
        # Преобразовать новый интерфейс в старый интерфейс
        formatted_message = f"{level}: {message}"
        self.write_log(formatted_message)

# Пример использования
logger = LoggerAdapter()
logger.log("INFO", "Система успешно запущена")
logger.log("ERROR", "Не удалось подключиться к базе данных")

Вывод:

[LEGACY] INFO: 系统启动成功
[LEGACY] ERROR: 数据库连接失败

Адаптер объекта (с использованием композиции)

Адаптер объекта реализуется через композицию, что является более распространённым подходом:

Пример

class LegacyPayment:
    """Устаревшая платёжная система, которая адаптируется"""
    def process_payment(self, amount_in_dollars):
        print(f"Обработка платежа: ${amount_in_dollars}")
        return True

class NewPaymentInterface:
    """Новый платёжный интерфейс"""
    def pay(self, amount, currency="CNY"):
        pass

class PaymentAdapter(NewPaymentInterface):
    """Объектный адаптер — реализован через композицию"""
   
    def __init__(self, legacy_payment):
        self.legacy_payment = legacy_payment
   
    def pay(self, amount, currency="CNY"):
        # Логика конвертации валют
        if currency == "CNY":
            amount_in_dollars = amount / 7.0  # Упрощённая конвертация по обменному курсу
        else:
            amount_in_dollars = amount
       
        # Вызов интерфейса старой системы
        return self.legacy_payment.process_payment(amount_in_dollars)

# Пример использования
legacy_payment = LegacyPayment()
payment = PaymentAdapter(legacy_payment)

# Использовать новый интерфейс для вызова старой системы
payment.pay(700, "CNY")  # Оплатить 700 RMB
payment.pay(100, "USD")  # Оплатить 100 USD

Вывод:

处理支付: $100.0
处理支付: $100

Примеры практического применения

Пример 1: Адаптер формата данных

Пример

import json

class XMLData:
    """Источник данных XML"""
    def get_xml_data(self):
        return """
        <users>
            <user>
<name>Чжан Сань</name>
                <age>25</age>
            </user>
            <user>
<name>Ли Сы</name>
                <age>30</age>
            </user>
        </users>
        """

class JSONProcessor:
    """Обработчик JSON (ожидает формат JSON)"""
    def process_json(self, json_data):
        data = json.loads(json_data)
        for user in data['users']:
            print(f"Имя: {user['name']}, Возраст: {user['age']}")

class XMLToJSONAdapter:
    """Адаптер XML в JSON"""
   
    def __init__(self, xml_data):
        self.xml_data = xml_data
   
    def convert_to_json(self):
        # Упрощённое преобразование XML в JSON
        xml_content = self.xml_data.get_xml_data()
        # В реальных приложениях следует использовать такие библиотеки, как xml.etree.ElementTree, для парсинга
        json_data = {
            "users": [
                {"name": "Чжан Сань", "age": 25},
                {"name": "Ли Сы", "age": 30}
            ]
        }
        return json.dumps(json_data, ensure_ascii=False)

# Используйте адаптер
xml_source = XMLData()
adapter = XMLToJSONAdapter(xml_source)
json_processor = JSONProcessor()

json_data = adapter.convert_to_json()
json_processor.process_json(json_data)

Вывод:

姓名: 张三, 年龄: 25
姓名: 李四, 年龄: 30

Случай 2: Адаптер стороннего сервиса

Пример

class WeChatPay:
    """WeChat Pay SDK"""
    def wechat_pay(self, amount, user_id):
        print(f"WeChat Pay: Пользователь {user_id} оплатил {amount} yuan")
        return {"status": "success", "transaction_id": "wx_123456"}

class AliPay:
    """Alipay SDK"""
    def alipay(self, money, user_account):
        print(f"Alipay: Аккаунт {user_account} оплатил {money} yuan")
        return {"code": 200, "trade_no": "ali_789012"}

class UnifiedPaymentAdapter:
    """Унифицированный платёжный адаптер"""
   
    def __init__(self, payment_service):
        self.payment_service = payment_service
   
    def pay(self, amount, user_info):
        # Унифицированный интерфейс оплаты
        if isinstance(self.payment_service, WeChatPay):
            return self.payment_service.wechat_pay(amount, user_info)
        elif isinstance(self.payment_service, AliPay):
            return self.payment_service.alipay(amount, user_info)
        else:
            raise ValueError("Неподдерживаемый способ оплаты")

# Клиентский код может выполнять унифицированные вызовы
def process_order(payment_adapter, amount, user_info):
    """Обработать оплату заказа"""
    result = payment_adapter.pay(amount, user_info)
    print(f"Результат оплаты: {result}")
    return result

# Пример использования
wechat_pay = WeChatPay()
ali_pay = AliPay()

wechat_adapter = UnifiedPaymentAdapter(wechat_pay)
ali_adapter = UnifiedPaymentAdapter(ali_pay)

# Унифицированный подход к вызову
process_order(wechat_adapter, 100, "user_001")
process_order(ali_adapter, 200, "user_002")

Вывод:

微信支付: 用户user_001支付100元
支付结果: {'status': 'success', 'transaction_id': 'wx_123456'}
支付宝: 账户user_002支付200元
支付结果: {'code': 200, 'trade_no': 'ali_789012'}

Лучшие практики применения паттерна «Адаптер»

1. Выберите правильный подход к реализации

Подход к реализации Применимый сценарий Преимущества Недостатки
Адаптер класса Мало адаптируемых классов и простой целевой интерфейс Простая реализация, меньше кода Требует множественного наследования, может усложнить иерархию классов
Адаптер объекта Большинство сценариев, особенно когда нужно адаптировать несколько классов Более гибкий, следует принципу композиции вместо наследования Требует создания объектов-адаптеров

2. Сохраняйте единственную ответственность адаптера

Пример

# Хорошая практика: единственная ответственность
class DataFormatAdapter:
    """Отвечает только за преобразование формата данных"""
    def convert_format(self, data):
        pass

# Плохая практика: слишком много обязанностей
class BadAdapter:
    """Обрабатывает преобразование форматов, валидацию, кэширование и т. д."""
    def convert_format(self, data):
        pass
   
    def validate_data(self, data):
        pass
   
    def cache_data(self, data):
        pass

3. Используйте абстракцию интерфейса

Пример

from abc import ABC, abstractmethod

class PaymentInterface(ABC):
    """Абстракция платежного интерфейса"""
    @abstractmethod
    def pay(self, amount, user_info):
        pass

class LoggerInterface(ABC):
    """Абстракция интерфейса логирования"""
    @abstractmethod
    def log(self, level, message):
        pass

Распространённые проблемы и решения

Проблема 1: слишком много адаптеров увеличивает сложность

Решение: используйте паттерн «Фабрика» для создания адаптеров

Пример

class AdapterFactory:
    """Фабрика адаптеров"""
   
    @staticmethod
    def create_payment_adapter(service_type):
        if service_type == "wechat":
            return UnifiedPaymentAdapter(WeChatPay())
        elif service_type == "alipay":
            return UnifiedPaymentAdapter(AliPay())
        else:
            raise ValueError(f"Неподдерживаемый тип оплаты: {service_type}")

# Используйте фабрику для создания адаптеров
wechat_adapter = AdapterFactory.create_payment_adapter("wechat")
ali_adapter = AdapterFactory.create_payment_adapter("alipay")

Задача 2: Вопросы производительности

Решение: реализовать ленивую загрузку и кэширование

Пример

class CachingAdapter:
    """Адаптер с кэшированием"""
   
    def __init__(self, adaptee):
        self.adaptee = adaptee
        self._cache = {}
   
    def process_data(self, key):
        if key not in self._cache:
            # Имитация длительной операции
            result = self.adaptee.expensive_operation(key)
            self._cache[key] = result
        return self._cache[key]

Практические упражнения

Упражнение 1: Создайте адаптер формата файлов

Реализуйте адаптер формата файлов, который преобразует данные формата CSV в формат JSON:

Пример

class CSVReader:
    """Читатель CSV-файлов"""
    def read_csv(self, filepath):
        # Имитация чтения CSV-файла
        return [
            ["имя", "возраст", "город"],
            ["Алиса", "25", "Пекин"],
            ["Боб", "30", "Шанхай"]
        ]

class JSONExporter:
    """Экспортер JSON"""
    def export_json(self, data):
        import json
        print("Экспорт данных JSON:")
        print(json.dumps(data, indent=2, ensure_ascii=False))

# Пожалуйста, реализуйте класс CSVToJSONAdapter здесь
# Ваш код...

# Тестовый код
csv_reader = CSVReader()
json_exporter = JSONExporter()

# Создайте адаптер и протестируйте
adapter = CSVToJSONAdapter(csv_reader)
json_data = adapter.convert_to_json()
json_exporter.export_json(json_data)

Упражнение 2: Дизайн-мышление

Рассмотрите следующий сценарий: как бы вы использовали паттерн «Адаптер»?

  1. Вашему приложению необходимо поддерживать несколько баз данных (MySQL, PostgreSQL, SQLite), но каждая база данных имеет свой метод подключения.
  2. Вам нужно интегрировать несколько сторонних API, но их методы аутентификации и форматы возвращаемых данных различаются.
  3. Вашей системе необходимо поддерживать несколько очередей сообщений (RabbitMQ, Kafka, Redis).

Пожалуйста, разработайте решение с использованием паттерна адаптер для одного из этих сценариев.

Итог

Паттерн адаптер — эффективный инструмент для решения проблем несовместимости интерфейсов. Из этой статьи вы должны освоить:

  • Основные понятия и сценарии применения паттерна адаптер.
  • Подходы к реализации адаптера класса и адаптера объекта.
  • Приёмы применения в реальных проектах.
  • Лучшие практики и предостережения при использовании паттерна адаптер.

Помните, что основная идея паттерна адаптер — это «преобразование», а не «изменение». Он помогает нам интегрировать новую функциональность без изменения существующего кода, и это важный паттерн проектирования для поддержки больших систем.

В реальной разработке правильное использование паттерна адаптер может сделать ваш код более гибким, сопровождаемым и легко расширяемым.

Другие расширения