Compreender modelos e visualizações em Laravel

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;

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

class Post extends Model
{
  utiliza HasFactory;

  // Adiciona propriedades preenchíveis
  protected $fillable = ['title', 'content', 'author'];

  // Especifica o nome da tabela se for diferente de 'posts'
  // protegeu $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

utiliza o Illuminate\Database\Migrations\Migration;
utiliza Illuminate\Database\Schema\Blueprint;
utiliza o esquema Illuminate\Support\Facades\Schema;

retorna nova classe extends Migration
{
  função pública up()
  {
  Schema::create('posts', function (Blueprint $table) {
  $table->id();
  $table->string('título');
  $table->texto('conteúdo');
  $table->string('autor');
  $table->timestamps();
  });
  }

  função pública 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:

// Cria um novo registo Post
Post::create(['title' =>  'Primeira mensagem', 'conteúdo' =>  'Este é o conteúdo.', 'author' =>  'Nome do autor']);

// Recupera todos os 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>Saída da etapa 1</h1>
<h1>Olá, mundo!</h1>

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

// Numa rota (routes/web.php)
Route::get('/', function () {
  retorna view('welcome');
});

Saída

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

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

<!-- recursos/vistas/posts/index.blade.php -->
<!DOCTYPE html>
<html>
<cabeça>
    <título>Posts</title>
</head>
<corpo>
    <h1>Todas as publicações</h1>
</body>
</html>

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

// Numa rota (routes/web.php)
Route::get('/posts', function () {
  retorna 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.

usa Iluminar\Suporte\Facades\Ver;

// Numa rota (routes/web.php)
Route::get('/landing', function () {
  Retorna 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.

usa Iluminar\Suporte\Facades\Ver;

// Numa rota (routes/web.php)
Route::get('/check-view', function () {
  Se (View::exists('posts.index')) {
  retorna view('posts.index');
  } else {
  devolve 'A vista não existe';
  }
});

Passo 5: Passar dados para vistas

Podes passar dados diretamente para uma vista utilizando uma matriz.

Route::get('/post', function () {
  $post = [
  'título' =>  "O meu primeiro post",
  'conteúdo' =>  Este é o conteúdo da minha primeira mensagem",
  ];
  Retorna 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>
<cabeça>
    <título>{{ $post['title'] }}</title>
</head>
<corpo>
    <h1>{{ $post['title'] }}</h1>
    <p>{Não te preocupes.</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.

// Em vez disto (causa o problema N+1)
$posts = Post::all();
vê ($posts as $post) {
  ecoa $post->autor->nome;
}

// Usa isto (resolve o problema N+1)
$posts = Post::with('author')->obtém();
vê ($posts as $post) {
  ecoa $post->autor->nome;
}

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.

utiliza Illuminate\Database\Eloquent\Model;

função pública 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.

utiliza o Illuminate\Support\Str;

class Post extends Model
{
  função estática protegida 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.

utiliza o Illuminate\Support\Str;

class Post extends Model
{
  função estática protegida 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
{
  função pública getRouteKeyName()
  {
  devolve '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.

utiliza Illuminate\Database\Eloquent\Collection;

class PostCollection extends Collection
{
  função pública published()
  {
  devolve $this->where('is_published', true);
  }
}

// No modelo Post
class Post extends Model
{
  public function newCollection(array $models = [])
  {
  devolve 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:

função pública up()
{
  Schema::create('products', function (Blueprint $table) {
  $table->id();
  $table->string('nome');
  $table->texto('descrição');
  $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 Produto

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;

usa App\Models\Product; // Importa o modelo Product
utiliza Illuminate\Http\Request;

class ProductController extends Controller
{
  // Define o método de índice
  função pública index()
  {
  // Vai buscar todos os produtos à base de dados
  $produtos = Produto::todos();
  // Passa os dados dos produtos para a vista
  retorna 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 :

@extende('layouts.app')

@secção('conteúdo')
    <h1>Os nossos produtos</h1>
  @foreach($produtos as $produto)
        <div class="produto">
            <h2>{{ $product->nome }}</h2>
            <p>{{ $product->descrição }}</p>
        </div>
  @endforeach
@secção final

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">
<cabeça>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <título>A minha aplicação Laravel</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}"> <!-- Link para o teu CSS -->
</head>
<corpo>
    <div class="contentor">
  @yield('content')  <!-- É aqui que o teu conteúdo será injetado -->
    </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:

utiliza App\Http\Controllers\ProductController;
.
.
.
// Define a rota para o índice de produtos
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.