Introdução ao Laravel: estrutura e filosofia

1. O que é o Laravel e sua filosofia central

1.1. História e propósito do framework

Criado por Taylor Otwell em 2011, o Laravel surgiu como uma alternativa mais expressiva e elegante ao CodeIgniter, que na época era o framework PHP mais popular. O objetivo principal era oferecer uma ferramenta que tornasse tarefas comuns como autenticação, roteamento e cache muito mais simples e intuitivas. Hoje, o Laravel é o framework PHP mais utilizado no mundo, com uma comunidade ativa e um ecossistema robusto.

1.2. Princípios fundamentais: convenção sobre configuração e elegância

Dois pilares sustentam a filosofia do Laravel: convenção sobre configuração e código expressivo. No primeiro, o framework assume decisões sensatas por padrão, reduzindo a quantidade de configurações necessárias para iniciar um projeto. No segundo, a sintaxe é pensada para ser limpa e legível, aproximando o código da linguagem natural.

// Exemplo de código expressivo no Laravel
$user = User::where('active', true)
            ->orderBy('name')
            ->first();

1.3. Ecossistema Laravel: Forge, Vapor, Nova e outros componentes

O Laravel não é apenas um framework, mas um ecossistema completo:

• Laravel Forge: gerenciamento de servidores e deploy automatizado
• Laravel Vapor: plataforma serverless para deploy em AWS Lambda
• Laravel Nova: painel administrativo elegante e poderoso
• Laravel Horizon: monitoramento de filas com interface visual
• Laravel Telescope: debug e monitoramento de requisições

2. Estrutura de diretórios e organização do projeto

2.1. Raiz do projeto

Ao criar um novo projeto Laravel, você encontra a seguinte estrutura:

meu-projeto/
├── app/           # Código principal da aplicação
├── bootstrap/     # Arquivos de inicialização do framework
├── config/        # Arquivos de configuração
├── database/      # Migrations, seeders e factories
├── public/        # Ponto de entrada pública (index.php)
├── resources/     # Views Blade, assets não compilados
├── routes/        # Definição de rotas da aplicação
├── storage/       # Logs, cache, arquivos de sessão
└── tests/         # Testes automatizados

2.2. O padrão MVC no Laravel

O Laravel segue o padrão Model-View-Controller de forma natural:

• Models (app/Models/): representam dados e lógica de negócio
• Views (resources/views/): templates Blade para apresentação
• Controllers (app/Http/Controllers/): intermediários entre models e views

// Exemplo de Controller
namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('users.index', compact('users'));
    }
}

2.3. Arquivos de configuração e o ambiente .env

O arquivo .env armazena configurações sensíveis como credenciais de banco de dados e chaves de API. Já os arquivos em config/ contêm configurações públicas que podem ser acessadas via helper config().

// Acessando configurações
$database = config('database.default');
$appName = env('APP_NAME', 'Laravel');

3. O ciclo de vida de uma requisição HTTP

3.1. Entrada pública: o arquivo index.php

Toda requisição passa pelo public/index.php, que carrega o autoload do Composer e inicializa o framework:

// public/index.php (simplificado)
require __DIR__.'/../vendor/autoload.php';
$app = require_once __DIR__.'/../bootstrap/app.php';
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
$response = $kernel->handle(
    $request = Illuminate\Http\Request::capture()
);
$response->send();
$kernel->terminate($request, $response);

3.2. Kernel HTTP e a pilha de middlewares

O Kernel HTTP gerencia a pilha de middlewares global e de grupos. Middlewares executam ações antes e depois da requisição ser processada pelo controller.

// Exemplo de middleware personalizado
namespace App\Http\Middleware;

use Closure;

class EnsureUserIsActive
{
    public function handle($request, Closure $next)
    {
        if (! $request->user()->is_active) {
            return redirect('login');
        }
        return $next($request);
    }
}

3.3. Roteamento, controllers e resposta final

O roteador encaminha a requisição para o controller apropriado, que processa a lógica e retorna uma resposta (view, JSON, redirect, etc).

4. Roteamento: a porta de entrada da aplicação

4.1. Rotas básicas e parâmetros

As rotas são definidas no arquivo routes/web.php (para interface web) ou routes/api.php (para APIs).

// Rotas básicas
Route::get('/hello', function () {
    return 'Hello World';
});

Route::post('/users', [UserController::class, 'store']);

// Parâmetros de rota
Route::get('/user/{id}', function ($id) {
    return "Usuário {$id}";
});

// Parâmetros opcionais
Route::get('/search/{query?}', function ($query = null) {
    return $query ?? 'Nenhum termo de busca';
});

4.2. Grupos de rotas, prefixos e namespaces

Route::prefix('admin')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard']);
    Route::get('/users', [AdminController::class, 'users']);
});

Route::middleware(['auth'])->group(function () {
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::post('/profile', [ProfileController::class, 'update']);
});

4.3. Rotas nomeadas e redirecionamentos

Route::get('/profile', [ProfileController::class, 'show'])->name('profile.show');

// Gerando URL a partir do nome da rota
$url = route('profile.show');

// Redirecionamento
return redirect()->route('profile.show');

5. Controllers e a camada de apresentação

5.1. Controllers básicos e Resource Controllers

Controllers organizam a lógica de requisições HTTP. Resource Controllers fornecem métodos pré-definidos para operações CRUD.

// Gerando um Resource Controller
// php artisan make:controller PostController --resource

class PostController extends Controller
{
    public function index() { /* Listar posts */ }
    public function create() { /* Formulário de criação */ }
    public function store(Request $request) { /* Salvar novo post */ }
    public function show($id) { /* Exibir post específico */ }
    public function edit($id) { /* Formulário de edição */ }
    public function update(Request $request, $id) { /* Atualizar post */ }
    public function destroy($id) { /* Excluir post */ }
}

// Registrando Resource Controller
Route::resource('posts', PostController::class);

5.2. Injeção de dependência em controllers

O Laravel resolve automaticamente as dependências dos controllers através do Service Container:

use App\Services\PaymentGateway;

class OrderController extends Controller
{
    protected $paymentGateway;

    public function __construct(PaymentGateway $paymentGateway)
    {
        $this->paymentGateway = $paymentGateway;
    }

    public function process(Order $order)
    {
        $this->paymentGateway->charge($order);
    }
}

5.3. Views Blade: templates, layouts e componentes

Blade é o motor de templates do Laravel, permitindo herança de layouts e componentes reutilizáveis:

{{-- resources/views/layouts/app.blade.php --}}
<html>
<head>
    <title>@yield('title')</title>
</head>
<body>
    <div class="container">
        @yield('content')
    </div>
</body>
</html>

{{-- resources/views/posts/index.blade.php --}}
@extends('layouts.app')

@section('title', 'Lista de Posts')

@section('content')
    @foreach($posts as $post)
        <div class="post">
            <h2>{{ $post->title }}</h2>
            <p>{{ $post->excerpt }}</p>
        </div>
    @endforeach
@endsection

6. Models, Eloquent ORM e bancos de dados

6.1. Migrations: versionamento de esquema do banco

Migrations permitem versionar e compartilhar alterações no banco de dados:

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

class CreatePostsTable extends Migration
{
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained();
            $table->string('title');
            $table->text('body');
            $table->timestamps();
        });
    }

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

6.2. Eloquent ORM: definição de models e consultas básicas

Eloquent é o ORM ativo do Laravel, proporcionando uma sintaxe elegante para interagir com o banco:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = ['title', 'body', 'user_id'];

    // Consultas básicas
    $posts = Post::where('user_id', 1)->get();
    $post = Post::find(1);
    $activePosts = Post::where('published', true)->orderBy('created_at', 'desc')->get();

    // Inserção
    Post::create(['title' => 'Novo Post', 'body' => 'Conteúdo...']);
}

6.3. Relacionamentos e convenções de nomenclatura

Eloquent suporta todos os tipos de relacionamentos de banco de dados:

class User extends Model
{
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

class Post extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }

    public function comments()
    {
        return $this->hasMany(Comment::class);
    }

    public function tags()
    {
        return $this->belongsToMany(Tag::class);
    }
}

// Uso dos relacionamentos
$user = User::find(1);
$posts = $user->posts; // Coleção de posts do usuário

$post = Post::find(1);
$author = $post->user; // Usuário autor do post

7. Service Container e Service Providers

7.1. O Service Container: ligação e resolução de classes

O Service Container gerencia dependências e permite injeção automática:

// Ligação de interface a implementação
$this->app->bind(PaymentInterface::class, StripePayment::class);

// Resolução automática
$payment = app(PaymentInterface::class);

7.2. Service Providers: onde registrar bindings e eventos

Service Providers são o ponto central para configurar serviços no Laravel:

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->singleton(CurrencyConverter::class, function ($app) {
            return new CurrencyConverter(config('services.currency.api_key'));
        });
    }

    public function boot()
    {
        // Configurações executadas após todos providers serem registrados
    }
}

7.3. Facades: acesso estático a serviços do container

Facades fornecem uma interface estática para classes do container:

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;

// Exemplo de uso de Facades
Cache::put('key', 'value', 600);
$users = DB::table('users')->get();

8. Artisan CLI e produtividade no desenvolvimento

8.1. Comandos essenciais

Artisan é a interface de linha de comando do Laravel, oferecendo dezenas de comandos úteis:

# Comandos essenciais
php artisan make:controller UserController
php artisan make:model Post -m  # Cria model com migration
php artisan migrate
php artisan route:list
php artisan tinker  # REPL interativo
php artisan cache:clear

8.2. Geração automática de código e scaffolding

O Artisan pode gerar classes completas com poucos comandos:

# Geração de código
php artisan make:model Product --all  # Model, migration, controller, factory, seeder
php artisan make:mail OrderShipped    # Classe de e-mail
php artisan make:event UserRegistered # Classe de evento
php artisan make:job ProcessVideo     # Job para filas

8.3. Customização de comandos Artisan

Você pode criar comandos personalizados para automatizar tarefas específicas:

namespace App\Console\Commands;

use Illuminate\Console\Command;

class GenerateSitemap extends Command
{
    protected $signature = 'sitemap:generate {--force}';
    protected $description = 'Gera o sitemap do site';

    public function handle()
    {
        $this->info('Gerando sitemap...');
        // Lógica de geração
        $this->info('Sitemap gerado com sucesso!');
    }
}

O Laravel representa uma evolução significativa na forma como desenvolvemos aplicações PHP, combinando elegância de código com produtividade. Sua filosofia centrada no desenvolvedor, aliada a um ecossistema maduro, torna o framework a escolha ideal tanto para iniciantes quanto para projetos enterprise complexos.

Referências

• Documentação oficial do Laravel — Documentação completa do framework, incluindo guias de instalação, estrutura, roteamento, Eloquent e Artisan.
• Laravel: The PHP Framework for Web Artisans — Site oficial com overview do ecossistema, tutoriais e recursos para iniciantes.
• Laravel News — Portal com notícias, tutoriais e artigos técnicos sobre o ecossistema Laravel.
• Laracasts: Laravel From Scratch — Série de vídeo-tutoriais gratuitos cobrindo fundamentos do Laravel para iniciantes.
• Laravel Daily — Blog com tutoriais práticos, dicas e exemplos de código para desenvolvimento com Laravel.
• GitHub do Laravel — Repositório oficial do framework, onde você pode explorar o código-fonte e contribuir.
• Laravel Bootcamp — Tutorial interativo oficial que ensina a construir uma aplicação completa com Laravel do zero.