Workerman development: How to implement a batch file processing system based on HTTP protocol

Workerman Development: How to implement a batch file processing system based on HTTP protocol, specific code examples are required

With the development of the Internet and digital technology, data processing has become increasingly is becoming more and more important, especially in enterprises. Sometimes, we need to process a large number of files, such as pictures, videos, audios, etc. At this time, manual operation is not only time-consuming and labor-intensive, but also error-prone. How to implement a batch file processing system is the topic to be discussed in this article.

Workerman is a high-performance socket framework developed in PHP, which is easy to use. Its feature is that it provides an event-driven programming model. This article will focus on how to use Workerman to develop a batch file processing system based on the HTTP protocol. We can achieve functions such as batch uploading, compression, and transcoding of files through this system.

1. Set up a development environment
First, we need to install PHP, Composer and Workerman. Here is an introduction to how to install Composer. Open your command line tool and enter the following command:

$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php composer-setup.php
$ php -r "unlink('composer-setup.php');"

After the installation is complete, we need to run the following command in the project directory to install Workerman:

$ composer require workerman/workerman

2. Create project and directory structure
We create a batch file processing system project, the project name is batchfile, and the directory structure is as follows:

├─applications #Application directory
│ ├─app #Application directory
│ │ └─Http #Http application directory
│ │ ├─Config #Configuration directory
│ │ ├─Controller # Controller Directory
│ │ ├─Events #Event Directory
│ │ ├─Libraries #Library Directory
│ │ ├─Models #Model Directory
│ │ ├─Tasks #Task Directory
│ │ └─Views #View Directory
│ └─config #Global Configuration File
├─public #WebRoot Directory
│ ├─css #CSS File Directory
│ ├─js #JS File Directory
│ └─index.php #Website entry file
├─start.php #System startup file
└─composer.json #Dependency management file

We create it in the directory structure An application directory is created, which contains directories such as Config, Controller, Events, Libraries, and Models. These directories are used to manage components of the application. For example, the Controller directory is used to manage controller classes, and the Models directory is used to manage data model classes, etc.

We create the index.php file in the public directory, which is our website entrance file. We will set up this file in the next steps.

3. Write the startup script
The Workerman framework uses Socket mode and cannot be accessed through the browser. So we need to save the startup file as a separate PHP file. Open the start.php file and enter the following code:

use WorkermanWorker;
require_once DIR . '/vendor/autoload.php';

$http_worker = new Worker("http://0.0.0.0:9000");

$http_worker->count = 4;

$http_worker->onWorkerStart = function($worker) {

require_once __DIR__ . '/applications/app/Http/routes.php';

};

Worker::runAll();

In the above code, we created a Worker instance named $http_worker. And the routing file routes.php is loaded through the onWorkerStart event.

4. Write routes
Open the file /applications/app/Http/routes.php and enter the following code:

use WorkermanProtocolsHttp;

$http->onMessage = function($connection, $data) {

$request_data = Http::requestData($data);
$request_path = $request_data['path'];
if (($pos = strpos($request_path, '?')) !== false) {
    $request_path = substr($request_path, 0, $pos);
}
$controller_action = str_replace('/', '\', $request_path);
$controller_action = ucfirst(strtolower($controller_action));
$controller_action = str_replace('-', '', $controller_action);
$controller_action = trim($controller_action, '\');
$controller_action = 'App\Http\Controllers\' . $controller_action . 'Controller';
if (!class_exists($controller_action)) {
    Http::header("HTTP/1.1 404 Not Found

");

    Http::end("404 Not Found");
    return;
}
$controller = new $controller_action();
$method = isset($request_data['query']['method']) ? $request_data['query']['method'] : 'index';
if (!method_exists($controller, $method)) {
    Http::header("HTTP/1.1 404 Not Found

");

    Http::end("404 Not Found");
    return;
}
$controller->$method();

};

In the above code, we parse the request data through the Http protocol, load the corresponding controller according to the request route, and access the methods in the controller.

5. Write the controller
Open the file /applications/app/Http/Controllers/BatchfileController.php and enter the following code:

namespace AppHttpControllers;

use WorkermanProtocolsHttp;
use WorkermanProtocolsHttpResponse;
use WorkermanProtocolsHttpRequest;

class BatchfileController
{

public function index()
{
    return new Response('Hello world'.PHP_EOL);
}

public function uploadFiles(Request $request)
{
    $files = $request->file();
    if(empty($files)){
        return new Response(json_encode([
            'message' => 'No files were uploaded.',
        ]));
    }
    //处理你需要处理的逻辑
    return new Response(json_encode([
        'message' => 'Files uploaded successfully.',
    ]));
}

}

Above In the code, we wrote a BatchfileController controller, which defined the index() and uploadFiles(Request $request) methods.

6. Receive file upload request
Open the file /applications/app/Http/Controllers/BatchfileController.php and enter the following code in the uploadFiles method:

public function uploadFiles(Request $ request)
{

$files = $request->file();
if(empty($files)){
    return new Response(json_encode([
        'message' => 'No files were uploaded.',
    ]));
}
$result = [];
foreach ($files as $name => $file) {
    $path = 'uploads/' . $file['name'];
    if(move_uploaded_file($file['tmp_name'], $path)){
        $result[] = [
            'name' => $file['name'],
            'type' => $file['type'],
            'size' => $file['size'],
            'path' => $path,
        ];
    }
}

//处理你需要处理的逻辑

return new Response(json_encode([
    'message' => 'Files uploaded successfully.',
    'files' => $result,
]));

}

In the above code, we obtain the uploaded file through the $request->file() method, and use the move_uploaded_file method to move the uploaded file to our into the customized upload directory, then save the file information into an array, and finally return the result.

7. Run the test
In command line mode, enter the project directory and execute the command php start.php to start the Workerman service. If everything is normal, enter http://localhost:9000 in the browser address bar and you will see the output of "Hello world". The running results are as follows:

If you want to test the file upload function, you can use the Postman or curl command to simulate the test. The request sample code is as follows:

curl -X POST
http://localhost:9000/file/upload
-H 'cache-control: no-cache'
-H 'content -type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW'
-F 'file1=@/path/to/file1.png'
-F 'file2=@/path/to/file2 .jpg'

So far, we have successfully used Workerman to develop a batch file processing system based on HTTP protocol and implemented the file upload function. We can further expand on this basis to achieve file compression, transcoding and other functions. The event-driven programming model of the Workerman framework allows us to easily extend the functionality of the application.

The above is the detailed content of Workerman development: How to implement a batch file processing system based on HTTP protocol. For more information, please follow other related articles on the PHP Chinese website!