Initialisation de l'application ThinkPHP6 (analyse du code source)

Initialisation de l'application d'analyse de code source ThinkPHP6

App Construct

Jetons d'abord un coup d'œil à ce qui est fait dans __construct. Fondamentalement, n'importe quel framework effectuera certaines opérations de base ici, c'est-à-dire s'étendra à partir d'ici.

public function __construct(string $rootPath = '')
{
    $this->thinkPath   = dirname(__DIR__) . DIRECTORY_SEPARATOR;
    $this->rootPath    = $rootPath ? rtrim($rootPath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR : $this->getDefaultRootPath();
    $this->appPath     = $this->rootPath . 'app' . DIRECTORY_SEPARATOR;
    $this->runtimePath = $this->rootPath . 'runtime' . DIRECTORY_SEPARATOR;
    if (is_file($this->appPath . 'provider.php')) {
        $this->bind(include $this->appPath . 'provider.php');
    }
    static::setInstance($this);
    $this->instance('app', $this);
    $this->instance('think\Container', $this);
}

● À en juger par le paramètre rootPath de la méthode magique, elle prend en charge la personnalisation du chemin du répertoire racine.

● Configurez thinkPath, rootPath, appPath, runtimePath

● Liez le fournisseur de services par défaut, en fournissant un total de deux, appReques et appExceptionHandle. En fait, c'est la requête que vous utilisez. Plus précisément, accédez à appPath pour afficher

● Définir l'instance de conteneur actuelle APP

● Liez l'instance App ($ this) au conteneur, qui sont respectivement app et thinkContainer

Vous devez faire attention ici. Le fait est que la classe App hérite de Container, elle lie donc sa propre instance au conteneur.

Il semble que toute l'application ait été initialisée ici ? Ici, je dois mettre une partie du contenu de Request run ici, car c'est le principal travail d'initialisation du framework. Je ne pense pas qu'il soit raisonnable de mettre cette partie du travail d'initialisation dans Request run.

Initialisation principale

public function initialize()
{
    $this->initialized = true;
    $this->beginTime = microtime(true);
    $this->beginMem  = memory_get_usage();
    // 加载环境变量
    if (is_file($this->rootPath . '.env')) {
        $this->env->load($this->rootPath . '.env');
    }
    $this->configExt = $this->env->get('config_ext', '.php');
    $this->debugModeInit();
    // 加载全局初始化文件
    $this->load();
    // 加载框架默认语言包
    $langSet = $this->lang->defaultLangSet();
    $this->lang->load($this->thinkPath . 'lang' . DIRECTORY_SEPARATOR . $langSet . '.php');
    // 加载应用默认语言包
    $this->loadLangPack($langSet);
    // 监听AppInit
    $this->event->trigger('AppInit');
    date_default_timezone_set($this->config->get('app.default_timezone', 'Asia/Shanghai'));
    // 初始化
    foreach ($this->initializers as $initializer) {
        $this->make($initializer)->init($this);
    }
    return $this;
}

● Charger le fichier de variable d'environnement .env

● Charger les fichiers de configuration et les fichiers au sein de l'application

● Chargez common.php dans l'application

● Chargez la fonction d'assistance dans helper.php dans le répertoire thinkPath

● Chargez le fichier de configuration

● Charger l'événement event.php dans le répertoire de l'application

● Enregistrez le service service.php dans le répertoire de l'application

● Chargez le pack de langue

● Écoutez l'événement AppInit . Vous pouvez utiliser cet événement pour effectuer des travaux de pré-demande

● Définir le fuseau horaire

● Injecter tous les services et démarrer le service

Enregistrement du service

Pendant le processus d'initialisation, effectuez l'enregistrement du service, alors à quoi sert l'enregistrement du service ? Comment utiliser le service ?

public function register($service, bool $force = false)
{
    $registered = $this->getService($service);
    if ($registered && !$force) {
        return $registered;
    }
    if (is_string($service)) {
        $service = new $service($this);
    }
    if (method_exists($service, 'register')) {
        $service->register();
    }
    if (property_exists($service, 'bind')) {
        $this->bind($service->bind);
    }
    $this->services[] = $service;
}

● Si le service a été enregistré, s'il doit être forcé à se réenregistrer

● Instancier le service

● Si le La méthode de registre est implémentée, elle doit être exécutée Méthode de registre

● Si l'attribut de liaison est défini, l'instance de service doit être liée au conteneur

● Enfin fusionnée dans l'ensemble du tableau de services , en attente du démarrage

Démarrage du service

Actuellement, il n'y a que les trois services suivants lors de l'initialisation dans le tableau $this->initializers

foreach ($this->initializers as $initializer) {
        $this->make($initializer)->init($this);
}

ces trois services sont :

think\initializer\BootService
think\initializer\Error
think\initializer\RegisterService

● Le service d'erreur est utilisé pour gérer les exceptions et les erreurs du framework

● RegisterService signifie littéralement enregistrer des services

● BootService consiste à activer les services

La gestion des erreurs sera abordée plus tard. Parlons de RegisterService et BootService ici.

Lorsque le RegisterService est créé à partir du conteneur

Il existe une méthode statique cachée make Chaque fois que l'objet instance est créé à partir du conteneur pour la première fois, la méthode make sera exécutée. Bien entendu, il faut d’abord mettre en œuvre la méthode.

La méthode Init sera alors exécutée. Lorsque vous entrez dans RegisterService, vous verrez cette méthode. Le contenu de la méthode est le suivant :

public function init(App $app)
{
    $file = $app->getRootPath() . 'runtime' . DIRECTORY_SEPARATOR . 'services.php';
    $services = $this->services;
    if (is_file($file)) {
        $services = array_merge($services, include $file);
    }
    foreach ($services as $service) {
        if (class_exists($service)) {
            $app->register($service);
        }
    }
}

Cette méthode est très étrange, un peu différente de ce que j'imaginais. Le service est obtenu directement à partir du répertoire d'exécution, et non à partir de service.php dans le répertoire de configuration. Pourquoi cela se produit-il ? Grâce au développement de composer, le framework TP peut également assurer la découverte automatique des packages, ce qui prouve également que l'équipe de développement se rapproche constamment de la communauté. Voyons comment cela est réalisé.

Parce que tout cela est dû à composer, alors jetez un œil à composer.json sous rootPath Allez en bas et vous trouverez la configuration suivante

"scripts": {
    "post-autoload-dump": [
        "@php think service:discover",
        "@php think vendor:publish"
    ]
}

De. Du point de vue de la configuration, le framework fournit un total de deux instructions, service:discover et supplier:publish. Je n'entrerai pas ici dans l'implémentation spécifique. Il vous suffit de savoir que la découverte de packages est implémentée par service:discover.

De plus, trois services sont injectés par défaut.

PaginatorService::class,
ValidateService::class,
ModelService::class,

Enfin, jetons un coup d'œil à BootService. C'est très simple. Du point de vue du nom, il n'est pas difficile de voir que ce qui suit est le code pour démarrer le service normalement, mais ce qui doit être expliqué ici, c'est que la méthode de démarrage doit être implémentée dans la classe de service avant de pouvoir être démarrée.

public function init(App $app)
{
    $app->boot();
}

Pour plus de connaissances ThinkPHP, veuillez visiter le

Tutoriel ThinkPHP !

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!