Applications de fichier unique de Symfony (SFAS) Utilisation de MicrokernelTrait: une approche rationalisée

Symfony 2.8 et 3.0 introduit des applications de fichiers (SFAS), une approche simplifiée pour construire des applications Symfony, particulièrement utiles pour les microservices ou les projets plus petits. Ceci est réalisé à travers le MicroKernelTrait. Cet article explore les SFAS, leurs avantages, leurs limites et comment ils se comparent à une configuration de symfony complète.

Bien qu'une application Symfony traditionnelle puisse impliquer de nombreux fichiers, les SFAS visent une structure plus concise. Cette approche, cependant, ne signifie pas un fichier vraiment single ; Il se concentre plut?t sur un seul fichier de noyau gérant la logique des applications.

Pour créer un SFA, vous aurez besoin d'un serveur Web et d'un compositeur. Un environnement de développement local comme Laravel Valet ou Homestead amélioré simplifie la configuration.

étape 1: installation de syfonie minimale

Installez le package Core Symfony à l'aide du compositeur:

composer require symfony/symfony

Créer app et web répertoires dans la racine de votre projet.

étape 2: le contr?leur avant (web/app_dev.php)

Ce fichier re?oit des demandes et les achemine vers le noyau d'application:

<?php
use Symfony\Component\HttpFoundation\Request;

require __DIR__.'/../vendor/autoload.php';
require __DIR__ . '/../app/SfaKernel.php';

$kernel = new SfaKernel('dev', true);
$request = Request::createFromGlobals();
$response = $kernel->handle($request);
$response->send();
$kernel->terminate($request, $response);

Remarque: la classe du noyau est située dans app/SfaKernel.php. La méthode loadClassCache() est omise pour la simplicité dans cette configuration minimale.

étape 3: La classe du noyau (app/SfaKernel.php)

Cette classe étend Symfony Kernel et utilise le MicroKernelTrait:

<?php
use Symfony\Component\HttpKernel\Kernel;
use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Routing\RouteCollectionBuilder;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\FrameworkBundle;

class SfaKernel extends Kernel
{
    use MicroKernelTrait;

    public function registerBundles()
    {
        return [
            new FrameworkBundle(),
        ];
    }

    protected function configureRoutes(RouteCollectionBuilder $routes)
    {
        $routes->add('/', 'kernel:home');
        $routes->add('/greet/{who}', 'kernel:greet');
    }

    protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader)
    {
        $c->loadFromExtension('framework', [
            'secret' => 'micr0', // Replace with a unique secret
        ]);
    }

    public function home() {
        return new Response('<p>Home, sweet home</p>');
    }

    public function greet($who)
    {
        return new Response("<h1>Greeting</h1><p>Hello $who</p>");
    }
}

La méthode configureRoutes() définit les routes d'application, et configureContainer() configure le conteneur d'injection de dépendance. Les méthodes home() et greet() agissent comme des contr?leurs simples.

Cas d'utilisation et considérations

Bien que les SFAS ne soient pas destinés aux applications à grande échelle, ils sont idéaux pour:

• Microservices: petits services indépendants.
• Projets de preuve de concept: Idées de prototypage rapidement.
• Applications simples: où une configuration de symfony complète n'est pas nécessaire.

Les limites incluent les défis organisationnels potentiels à mesure que l'application se développe et un éventuel manque de flexibilité par rapport à une configuration de symfony complète.

Comparaison avec la configuration complète des syfony

Les SFAS offrent une simplicité et une facilité de configuration, mais les installations de symfony complètes offrent une plus grande flexibilité, une évolutivité et une meilleure organisation pour les projets plus grands.

Conclusion

Symfony's MicroKernelTrait fournit un outil précieux pour construire des applications de symfony légères. Bien qu'il ne remplace pas la symfony complète dans tous les cas, il offre une approche rationalisée pour des cas d'utilisation spécifiques, permettant aux développeurs de tirer parti de la puissance de Symfony avec une complexité réduite.

(Remarque: Les URL de l'image dans l'entrée d'origine étaient toutes identiques. Je les ai gardées telles quelles, mais dans un scénario du monde réel, ils seraient probablement différents.)

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!