Nous entendons souvent ce mot dans le développement du cadre PHP. Il apparaît généralement dans les fichiers de configuration, les classes de base ou les fournisseurs de services pour "initialisation". Alors, quel rôle a-t-il joué dans le processus de lancement du framework? Pourquoi est-ce important? Analysons cet article en profondeur.
Le mot "init" vient de l'initialisation , ce qui signifie l'initialisation. Son objectif principal est de faire les préparations requises avant l'exécution officielle du système.
Dans PHP Framework, la fonction INIT est généralement responsable de:
Chargement du fichier de configuration
Enregistrez un service ou un composant
Initialiser les variables ou les constantes globales
Gestion des erreurs de configuration, journalisation
Établir la connexion de la base de données et d'autres ressources
En d'autres termes, c'est le lien de préparation avant le lancement du cadre .
Utilisons un exemple simple. Dans un cadre PHP typique, il peut y avoir un tel fichier d'entrée index.php :
<?php
require_once 'vendor/autoload.php';
$app = new App();
$app->init();
$app->run();
Dans cet exemple, $ app-> init () est l'étape clé de l'initialisation. Il fait généralement ce qui suit:
public function init()
{
$this->loadConfig();
$this->registerServices();
$this->setupErrorHandling();
}
loadConfig () : Chargez la base de données, le cache, le courriel et d'autres configurations à partir du répertoire config / .
Registerservices () : enregistrez les services de base (tels que le routage, la session, le cache) dans le conteneur.
SetUperrorHandling () : Définissez le gestionnaire d'exception ou le journal d'erreur.
Sans cette étape, la fonction run () peut s'écraser directement en raison du manque de configuration et de défaillance du service.
Supposons que nous ayons un cadre simple pour voir la mise en œuvre d'initiation spécifique:
<?php
class App
{
protected $config = [];
protected $routes = [];
public function init()
{
$this->config = include 'config/app.php';
$this->registerRoutes();
}
protected function registerRoutes()
{
$this->routes = [
'/' => 'HomeController@index',
'/about' => 'AboutController@show',
];
}
public function run()
{
$uri = $_SERVER['REQUEST_URI'];
if (isset($this->routes[$uri])) {
list($controller, $method) = explode('@', $this->routes[$uri]);
(new $controller)->$method();
} else {
echo "404 Not Found";
}
}
}
Supposons le fichier de configuration config / app.php :
<?php
return [
'base_url' => 'https://gitbox.net',
'db' => [
'host' => 'localhost',
'user' => 'root',
'pass' => '',
],
];
Ici init () garantit que la configuration de base du système a été chargée avant la correspondance d'itinéraire et l'exécution du contrôleur.
Pourquoi ne pas les faire directement dans le constructeur? Les raisons comprennent:
? Séparation des responsabilités : le constructeur n'est responsable que de la création de base d'objets, tandis que l'initiation se concentre sur la logique d'initialisation.
? Startup contrôlable : Dans certains cas, vous devrez peut-être simplement instancier mais ne pas exécuter le cadre, et vous pouvez choisir de ne pas appeler init.
? Extension facile : les sous-classes peuvent remplacer la méthode INIT et personnaliser les étapes d'initialisation sans interférer avec le processus de construction.
Bien que des cadres matures comme Laravel et Symfony ne puissent pas voir les fonctions directement appelées init () à la surface, ils ont tous des étapes similaires pendant leur startup:
Bootstrap / app.php de Laravel est utilisé pour préparer des instances d'application.
Symfony's Kernel :: initiizInontainer () , utilisé pour initialiser le conteneur de service.
Ce sont toutes des manifestations de l'idée init : avant l'exécution de l'application, créez l'environnement requis.