WP24Horas
PARCEIRO RECOMENDADO Vai colocar um WordPress no ar? Comece com uma hospedagem que acompanha o seu projeto. Conhecer a HostGator link patrocinado

Desenvolvimento e Programação

Injeção de Dependência Manual em Plugins WordPress – WordPress Extremo Dia 4

Por Asllan Maciel3 min de leitura
Injeção de Dependência Manual em Plugins WordPress
Esta entrada é parte 4 de 15 na série WordPress Extremo: Arquitetura e Engenharia de Plugins

WordPress Extremo: Arquitetura e Engenharia de Plugins

Como Criar um Plugin Profissional com Composer e PSR-4

Como Criar um Plugin WordPress com Composer e PSR-4 – WordPress Extremo Dia 1

Como Usar Serviços em Plugins para Código Limpo e Desacoplado - WordPress Extremo Dia 2

Como Usar Serviços em Plugins para Código Limpo e Desacoplado – WordPress Extremo Dia 2

Como Usar Repositórios em Plugins para Separar Lógica de Dados

Como Usar Repositórios em Plugins para Separar Lógica de Dados – WordPress Extremo Dia 3

Injeção de Dependência Manual em Plugins WordPress

Injeção de Dependência Manual em Plugins WordPress – WordPress Extremo Dia 4

Criando Hooks Personalizados com do_action e apply_filters

Hooks Avançados no WordPress: apply_filters, do_action e boas práticas

Como Criar Comandos WP-CLI Personalizados para Plugins

Criando Comandos WP-CLI Personalizados para Plugins WordPress

Como Implementar um Sistema de Logs Profissional em Plugins WordPress

Como Gerenciar Logs e Erros Internos em Plugins WordPress (Do Jeito Certo)

Como Tratar Erros e Exceptions em Plugins WordPress do Jeito Certo

Tratamento de Erros e Uso Inteligente de Exceptions em Plugins WordPress

Segurança Profunda em Plugins WordPress

Segurança Profunda em Plugins WordPress

Como Internacionalizar seu Plugin WordPress (i18n e l10n) do Jeito Certo

Internacionalização e Localização (i18n e l10n)

Criando Settings Pages Profissionais no WordPress

Criando Settings Pages Profissionais no WordPress

Como Criar Permissões Customizadas e Controle de Acesso em Plugins WordPress

Permissões Customizadas e Controle de Acesso em Plugins WordPress

Separação Clara de Camadas - Core, Domain e Infra

Separação Clara de Camadas: Core, Domain e Infra

Atualizações Automáticas de Plugin WordPress via GitHub

Atualizações Automáticas via GitHub.

Checklist Final de Publicação - WordPress.org e Produção

Checklist Final de Publicação: WordPress.org e Produção

E aí, dev! Hoje no Dia 4 da série WordPress Extremo, vou te mostrar um conceito que parece chato, mas que muda completamente o jogo quando você entende:

Injeção de Dependência – ou, como eu gosto de chamar:
“Fazendo seu código parar de criar coisas sozinho e deixar isso pra um gerente que organiza tudo.”

Vamos conversar sobre isso de forma simples, prática e sem frescura.


🤔 O que é Injeção de Dependência (DI)?

Quando um objeto precisa de outro pra funcionar, ele tem duas opções:

  1. Ele mesmo criar (new OutraClasse())
  2. Ou receber pronto de fora

A opção 1 é mais comum… mas acopla tudo e dificulta testes, manutenção e reuso.

A opção 2 — receber a dependência injetada — permite que você:

✅ Teste mais facilmente
✅ Troque implementações sem mexer no código que usa
✅ Centralize e gerencie seus objetos com clareza


🛠️ Exemplo real no plugin

Hoje vamos ajustar nosso HelloService para receber o UserRepository via construtor, em vez de instanciar direto com new.


🔧 Estrutura atual:

HelloService.php

namespace WpArquiteturaExtrema\Services;

use WpArquiteturaExtrema\Repositories\UserRepository;

class HelloService {
    public function execute() {
        $repo = new UserRepository();
        $editors = $repo->getEditors();

        foreach ($editors as $user) {
            error_log("Editor encontrado: " . $user->display_name);
        }
    }
}

Obs: Não preciso dizer que para o código acima funcionar, você precisa de usuários registrados como Editor, certo?


✅ Estrutura com DI (injeção manual)

HelloService.php

use WpArquiteturaExtrema\Repositories\UserRepository;

class HelloService {
    protected $repo;

    public function __construct(UserRepository $repo) {
        $this->repo = $repo;
    }

    public function execute() {
        $editors = $this->repo->getEditors();
        // ...
    }
}

Obs: repara que agora usamos o $this para puxar.

Init.php

use WpArquiteturaExtrema\Services\HelloService;
use WpArquiteturaExtrema\Repositories\UserRepository;

class Init {
    public function register() {
        add_action('init', [$this, 'init_plugin']);
    }

    public function init_plugin() {
        $repo = new UserRepository();
        $service = new HelloService($repo);
        $service->execute();
    }
}

Obs: Repare que aqui instanciamos UserRepository com $repo e passamos pra HelloService($repo).


💡 Benefícios dessa abordagem

  • Testes: você pode injetar um “FakeRepository” se quiser simular dados
  • Flexibilidade: você troca o repositório facilmente (ex: por um que consulta uma API)
  • Organização: seu código não decide suas dependências — ele só executa

⚙️ Próximos passos

  • Em breve, podemos automatizar isso com um container de injeção de dependências
  • E até usar uma biblioteca como league/container para projetos maiores

Mas por enquanto, a injeção manual já resolve 90% dos problemas de acoplamento.


🎯 Recado final

Se você chegou até aqui, parabéns!
Você já está trabalhando com um nível que a maioria dos devs WordPress nunca nem viu. E isso te destaca demais.


💬 Curtiu? Quer mais?

Se quiser se aprofundar nisso:

  • 👉 Temos mentorias e cursos
  • 👉 Segue lá no IG: @wp24horas

Ou comenta aqui sua dificuldade que eu te ajudo a implementar! 🚀

WordPress Extremo: Arquitetura e Engenharia de Plugins

Como Usar Repositórios em Plugins para Separar Lógica de Dados – WordPress Extremo Dia 3 Hooks Avançados no WordPress: apply_filters, do_action e boas práticas

Sobre o autor

Asllan Maciel

Asllan Maciel, Fundador do WP24Horas, Consultor de Marketing Digital e amante do Empreendedorismo Digital. Tem um caso de amor com o WordPress.