✴️HttpClientInterface

Documentação: Por que usar o HttpClientInterface no Flutter?

O uso de uma interface para o cliente HTTP no Flutter é uma prática alinhada com princípios de arquitetura limpa e boas práticas de desenvolvimento. Abaixo explicamos os motivos e as vantagens dessa abordagem.

O que é o HttpClientInterface?

O HttpClientInterface é uma abstração que define como a camada de comunicação com APIs deve funcionar, sem se comprometer com uma implementação específica.

Exemplo:

abstract class HttpClientInterface {
  Future<Response> get(
    String url, {
    Map<String, dynamic>? headers,
  });

  Future<Response> post(
    String url, {
    Map<String, dynamic>? headers,
    dynamic body,
  });

  Future<Response> put(
    String url, {
    Map<String, dynamic>? headers,
    dynamic body,
  });

  Future<Response> delete(
    String url, {
    Map<String, dynamic>? headers,
  });
}

Por que Criar uma Interface HTTP?

1. Desacoplamento

• A interface desacopla o restante da aplicação de uma implementação específica (como o Dio).

• Caso você decida substituir o cliente HTTP no futuro (por exemplo, para http ou outro), só será necessário implementar essa interface para o novo cliente, sem afetar o restante do sistema.

Exemplo: Hoje você usa o Dio:

class DioClient implements HttpClientInterface {
  final Dio dio;

  DioClient(this.dio);

  @override
  Future<Response> get(String url, {Map<String, dynamic>? headers}) {
    return dio.get(url, options: Options(headers: headers));
  }
}

Amanhã você pode trocar para XPTOClient:

class XPTOClientAdapter implements HttpClientInterface {
  final XPTOClient client;

  XPTOClientAdapter(this.client);

  @override
  Future<Response> get(String url, {Map<String, dynamic>? headers}) {
    return client.get(url, headers: headers);
  }
}

2. Testabilidade

• Nos testes, você pode fornecer uma implementação fake ou mock da interface, simulando diferentes respostas da API sem depender do comportamento real do cliente HTTP.

Exemplo de Mock para Testes:

class MockHttpClient implements HttpClientInterface {
  @override
  Future<Response> get(String url, {Map<String, dynamic>? headers}) async {
    return Response(
      requestOptions: RequestOptions(path: url),
      data: {'mockKey': 'mockValue'},
      statusCode: 200,
    );
  }

  @override
  Future<Response> post(String url, {Map<String, dynamic>? headers, dynamic body}) async {
    throw UnimplementedError();
  }
}

Nos testes, você injetaria o MockHttpClient no lugar do cliente real.

---

3. Alinhamento com Arquitetura Limpa

• As camadas superiores (datasources, repositories) dependem apenas de abstrações, não de implementações concretas.

• Isso segue o princípio da Inversão de Dependência do SOLID.

---

4. Centralização da Comunicação

• O HttpClientInterface centraliza as operações de comunicação (GET, POST, PUT, DELETE) em um único ponto, facilitando manutenção e ajustes.

• Por exemplo, se precisar adicionar cabeçalhos padrão em todas as requisições, basta configurar isso na implementação do cliente.

Exemplo:

class DioClient implements HttpClientInterface {
  final Dio dio;

  DioClient(this.dio);

  @override
  Future<Response> get(String url, {Map<String, dynamic>? headers}) {
    return dio.get(
      url,
      options: Options(headers: {
        ...?headers,
        'Authorization': 'Bearer token_padrao',
      }),
    );
  }
}

5. Flexibilidade para Extensões

• Adicionar novas funcionalidades, como log de requisições, retries, ou integração com ferramentas como o Sentry, pode ser feito diretamente na implementação do cliente HTTP sem alterar o restante do sistema.

Exemplo de Retry:

class DioClientWithRetry implements HttpClientInterface {
  final Dio dio;

  DioClientWithRetry(this.dio);

  @override
  Future<Response> get(String url, {Map<String, dynamic>? headers}) async {
    try {
      return await dio.get(url, options: Options(headers: headers));
    } catch (e) {
      // Lógica de retry aqui
      return await dio.get(url, options: Options(headers: headers));
    }
  }
}

Vantagens Resumidas

1. Manutenibilidade:

   • Mudanças no cliente HTTP não impactam o restante do sistema.

2. Testabilidade:

   • Permite criar mocks e fakes para simular respostas durante testes.

3. Flexibilidade:

   • Fácil substituição ou extensão do cliente HTTP.

4. Centralização:

   • Lógica de comunicação padronizada e configurada em um único lugar.

5. Conformidade com Arquitetura Limpa:

   • Segue princípios como o desacoplamento e a inversão de dependência.

---

Como Usar o HttpClientInterface no Projeto

1. Definir a Interface

Certifique-se de que a interface (HttpClientInterface) cobre todos os métodos necessários para sua aplicação.

2. Criar a Implementação

Implemente a interface utilizando a biblioteca HTTP escolhida (por exemplo, Dio).

3. Registrar no Container de Injeção

Registre a implementação no container de injeção para que seja facilmente resolvida pelas camadas superiores.

Exemplo de Registro no Injectable:

@module
abstract class RegisterModule {
  @singleton
  HttpClientInterface get httpClient => DioClient(dio: Dio());
}

4. Injetar e Usar nas Camadas Superiores

Use a interface nas camadas que dependem de comunicação HTTP (datasources, repositórios, etc.).

---

Com isso, o uso do HttpClientInterface traz organização, flexibilidade, e facilita tanto o desenvolvimento quanto a manutenção do seu projeto! 🚀