The steps of Laravel seed filling database include creating and running a Seeder, generating real data in conjunction with the factory, and organizing multiple Seeders. 1. Create a Seeder You can use the Artisan command or edit DatabaseSeeder.php and define the insert data logic in the run() method. 2. Run Seeder Use the php artisan db:seed command to specify a specific class or combine the migration command php artisan migrate:fresh --seed to reset and refill. 3. Use the factory to generate dynamic data, create a factory file through php artisan make:factory, define the Faker data template in the factory, and call the factory() method in Seeder to create multiple records. 4. When organizing multiple Seeders, split them according to the model or function, such as UsersTableSeeder, CategoriesTableSeeder, etc., and call them in dependency order in the main DatabaseSeeder to ensure that the parent record is inserted before the child record.

When you're building a Laravel application, one of the most important steps during development is populating your database with realistic data for testing and demos. This is where Laravel seeders come in handy — they let you fill your tables with sample data quickly and consistently.

The key idea here is to make your test data look real enough that it helps catch edge cases, improves UI previews, and make debugging easier.

What Are Seeders and Why Use Them?

In Laravel, seeders are classes used to insert dummy or sample data into your database tables. They're especially useful during development and testing phases when you don't want to manually enter data every time you reset your database.

You might use them:

• To create default users or roles
• To pre-fill categories or settings
• To generate realistic test data for features like search or filters

Laravel's seeder system works well with factories , which help generate dynamic, randomized data instead of hardcoding values ??each time.

How to Create and Run a Seeder

Creating a seeder is straightforward. You can either use the Artisan command:

 php artisan make:seeder UsersTableSeeder

Or edit the default DatabaseSeeder.php file located in database/seeders .

Once created, define what data should be inserted inside the run() method. For example:

 public function run()
{
    DB::table('users')->insert([
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => bcrypt('password'),
    ]);
}

To run the seeder:

 php artisan db:seed

If you want to run a specific seeder class:

 php artisan db:seed --class=UsersTableSeeder

You can also combine this with migrations using:

 php artisan migrate:fresh --seed

This resets your database and re-runs all migrations and seeders — great for starting fresh during development.

Using Factoryes with Seeders for Realistic Data

Hardcoding data in seeders gets tedious fast. That's where model factories shine. Factory allow you to define templates for your models and generate multiple records easily.

First, create a factory (if not already done):

 php artisan make:factory UserFactory --model=User

Then define how data should be generated in the factory file:

 $factory->define(User::class, function (Faker $faker) {
    Return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => bcrypt('password'), // default password for easy login
    ];
});

Now in your seeder, you can do something like:

 public function run()
{
    \App\Models\User::factory(10)->create();
}

This creates 10 users with realistic fake data, including names, emails, and passwords.

Some tips:

• Adjust the number passed to factory() based on your needs
• Chain methods like create() or make() depending on whether you want to save to the DB
• Use Faker extensively for fields like addresses, phone numbers, dates, etc.

Organizing Multiple Seeders for Larger Projects

As your app grows, you'll likely have multiple tables to seed. It's good practice to separate seeders by model or feature.

For example:

• UsersTableSeeder
• PostsTableSeeder
• CategoriesTableSeeder

Then, in your main DatabaseSeeder , call them in order:

 public function run()
{
    $this->call([
        UsersTableSeeder::class,
        CategoriesTableSeeder::class,
        PostsTableSeeder::class,
    ]);
}

This keeps things clean and lets you manage dependencies — like making sure categories exist before creating posts that reference them.

A few notes:

• Order matters! Make sure parent records are seen before child records
• Don't overdo it — only include what's necessary for basic functionality or testing
• Consider conditional seeing if you want to avoid duplicates in future runs

Final Thoughts

Using Laravel seeders with factories give you a powerful way to keep your development environment popular with realistic data without repetitive manual work. Whether you're setting up demo accounts, simulating activity, or just checking how lists and tables behave with more than one entry, seeders help you get there fast.

Just remember to update your seeders as your models evolve, and you'll always have a solid foundation for testing new features.

Basically that's it.

The above is the detailed content of Seeding Databases with Realistic Data Using Laravel Seeders. For more information, please follow other related articles on the PHP Chinese website!