大家都知道 laravel 專案寫起來是挺爽，但是在生產環境效能不高，我們來抽絲剝繭分析我自己專案的執行時間消耗：

Bootstrap 耗時

觀察初步結論： laravel 在呼叫 Illuminate\Foundation\Bootstrap\RegisterProviders

• 類 Illuminate\Foundation\Bootstrap\RegisterProviders 是用於註冊服務提供者的。
• 類 Illuminate\Foundation\Bootstrap\BootProviders 是用於啟動服務提供者的。
• laravel 的內建server php artisan serve 自帶了優化機制，上面資料僅體現首次載入的耗時。二次載入時會相比少很多。但此優化在 fpm 下無效。

我們進一步分析。

RegisterProviders 耗時

\Illuminate\Foundation\Bootstrap\RegisterProviders::bootstrap 方法程式碼如下：

    /**
     * Bootstrap the given application.
     *
     * @param  \Illuminate\Foundation\Application  $app
     * @return void
     */
    public function bootstrap(Application $app)
    {
        $app->registerConfiguredProviders();
    }

所以我們還是回到了 \Illuminate\Foundation\Application 這個檔案：

    /**
     * Register all of the configured providers.
     *
     * @return void
     */
    public function registerConfiguredProviders()
    {
        $providers = Collection::make($this->config['app.providers'])
                        ->partition(function ($provider) {
                            return Str::startsWith($provider, 'Illuminate\\');
                        });

        $providers->splice(1, 0, [$this->make(PackageManifest::class)->providers()]);

        (new ProviderRepository($this, new Filesystem, $this->getCachedServicesPath()))
                    ->load($providers->collapse()->toArray());
    }

針對上面的 (new ProviderRepository)->load 進行耗時分析發現數據為

毋庸置疑這就是消耗時間的大頭。

裡面的程式碼為

    /**
     * Register the application service providers.
     *
     * @param  array  $providers
     * @return void
     */
    public function load(array $providers)
    {
        $manifest = $this->loadManifest();

        // First we will load the service manifest, which contains information on all
        // service providers registered with the application and which services it
        // provides. This is used to know which services are "deferred" loaders.
        if ($this->shouldRecompile($manifest, $providers)) {
            $manifest = $this->compileManifest($providers);
        }

        // Next, we will register events to load the providers for each of the events
        // that it has requested. This allows the service provider to defer itself
        // while still getting automatically loaded when a certain event occurs.
        foreach ($manifest['when'] as $provider => $events) {
            $this->registerLoadEvents($provider, $events);
        }

        // We will go ahead and register all of the eagerly loaded providers with the
        // application so their services can be registered with the application as
        // a provided service. Then we will set the deferred service list on it.
        foreach ($manifest['eager'] as $provider) {
            $this->app->register($provider);
        }

        $this->app->addDeferredServices($manifest['deferred']);
    }

而再經過定位，發現慢在這一行

        foreach ($manifest['eager'] as $provider) {
            $this->app->register($provider);
        }

又回到 \Illuminate\Foundation\Application

    /**
     * Register a service provider with the application.
     *
     * @param  \Illuminate\Support\ServiceProvider|string  $provider
     * @param  array  $options
     * @param  bool   $force
     * @return \Illuminate\Support\ServiceProvider
     */
    public function register($provider, $options = [], $force = false)
    {
        if (($registered = $this->getProvider($provider)) && ! $force) {
            return $registered;
        }

        // If the given "provider" is a string, we will resolve it, passing in the
        // application instance automatically for the developer. This is simply
        // a more convenient way of specifying your service provider classes.
        if (is_string($provider)) {
            $provider = $this->resolveProvider($provider);
        }

        if (method_exists($provider, 'register')) {
            $provider->register();
        }

        // If there are bindings / singletons set as properties on the provider we
        // will spin through them and register them with the application, which
        // serves as a convenience layer while registering a lot of bindings.
        if (property_exists($provider, 'bindings')) {
            foreach ($provider->bindings as $key => $value) {
                $this->bind($key, $value);
            }
        }

        if (property_exists($provider, 'singletons')) {
            foreach ($provider->singletons as $key => $value) {
                $this->singleton($key, $value);
            }
        }

        $this->markAsRegistered($provider);

        // If the application has already booted, we will call this boot method on
        // the provider class so it has an opportunity to do its boot logic and
        // will be ready for any usage by this developer's application logic.
        if ($this->booted) {
            $this->bootProvider($provider);
        }

        return $provider;
    }

在 register 方法中，根據 get_class($provider) 和 執行耗時，得出以下資料

得出 RegisterProviders 瓶頸的結論

• App\Providers\ResponseMacroServicePrivoder 佔用 37ms
• Dingo\Api\Provider\LaravelServiceProvider 佔用 20ms
• Illuminate\Database\DatabaseServiceProvider 佔用 9ms
• Overtrue\LaravelWeChat\ServiceProvider 佔用 9ms

BootProviders 耗時

原因分析

• EasyWeChatComposer\Laravel\ServiceProvider::boot 的啟動速度，略慢，分析原因： 程式碼 Github boot 方法中，載入了路由。而 Laravel 的路由，確實是比較慢的。

[未完]

原文地址：https://segmentfault.com/a/1190000016411386