Laravel关联模型自动软删除实现及外键关联查询问询

Great question! Let's break this down step by step:

Laravel 5.2 doesn’t include a built-in, automatic mechanism that detects all model relationships and handles cascade deletes or delete restrictions out of the box. But you can implement this logic yourself—either on a per-model basis or with a reusable trait for broader use across your application.

Option 1: Per-Model Implementation Using Model Events #

You can leverage Laravel’s deleting model event to add custom logic before a model is deleted.

a) Simulate DELETE CASCADE (Cascade Delete) #

To automatically soft-delete or hard-delete related models when the parent model is deleted, add this to your model’s boot method:

protected static function boot()
{
    parent::boot();

    static::deleting(function ($model) {
        // Soft-delete related comments (matches Laravel's soft delete behavior)
        $model->comments()->delete();
        
        // For hard deletes (bypass soft delete entirely):
        // $model->comments()->forceDelete();
        
        // Repeat for other relationships (e.g., $model->attachments()->delete())
    });
}

b) Simulate DELETE RESTRICT (Throw Exception If Related Models Exist) #

To block deletion when associated records exist, check for related models in the deleting event and throw an exception:

protected static function boot()
{
    parent::boot();

    static::deleting(function ($model) {
        // Prevent deletion if any related comments exist
        if ($model->comments()->exists()) {
            throw new \RuntimeException("Cannot delete this model: it has associated comments.");
        }
        
        // Add checks for other relationships as needed
    });
}

Option 2: Reusable Trait for Scalable Handling #

For a more maintainable solution, create a trait that applies cascade/restrict logic based on model configuration. This way, you can reuse the logic across multiple models without repeating code.

Example Relationship Handler Trait #

trait RelationshipDeleteHandlerTrait
{
    public static function bootRelationshipDeleteHandlerTrait()
    {
        static::deleting(function ($model) {
            // Cascade delete specified relationships
            if (property_exists($model, 'cascadeDelete')) {
                foreach ($model->cascadeDelete as $relation) {
                    if (method_exists($model, $relation)) {
                        $model->{$relation}()->delete();
                    }
                }
            }

            // Restrict deletion if specified relationships have records
            if (property_exists($model, 'restrictDelete')) {
                foreach ($model->restrictDelete as $relation) {
                    if (method_exists($model, $relation) && $model->{$relation}()->exists()) {
                        throw new \RuntimeException("Cannot delete: associated {$relation} records exist.");
                    }
                }
            }
        });
    }
}

Use the Trait in Your Model #

class Post extends Model
{
    use SoftDeletes;
    use RelationshipDeleteHandlerTrait;

    // Define relationships to cascade delete when this model is deleted
    protected $cascadeDelete = ['comments', 'tags'];
    
    // Define relationships that block deletion if records exist
    protected $restrictDelete = ['author'];

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

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

There are three reliable ways to get foreign key information for a model:

1. Database-Level Query (Direct Foreign Key Constraints) #

Query your database’s system tables to fetch actual foreign key constraints. For MySQL, use this:

$model = new YourModel();
$tableName = $model->getTable();

$foreignKeys = \DB::select("
    SELECT 
        kcu.column_name as foreign_key,
        ccu.table_name as related_table,
        ccu.column_name as related_key
    FROM 
        information_schema.TABLE_CONSTRAINTS AS tc
        JOIN information_schema.KEY_COLUMN_USAGE AS kcu
          ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
        JOIN information_schema.REFERENTIAL_CONSTRAINTS AS rc
          ON tc.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
        JOIN information_schema.KEY_COLUMN_USAGE AS ccu
          ON rc.UNIQUE_CONSTRAINT_NAME = ccu.CONSTRAINT_NAME
    WHERE 
        tc.TABLE_NAME = ? AND tc.CONSTRAINT_TYPE = 'FOREIGN KEY'
", [$tableName]);

// Loop through results to view foreign key details
foreach ($foreignKeys as $fk) {
    echo "Foreign Key: {$fk->foreign_key}\n";
    echo "Related Table: {$fk->related_table}\n";
    echo "Related Key: {$fk->related_key}\n\n";
}

2. Laravel Schema Facade #

Use Laravel’s Schema builder to fetch foreign key info (works across supported databases):

$model = new YourModel();
$tableName = $model->getTable();

$foreignKeys = \Schema::getForeignKeys($tableName);

foreach ($foreignKeys as $fk) {
    echo "Foreign Key Column(s): " . implode(', ', $fk['columns']) . "\n";
    echo "Related Table: {$fk['foreign_table']}\n";
    echo "Related Column(s): " . implode(', ', $fk['foreign_columns']) . "\n\n";
}

3. Reflect on Model Relationships #

If you want to get relationships defined in your model (not just database-level constraints), use PHP reflection:

$model = new YourModel();
$reflection = new \ReflectionClass($model);
$publicMethods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);

$relationships = [];

foreach ($publicMethods as $method) {
    // Skip Laravel's internal methods
    if (str_starts_with($method->getName(), 'get') || $method->getName() === 'setKeysForSaveQuery') {
        continue;
    }

    try {
        $relation = $method->invoke($model);
        if ($relation instanceof \Illuminate\Database\Eloquent\Relations\Relation) {
            $relationships[] = [
                'name' => $method->getName(),
                'type' => class_basename($relation),
                'related_model' => class_basename($relation->getRelated()),
                'foreign_key' => $relation->getForeignKeyName(),
                'owner_key' => $relation->getOwnerKeyName()
            ];
        }
    } catch (\Exception $e) {
        // Skip methods that don't return a relationship
        continue;
    }
}

// Output relationship details
foreach ($relationships as $rel) {
    echo "Relationship Name: {$rel['name']}\n";
    echo "Type: {$rel['type']}\n";
    echo "Related Model: {$rel['related_model']}\n";
    echo "Foreign Key: {$rel['foreign_key']}\n";
    echo "Owner Key: {$rel['owner_key']}\n\n";
}

If you’re looking to build a more robust, package-like solution, combining the trait approach with reflection to auto-detect relationships (instead of manually defining $cascadeDelete/$restrictDelete) would be a great start—definitely something the Laravel community could benefit from!

内容的提问来源于stack exchange，提问作者Alex