Compreender modelos e visualizações em Laravel

Principais conclusões

• Os modelos do Laravel gerem a lógica da base de dados através do Eloquent ORM, permitindo um tratamento de dados limpo e eficiente.
• As vistas utilizam o motor de templates Blade para apresentar conteúdo dinâmico aos utilizadores de forma simples e organizada.
• A separação entre modelos e vistas melhora a organização do código e facilita a sua manutenção a longo prazo.
• Os controladores ligam os modelos às vistas, permitindo construir aplicações MVC completas e bem estruturadas.

Compreender os modelos e as visualizações é essencial se pretendes criar aplicações dinâmicas e orientadas para os dados com o Laravel. Esses dois componentes poderosos trabalham juntos para estruturar seus dados e exibi-los de forma elegante, fazendo a ponte entre a lógica do backend e o design do frontend.

Os Models no Laravel servem de ligação entre a tua aplicação e a tua base de dados, tornando o tratamento de dados muito mais simples. Por outro lado, as Views no Laravel gerem o lado da aplicação que está virado para o utilizador.

Neste guia, vamos explorar modelos e vistas em profundidade, descobrindo como simplificam as interações com a base de dados e transformam dados em bruto em páginas Web fantásticas.

Vamos lá começar.

O que são modelos em Laravel?

Os modelos no Laravel são o núcleo da arquitetura MVC da estrutura e gerem a forma como os dados são utilizados e organizados na tua aplicação.

Os modelos Laravel representam tabelas na tua base de dados, permitindo-te realizar operações essenciais – como consultar, atualizar e eliminar dados – através decódigo expressivo e legível por humanos.

Para além da interação básica com a base de dados, os modelos Laravel permitem-te adicionar lógica empresarial diretamente aos teus modelos, tornando o teu código mais modular e organizado.

Qual é o objetivo de criar um modelo no Laravel?

Os modelos em Laravel são a força motriz por trás da gestão e organização dos dados da tua aplicação, facilitando a interação com a tua base de dados sem esforço.

Eis porque é que a criação de um modelo é tão valiosa:

• Interação direta com a base de dados: Os modelos fazem a ponte entre as tabelas da tua base de dados, permitindo-te recuperar, criar, atualizar e apagar dados facilmente sem escreveres SQL puro.
• Organização lógica dos dados: Cada modelo representa uma tabela específica, como Utilizador ou Encomenda, dando aos teus dados uma estrutura clara e significativa que corresponde às necessidades da tua aplicação.
• Relações simplificadas: Os modelos permitem-te definir relações, como “um-para-muitos” ou “muitos-para-muitos“, o que te permite aceder a dados relacionados (como as mensagens de um utilizador) com o mínimo de código.
• Segurança de dados incorporada: Os modelos incluem funcionalidades como a proteção de atribuição em massa e a conversão de atributos, facilitando o tratamento seguro dos dados e evitando vulnerabilidades comuns.

Como criar um modelo em Laravel?

A criação de um modelo no Laravel envolve alguns passos claros, cada um tratado por comandos específicos e modificações de ficheiros.

Vê aqui como criar um modelo em Laravel, passo a passo, com código e explicações:

Passo 1: Utiliza o comando Artisan

Para criar um modelo em Laravel, utiliza a ferramenta de linha de comandos Artisan no teu terminal SSH com o seguinte comando:

php artisan make:model Post

Este comando gera um novo arquivo de modelo. Estamos a criar um modelo Post. Por padrão, o arquivo de modelo é criado no diretório app/Models.

Passo 2: Define as propriedades do modelo

Uma vez criado o ficheiro modelo, podes adicionar propriedades para definir a forma como este interage com a base de dados.

Adiciona a seguinte linha de código em app/Models/Post.php que acabaste de criar na etapa anterior.

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    // Add fillable properties
    protected $fillable = ['title', 'content', 'author'];

    // Specify the table name if it's different from 'posts'
    // protected $table = 'my_custom_table';
}

• Aqui, o título, o conteúdo e o autor são campos que podem ser preenchidos pela aplicação.
• Também podes especificar nomes de tabelas personalizados ou adicionar relações a outros modelos, se necessário.

Passo 3: Migração da base de dados

Para criar a tabela real na base de dados, gera um ficheiro de migração e define as colunas.

php artisan make:migration create_posts_table

Este comando cria um novo ficheiro de migração na pasta database/migrations.

Adiciona a seguinte linha de código dentro do novo ficheiro de migração na base de dados/migrações.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->string('author');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('posts');
    }
};

Este ficheiro de migração define a estrutura da tabela de mensagens, incluindo as suas colunas.

Cada campo especificado aqui (título, conteúdo, autor) corresponde a uma coluna na base de dados. O método timestamps() adiciona automaticamente as colunas created_at e updated_at.

Depois de definir a migração, executa-a com:

php artisan migrate

Até agora, criaste um modelo básico em Laravel para gerir registos de posts numa tabela da base de dados de posts.

Isto inclui a definição do modelo (Post) e um ficheiro de migração para criar a tabela com colunas como título, conteúdo e autor.

Executar a migração com php artisan migrate cria a tabela de posts na base de dados.

Passo 4: Utilizar modelos com o Eloquent ORM

Depois de configurar este modelo, podes utilizar o Eloquent ORM para interagir com a base de dados, por exemplo:

// Create a new Post record
Post::create(['title' => 'First Post', 'content' => 'This is the content.', 'author' => 'Author Name']);

// Retrieve all posts
$posts = Post::all();

Utilizando o Eloquent ORM, podes utilizar a interface de utilizador para lançar registos na tua base de dados. Podes aceder-lhes com Post::all() ou procurar registos específicos por ID utilizando Post::find(1).

O que são visualizações no Laravel?

No Laravel, as vistas são como o front end da tua aplicação. Apresentam a informação que a tua aplicação gera.

As visualizações são normalmente escritas no Blade, um mecanismo de modelos fornecido pelo Laravel. O Blade permite-te criar modelos HTML dinâmicos e reutilizáveis. Podes incorporar código PHP no teu HTML para gerar conteúdo dinamicamente.

Para utilizar uma vista, normalmente devolve-a a partir de um controlador. O controlador recolhe os dados necessários e passa-os para a vista, que depois processa o HTML com os dados fornecidos. Esta separação de conteúdos ajuda a manter o teu código organizado e de fácil manutenção.

Qual é o objetivo de usar visualizações no Laravel?

As visualizações em Laravel são a chave para tornar os teus dados seguros e gerenciáveis. As visualizações do Laravel permitem-te manter o teu código limpo, separado e organizado. Vê aqui porque é que elas são essenciais:

• Exibição de conteúdo sem esforço: As vistas são os modelos que apresentam os dados da tua aplicação, facilitando a apresentação de conteúdos dinâmicos em páginas Web sem sobrecarregar o teu código de backend.
• Separa a lógica e o design: As visualizações mantêm o HTML e o CSS separados da lógica comercial, tornando o código mais limpo e fácil de manter. Esta estrutura também simplifica as actualizações, uma vez que a lógica e o design não se sobrepõem.
• Layouts reutilizáveis: Podes criar layouts reutilizáveis, como cabeçalhos, rodapés e barras laterais, que aparecem em várias páginas com um design consistente, poupando-te tempo e esforço.
• Experiência dinâmica do utilizador: Ao passar dados para visualizações, podes criar páginas interactivas e dinâmicas que melhoram a experiência do utilizador, mantendo o teu código simplificado.

Como criar uma visualização em Laravel?

Criar e renderizar visualizações no Laravel é uma tarefa fundamental para aplicações web. Vê aqui como o fazer passo a passo, incluindo exemplos de código e explicações para cada parte:

Passo 1: Criar e renderizar vistas

Para criar uma vista, coloca o ficheiro de modelo HTML no diretório resources/views.

Cria um novo arquivo com uma extensão .blade.php. Essa extensão diz ao Laravel para usar o mecanismo de modelo Blade para analisar a visualização.

No arquivo de visualização, adiciona os modelos HTML, PHP e/ou Blade que definem a estrutura e o layout da página. Podes utilizar marcadores de posição para conteúdo dinâmico.

Guarda o ficheiro de visualização.

<!-- resources/views/greeting.blade.php -->
<h1>Step 1 output</h1>
<h1>Hello, world!</h1>

Para renderizar esta vista, utiliza o auxiliar view() num controlador ou numa rota:

// In a route (routes/web.php)
Route::get('/', function () {
    return view('welcome');
});

Saída

Passo 2: Diretórios de visualização aninhados

Podes organizar as vistas em subdirectórios para as manteres organizadas.

<!-- resources/views/posts/index.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>Posts</title>
</head>
<body>
    <h1>All Posts</h1>
</body>
</html>

Para renderizar uma vista aninhada, utiliza a notação de ponto:

// In a route (routes/web.php)
Route::get('/posts', function () {
    return view('posts.index');
});

A vista posts.index utiliza a notação de pontos para aceder ao diretório aninhado.

Passo 3: Criar a primeira vista disponível

Utiliza View::first() para apresentar a primeira vista disponível a partir de várias opções.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/landing', function () {
    return View::first(['custom.landing', 'default.landing']);
});

Se resources/views/custom/landing.blade.php existir, carrega essa visualização. Caso contrário, retorna para resources/views/default/landing.blade.php.

Passo 4: Determinar se existe uma vista

Verifica se uma vista existe antes de tentar renderizá-la.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/check-view', function () {
    if (View::exists('posts.index')) {
        return view('posts.index');
    } else {
        return 'View does not exist';
    }
});

Passo 5: Passar dados para vistas

Podes passar dados diretamente para uma vista utilizando uma matriz.

Route::get('/post', function () {
    $post = [
        'title' => 'My First Post',
        'content' => 'This is the content of my first post.',
    ];
    return view('posts.show', compact('post'));
});

Além disso, actualiza a vista em resources/views/posts/show.blade.php:

<!-- resources/views/posts/show.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>{{ $post['title'] }}</title>
</head>
<body>
    <h1>{{ $post['title'] }}</h1>
    <p>{{ $post['content'] }}</p>
</body>
</html>

Passo 6: Partilhar dados com todas as vistas

Podes partilhar dados globalmente na tua aplicação com todas as vistas utilizando o método View::share().

usa Iluminar\Suporte\Facades\Ver;

// Em App\Providers\AppServiceProvider.php
função pública boot()
{
  View::share('appName', 'My Laravel App');
}

Agora, para aceder a esta vista em qualquer ficheiro de vista, podes utilizar appName:

<!-- Exemplo em qualquer ficheiro de visualização -->
<h1>Saída da etapa 6</h1>
<h1>Bem-vindo a {{ $appName }}</h1>

Saída

Utilizando este código, podes construir e apresentar diferentes páginas em Laravel, organizar essas páginas de forma eficiente, lidar com vistas em falta e apresentar dados dinâmicos nas páginas.

Esta estrutura é fundamental para a construção de uma aplicação web funcional, organizada e dinâmica.

Dicas para o modelo Laravel

Aqui estão algumas dicas essenciais do modelo Laravel para te ajudar a construir aplicações seguras e de fácil manutenção. Utilizando estas técnicas, podes manter o teu código eficiente e seguro, garantindo um melhor controlo sobre os teus modelos e dados.

Vamos mergulhar em cada dica!

1. Detectando e prevenindo problemas com N+1

O problema da consulta N+1 ocorre quando várias consultas são enviadas ao banco de dados para obter dados relacionados, causando um desempenho lento. Evita-o utilizando o Eager Loading com o método with() do Laravel nas tuas consultas.

Isto acelera as tuas consultas ao carregar dados relacionados numa única chamada, evitando atrasos de desempenho e chamadas desnecessárias à base de dados.

// Instead of this (causes N+1 issue)
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name;
}

// Use this (solves N+1 issue)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;
}

2. Impedir o acesso a atributos em falta

Acessar um atributo inexistente em um modelo pode causar bugs confusos. Usa $guarded ou $fillable nos teus modelos para controlar que atributos estão acessíveis.

Ao definir atributos $fillable, assegura que apenas estes campos especificados podem ser acedidos e atribuídos em massa, protegendo o seu modelo de dados inesperados.

class Post extends Model
{
    protected $fillable = ['title', 'content', 'author_id'];
}

3. Evita a rejeição silenciosa de atributos

O Laravel pode ignorar silenciosamente atributos que não estão em $fillable, causando confusão. Para evitar isso, habilita guarded para os campos que queres proteger e define estritamente apenas o que é permitido.

Esta abordagem ajuda a evitar que o Laravel descarte atributos sem te alertar, mantendo os teus dados seguros e o teu código claro.

class Post extends Model
{
    protected $guarded = ['id'];
}

4. Ativar o modo estrito para os modelos

O modo estrito do Laravel garante que são lançados erros para atributos não reconhecidos, tornando a tua aplicação mais segura. Habilita o modo estrito no teu AppServiceProvider.

Com o modo estrito ativado, o Laravel alerta-te quando algo inesperado acontece, ajudando-te a detetar problemas mais cedo.

use Illuminate\Database\Eloquent\Model;

public function boot()
{
    Model::shouldBeStrict(true);
}

5. Utilizar UUIDs

Os UUIDs são identificadores únicos que tornam os modelos mais seguros, especialmente em URLs voltados para o público. Adiciona o auxiliar Str::uuid() para gerar UUIDs.

A utilização de UUIDs oculta os IDs numéricos da tua base de dados, tornando os dados da tua aplicação mais seguros e mais difíceis de prever.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->uuid = (string) Str::uuid();
        });
    }
}

6. Utiliza UUIDs como chave primária

Para uma camada adicional de segurança, utiliza UUIDs como chave primária. Substitui $primaryKey e $keyType no modelo e define o incremento como false.

A utilização de UUIDs como chaves primárias torna a tua base de dados menos previsível e aumenta a segurança ao impedir a adivinhação de IDs sequenciais.

class Post extends Model
{
    protected $primaryKey = 'uuid';
    protected $keyType = 'string';
    public $incrementing = false;
}

7. Utilização de ULIDs

Os ULIDs são identificadores únicos alternativos que combinam aleatoriedade com ordenação sequencial. Podes gerar ULIDs com Str::ulid().

Em palavras simples, os ULIDs oferecem uma ID única e classificável que é óptima para casos de utilização que requerem IDs ordenados mas seguros no URL.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->ulid = (string) Str::ulid();
        });
    }
}

8. Alterar o campo utilizado para a ligação ao modelo de itinerário

Por padrão, o Laravel vincula modelos a rotas usando a chave primária. Podes alterar isto para usar um UUID ou qualquer outro campo, sobrepondo getRouteKeyName().

Esta alteração torna os teus itinerários mais flexíveis, permitindo-te utilizar campos únicos como uuid em vez de IDs numéricos, acrescentando clareza e segurança.

class Post extends Model
{
    public function getRouteKeyName()
    {
        return 'uuid';
    }
}

9. Utiliza colecções de modelos personalizados

O Laravel permite-te criar colecções personalizadas para modelos específicos, facilitando a adição de métodos especializados para lidar com grupos de modelos.

Com colecções personalizadas, podes adicionar métodos como published() que filtram os dados da coleção, tornando-os mais legíveis e práticos.

use Illuminate\Database\Eloquent\Collection;

class PostCollection extends Collection
{
    public function published()
    {
        return $this->where('is_published', true);
    }
}

// In the Post model
class Post extends Model
{
    public function newCollection(array $models = [])
    {
        return new PostCollection($models);
    }
}

Utilizar Models e Views em conjunto no Laravel?

A criação de aplicações web dinâmicas requer a integração de Models e Views do Laravel. Nesta parte, aprenderemos como usar Models e Views juntos.

Vamos desenvolver uma aplicação básica que recupera e apresenta itens ou produtos de uma base de dados.

Aqui tens um guia passo a passo para o fazeres:

Passo 1: Configuração da base de dados

Primeiro, configura a tua ligação à base de dados no ficheiro de ambiente. Quando a base de dados estiver configurada, cria uma tabela para armazenar os teus produtos. Utiliza o seguinte comando Artisan para criar uma tabela de produtos:

php artisan make:migration create_products_table --create=products

Em seguida, define a migração. Para definir a migração, localiza o ficheiro de migração criado para a tabela products. Encontrarás este ficheiro em database/migrations/, com um nome semelhante a create_products_table. No nosso caso, chama-se 2024_11_12_125426_create_products_table.php.

Depois de localizares o ficheiro, abre-o e define o esquema como se mostra abaixo:

public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description');
        $table->timestamps();
    });
}

Salva o arquivo e, em seguida, executa a migração para criar a tabela de produtos no banco de dados. Para isso, navega até ao diretório raiz do teu projeto e executa o seguinte comando:

php artisan migrate

Passo 2: Criar um modelo para produtos

Nesta etapa, criaremos um modelo para os produtos usando o seguinte comando do Artisan:

php artisan make:model Product

Quando estiveres pronto, vamos definir as propriedades de preenchimento. Podemos conseguir isso adicionando a linha de código compartilhada abaixo no arquivo product.php localizado em app/Models/Product.php.

Terás de a adicionar à classe de produto, como mostra a imagem abaixo:

protected $fillable = ['name', 'description'];

Passo 3: Criar o controlador

Agora vamos criar o Controller, que será utilizado para tratar os pedidos relacionados com os produtos. Terás de executar o seguinte comando no diretório raiz :

php artisan make:controller ProductController

Agora, precisamos definir o Método de índice adicionando o seguinte bloco de código de índice no caminho do arquivo app/Http/Controllers/ProductController.php.

Adiciona o seguinte bloco de código ao teu ficheiro ProductController.php. O teu ProductController.php deve conter apenas este código:

<?php

namespace App\Http\Controllers;

use App\Models\Product; // Import the Product model
use Illuminate\Http\Request;

class ProductController extends Controller
{
    // Define the index method
    public function index()
    {
        // Fetch all products from the database
        $products = Product::all();
        // Pass the products data to the view
        return view('products.index', compact('products'));
    }
}

Passo 4: Criar a vista e o esquema

Nesta etapa, criaremos um diretório de produto e layout em resources/views/.

Agora, vamos criar um diretório de layout nas vistas, tal como fizemos com o diretório de produtos.

Em seguida, criaremos um arquivo de visualização chamado index.blade.php em resources/views/products/ com o seguinte bloco de código e o salvaremos :

@extends('layouts.app')

@section('content')
    <h1>Our Products</h1>
    @foreach($products as $product)
        <div class="product">
            <h2>{{ $product->name }}</h2>
            <p>{{ $product->description }}</p>
        </div>
    @endforeach
@endsection

Agora vamos adicionar o seguinte código no diretório de layout, criando um novo ficheiro com o nome app.blade.php e guardando-o .

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Laravel App</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}"> <!-- Link to your CSS -->
</head>
<body>
    <div class="container">
        @yield('content') <!-- This is where your content will be injected -->
    </div>
</body>
</html>

Passo 5: Definir rotas

Aqui, abriremos o arquivo Routes em routes/web.php. Adicionaremos a rota para o índice de produtos compartilhado no bloco de código abaixo:

use App\Http\Controllers\ProductController;
.
.
.
// Define route for products index
Route::get('/products', [ProductController::class, 'index']);

Seguir estes passos permitiu-te mostrar com sucesso os produtos da tua base de dados utilizando os modelos e vistas do Laravel. Este método melhora a experiência do utilizador, mantendo a organização do teu código, fornecendo informações dinâmicas em resposta às consultas do utilizador.

Uma lista dos teus itens deve agora ser apresentada de forma adequada na tua página inicial quando visitas /products. Adicionámos os seguintes detalhes de produtos como exemplos – podes adicionar os teus produtos para obteres o resultado esperado.

Palavras finais.

Neste guia, explorámos os conceitos essenciais de Modelos e Vistas em Laravel, ajudando-te a compreender como a gestão de dados e as interfaces de utilizador são estruturadas nesta estrutura.

Vimos como os modelos simplificam as interações com a base de dados e como as vistas, utilizando o motor de modelos Blade, permitem uma apresentação dinâmica e flexível dos dados.

Utilizando estes conceitos, podes criar aplicações que equilibram uma poderosa funcionalidade de back-end com uma experiência de utilizador com capacidade de resposta.