API Web com Laravel e PHP: Parte 1

Rafael Cárdenas

• 7 min read
API Web com Laravel e PHP: Parte 1

Laravel é um framework PHP popular e poderoso, projetado para desenvolver aplicativos web full-stack de forma fácil e rápida, permitindo que nos concentremos apenas na lógica de negócios e nas regras de nosso aplicativo, em vez de gastar tempo escrevendo as camadas inferiores que teremos resolvido. Neste guia, exploraremos como criar uma API do zero com esta ferramenta, para qualquer aplicativo que você precisar.

Nesta ocasião, escreveremos uma API para um blog básico no qual haverá entradas, autores e comentários. Vamos lidar com a codificação de dados no formato JSON. Nesta primeira parte, vamos nos concentrar na configuração inicial da API e na criação das primeiras entradas, deixando o resto para etapas posteriores.

Instalação

Antes de começar, é importante ter os seguintes pacotes de software instalados: um IDE ou editor de texto (VSCode, Sublime, Vim, etc.) e Docker, com os quais instalaremos e gerenciaremos todas as dependências do nosso projeto.

O Laravel 9 possui uma ferramenta chamada Sail que funciona como uma interface entre o desenvolvedor e o Docker, o que nos permitirá manipular nosso ambiente de desenvolvimento de forma simples.

Para instalar o Laravel e todas as suas dependências com o Sail, devemos primeiro ter certeza de que o Docker está rodando em nosso computador. Então, você deve executar o seguinte comando no terminal:

curl -s "https://laravel.build/api-exemplo?with=mysql" | bash

Escolhemos o MySQL como o mecanismo de banco de dados que armazenará todas as informações de nossa API. Se preferir, você pode substituir “api-example” pelo nome do seu aplicativo neste e em todos os comandos subsequentes deste guia.

Quando a instalação estiver concluída, você deve navegar para o novo diretório que contém nosso novo aplicativo da web...

cd api-exemplo

…e nosso projeto

./vendor/bin/sail up

Se fizemos tudo certo, podemos visitar http://localhost/ em nosso navegador para ver a tela inicial do Laravel. Isso garante que já temos o Laravel e todas as suas dependências instaladas corretamente.

Se você deseja inspecionar ou modificar as variáveis ​​de configuração que o Sail adiciona automaticamente, você pode encontrá-las a qualquer momento no arquivo.env na raiz do diretório do projeto.

Como precisaremos executar o Sail várias vezes neste guia, é recomendável configurar um alias em seu ambiente bash. Adicione esta linha ao seu arquivo de configuração do ambiente shell (geralmente .bashrc ou .zshrc em sua pasta pessoal) e reinicie o terminal:

alias sail='[ -f sail ] && sh sail || sh vendor/bin/sail'

Agora sim! Estamos prontos para começar a construir nossa API.

Modelo

Para criar e armazenar uma postagem no blog, precisamos informar ao Laravel que pretendemos armazenar essas informações em nosso banco de dados. Para isso vamos criar um modelo, que é uma classe PHP que representa um objeto e todas as suas propriedades que queremos armazenar e servir através da API.

O Laravel possui um motor de modelo muito poderoso chamado Eloquent, que não só nos permite definir modelos, mas também os relacionamentos entre eles e como estes são traduzidos em consultas de banco de dados. Além disso, possui comandos que permitem gerar modelos e outros arquivos automaticamente.

Para gerar nosso primeiro modelo BlogPost, executaremos o seguinte comando:

sail artisan make:model -m BlogPost

Isso irá gerar dois arquivos:

  • app/Models/BlogPost.php (Nossa aula de BlogPost)
  • database/migrations/2022_09_05_040815_create_blog_posts_table.php

A migração que cria a tabela blog_posts no banco de dados. O nome deste arquivo mudará dependendo da data em que você o gerou.

Primeiro, precisamos especificar quais campos queremos armazenar em nossa tabela de postagens do blog. Para isso, navegue até o novo arquivo de migração e edite-o para que fique assim:

<?php

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

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('blog_posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('blog_posts');
    }
};

Com isso, adicionamos as colunas de título e conteúdo que conterão o título e o conteúdo da postagem do blog, respectivamente. Para aplicar as alterações ao banco de dados, vamos executar este comando:

sail artisan migrate

Com isso, adicionamos as colunas de título e conteúdo que conterão o título e o conteúdo da postagem do blog, respectivamente. Para aplicar as alterações ao banco de dados, vamos executar este comando:

<?php

namespace App\Models;

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

class BlogPost extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'content'];
}

Agora, criaremos a visualização que traduzirá essas postagens do blog em objetos JSON para retornar em nossa API.

Visualização

Precisamos gerar um objeto que nos ajude a transformar todos os posts do blog em objetos JSON para retornar à nossa API quando estiverem prontos. O Laravel nomeia essas classes como Resources. Vamos criar um para nossa postagem no blog com este comando:

sail artisan make:resource BlogPostResource

Isso gerará o arquivo app/Http/Resources/BlogPostResource.php, que precisamos modificar para ter o seguinte conteúdo:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class BlogPostResource extends JsonResource
{
    /**
     * Transform the resource into an array.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
     */
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'content' => $this->content,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at
        ];
    }
}

Como você pode ver, aqui definimos quais são os campos de nossas postagens de blog que queremos expor à API através do método toArray. Feito isso, podemos começar a editar nosso controller.

Controlador

O Laravel também pode nos ajudar a gerar o controlador que precisamos para lidar com todos os posts do blog. Um controlador é uma classe que lida com as regras de negócios relacionadas a um modelo, por exemplo, como elas são criadas, exibidas, editadas, etc.

Vamos gerar nosso controller com este comando:

sail artisan make:controller BlogPostController --model=BlogPost --api

Isso gerará o arquivo app/Http/Controllers/BlogPostController.php que modificaremos para poder salvar novos posts, listá-los, editá-los ou excluí-los.

Criar uma postagem no blog

Para criar postagens, precisamos modificar o método store no BlogPostController para ter o seguinte:

public function store(Request $request)
{
    $request->validate([
        'title' => ['required', 'string'],
        'content' => ['required', 'string']
    ]);
    $post = BlogPost::create([
        'title' => $request->get('title'),
        'content' => $request->get('content')
    ]);
    return new BlogPostResource($post);
}

Como pode ser visto, o Laravel nos ajuda a validar que os valores de título e conteúdo que nos são enviados na API são do tipo de dados correto. Em seguida, usamos esses dados para criar um novo BlogPost e, finalmente, o devolvemos ao recurso que construímos anteriormente.

Para testar se nossa API está funcionando corretamente, primeiro precisamos registrar o controlador em uma rota em nossa API.

Para isso, basta adicionar esta linha ao arquivo routes/api.php:

Route::resource('blog-posts', BlogPostController::class);

Com isso, podemos executar esta requisição a partir do console:

curl --request POST \
  --url 'http://localhost/api/blog-posts/?=' \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --data '{
	"title": "Ola Mundo",
	"content": "Esta é a minha primeira postagem no blog"
}'

Se fizermos tudo certo, veremos uma resposta semelhante à seguinte:

{"data":{"id":1,"title":"Hello World","content":"Esta é minha primeira postagem no blog","created_at":"2022-09-06T03:19:51.000000Z " ,"updated_at":"2022-09-06T03:19:51.000000Z"}}%

Parabéns! Você acabou de criar sua primeira postagem usando sua nova API.

Para consultar a entrada que acabamos de criar, precisamos modificar o método show em nosso controlador para que ele contenha o seguinte:

public function show(BlogPost $blogPost)
{
    return new BlogPostResource($blogPost);
}

O Laravel procurará automaticamente o objeto correto com base na rota que enviamos para a API. Podemos consultar este comando no console:

curl --request GET \
  --url 'http://localhost/api/blog-posts/1?=' \
  --header 'Accept: application/json'

Receberemos a mesma resposta da seção anterior:

{"data":{"id":1,"title":"Hello World","content":"Esta é minha primeira postagem no blog","created_at":"2022-09-06T03:19:51.000000Z " ,"updated_at":"2022-09-06T03:19:51.000000Z"}}%

Também precisaremos de uma maneira de consultar uma lista de todas as entradas que criamos. Para fazer isso, modificaremos o método index:

public function index()
{
    return BlogPostResource::collection(BlogPost::all());
}

Feito o acima, veremos que ele nos traz uma lista de todas as entradas que existem até agora:

curl --request GET \
  --url 'http://localhost/api/blog-posts?=' \
  --header 'Accept: application/json'

{"data":[{"id":1,"title":"Olá Mundo","content":"Esta é minha primeira postagem no  blog","created_at":"2022-09-06T03:19:51.000000Z","updated_at":"2022-09-06T03:19:51.000000Z"}]}%

Editar ou excluir entradas

Para editar uma entrada, precisamos modificar o método de atualização da seguinte forma:

public function update(Request $request, BlogPost $blogPost)
{
    $attributes = $request->validate([
        'title' => ['required', 'string'],
        'content' => ['required', 'string']
    ]);
    $blogPost->update($attributes);
    return new BlogPostResource($blogPost);
}

Em seguida, tentaremos este comando no terminal. Observe como usamos PUT para editar a entrada:

curl --requer PUT \
   --url 'http://localhost/api/blog-posts/1?=' \
   --header 'Aceitar: aplicativo/json' \
   --header 'Tipo de conteúdo: aplicativo/json' \
   --dados '{
"title": "Olá Mundo",
"content": "Edição de teste"
}'

{"data":{"id":1,"title":"Hello World","content":"Editar teste","created_at":"2022-09-06T03:19:51.000000Z","updated_at " :"2022-09-06T03:19:51.000000Z"}}%

Finalmente, para remover a entrada, modificamos destroy da seguinte forma:

public function destroy(BlogPost $blogPost)
{
    $blogPost->delete();
}

E tentamos com DELETE:

curl --requer DELETE \
   --url 'http://localhost/api/blog-posts/1?=' \
   --header 'Aceitar: aplicativo/json' \
   --header 'Tipo de conteúdo: aplicativo/json' \

Conclusão

Acabamos de criar uma API muito simples para adições, cancelamentos e alterações simples de postagens de blog. Também demonstramos como usar o Laravel para realizar essa tarefa em apenas alguns minutos e seu poder de validar dados, manipular rotas, fazer interface com o banco de dados, etc. Esta é apenas uma amostra da capacidade desta ferramenta de gerar APIs extremamente robustas, úteis para aplicações muito grandes em produção.

Na próxima parte, adicionaremos usuários por meio de endpoints de registro e login e aprenderemos a lidar com tokens com Laravel para garantir a segurança dos dados de cada usuário. Fique ligado(a) no nosso blog!

🛑
As opiniões e comentários expressos neste artigo são de propriedade exclusiva de seu autor e não representam necessariamente o ponto de vista da Revelo. A Revelo Content Network acolhe todas as raças, etnias, nacionalidades, credos, gêneros, orientações, pontos de vista e ideologias, desde que promovam diversidade, equidade, inclusão e crescimento na carreira dos profissionais de tecnologia.