Symfony - Composants

Comme indiqué précédemment, les composants Symfony sont une bibliothèque PHP autonome fournissant une fonctionnalité spécifique, qui peut être utilisée dans n'importe quelle application PHP. De nouveaux composants utiles sont introduits dans chaque version de Symfony. Actuellement, il existe plus de 30 composants de haute qualité dans le framework Symfony. Apprenons-en plus sur l'utilisation des composants Symfony dans ce chapitre.

Installation d'un composant Symfony

Les composants Symfony peuvent être installés facilement à l'aide de la commande composer. La commande générique suivante peut être utilisée pour installer n'importe quel composant Symfony.

cd /path/to/project/dir 
composer require symfony/<component_name>

Laissez-nous créer une application php simple et essayez d'installer Filesystem composant.

Step 1 - Créer un dossier pour l'application, filesystem-example

cd /path/to/dev/folder 
mdkir filesystem-example 
cd filesystem-example

Step 2 - Installez le composant système de fichiers à l'aide de la commande suivante.

composer require symfony/filesystem

Step 3 - Créer un fichier main.php et entrez le code suivant.

<?php 
   require_once __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Filesystem\Filesystem; 
   use Symfony\Component\Filesystem\Exception\IOExceptionInterface; 
   
   $fs = new Filesystem(); 
   try { 
      $fs->mkdir('./sample-dir'); 
      $fs->touch('./sample-dir/text.txt'); 
   } catch (IOExceptionInterface $e) { 
      echo $e; 
   } 
?>

La première ligne est très importante, elle charge toutes les classes nécessaires à partir de tous les composants installés à l'aide de la commande Composer. Les lignes suivantes utilisent la classe Filesystem.

Step 4 - Exécutez l'application en utilisant la commande suivante et elle créera un nouveau dossier sample-dir et un dossier test.txt dessous.

php main.php

Détails des composants Symfony

Symfony fournit des composants allant d'une fonctionnalité simple, par exemple un système de fichiers, à une fonctionnalité avancée, par exemple des événements, une technologie de conteneur et une injection de dépendances. Faites-nous part de tous les composants un par un dans les sections suivantes.

Système de fichiers

Le composant système de fichiers fournit une commande système de base liée aux fichiers et répertoires, comme la création de fichiers, la création de dossiers, l'existence de fichiers, etc. Le composant système de fichiers peut être installé à l'aide de la commande suivante.

composer require symfony/filesystem

Chercheur

Le composant Finder fournit des classes fluides pour rechercher des fichiers et des répertoires dans un chemin spécifié. Il fournit un moyen simple de parcourir les fichiers dans un chemin. Le composant Finder peut être installé à l'aide de la commande suivante.

composer require symfony/finder

Console

Le composant de console fournit diverses options pour créer facilement des commandes, qui peuvent être exécutées dans un terminal. Symfony utilise leCommand composant largement pour fournir diverses fonctionnalités telles que la création d'une nouvelle application, la création d'un bundle, etc. Même le serveur Web intégré PHP peut être appelé à l'aide de la commande Symfony, php bin/console server:runcomme vu dans la section d'installation. leConsole Le composant peut être installé à l'aide de la commande suivante.

composer require symfony/console

Créons une application simple et créons une commande, HelloCommand en utilisant le Console et l’appelez.

Step 1 - Créez un projet à l'aide de la commande suivante.

cd /path/to/project 
composer require symfony/console

Step 2 - Créer un fichier main.php et incluez le code suivant.

<?php 
   require __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Console\Application; 
   
   $app = new Application(); 
   $app->run(); 
?>

Application class met en place les fonctionnalités nécessaires d'une application de console simple.

Step 3 - Lancez l'application, php main.php, ce qui produira le résultat suivant.

Console Tool  
Usage: 
   command [options] [arguments]  
Options: 
   -h, --help            Display this help message 
   -q, --quiet           Do not output any message 
   -V, --version         Display this application version 
         --ansi            Force ANSI output 
         --no-ansi         Disable ANSI output 
   -n, --no-interaction  Do not ask any interactive question 
   -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 
      2 for more verbose output and 3 for debug  
Available commands: 
   help  Displays help for a command 
   list  Lists commands

Step 4 - Créez une classe appelée HelloCommand extension Command classe dans le main.php lui-même.

use Symfony\Component\Console\Command\Command; 
use Symfony\Component\Console\Input\InputInterface; 
use Symfony\Component\Console\Output\OutputInterface; 
use Symfony\Component\Console\Input\InputArgument;

class HelloCommand extends Command { 
}

L'application utilise les quatre classes suivantes disponibles dans Command composant.

Command - Utilisé pour créer une nouvelle commande
InputInterface - Utilisé pour définir les entrées utilisateur
InputArgument - Utilisé pour obtenir les entrées utilisateur
OutputInterface - Utilisé pour imprimer la sortie sur la console

step 5 - Créer une fonction configure() et définissez le nom, la description et le texte d'aide.

protected function configure() { 
   $this 
      ->setName('app:hello') 
      ->setDescription('Sample command, hello') 
      ->setHelp('This command is a sample command') 
}

step 6 - Créer un argument d'entrée, user pour la commande et défini comme obligatoire.

protected function configure() { 
   $this 
      ->setName('app:hello') 
      ->setDescription('Sample command, hello') 
      ->setHelp('This command is a sample command') 
      ->addArgument('name', InputArgument::REQUIRED, 'name of the user'); 
}

step 7 - Créer une fonction execute() avec deux arguments InputArgument et OutputArgument.

protected function execute(InputInterface $input, OutputInterface $output) { 
}

step 8 - Utiliser InputArgument pour obtenir les détails de l'utilisateur saisis par l'utilisateur et les imprimer sur la console en utilisant OutputArgument.

protected function execute(InputInterface $input, OutputInterface $output) { 
   $name = $input->getArgument('name'); 
   $output->writeln('Hello, ' . $name); 
}

step 9 - Enregistrez le HelloCommand dans l'application à l'aide du add méthode de Application classe.

$app->add(new HelloCommand());

L'application complète est la suivante.

<?php 
   require __DIR__ . '/vendor/autoload.php'; 
   use Symfony\Component\Console\Application; 
   use Symfony\Component\Console\Command\Command; 
   use Symfony\Component\Console\Input\InputInterface; 
   use Symfony\Component\Console\Output\OutputInterface; 
   use Symfony\Component\Console\Input\InputArgument;  
   
   class HelloCommand extends Command { 
      protected function configure() { 
         $this 
            ->setName('app:hello') 
            ->setDescription('Sample command, hello') 
            ->setHelp('This command is a sample command') 
            ->addArgument('name', InputArgument::REQUIRED, 'name of the user'); 
      }  
      protected function execute(InputInterface $input, OutputInterface $output) { 
         $name = $input->getArgument('name'); 
         $output->writeln('Hello, ' . $name);
      }  
      $app = new Application(); 
      $app->add(new HelloCommand()); 
      $app->run(); 
   }         
?>

Step 10 - Maintenant, exécutez l'application à l'aide de la commande suivante et le résultat sera Hello, Jon comme prévu.

php main.php app:hello Jon

Symfony est livré avec un binaire pré-construit appelé console dans le répertoire bin de n'importe quelle application Web Symfony, qui peut être utilisé pour appeler les commandes dans une application.

Processus

Le composant de processus fournit des options pour exécuter n'importe quelle commande système dans un sous-processus, de manière sûre et efficace. Le composant de processus peut être installé à l'aide de la commande suivante.

composer require symfony/process

ClassLoader

Le composant ClassLoader fournit une implémentation pour les deux PSR-0 et PSR-4chargeur de classe standard. Il peut être utilisé pour charger automatiquement les classes. Il sera amorti dans un proche avenir. Le chargeur de classe basé sur Composer est préférable à ce composant. Le composant ClassLoader peut être installé à l'aide de la commande suivante.

composer require symfony/class-loader

PropriétéAccès

Le composant PropertyAccess fournit diverses options pour lire et écrire un objet et des détails de tableau en utilisant la notation de chaîne. Par exemple, un tableauProduct avec clé price accessible dynamiquement en utilisant [price] chaîne.

$product = array( 
   'name' => 'Cake' 
   'price' => 10 
);  
var priceObj = $propertyAccesserObj->getValue($product, '[price]');

Le composant PropertyAccess peut être installé à l'aide de la commande suivante.

composer require symfony/property-access

PropertyInfo

Le composant PropertyInfo est similaire au composant PropertyAccess, mais il ne fonctionne qu'avec des objets PHP et fournit beaucoup plus de fonctionnalités.

class Product { 
   private $name = 'Cake'; 
   private $price = 10;  
   
   public function getName() { 
      return $this->name; 
   }  
   public function getPrice() { 
      return $this->price; 
   } 
}  
$class = Product::class; 
$properties = $propertyInfoObj->getProperties($class);  
/* 
   Example Result 
   -------------- 
   array(2) { 
      [0] => string(4) "name" 
      [1] => string(5) "price" 
   } 
*/

Le composant PropertyInfo peut être installé à l'aide de la commande suivante.

composer require symfony/property-info

EventDispatcher

Le composant EventDispatcher fournit une programmation événementielle en PHP. Il permet aux objets de communiquer entre eux en distribuant des événements et en les écoutant. Nous apprendrons comment créer des événements et les écouter dans le chapitre Events and Event Listener.

Le composant EventDispatcher peut être installé à l'aide de la commande suivante.

composer require symfony/event-dispatcher

DépendanceInjection

Le composant DependencyInjection fournit un mécanisme simple et efficace pour créer un objet avec sa dépendance. Lorsqu'un projet se développe, il comporte de nombreuses classes avec une dépendance profonde, qui doivent être gérées correctement. Sinon, le projet échoue. DependencyInjection fournit un conteneur simple et robuste pour gérer la dépendance. Nous allons en apprendre davantage sur les conteneurs et le concept d'injection de dépendances dans le chapitre Conteneur de service.

Le composant DependencyInjection peut être installé à l'aide de la commande suivante.

composer require symfony/dependency-injection

Sérialiseur

Le composant Serializer fournit une option pour convertir un objet PHP dans un format spécifique tel que XML, JSON, Binary, etc., puis lui permet de le reconvertir en un objet original sans aucune perte de données.

Le composant Serializer peut être installé à l'aide de la commande suivante.

composer require symfony/serializer

Config

Le composant Config fournit des options pour charger, analyser, lire et valider des configurations de type XML, YAML, PHP et ini. Il fournit également diverses options pour charger les détails de configuration à partir de la base de données. C'est l'un des composants importants utiles pour configurer l'application Web de manière claire et concise. Le composant Config peut être installé à l'aide de la commande suivante.

composer require symfony/config

ExpressionLangage

Le composant ExpessionLanguage fournit un moteur d'expression à part entière. Les expressions sont à une seule ligne destinées à renvoyer une valeur. Le moteur d'expression permet de compiler, d'analyser et d'obtenir facilement la valeur d'une expression. Il permet à une ou plusieurs expressions d'être utilisées dans un environnement de configuration (fichier) par un programmeur non PHP, par exemple un administrateur système. Le composant ExpressionLanguage peut être installé à l'aide de la commande suivante.

composer require symfony/expression-language

OptionsRésolveur

Le composant OptionsResolver fournit un moyen de valider le système d'options utilisé dans notre système. Par exemple, le paramètre de base de données est placé dans un tableau, dboption avec l'hôte, le nom d'utilisateur, le mot de passe, etc., comme clés. Vous devez valider les entrées avant de l'utiliser pour vous connecter à une base de données. OptionsResolver simplifie cette tâche en fournissant une classe simple OptionsResolver et un résolveur de méthode, qui résout le paramètre de base de données et s'il y a un problème de validation, il le signalera.

$options = array( 
   'host'     => '<db_host>', 
   'username' => '<db_user>', 
   'password' => '<db_password>', 
);  
$resolver = new OptionsResolver(); 
$resolver->setDefaults(array( 
   'host'     => '<default_db_host>', 
   'username' => '<default_db_user>', 
   'password' => '<default_db_password>', 
)); 
$resolved_options = $resolver->resolve($options);

Le composant OptionsResolver peut être installé à l'aide de la commande suivante.

composer require symfony/options-resolver

Dotenv

Le composant Dotenv fournit diverses options pour analyser les fichiers .env et la variable qui y est définie pour être accessible via getenv(), $_ENV, ou $_SERVER. Le composant Dotenv peut être installé à l'aide de la commande suivante.

composer require symfony/dotenv

Cache

Le composant de cache fournit une extension PSR-6la mise en oeuvre. Il peut être utilisé pour ajouter une fonctionnalité de cache à notre application Web. Puisqu'il suitPSR-6, il est facile de démarrer et il peut être facilement utilisé à la place d'un autre composant de cache basé sur PSR-6. Le composant de cache peut être installé à l'aide de la commande suivante.

composer require symfony/cache

Intl

Le composant Intl est la bibliothèque de remplacement pour l'extension C Intl. Le composant Intl peut être installé à l'aide de la commande suivante.

composer require symfony/intl

Traduction

Le composant de traduction fournit diverses options pour internationaliser notre application. Normalement, les détails de traduction des différentes langues seront stockés dans un fichier, un fichier par langue, et il sera chargé dynamiquement pendant l'exécution de l'application. Il existe différents formats pour écrire un fichier de traduction. Le composant de traduction fournit diverses options pour charger n'importe quel type de format, tel que le simple fichier PHP, CSV, ini, Json, Yaml, fichier de ressources ICU, etc.

composer require symfony/translation

Flux de travail

Le composant de flux de travail fournit des outils avancés pour traiter une machine à états finis. En fournissant cette fonctionnalité de manière simple et orientée objet, le composant Workflow permet une programmation avancée en PHP avec une relative facilité. Nous l'apprendrons en détail dans le chapitre Concept avancé.

Le composant Workflow peut être installé à l'aide de la commande suivante.

composer require symfony/workflow

Yaml

Le composant Yaml fournit une option qui analyse le format de fichier YAML et le convertit en tableaux PHP. Il est également capable d'écrire un fichier YAML à partir d'un tableau php ordinaire. Le composant Yaml peut être installé à l'aide de la commande suivante.

composer require symfony/yaml

LDAP

Le composant Ldap fournit des classes PHP pour se connecter à un serveur LDAP ou Active Directory et authentifier l'utilisateur par rapport à celui-ci. Il fournit une option pour se connecter à un contrôleur de domaine Windows. Le composant LDAP peut être installé à l'aide de la commande suivante.

composer require symfony/ldap

Déboguer

Le composant de débogage fournit diverses options pour activer le débogage dans l'environnement PHP. Normalement, le débogage du code PHP est difficile, mais le composant de débogage fournit des classes simples pour faciliter le processus de débogage et le rendre propre et structuré. Le composant de débogage peut être installé à l'aide de la commande suivante.

composer require symfony/debug

Chronomètre

Le composant Stopwatch fournit une classe Stopwatch pour profiler notre code PHP. Une utilisation simple est la suivante.

use Symfony\Component\Stopwatch\Stopwatch; 
$stopwatch = new Stopwatch(); 
$stopwatch->start('somename');  

// our code to profile 
$profiled_data = $stopwatch->stop('somename');  
echo $profiled_data->getPeriods()

Le composant Chronomètre peut être installé à l'aide de la commande suivante.

composer require symfony/stopwatch

VarDumper

Le composant VarDumper offre une meilleure dump()fonction. Incluez simplement le composant VarDumper et utilisez la fonction de vidage pour obtenir les fonctionnalités améliorées. Le composant VarDumper peut être installé à l'aide de la commande suivante.

composer require symfony/var-dumper

BrowserKit

Le composant BrowserKit fournit une interface client de navigateur abstraite. Il peut être utilisé pour tester l'application Web par programme. Par exemple, il peut demander un formulaire, entrer les exemples de données et les soumettre pour rechercher un problème dans le formulaire par programme. Le composant BrowserKit peut être installé à l'aide de la commande suivante.

composer require symfony/browser-kit

Pont PHPUnit

Le composant PHPUnit Bridge fournit de nombreuses options pour améliorer l'environnement de test PHPUnit. Le composant PHPUnit Bridge peut être installé à l'aide de la commande suivante.

composer require symfony/phpunit-bridge

Atout

Le composant Asset fournit une gestion générique des actifs dans une application Web. Il génère une URL pour les actifs tels que CSS, HTML, JavaScript et effectue également la maintenance de la version. Nous vérifierons le composant d'actif en détail dans le chapitre View Engine. Le composant Asset peut être installé à l'aide de la commande suivante.

composer require symfony/asset

CssSelector

Le composant CssSelector fournit une option pour convertir les sélecteurs basés sur CSS en expression XPath. Un développeur Web connaît davantage l'expression des sélecteurs basée sur CSS que l'expression XPath, mais l'expression la plus efficace pour trouver un élément dans un document HTML et XML estXPath Expression.

CssSelector permet au développeur d'écrire l'expression dans CSS Selectors , cependant, le composant la convertit en expression XPath avant de l'exécuter. Ainsi, le développeur a l'avantage de la simplicité des sélecteurs CSS et de l'efficacité de l'expression XPath.

Le composant CssSelector peut être installé à l'aide de la commande suivante.

composer require symfony/css-selector

DomCrawler

Le composant DomCrawler fournit diverses options pour trouver l'élément dans un document HTML et XML à l'aide du concept DOM. Il fournit également l'option d'utiliser l'expression XPath pour rechercher un élément. Le composant DomCrawler peut être utilisé avec le composant CssSelector pour utiliser des sélecteurs CSS au lieu de l'expression XPath. Le composant DomCrawler peut être installé à l'aide de la commande suivante.

composer require symfony/dom-crawler

Forme

Le composant Form permet de créer facilement un formulaire dans une application Web. Nous apprendrons la programmation de formulaire en détail dans le chapitre Formulaire. Le composant Form peut être installé à l'aide de la commande suivante.

composer require symfony/form

HttpFoundation

Le composant HttpFoundation fournit une couche orientée objet à la spécification HTTP. Par défaut, PHP fournit des détails de requête et de réponse HTTP sous forme d'objet basé sur un tableau tel que$_GET, $_POST, $_FILES, $_SESSION, etc. Les fonctionnalités basées sur HTTP telles que la configuration d'un cookie peuvent être effectuées à l'aide d'une fonction ancienne simple setCookie(). HttpFoundation fournit toutes les fonctionnalités liées à HTTP dans un petit ensemble de classes telles que Request, Response, RedirectResponse, etc. Nous en apprendrons davantage sur ces classes dans les chapitres suivants.

Le composant HttpFoundation peut être installé à l'aide de la commande suivante.

composer require symfony/http-foundation

HttpKernel

Le composant HttpKernel est le composant principal de la configuration Web de Symfony. Il fournit toutes les fonctionnalités requises pour une application Web - depuis la réception duRequest s'opposer au renvoi du Responseobjet. L'architecture complète de l'application Web Symfony est fournie par HttpKernel comme décrit dans l'architecture d'un framework Web Symfony.

Le composant HttpKernel peut être installé à l'aide de la commande suivante.

composer require symfony/http-kernel

Routage

Le composant de routage mappe la requête HTTP à un ensemble prédéfini de variables de configuration. Le routage décide quelle partie de notre application doit gérer une demande. Nous en apprendrons plus sur le routage dans le chapitre Routage.

Le composant de routage peut être installé à l'aide de la commande suivante.

composer require symfony/filesystem

Création de modèles

Le composant de création de modèles fournit l'infrastructure nécessaire pour créer un système de modèles efficace. Symfony utilise le composant Templating pour l'implémentation de son moteur View. Nous en apprendrons plus sur le composant de création de modèles dans le chapitre Moteur de visualisation.

Le composant de création de modèles peut être installé à l'aide de la commande suivante.

composer require symfony/templating

Validateur

Le composant Validator fournit une implémentation de JSR-303 Bean Validation Specification. Il peut être utilisé pour valider un formulaire dans un environnement Web. Nous en apprendrons plus sur Validator dans le chapitre Validation.

Le composant Validator peut être installé à l'aide de la commande suivante.

composer require symfony/validator

Sécurité

Le composant de sécurité fournit un système de sécurité complet pour notre application Web, que ce soit l'authentification de base HTTP, l'authentification HTTP Digest, l'authentification par formulaire interactif, la connexion de certification X.509, etc. Il fournit également un mécanisme d'autorisation basé sur le rôle de l'utilisateur via un système ACL intégré . Nous en apprendrons plus en détail dans le chapitre Concept avancé.

Le composant de sécurité peut être installé à l'aide de la commande suivante.

composer require symfony/security

↰ Previous page Next page ↱