Introdução ao Laravel Framework – Parte 05: Controladores

Saudações, devs! ✌😎

No post anterior falamos sobre rotas. Agora vamos falar sobre controladores.

Sim, é extremamente importante que você compreenda o conceito de rotas para entender o papel dos controladores no Laravel Framework. Visite o post anterior.

Bora! 🚀

O que é um controlador?

Como visto no post anterior, as rotas são usadas para definir o fluxo a da aplicação, ou seja, qual será o caminho que a requisição irá percorrer uma vez que ela chega ao servidor.

Nesse sentido, verificações de regras de negócio, validações e outros tratamentos complexos devem ser realizados por outro componente do sistema: o controlador.

No Laravel Framework os controladores são criados mediante comandos no Artisan e ficam na pasta app/Http/Controllers.

Criando controladores

Para criar um controlador, é necessário acessar o terminal (dentro da pasta do projeto) e digitar o seguinte comando, substituindo <ControllerName> pelo nome do controlador:

php artisan make:controller <ControllerName>

Assim, para criar um controlador de produtos, seguindo a recomendação de usar o sufixo Controller no nome, digitamos o seguinte comando:

php artisan make:controller ProductController

Após digitar <Enter>, será exibida a mensagem Controller created successfully. Isso significa que o controller foi criado e está na pasta app/Http/Controllers.

Exemplo de Controlador

No código a seguir, o controlador criado anteriormente possui:

• Um atributo privado products que é um array de produtos;
• Um método index() que retorna ao browser os produtos do referido atributo.

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class ProductController extends Controller
{
    //..array of products
    private $products = ['TV', 'Smartphone', 'Tablet'];

    //..method to show the products
    public function index(){
        echo "<h1>Produtos</h1>";
        foreach($this->products as $p){
            echo "<p>{$p}</p>";
        }
    }
}

Direcionando uma rota a um controlador

Uma vez que o controlador é criado, é necessário definir uma rota para chegar até ele. Isso significa que cada rota deve “apontar” para um controlador e um método. As rotas são definidas no arquivo routes/web.php.

No código a seguir, temos o exemplo de uma rota definida no arquivo routes/web.php, considerando as versões 8.x e 7.x do Laravel Framework.

//..Laravel 7.X
Route::get('/product', "ProductCtr@index");

//..Laravel 8.X
Route::get('/product’, [ProductCtr::class, 'index']);

O método Route::get recebe as requisições via método get e recebe dois parâmetros (ou argumentos):

• A rota;
• O controlador e o método específico

Na versão 8.x, o segundo parâmetro é um array, contendo a classe do controlador e o nome do método.

Informando parâmetros aos controladores

No exemplo anterior, o método index do controlador ProductController é acessado via rota /products. Note que não informamos parâmetro algun, logo, a chamada desse método foi bem simples.

Entretanto, as requisições normalmente precisam passar parâmetros para os controladores e seus métodos.

No exemplo a seguir, vamos adicionar um método chamado addProduct($product) que recebe um produto como parâmetro para ser inserido na lista de produtos.

Abra o controlador ProductController e adicione o seguinte código:

public function addProduct($product){
    $this->products[] = $product; //..adding a product
    $this->index(); //..executing the index
}

Depois que o método for criado, vamos até o arquivo de rotas (routes/web.php) para adicionar a rota que adiciona o produto. Note que consideramos as versões 7.x e 8.x do Laravel Framework.

//..Laravel 7.x
Route::get('/product/add/{produto}', "ProductCtr@addProduct");

//..Laravel 8.x
Route::get('/product/add/{produto}’, [ProductCtr::class, 'addProduct']);

Note que o parâmetro é informado apenas na rota, e não o segundo parâmetro, onde temos o controlador e o método.

Controladores para CRUD

Normalmente um controlador deve tratar requisições básicas de operações CRUD (Create-Read-Update-Delete).

Assim, vamos criar um novo controlador com todos os métodos padronizados para o CRUD. No terminal, digite o comando:

php artisan make:controller ClientController --resource

Note o parâmetro –resource. É ele quem cria um controlador com os seguintes métodos já padronizados:

• index(): página inicial do recurso;
• create(): abre o formulário  para a criação de um novo recurso;
• store(Request $request): armazena uma nova instância do recurso no banco de dados;
• show($id): exibe os dados de um recurso;
• edit($id): exibe o formulário para edição de um recurso;
• update(Request $resquest, $id): atualiza um recurso no banco de dados;
• destroy($id): exclui um recurso no banco de dados.

Esse controlador é chamado “resource”, pois possui os principais métodos para manipular recursos.

Associando rotas a controladores resource

Após usamos o parâmetro –resource na criação do controller, é possível associar todos os métodos dele as rotas no arquivo routes/web.php, sem a necessidade de especificar cada uma delas.

Para isso, digite no arquivo de rotas a seguinte linha:

//..Laravel 7.x
Route::resource('/client', 'ClientController');

//..Laravel 8.x
Route::resource('/client’, ClientController::class);

Depois que a rota resource foi definida, digite o seguinte comando para inspecionar as rotas e verificar que elas estão definidas especificamente para cada um dos métodos do controlador resource.

php artisan route:list 

Métodos HTTP

Compo de ser observado no tópico anterior, nas lista de rotas, o Laravel Framework usa os métodos HTTP para fazer requisições aos controladores.

Convém destacar que os métodos CRUD gerados no controlador, usam os métodos HTTP como a seguir:

• GET | HEAD: recuperar dados (index, create, show, edit);
• POST: Enviar dados ao servidor (store);
• PUT | PATCH: atualizar dados (update);
• DELETE: excluir dados (destroy).

Isso significa que os dados enviados via formulário devem contemplar os métodos HTTP específicos para cada operação. Entretanto, normalmente os formulários HTML suportam no atributo method somente os valores GET e POST. Assim, é necessário usar recursos do Laravel para resolver isso, como veremos nos próximos posts.

Para saber mais sobre métodos HTTP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods

Para saber mais sobre o significado dos retornos das requisições via método HTTP: https://httpstatuses.com/

Conclusão

No padrão arquitetural MVC (Model-View-Controller), os controladores são os responsáveis por fazer o intermédio entre a camada model (dados) e a view (interface gráfica do usuário).

Logo, eles são os responsáveis por controlar o fluxo da aplicação, aplicar regras de negócios, validações e outros tratamentos mais complexos.

Assim, o arquivo de rotas (routes/web.php) deve se restringir a simplesmente direcionar a requisição a um controlador.

No próximo post falaremos sobre views no Laravel. Até lá! 😉