Comprendre la configuration du bundle Symfony et un conteneur de service

Cet article explore la configuration du faisceau Symfony2 et son interaction avec le conteneur d'injection de dépendance. Ces concepts peuvent être difficiles pour les nouveaux arrivants, en particulier ceux qui ne connaissent pas l'injection de dépendance. Les exemples ici utilisent YAML, bien que Symfony prenne en charge les tableaux XML et PHP. Le choix dépend de la préférence; Il n'y a pas d'option de "meilleure".

Concepts clés:

• Bundles Symfony: similaire aux plugins, paquets encapsulent les fonctionnalités (blogs, forums, etc.). Ils favorisent la modularité et la réutilisation du code. Ils peuvent être prédéfinis ou créés sur mesure.
• Configuration du bundle: peut être configuré directement dans le fichier de configuration d'application principal (plus simple, mais moins portable) ou dans des fichiers de configuration de bundle dédiés (plus modulaires et réutilisables). La configuration sémantique, à l'aide d'une classe d'extension, offre le plus de flexibilité pour les faisceaux complexes et distribuables.
• Contasseur d'injection de dépendance: gère les cycles de vie et les dépendances de service, résultant en un code plus propre, plus maintenable et testable.
• Débogage: Utiliser des commandes de console comme debug:container et debug:config pour dépanner les enregistrements et configurations de service.

Création du bundle:

Un bundle est un répertoire contenant des fichiers (PHP, CSS, javascript, images) implémentant une seule fonctionnalité. Dans Symfony2, presque tout est un paquet. Lors de la création d'un bundle (manuellement ou en utilisant php app/console generate:bundle), le fichier BundleNameBundle.php est crucial. Sa classe étend SymfonyComponentHttpKernelBundleBundle et enregistre le bundle en AppKernel::registerBundles(). Le BundleNameExtension.php (dans le dossier DependencyInjection facultatif) charge et gère la configuration du bundle.

Configuration du bundle de chargement (moyen facile):

L'approche la plus simple configure des paramètres et des services directement dans app/config/config.yml. Bien que fonctionnel, cela couple étroitement le faisceau à l'application, limitant la portabilité. Une meilleure alternative (bien que encore moins idéale) consiste à créer un fichier de configuration distinct (par exemple, Resources/config/services.yml) dans le bundle et à l'importer dans le fichier de configuration principal:

imports:
    - { resource: parameters.yml }
    - { resource: security.yml }
    - { resource: ../../src/Cvuorinen/ExampleBundle/Resources/config/services.yml }

Configuration du bundle de chargement (chemin sémantique):

La classe BundleNameExtension.php gère le chargement de configuration. Il utilise une classe Configuration.php (également dans DependencyInjection) pour la validation et le traitement des configurations liées aux bundle à partir de app/config/. L'extension charge ensuite la configuration spécifique du faisceau (à partir de Resources/config/) à l'aide d'un chargeur (par exemple, YamlFileLoader). Les services définis ici peuvent utiliser des paramètres à partir de la configuration principale de l'application. Cette approche est particulièrement utile pour créer des faisceaux réutilisables et distribuables.

Structure du fichier de configuration:

Les fichiers de configuration contiennent principalement des paramètres et des services.

• Paramètres: Valeurs statiques (informations d'identification, touches API, URL). Défini sous la clé parameters. La meilleure pratique consiste à définir les noms de classe de service comme des paramètres pour une meilleure extensibilité.

• Services: Classes contenant la logique métier. Les définir dans le fichier de configuration exploite l'injection de dépendance.

Exemple services.yml:

imports:
    - { resource: parameters.yml }
    - { resource: security.yml }
    - { resource: ../../src/Cvuorinen/ExampleBundle/Resources/config/services.yml }

Utiliser app/console container:debug pour tester et déboguer la configuration.

Utilisation de services dans un contrôleur:

Un service simple Greeter:

parameters:
    cvuorinen_example.greeter.class: Cvuorinen\ExampleBundle\Service\Greeter
    cvuorinen_example.greeter.greeting: "Hello"

services:
    cvuorinen_example.greeter:
        class: %cvuorinen_example.greeter.class%
        arguments: [%cvuorinen_example.greeter.greeting%]

un contrôleur utilisant le service:

namespace Cvuorinen\ExampleBundle\Service;

class Greeter
{
    public function greet($name) { return "Hello $name"; }
}

Injection de dépendance:

L'exemple ci-dessus montre l'injection de base du constructeur. Symfony prend également en charge l'injection de setter et de propriété. Les services peuvent être déclarés privés pour limiter leur accessibilité. Les usines peuvent être utilisées pour créer des services (par exemple, en utilisant le Doctrine Entity Manager pour créer des référentiels).

Conclusion:

Cela fournit un aperçu complet de la configuration du bundle Symfony et de l'injection de dépendance. Une exploration plus approfondie de sujets avancés (configurations primordiales, partage de paramètres, définition des contrôleurs en tant que services) est encouragée. N'oubliez pas de consulter la documentation officielle de Symfony pour des informations détaillées. Évitez d'injecter le conteneur de service lui-même dans les services pour maintenir un couplage lâche. La section FAQS est omise car elle est redondante compte tenu de l'explication détaillée ci-dessus.

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!