# Injectable

## **Documentação: Uso do Injectable no Flutter**

O **Injectable** é uma biblioteca que facilita a configuração de **injeção de dependências** no Flutter, trabalhando junto com o **GetIt** para gerenciar instâncias e abstrair implementações de forma modular e reutilizável.

***

### **Arquivo de Configuração**

No projeto, o arquivo de configuração do **Injectable** é responsável por definir as dependências que serão registradas no container de injeção.

#### Exemplo de Arquivo de Configuração

```
final getIt = GetIt.instance;

@module
abstract class RegisterModule {
  // Registra DioConfig como Singleton
  @singleton
  DioConfig get dioConfig => DioConfig();

  // Registra Dio usando DioConfig
  @singleton
  Dio get dio => DioConfig().dio;

  // Registra o HttpClientInterface com a implementação baseada no Dio
  @singleton
  HttpClientInterface get httpClient => DioClientImpl(dio: dio);
}

// Inicializa o Injectable
@InjectableInit(
  initializerName: 'init', // Nome do método gerado
  preferRelativeImports: true, // Usa importações relativas
  asExtension: true, // Permite chamar como extensão
)
void configureDependencies() => getIt.init();

```

#### Explicação do Arquivo

1. **`@module`**:
   * Define uma classe abstrata usada para registrar dependências.
2. **Anotações como `@singleton`**:
   * Determinam o ciclo de vida da instância:
     * `@singleton`: Cria uma única instância compartilhada.
     * `@lazySingleton`: Cria uma instância única sob demanda.
     * `@factory`: Cria uma nova instância sempre que solicitada.
3. **`configureDependencies`**:
   * Método usado para inicializar as dependências no início da aplicação.

***

### **Como Usar as Tags nas Classes**

#### **Registrando Classes com Anotações**

Para que o **Injectable** saiba como gerenciar suas classes, adicione as anotações apropriadas diretamente nas implementações.

**Exemplo de Classe `DioClientImpl`**

```
import 'package:injectable/injectable.dart';

@singleton
class DioClientImpl implements HttpClientInterface {
  final Dio dio;

  DioClientImpl({required this.dio});
}

```

Exemplo de Usecase

```
import 'package:injectable/injectable.dart';

@lazySingleton
class ExampleUsecase {
  final ExampleRepository repository;

  ExampleUsecase({required this.repository});
}

```

### **Passos para Usar no Projeto**

1. **Configurar Dependências**:

   * No início do aplicativo (por exemplo, no `main.dart`), chame o método de inicialização:

   ```dart
   void main() {
     configureDependencies(); // Configura as dependências
     runApp(MyApp());
   }
   ```
2. **Resolver Instâncias**:

   * Use o `getIt` para acessar as dependências registradas:

   ```dart
   final httpClient = getIt<HttpClientInterface>();
   ```

***

### **Vantagens do Injectable**

1. **Automatização**:
   * O `build_runner` gera o código necessário para registrar as dependências.
2. **Desacoplamento**:
   * As classes dependem apenas de abstrações, facilitando substituições e testes.
3. **Flexibilidade**:
   * Suporte para diferentes ciclos de vida (`@singleton`, `@factory`, etc.).
