Middleware CakePHP : bibliothèques de graphiques et de traitement d'images intégrées pour réaliser des opérations d'image riches

Middleware CakePHP : intégrez des bibliothèques de graphiques et de traitement d'images pour réaliser des opérations d'image riches

Introduction :
Lors du développement d'applications Web, il est souvent nécessaire de traiter les images, comme la mise à l'échelle, le recadrage, l'ajout de filigranes, etc. CakePHP, en tant que framework PHP populaire, offre des fonctions et une extensibilité riches, et ses fonctions middleware sont particulièrement puissantes. Cet article explique comment utiliser le middleware CakePHP pour intégrer des bibliothèques de graphiques et de traitement d'images afin de réaliser des opérations d'image riches, et est accompagné d'exemples de code.

1. Installer et configurer le middleware :
Avant de commencer, vous devez vous assurer que le framework CakePHP a été installé. Il peut être installé via Composer. La commande spécifique est la suivante :

composer create-project --prefer-dist cakephp/app

Une fois l'installation terminée, vous devez configurer le middleware. Ouvrez le fichier config/middleware.php et recherchez le code suivant :

// Prioritize your own middleware by adding it BEFORE the default ones.
//$middlewareQueue->add(new CakeHttpMiddlewareBodyParserMiddleware());
//$middlewareQueue->add(new CakeRoutingMiddlewareAssetMiddleware());
//$middlewareQueue->add(new CakeRoutingMiddlewareRoutingMiddleware());

Ici, nous pouvons ajouter un middleware personnalisé. Nous verrons ensuite comment implémenter un middleware.

2. Créer un middleware :
Tout d'abord, nous devons créer une classe middleware. Créez un nouveau fichier ImgProcessMiddleware.php dans le répertoire src/Middleware. Le code est le suivant :

<?php
namespace AppMiddleware;
use CakeHttpServerRequest;
use CakeHttpResponse;
use CakeHttpExceptionNotFoundException;
class ImgProcessMiddleware
{
    public function __invoke(ServerRequest $request, Response $response, $next)
    {
        // 检查请求是否是图片操作请求
        if ($request->getParam('action') === 'processImage') {
            // 获取要处理的图片路径
            $imagePath = $request->getQuery('image_path');
            // 处理图片
            $processedImage = $this->processImage($imagePath);
            // 将处理后的图片响应给客户端
            $response = $response->withType('image/jpeg')
                                 ->withStringBody($processedImage);
            return $response;
        }
        // 请求不是图片操作请求，继续下一个中间件
        return $next($request, $response);
    }
    private function processImage($imagePath)
    {
        // 图片处理的具体逻辑
        // 这里使用的是Imagine库，你也可以选择其他图形和图像处理库
        $imagine = new ImagineGdImagine();
        $image = $imagine->open($imagePath);
        $image->resize(new ImagineImageBox(100, 100))
              ->save($imagePath);
        return $image->get('jpeg');
    }
}

Dans le code ci-dessus, nous avons créé une classe middleware ImgProcessMiddleware. Dans la méthode __invoke, nous vérifions si l'opération demandée est processImage. Si tel est le cas, obtenons le chemin de l'image à traiter et appelons la méthode processImage pour le traitement de l'image. Une fois le traitement terminé, l'image traitée est renvoyée au client en tant que corps de réponse.

3. Enregistrez le middleware :
Ensuite, nous devons enregistrer le middleware dans l'application. Ouvrez le fichier config/middleware.php et recherchez le code suivant :

// Uncomment the following line if you want to check HTTP methods + content types
// against the declared route types
//$middlewareQueue->add(new RoutingMiddleware($this));

Ici, nous pouvons ajouter un middleware au type de route défini (si nécessaire). Ajoutez le code suivant après le code :

// 添加自定义的中间件到中间件队列
$middlewareQueue->add(new AppMiddlewareImgProcessMiddleware());

Après l'avoir ajouté, enregistrez le fichier. Nous avons maintenant enregistré avec succès le middleware dans l'application.

4. Testez le middleware :
Grâce aux étapes ci-dessus, nous avons intégré avec succès la bibliothèque de graphiques et de traitement d'images. Nous pouvons maintenant tester le middleware en créant une route et un contrôleur simples. Créez un nouveau fichier ImagesController.php dans le répertoire src/Controller avec le code suivant :

<?php
namespace AppController;
use CakeControllerController;
class ImagesController extends Controller
{
    public function view()
    {
        // 显示原始图片
        $this->viewBuilder()->setLayout(false);
    }
    public function process()
    {
        // 处理图片
        $this->viewBuilder()->setLayout(false);
    }
}

Dans le code ci-dessus, nous avons créé deux actions simples : afficher et traiter. L'action d'affichage est utilisée pour afficher l'image d'origine et l'action de processus est utilisée pour traiter l'image.

Ensuite, nous devons créer le fichier de vue correspondant. Créez deux nouveaux fichiers dans le répertoire src/Template/Images : view.ctp et process.ctp. Transmettez le chemin d'accès de l'image requis aux deux fichiers de vue, puis affichez l'image d'origine dans le fichier view.ctp et l'image traitée dans le fichier process.ctp.

Enfin, nous devons créer des itinéraires et associer des actions à des vues. Ajoutez le code suivant dans le fichier config/routes.php :

use CakeRoutingRouteBuilder;
use CakeRoutingRouter;
// 添加自定义路由
Router::scope('/', function (RouteBuilder $routes) {
    $routes->connect('/images/view', ['controller' => 'Images', 'action' => 'view']);
    $routes->connect('/images/process', ['controller' => 'Images', 'action' => 'process']);
});

Enregistrez et fermez le fichier.

Maintenant, accéder à /images/view affichera l'image originale, et accéder à /images/process traitera et affichera l'image traitée.

Conclusion : 
Grâce à l'introduction de cet article, nous avons appris à utiliser le middleware CakePHP pour intégrer des bibliothèques de graphiques et de traitement d'images afin de réaliser des opérations d'image riches. Le middleware joue un rôle clé dans CakePHP, offrant aux développeurs un moyen plus flexible et plus efficace de gérer les demandes et les réponses.

Exemple de code : [ImgProcessMiddleware.php]

<?php
namespace AppMiddleware;
use CakeHttpServerRequest;
use CakeHttpResponse;
use CakeHttpExceptionNotFoundException;
class ImgProcessMiddleware
{
    public function __invoke(ServerRequest $request, Response $response, $next)
    {
        // 检查请求是否是图片操作请求
        if ($request->getParam('action') === 'processImage') {
            // 获取要处理的图片路径
            $imagePath = $request->getQuery('image_path');
            // 处理图片
            $processedImage = $this->processImage($imagePath);
            // 将处理后的图片响应给客户端
            $response = $response->withType('image/jpeg')
                                 ->withStringBody($processedImage);
            return $response;
        }
        // 请求不是图片操作请求，继续下一个中间件
        return $next($request, $response);
    }
    private function processImage($imagePath)
    {
        // 图片处理的具体逻辑
        // 这里使用的是Imagine库，你也可以选择其他图形和图像处理库
        $imagine = new ImagineGdImagine();
        $image = $imagine->open($imagePath);
        $image->resize(new ImagineImageBox(100, 100))
              ->save($imagePath);
        return $image->get('jpeg');
    }
}

Remarque : La bibliothèque Imagine dans l'exemple de code peut être installée via Composer. La commande spécifique est la suivante :

composer require imagine/imagine

Ensuite, ajoutez le code suivant au fichier middleware (ImgProcessMiddleware). .php). Citation :

use ImagineGdImagine;
use ImagineImageBox;

Grâce aux étapes ci-dessus, nous pouvons rapidement intégrer des bibliothèques de graphiques et de traitement d'images dans les applications CakePHP pour réaliser des opérations d'image riches. Cela fournira des fonctionnalités plus flexibles et efficaces pour nos projets. J'espère que cet article sera utile à tous ceux qui rencontrent des problèmes de traitement d'image pendant le développement.

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!