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

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, essentiellement n'importe quel framework Ils effectueront quelques opérations de base ici, c'est-à-dire s'étendront à 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, qui en fournit un total de deux, appReques et appExceptionHandle. En fait, c'est la requête que vous utilisez. . Accédez spécifiquement à 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 le fichier 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

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

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

● Chargez le pack de langue

● Écoutez l'événement AppInit et utilisez cet événement pour effectuer un travail 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, puis à 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;
}

● Le service a-t-il été enregistré? Si vous devez forcer la réinscription

● Instancier le service

● Si la méthode d'enregistrement est implémentée, vous devez exécuter la méthode de registre

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

● et enfin fusionnée dans l'ensemble du tableau de services, en attendant le démarrage

service à démarrer

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. les services sont :

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

● Le service d'erreur est le

● RegisterService utilisé pour gérer les exceptions et les erreurs du framework signifie littéralement enregistrer le service

● BootService consiste à activer le service

La gestion des erreurs sera abordée plus tard, ici il est dit Regardons RegisterService et BootService.

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"
    ]
}

Du point de vue de la configuration, le framework Au total, deux instructions sont fournies, service:discover et supplier:publish. Je n'entrerai pas dans les détails de l'implémentation ici. 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();
}

Ce qui précède est l'initialisation de l'ensemble de l'application, les détails spécifiques seront discutés plus tard.

Cet article provient de la colonne d'articles techniques du framework ThinkPHP : http://www.php.cn/phpkj/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!