Aš dažnai matau komandas pasiekti (per Socket.io arba Pusher), kai jiems tiesiog reikia atnaujinti naudotojo sąsają su serverio pusės būsenos pokyčiais. Nors "WebSockets" yra galingi, jie dažnai yra pernelyg dideli. Tai yra protokolas, kurį turėtumėte valdyti. WebSockets Server-Sent Events (SSE) SSE veikia per standartinį HTTP/1.1 arba HTTP/2. Ji nereikalauja sudėtingų rankų, veikia su standartiniais autentifikavimo mechanizmais, o natūralus palaikymas yra pastatytas į kiekvieną šiuolaikinę naršyklę per . EventSource API Šiame vadove mes įgyvendinsime SSE „Symfony 7.4“ naudojant du metodus: 
 
 
 Natūralus požiūris: naudojant StreamedResponse (puikus suprasti protokolą ir paprastas, mažai konkurencijos užduotis). Gamybos metodas: naudojant „Mercure“ protokolą (skaliuojamas, neužblokuojantis „Symfony“ standartas). Vietinis požiūris (StreamedResponse) Simfonijos Leidžia jums ir palaipsniui išplauti duomenis į klientą.Tai yra SSE standarto „žalias“ įgyvendinimas. StreamedResponse keep an HTTP connection open Mes naudosime generatorių arba grandinę, kad imituotume srautinį duomenų srautą. namespace App\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\Routing\Attribute\Route;

#[Route('/api/stream', name: 'api_stream_stock')]
class StockStreamController extends AbstractController
{
    #[Route('/stock/{symbol}', name: 'stock_ticker', methods: ['GET'])]
    public function stream(string $symbol): StreamedResponse
    {
        // 1. Create the StreamedResponse
        $response = new StreamedResponse(function () use ($symbol) {
            // 2. Prevent PHP time limits for long-running processes
            set_time_limit(0); 
            
            // 3. Simple loop to simulate data stream
            // In a real app, you might check Redis or a Database here
            $i = 0;
            while (true) {
                // Connection check: Stop if client disconnected
                if (connection_aborted()) {
                    break;
                }

                $data = [
                    'symbol' => strtoupper($symbol),
                    'price' => rand(100, 200),
                    'timestamp' => date('c'),
                    'sequence' => $i++
                ];

                // 4. Format according to SSE Spec
                // Format: "data: {payload}\n\n"
                echo "event: stock_update\n"; // Optional event name
                echo 'data: ' . json_encode($data) . "\n\n";

                // 5. Critical: Flush the buffer to send data immediately
                ob_flush();
                flush();

                // simulate delay
                sleep(2);
            }
        });

        // 6. Set Headers specifically for SSE
        $response->headers->set('Content-Type', 'text/event-stream');
        $response->headers->set('Cache-Control', 'no-cache');
        $response->headers->set('X-Accel-Buffering', 'no'); // Crucial for Nginx

        return $response;
    }
}
 Tam nereikia bibliotekos. naršyklės gimtoji „EventSource“ yra tvirta. <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Symfony SSE Stream</title>
</head>
<body>
    <h1>Live Ticker: <span id="symbol">LOADING...</span></h1>
    <div id="price" style="font-size: 2rem;">--</div>
    <ul id="log"></ul>

    <script>
        const symbol = 'AAPL';
        // Connect to the Symfony endpoint
        const eventSource = new EventSource(`/api/stream/stock/${symbol}`);

        // Listen for the specific 'stock_update' event name defined in PHP
        eventSource.addEventListener('stock_update', (e) => {
            const data = JSON.parse(e.data);
            
            document.getElementById('symbol').innerText = data.symbol;
            document.getElementById('price').innerText = '$' + data.price;
            
            // Log for visibility
            const li = document.createElement('li');
            li.innerText = `${data.timestamp}: $${data.price}`;
            document.getElementById('log').prepend(li);
        });

        eventSource.onerror = (err) => {
            console.error("EventSource failed:", err);
            // EventSource auto-reconnects by default, but you can handle closure here
        };
    </script>
</body>
</html>
 Serverio konfigūracija (kritinė) Štai kur dauguma kūrėjų nepavyksta. žiniatinklio serveriai (nginx ir kt.) mėgsta buferio išvestį, kad optimizuotų suspaudimą. „SSE“ atveju buferiavimas žudo srautą (klientas negauna nieko, kol buferis neužpildo). Turi būti neįgalus Arba naudokite Mes pridėjome kontrolierių. fastcgi_buffering X-Accel-Buffering: no header # inside your location ~ \.php$ block
fastcgi_split_path_info ^(.+\.php)(/.+)$;
# ... standard config ...
# Ensure buffering is off for SSE if headers fail
fastcgi_buffering off;
 Patikrinkite savo Užtikrinkite Nustatyta į Arba mažos vertės. php.ini output_buffering Off Patikrinimas : 
 
 
 
 
 
 Start your local server:  symfony server:start 
 
 Open your terminal. 
 
 Use   to verify the stream without a browser: curl curl -N -v http://127.0.0.1:8000/api/stream/stock/AAPL
 
 
 
 N: Išjungia buferiavimą kreivėse. Tikėtina išvestis: turėtumėte matyti vieną JSON objektą kas 2 sekundes. „Senior“ realybės patikrinimas (kodėl vietiniai yra pavojingi) Nors aukščiau pateiktas kodas veikia, retai rekomenduoju jį didelio srauto gamybos programoms. Kai klientas prisijungia prie /api/stream/stock/AAPL, šis PHP-FPM darbuotojo procesas įeina į • . PHP is synchronous while(true) loop It is locked Jei turite 50 PHP-FPM darbuotojų ir 50 vartotojų atidaro šį puslapį, visa jūsų svetainė sugenda. Jis taip pat išlaiko atvirą duomenų bazės ryšį, jei nesate atsargūs. Jūs turite atsisiųsti atvirą ryšio valdymą į specialiai jam sukurtą paslaugą. „Symfony“ ekosistemoje šis sprendimas . Mercure Gamybos metodas (Gyvsidabrio metodas) "Mercure" yra atviras protokolas, skirtas realaus laiko atnaujinimams. 
 
 
 
 
 Klientas prisijungia prie „Hub“ (o ne jūsų „PHP“ programėlės), kad galėtų klausytis įvykių. Symfony siunčia vieną POST užklausą į centrą, kai duomenys pasikeičia. Hub transliuoja duomenis tūkstančiams klausytojų. Rezultatas: nulinis PHP procesų blokavimas. Gamybos aplinkoje jūs negalite palikti savo srauto viešai. turite kontroliuoti, kas gali klausytis ko. Gyvsidabrio naudojimas Dėl to JSON Web Tokens (JWT) 
 
 
 Publisher JWT: Leidžia jūsų „Symfony“ programai stumti duomenis (automatiniu būdu tvarkomus paketu per MERCURE_JWT_SECRET). Abonentas JWT: leidžia vartotojo naršyklę klausytis privačių atnaujinimų. Štai kaip įgyvendinti Išmanusis telefonas „Symfony 7.4“ Subscriber JWT Įdiegti JWT biblioteką Mums reikia bibliotekos rankiniu būdu generuoti žetonus mūsų vartotojams. Tai yra PHP ekosistemos standartas. lcobucci/jwt composer require lcobucci/jwt
 Token Generator paslaugos Sukurkite paslaugą, kuri sukuria pasirašytą JWT konkrečiam vartotojui. reikalauti, kad būtų išvardytos temos, kurioms vartotojas turi teisę naudotis. mercure //src/Service/MercureTokenGenerator.php

namespace App\Service;

use Lcobucci\JWT\Configuration;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use Lcobucci\JWT\Signer\Key\InMemory;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

class MercureTokenGenerator
{
    private Configuration $config;

    public function __construct(
        // Inject the same secret used in your .env for the Mercure Hub
        #[Autowire('%env(MERCURE_JWT_SECRET)%')]
        private string $secret
    ) {
        $this->config = Configuration::forSymmetricSigner(
            new Sha256(),
            InMemory::plainText($this->secret)
        );
    }

    public function generate(string $userTopic): string
    {
        return $this->config->builder()
            ->withClaim('mercure', [
                'subscribe' => [
                    $userTopic, // Allow access to this specific topic
                    // 'https://mysite.com/books/{id}' // You can add patterns here
                ]
            ])
            ->getToken($this->config->signer(), $this->config->signingKey())
            ->toString();
    }
}
 Žetonų įvedimas (slapukų metodas) Native naršyklė nepalaiko HTTP antraštės siuntimo (pvz., ) ir EventSource API Authorization: Bearer Norėdami tai išspręsti nepridėdami sunkių JavaScript polyfills, mes naudojame „Mercure Hub“ automatiškai ieško slapuko, pavadinto . Cookie mercureAuthorization //src/Controller/StockPageController.php

namespace App\Controller;

use App\Service\MercureTokenGenerator;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class StockPageController extends AbstractController
{
    #[Route('/dashboard', name: 'app_dashboard')]
    public function index(MercureTokenGenerator $tokenGenerator): Response
    {
        // 1. Define the private topic this user is allowed to see
        $userTopic = 'https://mysite.com/user/123/alerts';

        // 2. Generate the JWT
        $token = $tokenGenerator->generate($userTopic);

        // 3. Create the response (render your Twig template)
        $response = $this->render('dashboard/index.html.twig', [
            'userTopic' => $userTopic
        ]);

        // 4. Attach the JWT as a Cookie
        // The Hub must be on the same domain (or subdomain) for this to work
        $response->headers->setCookie(Cookie::create(
            'mercureAuthorization',
            $token,
            0,              // Session cookie
            '/.well-known/mercure', // Path (critical: restricts cookie to Hub)
            null,           // Domain (null = current domain)
            false,          // Secure (true if HTTPS)
            true,           // HttpOnly
            false,          // Raw
            'strict'        // SameSite
        ));

        return $response;
    }
}
 Atnaujinti leidėją Dabar atnaujinkite savo leidėjo paslaugą, kad atnaujinimas būtų pažymėtas kaip privatus. // ...
public function publishPrivateAlert(string $userId, string $message): void
{
    $topic = "https://mysite.com/user/{$userId}/alerts";
    
    $update = new Update(
        $topic,
        json_encode(['alert' => $message]),
        true // <--- TRUE marks this as Private
    );

    $this->hub->publish($update);
}
 Kliento pusė (reikalingų pakeitimų nėra) Kadangi mes naudojame a , JavaScript išlieka tas pats. naršyklė automatiškai išsiųs slapukas, kai jis prisijungia prie Hub. Cookie mercureAuthorization // The browser sends the cookie automatically!
const eventSource = new EventSource(hubUrl);
 patikrinimas 
 
 
 
 
 Išvalyti slapukus: Išvalykite savo naršyklės slapukus. Load Dashboard: Visit /dashboard. Patikrinkite tinklo skirtuką. Turėtumėte matyti Set-Cookie antraštę su mercureAuthorization. Patikrinkite ryšį: „EventSource“ užklausa į centrą dabar turėtų būti žalia (200 „OK“). Testavimas Privatumas: Pabandykite tiesiogiai apvynioti centrą be slapuko; gausite 401 Neįgaliotas privačioms temoms. Išvada Kaip mes išnagrinėjome, „Symfony 7.4“ realaus laiko duomenų įgyvendinimas yra ne tik apie ryšio atidarymą, bet ir apie tai, kaip pasirinkti architektūrą, atitinkančią jūsų eismo modelius. Tuo metu, kai siūlo greitą, nepriklausomą maršrutą administracinėms užduotims (pavyzdžiui, eksporto pažangos juostoms) arba mažai eismo turinčioms vidinėms priemonėms, ji kelia didelę riziką, susijusią su PHP darbuotojų išsekimu. Native StreamedResponse Dėl bet kokios vartotojui skirtos funkcijos, nesvarbu, ar tai yra tiesioginė valdymo lentelė, pranešimų centras, ar bendradarbiavimo įrankis. Tai yra Dėl to Jis visiškai atjungia jūsų programų logiką nuo ryšio valdymo, leidžiančio jūsų „Symfony“ atgalinei galiai išlikti neprilygstamai ir efektyviai, o „Caddy“ susidoroja su sunkiu tūkstančių tuščių ryšių palaikymu. Mercure non-negotiable standard modern Symfony ecosystem Šių modelių įsisavinimas leidžia jums pereiti už paprastų "request-response" gyvavimo ciklų ir kurti programas, kurios jaučiasi gyvos ir reaguojančios. Laikykimės prisilietimo Realaus laiko architektūra dažnai sukelia paslėptų sudėtingumų, susijusių su apkrovos balansavimu, atvirkštine proxy konfigūracija (Nginx / HAProxy) ir saugumo ribomis. Aptarkime, kaip mes galime paruošti jūsų paraišką realiu laiku.

Read My Stories

Šis garso įrašas sukurtas originalia istorijos kalba!

Viskas, ką reikia žinoti, kad galėtumėte valdyti serverio siunčiamus įvykius (SSE) „Symfony 7.4“

About Author

KOMENTARAI

PABAIGTI ŽYMES

ŠIS STRAIPSNIS BUVO PRISTATYMAS

Related Stories

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps