Use the PHP framework Lumen to develop a simple and easy-to-use RESTful API service

With the rapid development of Internet technology, more and more applications are beginning to use RESTful APIs for data transmission and interaction. RESTful API is a lightweight framework for communication based on HTTP protocol, which has the advantages of easy expansion and strong compatibility. PHP is a very popular server-side programming language, and there are many excellent frameworks to choose from. Among them, Lumen is a lightweight PHP framework that can quickly build RESTful API services.

This article will introduce the steps to use Lumen to develop a simple and easy-to-use RESTful API service. The following aspects will be covered:

1. Introduction to Lumen
2. RESTful API basics
3. Start building RESTful API services
4. Writing controllers
5. Writing model
6. Writing route
7. Testing API

1. Introduction to Lumen

Lumen is a micro-framework of the Laravel framework. Has fast and efficient features. Compared with Laravel, Lumen is more lightweight and has faster response speed. Lumen uses Composer as a dependency management tool, which is based on PHP 7 or above and supports RESTful API encapsulation.

2. Basic knowledge of RESTful API

RESTful API is a data transmission and interaction method based on HTTP protocol for communication. The basic constraints of RESTful API include:

• Client/Server Model
• Stateless
• Cacheable
• Unified Interface
• Layered system

Commonly used HTTP methods include GET, POST, PUT, and DELETE. By combining these HTTP methods and URL resource paths, a RESTful API service can be built.

3. Start building a RESTful API service

First, you need to install the Lumen framework. Enter the following command in the command line terminal:

composer create-project --prefer-dist laravel/lumen your-project-name

After the installation is completed, enter the project directory and create the controller, model and other necessary files through the artisan command line tool:

php artisan make:controller YourControllerName
php artisan make:model YourModelName

Now, we have We have completed the installation of the Lumen framework and created the necessary files for our next work.

4. Write the controller

The controller is a PHP class used to process requests and return responses. In the Lumen framework, controllers are usually saved in the /app/Http/Controllers folder.

Write a controller to handle CRUD operations on data. Here we assume that we have a user data table, including id, name, email and other fields:

<?php

namespace AppHttpControllers;

use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesValidator;

class UserController extends Controller
{
    public function index()
    {
        return response()->json(User::all());
    }

    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|max:255',
            'email' => 'required|email|unique:users'
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        } else {
            $user = User::create([
                'name' => $request->input('name'),
                'email' => $request->input('email')
            ]);
            return response()->json($user, 201);
        }
    }

    public function update(Request $request, $id)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'max:255',
            'email' => 'email|unique:users'
        ]);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        } else {
            $user = User::find($id);
            if ($user) {
                $user->name = $request->input('name');
                $user->email = $request->input('email');
                $user->save();
                return response()->json($user);
            } else {
                return response()->json(['error' => 'User not found'], 404);
            }
        }
    }

    public function show($id)
    {
        $user = User::find($id);
        if ($user) {
            return response()->json($user);
        } else {
            return response()->json(['error' => 'User not found'], 404);
        }
    }

    public function destroy($id)
    {
        $user = User::find($id);
        if ($user) {
            $user->delete();
            return response()->json(['message' => 'User deleted']);
        } else {
            return response()->json(['error' => 'User not found'], 404);
        }
    }
}

Here we write a controller class named UserController, which contains index, store, update, show and destroy Wait for 5 ways. They respectively correspond to the five common operations of RESTful API - obtaining resources, creating resources, updating resources, obtaining specified resources, and deleting resources.

In the above code, we use the responder (response()) and model (User) of the Lumen framework, as well as the validator (Validator) provided by the Lumen framework. In addition to these, you can also introduce other dependencies in the controller to perform more complex operations.

5. Write the model

Models are usually used to express data tables so that when the controller is called to handle data requests, the data can be read and processed correctly. In the Lumen framework, model files are usually stored in the /app/Models folder.

The following is a simple model. In this model, we have agreed that the data table name is users:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentModel;

class User extends Model
{
    protected $table = 'users';
    protected $fillable = ['name', 'email'];
}

The User class in the above code inherits from the Model class of the Lumen framework, which contains Some essential attribute variables and methods are included. Here, we use protected $table = 'users' to agree that the data table corresponding to this model is named users, and we also use the fillable attribute to limit the fields that can be batch assigned.

6. Write routing

Routing specifies the URL path of the request and the corresponding controller method, which is used to distribute the request. In the Lumen framework, routing files are usually stored in the /routes folder.

<?php

$router->get('/', function () use ($router) {
    return $router->app->version();
});

$router->get('/users', 'UserController@index');
$router->post('/users', 'UserController@store');
$router->get('/users/{id}', 'UserController@show');
$router->put('/users/{id}', 'UserController@update');
$router->delete('/users/{id}', 'UserController@destroy');

In the above code, we specify the corresponding URL paths and processing methods for the five operations, in which the get, post, put, and delete of the router ($router) are used to specify the HTTP request method.

7. Test API

Now that we have successfully completed the installation of the Lumen framework, the writing of the controller code, the definition of the model and the setting of the routing, we can test it. Enter the following command in the command line terminal to start the Web service:

php -S 127.0.0.1:8000 -t public

Then open the browser and enter localhost:8000/users to access the above API service. You will see a user list. Alternatively, you can use Postman or other HTTP client tools to test the interface.

Summary

Using the Lumen framework, we can easily build a simple and easy-to-use RESTful API service. With the support of the Lumen framework, we can quickly write necessary files such as controllers, models, and routes, and start web services through command line tools for testing. Compared with the traditional PHP development method, this method can greatly improve our development efficiency and program operation efficiency.

The above is the detailed content of Use the PHP framework Lumen to develop a simple and easy-to-use RESTful API service. For more information, please follow other related articles on the PHP Chinese website!