Utilisation du Seeder du framework Laravel pour implémenter la fonction de remplissage automatique des données

Cet article présente principalement l'utilisation de Seeder par le framework Laravel pour réaliser la fonction de remplissage automatique des données. Il analyse les compétences opérationnelles et les précautions associées au remplissage automatique des données de Laravel basées sur la classe Seeder sous forme d'exemples. référez-vous à lui

L'exemple de cet article décrit comment le framework Laravel utilise Seeder pour implémenter la fonction de remplissage automatique des données. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Laravel remplit automatiquement les données à l'aide de la classe Seeder

<?php
use Illuminate\Database\Seeder;
use Illuminate\Database\Eloquent\Model;
class DatabaseSeeder extends Seeder
{
  /**
   * Run the database seeds.
   */
  public function run()
  {
    //
  }
}
class MyTableSeeder extends Seeder
{
  public function run()
  {
    //
  }
}

Votre Seeder personnalisé n'a qu'une seule fonction d'exécution, dans laquelle vous écrivez vos étapes de remplissage automatique

Vous remarquerez ces deux fonctions

Model::unguard();
//你的填充操作
Model::reguard();

J'étais très confus au sujet de ces deux fonctions. À quoi servent-elles? Je ne peux que spéculer sur le fait qu'il s'agit d'une fonction. paire de fonctions qui réagissent les unes contre les autres. J'ai donc vérifié le code source.

Ces deux fonctions sont définies sous Model.php sous le répertoire vendorlaravelframeworksrcIlluminateDatabaseEloquent

/**
* Disable all mass assignable restrictions.
*
* @param bool $state
* @return void
*/
public static function unguard($state = true)
{
    static::$unguarded = $state;
}
/**
* Enable the mass assignment restrictions.
*
* @return void
*/
public static function reguard()
{
    static::$unguarded = false;
}

En regardant les commentaires de l'auteur de Laravel, vous pouvez savoir qu'il y a des restrictions sur le remplissage des données fonctionnent.

Donc, unguard est à l'avant et unguard est à l'arrière. Unguard est responsable de la levée des restrictions sur les opérations de remplissage automatique et unguard est responsable du rétablissement des restrictions.

Avant de remplir l'opération, il est recommandé d'utiliser la fonction membre du modèle

Model::truncate();

Cette fonction effacera le tableau de données correspondant au modèle, veuillez donc l'utiliser avec prudence. .

<?php
use Illuminate\Database\Seeder;
use Illuminate\Database\Eloquent\Model;
class DatabaseSeeder extends Seeder
{
  /**
   * Run the database seeds.
   */
  public function run()
  {
    Model::unguard();
    $this->call(&#39;PostTableSeeder&#39;);
    Model::reguard();
  }
}
class PostTableSeeder extends Seeder
{
  public function run()
  {
    App\Post::truncate();
    factory(App\Post::class, 1000)->create();
  }
}

Certains lecteurs ici peuvent se demander : pourquoi n'écrivons-nous pas toutes les opérations de remplissage dans la fonction d'exécution du DatabaseSeeder intégré ?

Parce que lorsque nous développons un système complet, il peut y avoir de nombreux tableaux de données à remplir, et nous ne voulons pas avoir à modifier beaucoup la fonction d'exécution à chaque fois. Nous souhaitons également conserver le processus de remplissage à chaque fois que nous remplissons, nous préférons donc écrire une nouvelle classe puis l'appeler avec la fonction $this->call().

Parlons ensuite de l’usine.

Répertoire de fichiersdatabasefactoriesModelFactory.php

$factory->define(App\Post::class, function ($faker) {
  return [
    'title' => $faker->sentence(mt_rand(3, 10)),
    'content' => join("\n\n", $faker->paragraphs(mt_rand(3, 6))),
    'published_at' => $faker->dateTimeBetween('-1 month', '+3 days'),
  ];
});

Bien que je puisse le comprendre, je ne sais pas ce qu'est la variable $factory ? Vérifiez donc la classe Factory pour la trouver.

Trouvez le code source

/**
* Define a class with a given set of attributes.
*
* @param string $class
* @param callable $attributes
* @param string $name
* @return void
*/
public function define($class, callable $attributes, $name = 'default')
{
    $this->definitions[$class][$name] = $attributes;
}

/**
* Create an instance of the given model and persist it to the database.
*
* @param string $class
* @param array $attributes
* @return mixed
*/
public function create($class, array $attributes = [])
{
    return $this->of($class)->create($attributes);
}

pour commencer à remplir les données. Nous utilisons toujours la ligne de commande artisanale.

php artisan db:seed

Cette commande exécutera les fonctions d'exécution de toutes les classes que vous avez écrites dans DatabaseSeeder.php Si le projet devient compliqué à l'avenir, il n'est pas nécessaire d'exécuter celles qui ont déjà été exécutées, alors ajoutez des paramètres après la ligne de commande et exécutez simplement l'exécution d'une certaine classe. Utilisez simplement la fonction

php artisan db:seed --class=你要执行的类名称

Ce qui précède est l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois !

Recommandations associées :

À propos des opérations de liaison des routes et des contrôleurs du framework Laravel

Pour le cycle de vie du framework Laravel Analyse des principes

Paramètres de routage du framework Laravel

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!