大家都知道 laravel 项目写起来是挺爽，但是在生产环境性能不高，我们来抽丝剥茧分析我自己项目的运行时间消耗：

Bootstrap 耗时

观察初步结论： laravel 在调用 Illuminate\Foundation\Bootstrap\RegisterProviders 和 Illuminate\Foundation\Bootstrap\BootProviders 的 bootstrap 方法时，消耗时间是大头。

• 类 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 的路由，确实是比较慢的。

[未完]