framework

Autowiring em Container de Injeção de Dependência

No artigo Entendendo Injeção de Dependência vimos sobre o que é injeção de dependência, seu funcionamento e como se dá a sua aplicação. No artigo Container De Injeção De Dependência (DI Container) vimos como funciona um container para gerenciar o mapa de dependências.

Nesse artigo veremos uma funcionalidade relativamente comum nos containers de dependência de frameworks que é a habilidade de resolver as dependências de um construtor (principalmente) automaticamente, chamada de autowiring.

No artigo Container De Injeção De Dependência (DI Container) implementamos um protótipo (simples, porém funcional) de um container e, em determinado momento, chegamos nesse tipo de caso de uso:

$indexController = new IndexController(
    $container->get('user.repository')
);

$userController = new UserController(
    $container->get('user.repository')
);

$registerController = new RegisterController(
    $container->get('user.repository')
);

Alguns controladores precisavam receber a instância de UserRepository e tivemos que manualmente passá-la para cada um deles. Agora, imagine se cada um desses controladores tivesse que receber outras dependências? Nenhum problema, só que ficaria meio chato e improdutivo ter que ficar repetindo essas construções na instanciação deles, concorda?

E se desenvolvermos uma forma do nosso container automaticamente resolver essas dependências? Desse modo, tudo o que faríamos seria pedir para o Container uma instância desses controladores, sem a necessidade de nos preocuparmos em passar manualmente para o construtor de cada um deles as suas dependências. Teríamos como resultado um código assim:

$indexController = $container->get(IndexController::class);

$userController = $container->get(UserController::class);

$registerController = $container->get(RegisterController::class);

Estamos pedindo as instâncias desses controladores sem nos preocuparmos em alimentá-los de suas dependências, deixamos esse trabalho para o Container.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Estrutura inicial do projeto

Vamos criar o protótipo de uma aplicação para que possamos testar a nossa implementação de Container. A nossa aplicação terá essa estrutura:

- [blog-artigo-di]
- - - [app]
- - - - [Http]
- - - - - - [Controller]
- - - - - - - UserController.php
- - - - [Repositories]
- - - - - LeadRepository.php
- - - - - TagRepository.php
- - - - - UserRepository.php
- - - Container.php
- index.php

O repositório dessa estrutura no GitHub você encontra clicando aqui. Se desejar, você pode fazer download direto dela clicando nesse link: sem-autowiring.zip

Depois de baixar e colocar no local onde normalmente você executa seus projetos, basta que você execute composer install pois o projeto faz uso da PSR-4 para autoloading:

$ ~/D/w/blog-artigo-di> composer install

O nosso Container atualmente possui uma implementação simples e que ainda não suporta a resolução automática de dependências. Abra app/Container.php:

<?php
declare(strict_types=1);

namespace App;

use Closure;

final class Container
{
    private $instances = [];

    public function set(string $id, Closure $closure) : void
    {
        $this->instances[$id] = $closure;
    }

    public function get(string $id) : object
    {
        return $this->instances[$id]($this);
    }

    public function singleton(string $id, Closure $closure) : void
    {
        $this->instances[$id] = function () use ($closure) {
            static $resolvedInstance;

            if (null !== $resolvedInstance) {
                $resolvedInstance = $closure($this);
            }

            return $resolvedInstance;
        };
    }
}

Esse container já foi explicado na indicação de leitura no início desse artigo. Portanto, não vamos entrar novamente em seus pormenores.

O arquivo index.php na raiz do projeto é o responsável pelo bootstrap da nossa aplicação protótipo:

<?php

// Carrega o autoload do Composer
require './vendor/autoload.php';

use App\Repositories\TagRepository;
use App\Repositories\LeadRepository;
use App\Repositories\UserRepository;
use App\Http\Controller\UserController;

// Instancia o container
$container = new App\Container();

// Adiciona referências ao container
$container->set(TagRepository::class, function() {
    return new TagRepository();
});

$container->set(LeadRepository::class, function() {
    return new LeadRepository();
});

$container->set(UserRepository::class, function() {
    return new UserRepository();
});

// Instancia o UserController passando para ele as dependências necessárias
$userController = new UserController(
    $container->get(TagRepository::class),
    $container->get(UserRepository::class),
    $container->get(LeadRepository::class)
);

$userController->index();

Para testar o exemplo, na raiz do projeto execute:

$ ~/D/w/blog-artigo-di> php -S localhost:8000

Isso executará o servidor embutido do PHP em cima da raiz do nosso projeto, permitindo que o acessemos pelo navegador através da URL: http://localhost:8000/

O resultado será:

/Users/kennedytedesco/Documents/www/blog-artigo-di/app/Http/Controller/UserController.php:31:
array (size=2)
  'id' => int 1
  'name' => string 'tag' (length=3)

/Users/kennedytedesco/Documents/www/blog-artigo-di/app/Http/Controller/UserController.php:31:
array (size=2)
  'id' => int 2
  'name' => string 'user' (length=4)

/Users/kennedytedesco/Documents/www/blog-artigo-di/app/Http/Controller/UserController.php:31:
array (size=2)
  'id' => int 3
  'name' => string 'lead' (length=4)

Indica que o método index() do UserController foi executado com sucesso. Ou seja, as dependências, os repositórios necessários para o funcionamento dessa classe foram injetados com sucesso. Até aqui tudo bem, ademais, injetamos tais dependências manualmente:

$userController = new UserController(
    $container->get(TagRepository::class),
    $container->get(UserRepository::class),
    $container->get(LeadRepository::class)
);

Implementando a resolução automática de dependências

Para que possamos implementar a resolução automática das dependências utilizaremos a API de reflexão do PHP. Essa API nos fornece meios para que façamos engenharia reversa nas classes, extraindo muitas de suas informações internas como quantos métodos possui, quais são públicos, protegidos ou privados, se implementa um construtor, quais são os parâmetros do construtor, se são opcionais ou exigidos, entre outras informações.

Dessa forma, se o usuário pedir para o Container a instanciação do UserController:

$userController = $container->get(UserController::class);

Que tal a gente usar reflexão para obter quais dependências (classes) ele necessita para ser instanciado e então resolver essas dependências automaticamente usando o próprio Container e retornar a instância dele?

É exatamente isso que a nossa implementação de autowiring fará. Para tanto, começaremos alterando o código do nosso container app\Container.php para:

<?php
declare(strict_types=1);

namespace App;

use Closure;
use ReflectionClass;
use ReflectionParameter;

final class Container
{
    private $instances = [];

    public function set(string $id, Closure $closure) : void
    {
        $this->instances[$id] = $closure;
    }

    public function get(string $id) : object
    {
        // Se essa referência existe no mapa do container, então a retorna diretamente.
        if ($this->has($id)) {
            return $this->instances[$id]($this);
        }

        // Se a referência não existe no container, então foi passado uma classe para ser instanciada
        // Façamos então a reflexão dela para obter os parâmetros do método construtor
        $reflector = new ReflectionClass($id);
        $constructor = $reflector->getConstructor();

        // Se a classe não implementa um método construtor, então vamos apenas retornar uma instância dela.
        if (null === $constructor) {
            return new $id();
        }

        // Itera sobre os parâmetros do construtor para realizar a resolução das dependências que ele exige.
        // O método "newInstanceArgs()" cria uma nova instância da classe usando os novos argumentos passados.
        // Usamos "array_map()" para iterar os parâmetros atuais, resolvê-los junto ao container e retornar um array das instâncias já resolvidas pelo container.
        return $reflector->newInstanceArgs(array_map(
            function (ReflectionParameter $dependency) {
                // Busca no container a referência da classe desse parâmetro
                return $this->get(
                    $dependency->getClass()->getName()
                );
            },
            $constructor->getParameters()
        ));
    }

    public function singleton(string $id, Closure $closure) : void
    {
        $this->instances[$id] = function () use ($closure) {
            static $resolvedInstance;

            if (null !== $resolvedInstance) {
                $resolvedInstance = $closure($this);
            }

            return $resolvedInstance;
        };
    }

    public function has(string $id) : bool
    {
        return isset($this->instances[$id]);
    }
}

(Através do GitHub você pode visualizar o que foi adicionado/removido. Basta visualizar esse commit aqui).

A partir do momento que o nosso Container consegue resolver as dependências automaticamente, podemos alterar no index.php a forma de instanciar, que era uma instanciação direta da classe usando new UserController:

$userController = new UserController(
    $container->get(TagRepository::class),
    $container->get(UserRepository::class),
    $container->get(LeadRepository::class)
);

Para uma instanciação que usa o Container (para que ele possa resolver as dependências para nós):

$userController = $container->get(UserController::class);
$userController->index();

(O código completo do exemplo com autowiring encontra-se no branch master do repositório desse exemplo).

Você pode testar o exemplo e terá o mesmo resultado obtido anteriormente quando não usávamos autowiring. O UserController continuará sendo instanciado com sucesso.

Laravel - Framework PHP (Parte 3/3)
Curso de Laravel - Framework PHP (Parte 3/3)
CONHEÇA O CURSO

Concluindo

Vimos nesse artigo a fundação sobre como a resolução automática de dependências é feita nos containers de injeção de dependência. É por esse caminho que Symfony, Laravel entre outros frameworks (inclusive de outras linguagens) fazem. Obviamente o nosso Container é simples, didático e bem direto ao ponto, não estando 100% pronto para uso em projetos reais. Algumas verificações de segurança (se a classe existe, senão lançar uma exceção etc) precisariam ser implementadas. Na realidade, existem boas implementações de containers por aí e, se você usa um Web Framework, não vai precisar criar a sua própria. No entanto, saber como funciona, é essencial. Essa foi a intenção desse artigo.

Até a próxima!

Os principais Frameworks PHP

De maneira mais simples e objetiva, um Framework é um conjunto de funcionalidades que auxiliam o desenvolvedor a criar aplicações de forma mais rápida.

Caso você ainda não saiba para que serve um framework, aqui no blog possuímos um artigo bem legal que, sem dúvidas, irá te auxiliar no entendimento.

Desta forma, neste artigo falaremos brevemente sobre os principais Frameworks PHP.

Desenvolvedor Laravel Full-Stack
Formação: Desenvolvedor Laravel Full-Stack
Nesta formação você aprenderá desenvolver aplicações PHP usando o framework Laravel com maestria. Ao final desta formação, você terá condições de trabalhar em grandes aplicações web ou APIs integradas com diversos serviços, tudo isso utilizando as melhores práticas do mercado.
CONHEÇA A FORMAÇÃO

Laravel

Framework open source, o Laravel é, sem dúvidas, um dos mais utilizados atualmente. Desenvolvido por Taylor B. Otwell sobre a licença MIT, o Laravel possui seu código hospedado no GitHub e é um framework para os apreciadores de um código bonito, como diz seu slogan: “The PHP Framework For Web Artisans”.

Por possuir uma sintaxe simples e clara, permite que o desenvolvedor trabalhe de maneira mais rápida e extremamente estruturada. Possui uma imensa comunidade ativa, o que o torna ainda mais aceito no mercado.

Utiliza o padrão arquitetural MVC, que divide a aplicação em três camadas distintas, sendo elas o Model, View e Controller, onde:

  • Model: determina as entidades do projeto, ou seja, quais tabelas serão mapeadas;

  • View: camada responsável por exibir informações ao usuário, normalmente páginas HTML;

  • Controller: camada que faz o “meio de campo” entre a view e o model, ou seja, obtém a requisição que o usuário realiza, busca os dados através do model e retorna à view.

Em seu site (https://laravel.com/) é possível encontrar toda sua documentação, novidades do framework (Podcats, blog, tutoriais..), parceiros e muito mais.

CodeIgniter 3 - Framework PHP
Curso de CodeIgniter 3 - Framework PHP
CONHEÇA O CURSO

CodeIgniter

Com sua primeira versão pública lançada em 2006, o CodeIgniter é um excelente framework para desenvolvimento de aplicações PHP que exijam mais rapidez em seu desenvolvimento.

Assim como dito em seu site, fornece um conjunto de ferramentas simples e elegantes para criar aplicativos web com recursos completos. De código open source e extremamente leve e rápido, é um framework ideal para desenvolvedores iniciantes, por possuir a simplicidade atrelada ao desenvolvimento.

Em seu site (https://codeigniter.com/) é possível encontrar toda documentação necessária para sua utilização, além de links para canais de comunicação entre a comunidade.

Symfony - Fundamentos
Curso de Symfony - Fundamentos
CONHEÇA O CURSO

Symfony

Framework Open source, o Symfony é ideal para construção de aplicações mais robustas por oferecer ao desenvolvedor total controle de suas configurações. Lançado em 2005, é um framework criado sobre o conceito de aprendizagem rápida sobre os componentes do Symfony.

Utiliza também paradigma MVC e uma comunidade ativa em mais de 120 países (Como informado em seu site).

Em seu site (https://symfony.com/), você poderá encontrar mais informações sobre sua documentação, comunidade, realizar seu download e ficar por dentro de todas as novidades acerca deste framework.

Zend Expressive - Microframework PHP
Curso de Zend Expressive - Microframework PHP
CONHEÇA O CURSO

Zend

Lançado em 2005, o Zend é um Framework orientado a objetos de código aberto que permite que o desenvolvedor faça a reutilização de seus componentes. De fácil escrita, implementar códigos mais complexos com o Zend torna-se algo mais acessível.

Possui uma comunidade extremamente ativa e certificação oficial aceita no mercado que, por sinal, é um grande diferencial por ser um framework utilizado por grandes empresas.

Em seu site (http://www.zend.com/) é possível realizar o download do framework, além de encontrar toda sua documentação e tudo sobre sua certificação.

CakePHP

O CakePHP é um framework que possibilita a criação de aplicações robustas por programadores de todos os níveis, sem perder sua flexibilidade. É um framework sobre a licença MIT perfeito para aplicações de uso comercial.

Assim como informado em seu site, oferece uma camada flexível de acesso ao banco de dados e torna a construção de sistemas pequenos e complexos muito mais simples.

Em seu site (https://cakephp.org/), além de se “deliciar” com uma página extremamente fofíssima, para os amantes de bolinhos <3, é possível realizar o download da ferramenta, encontrar sua documentação, sua comunidade e uma loja online de produtos do Framework, com camisetas e lindíssimos elefantinhos (os CakePHP ElePHPant).

Concluindo:

O uso de Frameworks, sem dúvidas, caiu no gosto popular de diversos desenvolvedores, pois permite a criação de aplicações mais profissionais em um tempo muito menor de desenvolvimento, quando comparado ao uso da linguagem “pura”, ou seja, sem framework algum.

E você? Utiliza algum Framework? Conte pra gente sua experiência e até o próximo artigo! =)

Para que serve um framework?

A utilização de frameworks já está inclusa no dia a dia de muitos desenvolvedores. O principal benefício que faz muitos desenvolvedores utilizarem frameworks é o poder de reutilização de estruturas de código, poupando horas de desenvolvimento e fazendo com que os desenvolvedores possam focar no que é de fato importante e que agrega valor ao negócio com relação ao software que está sendo desenvolvido.

Laravel - Framework PHP (Parte 1/3)
Curso de Laravel - Framework PHP (Parte 1/3)
CONHEÇA O CURSO

O que vem a ser um framework?

Um framework é uma estrutura-base que contém um conjunto de funções e componentes pré-definidos, funções e componentes estes que se relacionam para disponibilizar funcionalidades específicas ao desenvolvimento de software. Estas funções e componentes genéricos pré-prontos agilizam o processo, poupam tempo e evitam retrabalho para o desenvolvedor.

Os frameworks podem ser criados ou pela própria comunidade ou por empresas mantenedoras de uma linguagem ou ambiente de desenvolvimento, como a Microsoft e a Oracle.

Por que utilizar um framework?

O foco principal de um framework é a reusabilidade. Você pode utilizar um framework para desenvolver várias aplicações, reaproveitando estas estruturas pré-disponibilizadas para lidar com tarefas repetitivas ou que são comuns em vários tipos de sistemas (como, por exemplo, a funcionalidade de autenticação). Nesse exemplo, você não precisa dedicar tempo para desenvolver a funcionalidade de login, já que existem frameworks já testados para essa finalidade. Além disso, se necessário, você pode personalizar estes componentes pré-disponibilizados de acordo com as demandas do projeto em questão.

Um exemplo: a Microsoft tem o .NET Framework, que disponibiliza componentes pré-configurados para rodar aplicativos em diferentes plataformas. Se você vai criar uma aplicação web, por exemplo, você não precisa desenvolver toda a estrutura necessária para lidar com requisições HTTP (que é uma tarefa repetitiva): basta você criar uma classe que estenda a clases Controller e… Pronto! Você já tem automaticamente uma classe que consegue lidar com requisições HTTP.

Bootstrap 4 - Básico
Curso de Bootstrap 4 - Básico
CONHEÇA O CURSO

Existem diversos frameworks para as mais diferentes linguagens e plataformas, seja desktop, web ou mobile, tanto com relação ao front-end quanto ao back-end. Devemos escolher os frameworks corretos para cada tipo da aplicação, para que ele realmente ajude no objetivo final.

Ao final, podemos concluir que um framework é um facilitador para o desenvolvedor chegar no resultado final que ele deseja – que é o desenvolvimento de uma aplicação, poupando tempo e esforço de desenvolvimento.