Arquitetura e Design Patterns em Laravel
Dominar Laravel avançado começa pelo entendimento profundo de sua arquitetura. O padrão MVC tradicional é apenas a base. Em projetos reais, você precisa conhecer Repository Pattern, Service Layer e Dependency Injection para manter código escalável e testável. A Container de IoC do Laravel é poderosa, mas muitos desenvolvedores não a exploram adequadamente.
// Service Layer para separação de responsabilidades
namespace App\Services;
class PaymentService {
private PaymentRepository $repository;
public function __construct(PaymentRepository $repository) {
$this->repository = $repository;
}
public function processPayment(Order $order): bool {
$transaction = $this->repository->create([
'order_id' => $order->id,
'amount' => $order->total,
'status' => 'pending'
]);
try {
// Integração com gateway
$response = $this->chargeCard($order->payment_method);
$transaction->update(['status' => 'completed', 'gateway_id' => $response->id]);
return true;
} catch (Exception $e) {
$transaction->update(['status' => 'failed', 'error' => $e->getMessage()]);
return false;
}
}
}
// No Controller: injeção automática
public function checkout(PaymentService $service) {
$service->processPayment($this->order);
}
Otimização de Performance e Queries
A maioria dos problemas de performance em Laravel vem de queries ineficientes. Você precisa dominar Eager Loading, Query Optimization e Caching estratégico. O comando debugbar é seu melhor amigo durante desenvolvimento, mas implementar índices no banco de dados é obrigação em produção.
// ❌ Problema: N+1 queries
$users = User::all();
foreach ($users as $user) {
echo $user->posts->count(); // Query por usuário
}
// ✅ Solução: Eager Loading
$users = User::with('posts')->get();
foreach ($users as $user) {
echo $user->posts->count(); // Sem queries adicionais
}
// ✅ Caching inteligente
$topProducts = Cache::remember('top_products', 3600, function () {
return Product::where('active', true)
->withCount('orders')
->orderByDesc('orders_count')
->limit(10)
->get();
});
// ✅ Chunking para grandes datasets
User::chunk(1000, function ($users) {
foreach ($users as $user) {
// Processar 1000 de uma vez
SendEmailJob::dispatch($user);
}
});
Filas, Jobs e Background Processing
Operações pesadas devem ser assíncronas. Jobs no Laravel transformam tarefas longas em processamento em background, mantendo seu usuário feliz. Redis é a melhor opção para fila em produção, e você deve conhecer como implementar retry logic e deadline handling adequadamente.
// Job com retry e timeout
namespace App\Jobs;
class ProcessLargeExport implements ShouldQueue {
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
public $tries = 5;
public $timeout = 300; // 5 minutos
public $backoff = [10, 30, 60, 120, 300]; // Espera progressiva
public function __construct(private Report $report) {}
public function handle() {
try {
$this->report->export();
event(new ReportExported($this->report));
} catch (Exception $e) {
if ($this->attempts() > 2) {
Mail::send(new ExportFailedMail($this->report, $e));
}
throw $e;
}
}
public function failed(Exception $exception) {
$this->report->markAsFailed($exception->getMessage());
}
}
// Dispatch com delay
ProcessLargeExport::dispatch($report)->delay(now()->addMinutes(5));
Autenticação Avançada e Autorização
Laravel oferece mais que autenticação básica. Você precisa implementar role-based access control (RBAC), dois fatores e auditoria. Policies e Gates são fundamentais para autorização granular em aplicações complexas.
// Policy com lógica avançada
namespace App\Policies;
class PostPolicy {
public function update(User $user, Post $post): bool {
// Autor ou admin
return $user->id === $post->user_id || $user->isAdmin();
}
public function delete(User $user, Post $post): bool {
// Só admin ou autor (se publicado há menos de 1 hora)
if ($user->isAdmin()) return true;
if ($user->id === $post->user_id && $post->published_at?->diffInMinutes() < 60) {
return true;
}
return false;
}
}
// No Controller
public function update(Post $post) {
$this->authorize('update', $post); // Valida policy automaticamente
$post->update(request()->validated());
}
// Duas Fatores com Fortify
use Laravel\Fortify\Fortifiable;
class User extends Model {
use Fortifiable;
public function hasTwoFactorEnabled(): bool {
return $this->two_factor_secret !== null;
}
}
Testes Automatizados e Qualidade
Não escreva código que não passa em testes. Em projetos reais, testes economizam horas de debugging. PHPUnit com fixtures do Laravel permite testar desde queries até fluxos completos de API com facilidade. Cobertura acima de 80% é o padrão que você deve buscar.
// Feature Test: testa fluxo real
namespace Tests\Feature;
class OrderFlowTest extends TestCase {
public function test_complete_purchase_flow() {
$user = User::factory()->create();
$product = Product::factory()->create(['price' => 99.90]);
// Simula requisição autenticada
$response = $this->actingAs($user)
->postJson('/api/orders', [
'items' => [['product_id' => $product->id, 'quantity' => 2]]
])
->assertStatus(201);
$order = Order::findOrFail($response->json('id'));
$this->assertEquals(199.80, $order->total);
// Verifica envio de email
Mail::assertSent(OrderConfirmation::class);
}
public function test_payment_failure_handling() {
$this->mock(PaymentGateway::class, function ($mock) {
$mock->shouldReceive('charge')->andThrow(PaymentException::class);
});
$response = $this->actingAs(User::factory()->create())
->postJson('/api/orders/1/pay')
->assertStatus(422);
}
}
Conclusão
Dominar Laravel avançado exige três pilares: primeiro, entender padrões de design e arquitetura (Service Layer, Repository Pattern) para código escalável; segundo, otimizar relentlessly com eager loading, caching e background jobs porque performance importa; terceiro, implementar testes como parte do desenvolvimento, não como reflexão tardia. Projetos reais exigem profundidade nesses temas, não superficialidade em muitos.