Tutorial Avançado de Laravel: Eloquent ORM e Relacionamentos Polimórficos

O Laravel Eloquent ORM oferece recursos avançados que transformam o desenvolvimento de aplicações PHP complexas. Entre esses recursos, os relacionamentos polimórficos destacam-se como uma solução elegante para arquiteturas de banco de dados flexíveis, permitindo que um modelo se relacione com múltiplos outros modelos através de uma única associação.

O que são Relacionamentos Polimórficos?

Relacionamentos polimórficos permitem que um modelo seja associado a diferentes tipos de modelos usando uma única relação. Este padrão resolve problemas arquiteturais comuns onde múltiplas entidades compartilham comportamentos similares.

Considere um sistema onde usuários podem comentar em posts, vídeos e produtos. Tradicionalmente, seria necessário criar três tabelas diferentes: post_comments, video_comments e product_comments. Com relacionamentos polimórficos, uma única tabela comments gerencia todos os comentários.

Implementação Prática: Sistema de Comentários

Vamos construir um sistema onde comentários podem ser aplicados a diferentes tipos de conteúdo. Primeiro, criamos o modelo Comment:

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

Configurando as Migrações

A migração da tabela comments utiliza o método morphs() que cria automaticamente as colunas necessárias:

id();
            $table->text(\'body\');
            $table->morphs(\'commentable\'); // Cria commentable_id e commentable_type
            $table->foreignId(\'user_id\')->constrained();
            $table->timestamps();
        });
    }
}

Modelos que Recebem Comentários

Os modelos Post e Video implementam a relação inversa usando morphMany():

morphMany(Comment::class, \'commentable\');
    }
}

class Video extends Model
{
    protected $fillable = [\'title\', \'url\', \'duration\', \'user_id\'];
    
    public function comments()
    {
        return $this->morphMany(Comment::class, \'commentable\');
    }
}

Utilizando os Relacionamentos

Com a estrutura configurada, podemos criar e consultar comentários de forma intuitiva:

comments()->create([
    \'body\' => \'Excelente artigo!\',
    \'user_id\' => auth()->id()
]);

$video = Video::find(1);
$video->comments()->create([
    \'body\' => \'Vídeo muito informativo!\',
    \'user_id\' => auth()->id()
]);

// Consultar comentários
$postComments = $post->comments()->with(\'user\')->get();
$videoComments = $video->comments()->latest()->take(5)->get();

// Encontrar o modelo pai de um comentário
$comment = Comment::find(1);
$parentModel = $comment->commentable; // Retorna Post ou Video

Relacionamentos Polimórficos Many-to-Many

O Laravel também suporta relacionamentos polimórficos many-to-many através de morphToMany() e morphedByMany(). Útil para sistemas de tags onde múltiplos modelos podem ter múltiplas tags:

morphedByMany(Post::class, \'taggable\');
    }
    
    public function videos()
    {
        return $this->morphedByMany(Video::class, \'taggable\');
    }
}

class Post extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, \'taggable\');
    }
}

Comparação com Outros Tipos de Relacionamentos

Otimização e Melhores Práticas

Para maximizar performance com relacionamentos polimórficos, considere estas estratégias:

• Indexação: Crie índices compostos nas colunas commentable_type e commentable_id
• Eager Loading: Use with() para evitar o problema N+1
• Scopes: Crie scopes para consultas específicas por tipo
• Caching: Implemente cache para consultas frequentes

whereHasMorph(\'commentable\', [Post::class, Video::class])
    ->latest()
    ->paginate(20);

// Scope para filtrar por tipo
class Comment extends Model
{
    public function scopeForType($query, $type)
    {
        return $query->where(\'commentable_type\', $type);
    }
}

Os relacionamentos polimórficos no Laravel oferecem uma abordagem elegante para arquiteturas complexas, reduzindo duplicação de código e mantendo flexibilidade. Explore mais recursos avançados de desenvolvimento web para criar aplicações robustas e escaláveis.