# Dominando Controladores

%[https://www.youtube.com/watch?v=2xTtgKFjcs8] 

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768494056681/08185060-fd63-4b76-9a7a-7160c17a1bad.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

Controladores são uma parte essencial do desenvolvimento com Laravel.  
Eles permitem que você organize a lógica da aplicação, separando o código que lida com as requisições HTTP das rotas. Isso facilita a manutenção e a escalabilidade do código.

#### Criando Controladores

No Laravel, você pode criar controladores usando o Artisan CLI. Para criar um controlador básico, execute o seguinte comando no terminal:

```php
php artisan make:controller NomeDoController
```

Isso criará um arquivo de controlador em `app/Http/Controllers/NomeDoController.php`.

#### Estrutura Básica de um Controlador

Um controlador básico pode parecer com o seguinte:

```php
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class NomeDoController extends Controller
{
    public function index()
    {
        return view('index');
    }

    public function show($id)
    {
        return view('show', ['id' => $id]);
    }
}
```

#### Definindo Rotas para Controladores

Para mapear as rotas para os métodos de um controlador, você usa a sintaxe de array:

```php
Route::get('/home', [NomeDoController::class, 'index']);
Route::get('/user/{id}', [NomeDoController::class, 'show']);
```

Neste exemplo, a rota `/home` chama o método `index` do `NomeDoController`, e a rota `/user/{id}` chama o método `show`.

Lembre-se de criar o arquivo blade para cada um.  
`index.blade.php e show.blade.php`

#### Controladores de Recursos

Controladores de recursos são uma forma eficiente de lidar com operações CRUD (Create, Read, Update, Delete). Eles seguem as convenções RESTful e podem ser criados usando o Artisan CLI:

```php
php artisan make:controller NomeDoController --resource
```

Um controlador de recurso inclui métodos para as ações típicas de CRUD:

* `index` – Mostrar uma lista de itens
    
* `create` – Mostrar um formulário para criar um novo item
    
* `store` – Salvar um novo item
    
* `show` – Mostrar um item específico
    
* `edit` – Mostrar um formulário para editar um item
    
* `update` – Atualizar um item específico
    
* `destroy` – Excluir um item específico
    

Para registrar um controlador de recurso, use o método `resource` no seu arquivo de rotas:

```php
Route::resource('users', NomeDoController::class);
```

Isso mapeia automaticamente as rotas adequadas para os métodos do controlador.

#### Passando Dados para as Views

Ao retornar uma view de um controlador, você pode passar dados para a view usando o método `with` ou um array associativo:

```php
public function show($id)
{
    $cliente = 'áreadev';
    return view('show', ['cliente' => $cliente]);
}
```

Na view show.blade.php chame a variável:

`{{ $cliente }}`

Veja no navegador: [http://localhost/users/1](http://localhost/users/1)

### Middleware nos Controladores

No Laravel, middleware é uma camada intermediária entre uma requisição HTTP e a aplicação, que permite filtrar e processar essa requisição antes que ela chegue ao controlador.

Para continuarmos esse assunto vamos precisar instalar o "laravel/breeze".

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1720899476539/70437338-ab4f-4bde-9bef-485000fc2c44.png align="center")

Observe que não existe a opção de autenticação (Log in / Register) na nossa aplicação.

Clique no link e siga os passos: [https://laravel.com/docs/11.x/starter-kits#laravel-breeze](https://laravel.com/docs/11.x/starter-kits#laravel-breeze)

siga a ordem dos comandos:

1. ```bash
       composer require laravel/breeze --dev
    ```
    
2. ```bash
       php artisan breeze:install
    ```
    

Vai aparecer umas perguntinhas, você pode seguir essa ordem:

![Pergunta 1: Escolha a stack Breeze que você gostaria de instalar?](https://cdn.hashnode.com/res/hashnode/image/upload/v1720899119917/ee66f8f6-7384-4fb2-89b8-0ed53cfe3277.png align="center")

![Pergunta 02: Gostaria de suporte a dark mode?](https://cdn.hashnode.com/res/hashnode/image/upload/v1720899141762/837b7af9-35e0-46df-bd95-8da4ddc8b5b3.png align="center")

![Pergunta 03: Qual estrutura de teste você prefere?](https://cdn.hashnode.com/res/hashnode/image/upload/v1720899160826/6f852426-582d-49a4-97cb-7b53c18ef86d.png align="center")

![Instalando e construindo as dependencias](https://cdn.hashnode.com/res/hashnode/image/upload/v1720899180928/6218ed78-2764-4118-97ab-d10b29d68656.png align="center")

3. ```bash
       sail artisan migrate
       sail npm install
       sail npm run dev
    ```
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1720900245848/88ffb448-3ad2-43dd-a46a-0199a146fcd6.png align="center")

Agora temos a opção de Log in e Register.

Middleware pode ser aplicado a controladores inteiros ou a métodos específicos dentro de um controlador.

Para aplicar middleware a um controlador, use o método `middleware` no construtor:

```php
namespace App\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Routing\Controllers\HasMiddleware;
use Illuminate\Routing\Controllers\Middleware;

class NomeDoController extends Controller implements HasMiddleware
{
    public static function middleware(): array
    {
        return ['auth'];
    }

    // Outros métodos do controlador
}
```

Agora só podemos visualizar a rota: [localhost/users/1](http://localhost/users/1) se estiver autenticado.

### Middleware na rota

Para adicionar um middleware na rota basta adicionar o middleware no final.

`Route::resource('users', NomeDoController::class)->middleware('auth');`

Assiste o vídeo Parte II

%[https://www.youtube.com/watch?v=e9bJUeZW2nM&t=321s] 

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768494079506/be08db07-7b6f-4082-868d-f38aaf71f67b.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

## Conclusão

Controladores no Laravel proporcionam uma maneira organizada de lidar com a lógica de sua aplicação, promovendo uma separação clara entre rotas e ações.  
Com o uso de controladores básicos, controladores de recursos, injeção de dependências e middleware, você pode construir aplicações robustas e manuteníveis. Nos próximos tópicos, exploraremos como criar e renderizar views, usar o Blade templating engine e trabalhar com dados de maneira eficiente usando o Eloquent ORM.