How to use Laravel to implement data storage and reading functions

How to use Laravel to implement data storage and reading functions

Introduction:
Laravel is a popular PHP framework that provides simple and elegant syntax and powerful features that allow developers to easily build powerful web applications. Among them, data storage and reading are basic functions that every web application must have. This article will introduce in detail how to use Laravel to realize data storage and reading functions, and give specific code examples. I hope it will be helpful to everyone's learning and development.

1. Data storage

1. Database configuration:
   First, we need to configure the database. In Laravel, you can set database-related configuration items in the .env file in the project root directory, such as database type, host name, user name, password, etc. The specific configuration is as follows:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=test
DB_USERNAME=root
DB_PASSWORD=

Among them, DB_CONNECTION represents the type of database, DB_HOST represents the host name of the database, and DB_PORT represents The port number of the database, DB_DATABASE represents the name of the database, DB_USERNAME represents the user name of the database, DB_PASSWORD represents the password of the database. Make corresponding modifications according to your actual situation.

2. Create migration files:
   In Laravel, use migration files to manage structural changes in the database. You can generate migration files through the command line:

   php artisan make:migration create_users_table

   Execute the above After executing the command, a migration file named create_users_table will be generated in the database/migrations directory. In this file, we can use the Schema class to create a table and define the columns in the table. The specific code examples are as follows:

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

class CreateUsersTable extends Migration
{
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('users');
    }
}

In the above code, the up method is used to create the table, and the down method is used to delete the table. The specific table structure can be modified according to actual needs.

3. Execute migration:
   After creating the migration file, you can use the following command to execute the migration and synchronize the table structure to the database:

   php artisan migrate

   Execute the above After executing the command, Laravel will automatically read all migration files in the database/migrations directory and execute them.

4. Model definition:
   In Laravel, the model is used to interact with the database table. The model file can be generated through the command line:

   php artisan make:model User

   After executing the above command , a model file named User will be generated in the app directory. In this file, we can define the mapping relationship with the database table, the attributes and methods of the model, so as to store and read the data. Specific code examples are as follows:

namespace App;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
    protected $table = 'users';

    protected $fillable = ['name', 'email', 'password'];

    protected $hidden = ['password'];

    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

In the above code, the $table attribute represents the database table name corresponding to the model, and the $fillable attribute represents Fields that can be assigned values ​​in batches, the $hidden attribute represents hidden fields, and the posts method defines the association with the Post model.

5. Data storage:
   After creating the model, you can use the model class to store data. For example, to add a piece of user data to the database, you can use the following code:

$user = new User;
$user->name = 'John';
$user->email = 'john@example.com';
$user->password = bcrypt('password');
$user->save();

In the above code, a User object is first created and then set through attribute assignment. The properties of the object, and finally call the save method to save the data to the database.

2. Data reading

1. Query constructor:
   Laravel provides a powerful query constructor that can easily construct database query statements. Use the query builder to implement complex conditional queries, sorting, paging and other functions. Specific code examples are as follows:

$users = User::where('age', '>', 18)
       ->orderBy('created_at', 'desc')
       ->paginate(10);

In the above code, the query conditions can be set through the where method, the orderBy method can set the sorting rules, paginate Method can realize paging. By default, 10 pieces of data will be displayed on each page.

2. Original query:
   In addition to using the query builder, you can also use original query statements to operate the database. Using raw queries allows you to operate the database more flexibly, but you need to pay attention to security. The specific code examples are as follows:

$users = DB::select('select * from users where age > ?', [18]);

In the above code, the select method is used to execute the original query, and the query conditions can be set through parameter binding.

3. Model correlation query:
   In Laravel, you can also use model correlation query to implement more complex data reading operations. For example, to get all articles published by a user, you can use the following code:

$user = User::find(1);
$posts = $user->posts;

In the above code, the find method is used to find the corresponding model object based on the primary key, and then Access related objects through the properties of the model object.

Conclusion:
This article introduces how to use Laravel to implement data storage and reading functions, and gives specific code examples. In actual development, you can flexibly use corresponding methods to complete data storage and reading according to your own needs. I hope this article will be helpful to everyone and enable you to have a deeper understanding and mastery of the data manipulation functions of the Laravel framework.

The above is the detailed content of How to use Laravel to implement data storage and reading functions. For more information, please follow other related articles on the PHP Chinese website!