O Laravel é um framework PHP popular para a criação de aplicativos web modernos e dinâmicos no atual cenário de constante evolução e ritmo acelerado de desenvolvimento web. Um de seus principais recursos é o Laravel Eloquent, um mapeador objeto-relacional (ORM) que permite que os desenvolvedores executem com eficiência operações de criação, leitura, atualização e exclusão — CRUD (Create, Read, Update, Delete) — em um banco de dados.
Este tutorial demonstra como você pode executar essas operações em seu aplicativo Laravel usando o Eloquent ORM do Laravel, e como implementar seu aplicativo CRUD do Laravel usando o MyKinsta.
Funcionalidade CRUD no Laravel
As operações CRUD são a espinha dorsal de qualquer aplicativo voltado a banco de dados. Elas permitem que você execute as operações mais básicas e essenciais do banco de dados, como a criação de novos registros, e a leitura, atualização e exclusão dos existentes. Essas operações são cruciais para a funcionalidade de qualquer aplicativo Laravel que interaja com um banco de dados.
O Eloquent oferece uma maneira simples e intuitiva de interagir com o banco de dados, diminuindo as complexidades do gerenciamento do banco de dados para que você possa se concentrar na criação do seu aplicativo. Seus métodos e classes integrados permitem que você faça CRUD de registros no banco de dados com facilidade.
Pré-requisitos
Para seguir este tutorial, certifique-se de que você tenha o seguinte:
- XAMPP
- Composer
- Uma conta MyKinsta
- Uma conta no GitHub, GitLab ou Bitbucket para enviar seu código
- Versão 5 do Bootstrap
Etapas
- Instale o Laravel e crie um novo aplicativo
- Crie um banco de dados
- Crie uma tabela
- Crie um controlador
- Configure o template
- Adicione uma rota
- Gere arquivos Blade
- Implemente e teste seu aplicativo CRUD
Para se orientar ao longo do processo, confira o código completo do tutorial.
Instale o Laravel e crie um novo aplicativo
Abra o terminal onde você deseja criar o aplicativo Laravel e siga as etapas abaixo.
- Para instalar o Laravel, execute:
composer global require laravel/installer- Para criar um novo aplicativo Laravel, execute:
laravel new crudpostsCrie um banco de dados
Para criar um novo banco de dados para o seu aplicativo:
- Inicie os servidores Apache e MySQL no painel de controle do XAMPP e acesse
http://localhost/phpmyadminem seu navegador.
- Clique em New (Novo) na barra lateral esquerda. Você deverá ver o seguinte:
- Adicione o nome do banco de dados e clique em Create.
- Edite o arquivo .env do seu aplicativo na raiz do aplicativo Laravel. Ele contém todas as variáveis de ambiente usadas pelo aplicativo. Localize as variáveis prefixadas com
DB_e edite-as com suas credenciais do banco de dados:
DB_CONNECTION=
DB_HOST=
DB_PORT=
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=Crie uma tabela
As linhas de dados em seu aplicativo são armazenadas em tabelas. Você precisa de apenas uma tabela para este aplicativo, criada usando as migrações do Laravel.
- Para criar uma tabela e gerar um arquivo de migração usando a interface de linha de comando do Laravel, Artisan, execute:
php artisan make:migration create_posts_tableO comando acima cria um novo arquivo,
yyyy_mm_dd_hhmmss_create_posts_table.php, em database/migrations.
- Abra o arquivo yyyy_mm_dd_hhmmss_create_posts_table.php para definir as colunas que você deseja em sua tabela de banco de dados na função up:
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('body');
$table->timestamps();
});
}Esse código define o que a tabela de posts contém. Ela tem quatro colunas: id, title, body, e timestamps.
- Execute os arquivos de migração na pasta database/migrations para criar tabelas no banco de dados:
php artisan migrateO resultado é semelhante a este:
- Vá ao banco de dados que você criou anteriormente para confirmar que criou as tabelas:
Crie um controlador
O controlador contém todas as funções para executar as operações CRUD no banco de dados.
Gere um arquivo controlador dentro do seu aplicativo Laravel usando o Artisan:
php artisan make:controller PostController --apiA execução desse comando cria um arquivo PostController.php em app/Http/Controllers, com código padrão e declarações de função vazias index, store, show, update, e destroy.
Criando funções
Em seguida, crie as funções que armazenam, indexam, atualizam, destroem, criam, mostram e editam os dados.
Você pode adicioná-las ao arquivo app/Http/Controller/PostController.php mostrado abaixo.
A função store
A função store adiciona um post ao banco de dados.
Role até a função store e adicione o seguinte código dentro das chaves vazias:
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success','Post created successfully.');Esse código recebe um objeto que contém o título e o corpo do post, valida os dados, adiciona um novo post ao banco de dados se os dados forem válidos, e redireciona o usuário para a página inicial com uma mensagem de sucesso.
A função index
A função index pesquisa todos os posts do banco de dados e envia os dados para a página posts.index.
A função update
A função <update contém o id do post a ser atualizado, o novo title do post, e o body. Depois de validar os dados, ela procura o post com o mesmo id. Se o encontrar, a função update atualiza o post no banco de dados com os novos title e body. Em seguida redireciona o usuário à página inicial com uma mensagem de sucesso.
A função destroy
A função destroy localiza um post com o endereço id fornecido e o exclui do banco de dados. Daí redireciona o usuário à página inicial com uma mensagem de sucesso.
As funções acima são as usadas para executar as operações CRUD no banco de dados. No entanto, você deve definir mais funções dentro do controlador para renderizar as páginas necessárias em resources/views/posts/.
A função create
A função create renderiza a página resources/views/posts/create.blade.php, que contém o formulário para adicionar posts ao banco de dados.
A função show
A função show localiza um post com o endereço id fornecido no banco de dados e renderiza a página resources/views/posts/show.blade.php com o post.
A função edit
A função edit localiza um post com o endereço id fornecido no banco de dados e renderiza a página resources/views/posts/edit.blade.php com os detalhes do post em um formulário.
Configure o modelo
O modelo Post interage com a tabela de posts no banco de dados.
- Para criar um modelo com o Artisan, execute:
php artisan make:model PostEsse código cria um arquivo Post.php dentro da pasta App/Models.
- Crie um array
<fillable. Adicione o seguinte código dentro da classePost, abaixo da linhause HasFactory;:
protected $fillable = [
'title',
'body',
];Esse código cria um array fillable que permite que você adicione itens ao banco de dados no seu aplicativo Laravel.
- Conecte o modelo
Postao arquivo PostController.php. Abra o PostController.php e adicione a linha a seguir debaixo deuse IlluminateHttpRequest;, desta forma:
use Illuminate\Http\Request;
use App\Models\Post;Agora o arquivo PostController.php deve ter a seguinte aparência:
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\Post;
class PostController extends Controller
{
/**
* Display a listing of the resource.
*
* @return Illuminate\Http\Response
*/
public function index()
{
$posts = Post::all();
return view('posts.index', compact('posts'));
}
/**
* Store a newly created resource in storage.
*
* @param Illuminate\Http\Request $request
* @return Illuminate\Http\Response
*/
public function store(Request $request)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success', 'Post created successfully.');
}
/**
* Update the specified resource in storage.
*
* @param Illuminate\Http\Request $request
* @param int $id
* @return Illuminate\Http\Response
*/
public function update(Request $request, $id)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
$post = Post::find($id);
$post->update($request->all());
return redirect()->route('posts.index')
->with('success', 'Post updated successfully.');
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return Illuminate\Http\Response
*/
public function destroy($id)
{
$post = Post::find($id);
$post->delete();
return redirect()->route('posts.index')
->with('success', 'Post deleted successfully');
}
// routes functions
/**
* Show the form for creating a new post.
*
* @return Illuminate\Http\Response
*/
public function create()
{
return view('posts.create');
}
/**
* Display the specified resource.
*
* @param int $id
* @return Illuminate\Http\Response
*/
public function show($id)
{
$post = Post::find($id);
return view('posts.show', compact('post'));
}
/**
* Show the form for editing the specified post.
*
* @param int $id
* @return Illuminate\Http\Response
*/
public function edit($id)
{
$post = Post::find($id);
return view('posts.edit', compact('post'));
}
}Adicione rotas
Depois de criar as funções do controlador e o modelo Post, você deve adicionar rotas às funções do seu controlador.
- Abra routes/web.php e exclua a rota padrão que o aplicativo gerou. Substitua-a pelo código abaixo para conectar as funções do controlador às suas respectivas rotas:
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');- Para conectar as rotas, abra app/Http/Controllers/PostController.php e adicione a linha a seguir sob a linha
use IlluminateSupportFacadesRoute;, assim:
use IlluminateSupportFacadesRoute;
use AppHttpControllersPostController;Agora o arquivo routes/web.php deve ter o seguinte aspecto:
<?php
use Illuminate\Support\Facades\Route;
use AppHttpControllersPostController;
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');Gere arquivos Blade
Agora que você tem as rotas, pode criar os arquivos do Laravel Blade. Antes de usar o Artisan para gerar os arquivos Blade, crie o comando make:view, com o qual você pode gerar arquivos blade.php.
- Execute o seguinte código na CLI para criar um arquivo de comando MakeViewCommand dentro da pasta app/Console/Commands:
php artisan make:command MakeViewCommand- Crie um comando para gerar arquivos .blade.php a partir da CLI, substituindo o código no arquivo MakeViewCommand pelo seguinte:
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
use File;
class MakeViewCommand extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'make:view {view}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Create a new blade template.';
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$view = $this->argument('view');
$path = $this->viewPath($view);
$this->createDir($path);
if (File::exists($path))
{
$this->error("File {$path} already exists!");
return;
}
File::put($path, $path);
$this->info("File {$path} created.");
}
/**
* Get the view full path.
*
* @param string $view
*
* @return string
*/
public function viewPath($view)
{
$view = str_replace('.', '/', $view) . '.blade.php';
$path = "resources/views/{$view}";
return $path;
}
/**
* Create a view directory if it does not exist.
*
* @param $path
*/
public function createDir($path)
{
$dir = dirname($path);
if (!file_exists($dir))
{
mkdir($dir, 0777, true);
}
}
}Crie uma página inicial
Em seguida, crie sua página inicial. A página inicial é o arquivo index.blade.php, que lista todos os posts.
- Para criar a página inicial, execute:
php artisan make:view posts.indexIsso cria uma pasta posts dentro da pasta /resources/views e um arquivo index.blade.php abaixo dela. O caminho resultante é /resources/views/posts/index.blade.php.
- Adicione o seguinte código dentro do arquivo index.blade.php:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
integrity="sha384-GLhlTQ8iRABdZLl6O3oVMWSktQOp6b7In1Zl3/Jr59b6EGGoI1aFkw7cmDA6j6gD" crossorigin="anonymous">
<title>Posts</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-light bg-warning">
<div class="container-fluid">
<a class="navbar-brand h1" href={{ route('posts.index') }}>CRUDPosts</a>
<div class="justify-end ">
<div class="col ">
<a class="btn btn-sm btn-success" href={{ route('posts.create') }}>Add Post</a>
</div>
</div>
</div>
</nav>
<div class="container mt-5">
<div class="row">
@foreach ($posts as $post)
<div class="col-sm">
<div class="card">
<div class="card-header">
<h5 class="card-title">{{ $post->title }}</h5>
</div>
<div class="card-body">
<p class="card-text">{{ $post->body }}</p>
</div>
<div class="card-footer">
<div class="row">
<div class="col-sm">
<a href="{{ route('posts.edit', $post->id) }}"
class="btn btn-primary btn-sm">Edit</a>
</div>
<div class="col-sm">
<form action="{{ route('posts.destroy', $post->id) }}" method="post">
@csrf
@method('DELETE')
<button type="submit" class="btn btn-danger btn-sm">Delete</button>
</form>
</div>
</div>
</div>
</div>
</div>
@endforeach
</div>
</div>
</body>
</html>O código acima cria uma página HTML simples que usa o Bootstrap para criar o estilo. Ele estabelece uma barra de navegação e um template de grade que lista todos os posts no banco de dados com detalhes e dois botões de ação — Edit e Delete — usando o auxiliar @foreach do Blade.
O botão Edit leva o usuário à página Edit post, onde ele pode editar o post. O botão Delete exclui o post do banco de dados usando {{ route('posts.destroy', $post->id) }} com um método DELETE.
Observação: O código da barra de navegação para todos os arquivos é o mesmo do arquivo anterior.
- Crie a página create.blade.php. O arquivo Blade chamado create adiciona posts ao banco de dados. Use o seguinte comando para gerar o arquivo:
php artisan make:view posts.createIsso gera um arquivo create.blade.php dentro da pasta /resources/views/posts.
- Adicione o seguinte código ao arquivo create.blade.php:
// same as the previous file. Add the following after the nav tag and before the closing body tag.
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Add a Post</h3>
<form action="{{ route('posts.store') }}" method="post">
@csrf
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required></textarea>
</div>
<br>
<button type="submit" class="btn btn-primary">Create Post</button>
</form>
</div>
</div>
</div>O código acima cria um formulário com os campos title e body e um botão submit para adicionar um post ao banco de dados por meio da ação {{ route('posts.store') }} com um método POST.
- Crie a página Edit post para editar posts no banco de dados. Use o seguinte comando para gerar o arquivo:
php artisan make:view posts.editIsso cria um arquivo edit.blade.php dentro da pasta /resources/views/posts.
- Adicione o seguinte código ao arquivo edit.blade.php:
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Update Post</h3>
<form action="{{ route('posts.update', $post->id) }}" method="post">
@csrf
@method('PUT')
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title"
value="{{ $post->title }}" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required>{{ $post->body }}</textarea>
</div>
<button type="submit" class="btn mt-3 btn-primary">Update Post</button>
</form>
</div>
</div>
</div>O código acima cria um formulário com os campos title e body e um botão de envio para editar um post com o id especificado no banco de dados por meio da ação {{ route('posts.update') }} com um método PUT.
- Em seguida reinicie o servidor de aplicativos usando o código abaixo:
php artisan serveVisite http://127.0.0.1:8000 em seu navegador para ver seu novo blog. Clique no botão Add Post para adicionar novos posts.
Implemente e teste seu aplicativo CRUD
Prepare seu aplicativo para a implantação da seguinte forma:
- Torne a implantação fácil e objetiva declarando a pasta pública. Adicione um arquivo .htaccess à raiz da pasta do aplicativo com o seguinte código:
<IfModule mod_rewrite.c >
RewriteEngine On
RewriteRule ^(.*)$ public/$1 [L]
</IfModule >- Force seu aplicativo a usar
HTTPSadicionando o seguinte código acima de suas rotas dentro do arquivo routes/web.php:
use IlluminateSupportFacadesURL;
URL::forceScheme('https');- Envie seu código para um repositório Git. A Kinsta oferece suporte a implantações do GitHub, GitLab ou Bitbucket.
Configure um projeto no MyKinsta
- Crie uma conta MyKinsta, se você ainda não tiver uma.
- Faça login em sua conta e clique no botão Adicionar serviço no painel para criar um novo aplicativo.
- Se você for novo no aplicativo, conecte-se à sua conta do GitHub, GitLab ou Bitbucket e conceda permissões específicas.
- Preencha o formulário e adicione o valor
APP_KEY. Você pode encontrar o valor correspondente no arquivo .env.
- Selecione seus recursos de build e se você deseja usar o caminho de build do aplicativo ou compilar o aplicativo com o Dockerfile. Para esta demonstração, deixe o MyKinsta criar o aplicativo com base em seu repositório.
- Especifique os diferentes processos que você deseja executar durante a implantação. Por ora você pode deixá-lo em branco.
- Por fim, adicione seu método de pagamento.
Após confirmar o método de pagamento, o MyKinsta implementa seu aplicativo e atribui a você uma URL, conforme mostrado abaixo:
Você pode visitar o link, mas obtém uma página 500 | Server Error, porque o aplicativo precisa de uma conexão de banco de dados válida para funcionar. A seção a seguir resolve esse problema.
Crie um banco de dados via MyKinsta
- Para criar um banco de dados, vá ao painel MyKinsta e clique em Adicionar serviço.
- Selecione Banco de dados e preencha o formulário com o nome que deseja para o banco de dados, tipo, nome de usuário e senha. Adicione o local do centro de dados e um tamanho de banco de dados adequado ao seu aplicativo.
- A página seguinte exibirá um resumo dos custos e o seu método de pagamento. Clique em Criar banco de dados para concluir o processo.
- Após criar o banco de dados, o MyKinsta redireciona você para sua lista de serviços. Clique no banco de dados que você acabou de criar e role para baixo até Conexões externas. Copie as credenciais do banco de dados.
- Volte para a página de Implantação do aplicativo e clique em Configurações. Em seguida role para baixo até Variáveis de ambiente e clique em Adicionar variáveis de ambiente. Adicione as credenciais do banco de dados como variáveis de ambiente na seguinte ordem:
DB_CONNECTION=mysql
DB_HOST=External hostname
DB_PORT=External port
DB_DATABASE=Database name
DB_USERNAME=Username
DB_PASSWORD=PasswordAgora a lista de variáveis de ambiente do aplicativo deve estar assim:
- Vá para a página Deployments do aplicativo e implemente manualmente o aplicativo clicando em Deploy Now para aplicar as alterações. A essa altura, você já criou um banco de dados e o conectou ao seu aplicativo.
- Finalmente, para criar as tabelas no seu banco de dados MyKinsta, conecte o banco de dados ao seu aplicativo local atualizando o arquivo .env com as mesmas credenciais que você inseriu no seu aplicativo no MyKinsta, e execute o seguinte comando:
php artisan migrateEsse comando executa todos os arquivos de migração e cria todas as tabelas definidas no seu aplicativo MyKinsta.
Agora você já pode testar seu aplicativo com a URL atribuída após a primeira implantação.
Resumo
O Laravel é um framework abrangente para a criação de aplicativos web robustos e escaláveis que exigem funcionalidade CRUD. Com sua sintaxe intuitiva e recursos avançados, o Laravel facilita a criação de operações CRUD em seu aplicativo.
Este artigo abordou os conceitos fundamentais das operações CRUD e como implementá-las usando os recursos internos do Laravel. E também explicou:
- Como criar um banco de dados no MyKinsta e conectá-lo ao seu aplicativo
- Como usar as migrações do Laravel para definir a tabela do banco de dados, criar o arquivo do controlador e suas funções
- Como definir um template e conectá-lo ao controlador. O roteamento do Laravel gera arquivos Blade para criar páginas e formulários correspondentes, e para implementar e testar o aplicativo usando o MyKinsta
Agora que você já viu como é fácil realizar operações CRUD no Laravel, confira o MyKinsta para desenvolvimento e hospedagem de aplicativos da web.
Sou o líder da equipe editorial na Kinsta. Sou um entusiasta de código aberto e adoro programar. Com mais de 7 anos de experiência em redação e edição técnica para a indústria de tecnologia, adoro colaborar com pessoas para criar conteúdos claros e concisos e melhorar fluxos de trabalho.
Deixe um comentário