Swift Academy · Aula

Por que Usar Injeção de Dependências

Separe a construção do uso para facilitar os testes.

Por que Usar Injeção de Dependências é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Por Que Usar Injeção de Dependências

Injeção de dependências (DI) significa fornecer a um objeto aquilo de que ele precisa externamente, em vez de permitir que ele mesmo crie esses recursos. Isso desacopla os componentes e facilita a realização de testes.

O Problema: Acoplamento Forte

Quando um tipo constrói seus próprios colaboradores, ele fica preso a essas classes concretas e não pode ser reconfigurado nem testado de forma isolada.

class Logger {
    func log(_ m: String) { print("LOG: \(m)") }
}
class Service {
    let logger = Logger() // hard-coded dependency
    func run() { logger.log("running") }
}
Service().run()

O Acoplamento Prejudica os Testes

Como Service sempre cria um Logger real, um teste não consegue capturar nem simular a saída do registro. A dependência fica invisível externamente.

class Logger { func log(_ m: String) { print(m) } }
class Service {
    let logger = Logger()
    func run() { logger.log("hello") }
}
// No way to swap Logger here.
Service().run()

A Ideia: Injete a Dependência

Em vez disso, passe a dependência como argumento. Quem chama decide qual implementação fornecer, então Service deixa de se preocupar com isso.

class Logger { func log(_ m: String) { print("LOG: \(m)") } }
class Service {
    let logger: Logger
    init(logger: Logger) { self.logger = logger }
    func run() { logger.log("running") }
}
Service(logger: Logger()).run()

Benefícios do Desacoplamento

Com a injeção, o mesmo Service funciona com diferentes registradores, em produção ou em testes, sem alterar seu código.

class Logger { var lines: [String] = []
    func log(_ m: String) { lines.append(m) } }
class Service {
    let logger: Logger
    init(logger: Logger) { self.logger = logger }
    func run() { logger.log("event") }
}
let l = Logger()
Service(logger: l).run()
print(l.lines)

Responsabilidade Única

A DI apoia o princípio da responsabilidade única: um tipo se concentra em sua função e delega outras preocupações aos colaboradores injetados.

struct Mailer { func send(_ to: String) { print("Mail to \(to)") } }
struct SignupFlow {
    let mailer: Mailer
    func register(_ email: String) { mailer.send(email) }
}
SignupFlow(mailer: Mailer()).register("a@b.com")

Flexibilidade

Você pode recombinar objetos de novas maneiras. A ligação acontece nas extremidades do app, mantendo o núcleo flexível.

struct Engine { let power: Int }
struct Car {
    let engine: Engine
    func describe() { print("Power: \(engine.power)") }
}
Car(engine: Engine(power: 200)).describe()
Car(engine: Engine(power: 90)).describe()

Dependências Explícitas

Um inicializador que lista suas dependências documenta exatamente do que o tipo precisa. Dependências ocultas e criadas internamente escondem esse contrato.

struct Repo { func load() -> [Int] { [1, 2, 3] } }
struct Report {
    let repo: Repo // visible dependency
    func total() -> Int { repo.load().reduce(0, +) }
}
print(Report(repo: Repo()).total())

Composição em Vez de Construção

A DI favorece a composição de objetos externamente. Uma pequena raiz de composição monta o grafo; o restante do código apenas recebe aquilo de que precisa.

struct DB { func count() -> Int { 42 } }
struct Stats { let db: DB; func show() { print(db.count()) } }
// Composition root:
let app = Stats(db: DB())
app.show()

Não Apenas para Apps Grandes

Até programas pequenos se beneficiam: injetar uma dependência permite trocar o comportamento e deixa as intenções claras, sem frameworks adicionais.

struct Clock { func now() -> Int { 12 } }
struct Greeter {
    let clock: Clock
    func greet() { print(clock.now() < 12 ? "Morning" : "Afternoon") }
}
Greeter(clock: Clock()).greet()

Nenhum Framework é Necessário

A DI em Swift não precisa de biblioteca. Inicializadores simples e protocolos são suficientes. As próximas lições mostram a injeção pelo construtor, protocolos e simulações.

struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
    let adder: Adder
    func run() { print(adder.add(2, 3)) }
}
Calc(adder: Adder()).run()

Verificação Rápida

Qual é a ideia central da injeção de dependências?

Recapitulação

Injeção de dependências fornece colaboradores externamente, em vez de construí-los internamente, reduzindo o acoplamento, esclarecendo as dependências e possibilitando testes. No Swift, não é necessário usar um framework. A seguir, você verá a forma mais comum: a injeção pelo construtor.

Perguntas Frequentes

A aula “Por que Usar Injeção de Dependências” é grátis?

Sim — o texto completo de “Por que Usar Injeção de Dependências” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Por que Usar Injeção de Dependências”?

Separe a construção do uso para facilitar os testes. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Por que Usar Injeção de Dependências”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy