Furnizorii de servicii din Laravel: ce sunt aceștia și cum se utilizează Furnizorii de servicii din Laravel

Furnizorii de servicii Laravel sunt locul central unde este pornită aplicația. Adică, serviciile de bază Laravel și serviciile de aplicații, clasele și dependențele acestora sunt plasate în containerul de servicii prin intermediul furnizorilor. 

Cu alte cuvinte, furnizorii de servicii sunt ca o pâlnie prin care turnăm combustibil „de clasă” într-un rezervor numit „container de service” al unui motor numit Laravel.

Exemplu

Dacă deschidem config/app.php vom vedea o matrice cu numele „furnizor”

'providers' => [

        /*
        * Laravel Framework Service Providers...
        */
        Illuminate\Auth\AuthServiceProvider::class,
        Illuminate\Broadcasting\BroadcastServiceProvider::class,
        Illuminate\Bus\BusServiceProvider::class,
        Illuminate\Cache\CacheServiceProvider::class,
        Illuminate\Foundation\Providers\ConsoleSupportServiceProvider::class,
        Illuminate\Cookie\CookieServiceProvider::class,
        .
        .
        .
],

Aceștia sunt câțiva dintre furnizorii de servicii furnizați împreună cu laravel, adică servicii de bază care sunt plasate în containerul de servicii.

Cand eu service provider sunt executate?

Dacă ne uităm la documentație la cerere ciclu de viață , următoarele fișiere sunt executate la început:

• public/index.php
• bootstrap/app.php
• app/Http/Kernel.php si a lui Middlewares
• Service Providers: conținutul acestui articol

cali service provider sunt incarcate? 

Ei sunt aceia definite în matrice config/app.php:

return [
 
    // ... other configuration values
 
    'providers' => [
 
        /*
         * Laravel Framework Service Providers...
         */
        Illuminate\Auth\AuthServiceProvider::class,
        Illuminate\Broadcasting\BroadcastServiceProvider::class,
 
        // ... other framework providers from /vendor
        Illuminate\Validation\ValidationServiceProvider::class,
        Illuminate\View\ViewServiceProvider::class,
 
        /*
         * PUBLIC Service Providers - the ones we mentioned above
         */
        App\Providers\AppServiceProvider::class,
        App\Providers\AuthServiceProvider::class,
        // App\Providers\BroadcastServiceProvider::class,
        App\Providers\EventServiceProvider::class,
        App\Providers\RouteServiceProvider::class,
 
    ],
 
];

După cum putem vedea, există o listă de service provider nu este public în folder /vendor, nu trebuie nici să le atingem, nici să le modificăm. Cele care ne interesează sunt mai jos, cu BroadcastServicerProvider dezactivat implicit, probabil pentru că este rar folosit.

Toți acești furnizori de servicii rulează de sus în jos, repetând lista de două ori:

• Prima iterație caută o metodă opțională register(), util pentru (eventual) executarea a ceva configurat înainte de metodă boot().

• a doua iterație execută metoda boot() a tuturor furnizorilor. Din nou, unul câte unul, de sus în jos, a matricei 'providers'.

• În cele din urmă, după ce toți furnizorii de servicii au fost procesați, Laravel trece la analizarea căii (rutei), rularea controlerului, utilizarea șabloanelor etc.

Furnizori de servicii Laravel predefiNiTi

I Service Providers incluse în Laravel, sunt toți cei prezenți în folder app/Providers:

• AppServiceProvider
• AuthServiceProvider
• BroadcastServiceProvider
• EventServiceProvider
• RouteServiceProvider

Toate sunt clase PHP, fiecare legată de subiectul său: App, Auth, Broadcasting, Events e Routes. Dar toate au un lucru în comun: metoda boot().

În cadrul acestei metode, putem scrie orice cod legat de oricare dintre acele secțiuni: auth, events, route, etc. Cu alte cuvinte, Furnizorii de servicii sunt doar clase pentru a înregistra unele funcționalități globale.

Sunt separați ca „furnizori”, deoarece rulează foarte devreme în ciclul de viață al aplicației, așa că ceva global este convenabil aici înainte ca scriptul de execuție să ajungă la Modele sau Controlere.

Cea mai mare parte a funcționalității se află în RouteServiceProvider, aici este codul:

class RouteServiceProvider extends ServiceProvider
{
    public const HOME = '/dashboard';
 
    public function boot()
    {
        $this->configureRateLimiting();
 
        $this->routes(function () {
            Route::prefix('api')
                ->middleware('api')
                ->group(base_path('routes/api.php'));
 
            Route::middleware('web')
                ->group(base_path('routes/web.php'));
        });
    }
 
    protected function configureRateLimiting()
    {
        RateLimiter::for('api', function (Request $request) {
            return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
        });
    }
}

Aceasta este clasa în care sunt configurate fișierele route, Cu routes/web.php e routes/api.php incluse implicitdefinita. Rețineți că pentru API există și configurații diferite: Prefixul punctului final /api și middleware api pentru toți routes.

Putem edita service providers, care nu sunt în folder /vendor. Personalizarea acestor fișiere se face atunci când aveți mai multe căi și doriți să le separați în fișiere specifice. Tu creezi routes/auth.php și puneți căile acolo, apoi „activați” acel fișier în metodă boot() di RouteServiceProvider, doar adăugați a treia propoziție:

`Route::middleware('web') // or maybe you want another middleware?
    ->group(base_path('routes/auth.php'));

AppServiceProvider e gol. Un exemplu tipic de adăugare de cod AppServiceProvider, este despre dezactivarea încărcării lene în Eloquent . Pentru a face acest lucru, trebuie doar adăugați două rânduri în metodă boot():

// app/Providers/AppServiceProvider.php
use Illuminate\Database\Eloquent\Model;
 
public function boot()
{
    Model::preventLazyLoading(! $this->app->isProduction());
}

Acest lucru va arunca o excepție dacă un model de relație nu este încărcat.

Crează-ți propriul service provider personalizate

Pe lângă fișierele predefinoapte, putem crea cu ușurință unul nou Service Provider, legate de alte subiecte decât cele predefiterminat ca auth/event/routes.

Un exemplu destul de tipic este configurația vizualizării Blade. Putem crea o directivă Blade, apoi adăugați acel cod în metodă boot() din oricare service provider, inclusiv implicit AppServiceProvider. Acum să creăm un ViewServiceProvider separa.

Îl putem genera cu această comandă:

php artisan make:provider ViewServiceProvider

Care va genera clasa atât de predefinoapte:

namespace App\Providers;
 
use Illuminate\Support\ServiceProvider;
 
class ViewServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
 
    /**
     * Bootstrap services.
     *
     * @return void
     */
    public function boot()
    {
        //
    }
}

După cum putem vedea în interior, există două metode:

Metoda register().

Metoda register() ne permite defilink-uri terminate către containerul nostru de servicii. De exemplu, în următorul cod:

public function register()
{
    $this->app->singleton(my_class, function($app){
        return new MyClass($app);
    });
}

$this->app este o variabilă globală în laravel pe care o clasă singleton o poate accesa prin intermediul aplicației.

Singleton este o caracteristică. Când aplicăm această caracteristică, informăm aplicația că orice clasă este transmisă ca parametru în aplicație ar trebui să aibă o singură instanță în întreaga aplicație. Aceasta înseamnă că MyClass va fi rezolvată o dată și va avea o singură instanță, care poate fi accesată folosind variabila my_class.

Metoda boot().

Metoda boot() vă permite să accesați toate serviciile înregistrate anterior folosind metoda register. Puteți include apoi întregul serviciu în aplicația dvs. folosind această metodă.

Revenind la exemplul anterior, să eliminăm metoda register() si in interior boot() adăugați codul directivei Blade:

use Illuminate\Support\Facades\Blade;
 
public function boot()
{
    Blade::directive('datetime', function ($expression) {
        return "<?php echo ($expression)->format('m/d/Y H:i'); ?>";
    });
}

Un alt exemplu de ViewServiceProvider privește View Composers, aici este fragmentul de pe site-ul oficial Laravel :

use App\View\Composers\ProfileComposer;
use Illuminate\Support\Facades\View;
use Illuminate\Support\ServiceProvider;
 
class ViewServiceProvider extends ServiceProvider
{
    public function boot()
    {
        // Using class based composers...
        View::composer('profile', ProfileComposer::class);
 
        // Using closure based composers...
        View::composer('dashboard', function ($view) {
            //
        });
    }
}

Pentru a rula, acest nou furnizor trebuie adăugat/înregistrat în matricea de furnizori config/app.php:

return [
    // ... other configuration values
 
    'providers' => [
 
        App\Providers\AppServiceProvider::class,
        App\Providers\AuthServiceProvider::class,
        // App\Providers\BroadcastServiceProvider::class,
        App\Providers\EventServiceProvider::class,
        App\Providers\RouteServiceProvider::class,
 
        // Add your provider here
        App\Providers\ViewServiceProvider::class,
    ],
];

Ercole Palmeri

Ați putea fi interesat și de:

• Ce este un cadru în inginerie software, defidefiniție și tipuri de cadre
• Reply se află în topul PAC Innovation RADAR ca furnizor principal de servicii Salesforce în Europa
• SOLID care sunt cele 5 principii ale programării orientate pe obiecte
• Principiul substituției Liskov, al treilea principiu SOLID
• Europa acceptă utilizarea instrumentelor native din cloud pe măsură ce piața se maturizează