Как адаптер связан с Coupling?

Как адаптер связан с Coupling

Адаптер (Adapter) — это паттерн проектирования, который снижает coupling (связанность) между компонентами. Это один из ключевых способов управления зависимостями в архитектуре приложения.

Что такое Coupling (связанность):

Coupling — это степень зависимости между компонентами. Выделяют два типа:

Tight Coupling (тесная связанность)

// Компонент A жестко зависит от компонента B
class UserComponent {
  apiService = new SpecificAPIService(); // Жесткая зависимость
  
  loadUser() {
    return this.apiService.fetchUser(); // Зависит от конкретной реализации
  }
}

// Проблемы:
// - Если изменить SpecificAPIService, нужно менять UserComponent
// - Сложно тестировать (нельзя подменить сервис в тестах)
// - Сложно переиспользовать компонент с другим сервисом

Loose Coupling (слабая связанность)

// Компонент A зависит от интерфейса, не от реализации
class UserComponent {
  constructor(apiService) {
    this.apiService = apiService; // Инъекция зависимости
  }
  
  loadUser() {
    return this.apiService.fetchUser();
  }
}

// Преимущества:
// - Легко подменить реализацию
// - Просто тестировать (можно передать mock)
// - Можно переиспользовать с разными сервисами

Как Адаптер снижает Coupling:

Преобразование интерфейсов

// Старый API сервис с несовместимым интерфейсом
class OldAPIService {
  getUsers() {
    return fetch('/api/old/users').then(r => r.json());
  }
}

// Новый интерфейс, который ожидает приложение
interface APIAdapter {
  fetchUsers(): Promise<User[]>;
}

// Адаптер преобразует старый сервис в новый интерфейс
class APIAdapter implements APIAdapter {
  constructor(private oldService: OldAPIService) {}
  
  fetchUsers(): Promise<User[]> {
    return this.oldService.getUsers().then(data => {
      return data.map(user => ({...user})); // Трансформация
    });
  }
}

// Теперь компоненты зависят от интерфейса, не от реализации
class UserList {
  constructor(private api: APIAdapter) {}
  
  loadUsers() {
    return this.api.fetchUsers();
  }
}

Практический пример в React:

Без адаптера (Tight Coupling)

// UserRepository жестко привязан к конкретной реализации
class UserRepository {
  async getUser(id) {
    const response = await fetch(`https://api.example.com/users/${id}`);
    return response.json();
  }
}

function UserProfile() {
  const repo = new UserRepository(); // Зависимость
  const [user, setUser] = useState(null);
  
  useEffect(() => {
    repo.getUser(1).then(setUser);
  }, []);
  
  return <div>{user?.name}</div>;
}

// Проблемы при тестировании:
// - Реальный запрос к API
// - Сложно изменить сервис
// - Зависит от конкретного URL

С адаптером (Loose Coupling)

// Интерфейс (контракт)
interface IUserRepository {
  getUser(id: number): Promise<User>;
}

// Конкретная реализация
class APIUserRepository implements IUserRepository {
  async getUser(id: number): Promise<User> {
    const response = await fetch(`https://api.example.com/users/${id}`);
    return response.json();
  }
}

// Адаптер для тестирования
class MockUserRepository implements IUserRepository {
  async getUser(id: number): Promise<User> {
    return { id, name: 'Test User' };
  }
}

function UserProfile({ userRepository }) { // Injection
  const [user, setUser] = useState(null);
  
  useEffect(() => {
    userRepository.getUser(1).then(setUser);
  }, [userRepository]);
  
  return <div>{user?.name}</div>;
}

// Использование в приложении
<UserProfile userRepository={new APIUserRepository()} />

// Использование в тестах
test('renders user name', () => {
  const mockRepo = new MockUserRepository();
  render(<UserProfile userRepository={mockRepo} />);
  // Тестируем без реальных запросов
});

Адаптер для трансформации данных:

Пример с несовместимыми структурами

// Старый API возвращает: { user_name, user_email }
// Новое приложение ожидает: { name, email }

class ResponseAdapter {
  transformUserResponse(oldResponse) {
    return {
      name: oldResponse.user_name,
      email: oldResponse.user_email,
      // Другие трансформации
    };
  }
}

// API сервис использует адаптер
class UserService {
  constructor(private adapter: ResponseAdapter) {}
  
  async getUser(id) {
    const response = await fetch(`/api/user/${id}`);
    const data = await response.json();
    return this.adapter.transformUserResponse(data);
  }
}

Адаптер и Dependency Injection:

// Context + Adapter = Loose Coupling
const APIContext = createContext<IUserRepository>(null);

function App() {
  const userRepository = new APIUserRepository();
  
  return (
    <APIContext.Provider value={userRepository}>
      <UserProfile />
    </APIContext.Provider>
  );
}

function UserProfile() {
  const userRepository = useContext(APIContext);
  // Компонент не знает конкретную реализацию
}

Плюсы использования Adapter для снижения Coupling:

• Гибкость — легко менять реализацию без изменения кода
• Тестируемость — подменяешь реальный сервис на mock
• Переиспользуемость — компонент работает с любой реализацией интерфейса
• Масштабируемость — добавляешь новые реализации, не меняя существующий код
• Понятность — явный контракт между компонентами

Важные моменты:

Адаптер преобразует интерфейсы, позволяя компонентам зависеть от абстракций, а не от конкретных реализаций. Это основной способ достичь Loose Coupling и применить принцип Dependency Inversion из SOLID.

В современном React это часто реализуется через Dependency Injection, Context API и кастомные хуки, которые скрывают конкретную реализацию и предоставляют интерфейс для компонентов.