הרכיב Symfony Cache הוא לעתים קרובות הכלי הנפוץ ביותר בארסנל של מפתחים. בעוד פונקציונלי, זה בקושי מגרד את פני השטח של מה המרכיב יכול לעשות בסביבות גבוהות, מפוזרות. $cache->get() ב-Symfony 7.3, הרכיב Cache אינו רק אחסון ערכים מפתח; זהו מערכת מתוחכמת המסוגלת לארכיטקטורה ברמה, הגנה מפני סיכוי, והצפנה גלויה. מאמר זה בוחן אסטרטגיות קישוריות חשובות לפתור בעיות אדריכליות יקרות: , (הנפילה של העדר) (למשל ) ו . latency concurrency security GDPR distributed invalidation ארכיטקטורה של עיכוב: שרשרת (Chain) Caching בארכיטקטורות של מיקרו-שירותים או מונוליטים עם תנועה גבוהה, שיחת רשת ל-Redis (בדרך כלל 1-3ms) עלולה בסופו של דבר להפוך לבלבול בהשוואה לזיכרון מקומי (ננו-שניות). הפתרון הוא a לפעול בצורה יעילה כמו קיצור עבור היישום שלך. , . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) • Configuration אנו נגדיר קבוצה שמקריאה תחילה מ- APCu. אם היא מפספסת, היא קוראת מ- Redis, ולאחר מכן מקריאה מ- APCu. composer require symfony/cache symfony/orm-pack redis
 תבנית ( ) : config/packages/cache.yaml framework:
    cache:
        # Prefix all keys to avoid collisions in shared Redis instances
        prefix_seed: '%env(APP_SECRET)%'

        pools:
            # L2 Cache: Redis (Shared)
            cache.redis:
                adapter: cache.adapter.redis
                provider: 'redis://%env(REDIS_HOST)%:6379'
                default_lifetime: 3600 # 1 hour

            # L1 Cache: APCu (Local Memory)
            cache.apcu:
                adapter: cache.adapter.apcu
                default_lifetime: 60 # Short TTL to prevent stale local data

            # The Chain: L1 + L2
            cache.layered:
                adapter: cache.adapter.chain
                provider: [cache.apcu, cache.redis]
 שימוש הזרקו את האוכלוסייה הספציפית באמצעות המאפיין Target. namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

class DashboardService
{
    public function __construct(
        #[Target('cache.layered')]
        private readonly CacheInterface $cache
    ) {}

    public function getStats(): array
    {
        // 1. Checks APCu. Hit? Return.
        // 2. Miss? Checks Redis. Hit? Populate APCu & Return.
        // 3. Miss? Run Callback. Populate Redis & APCu.
        return $this->cache->get('stats_v1', function (ItemInterface $item): array {
            $item->expiresAfter(3600);
            return $this->computeHeavyStats();
        });
    }
    
    private function computeHeavyStats(): array 
    { 
        // Simulation of heavy work
        return ['users' => 10500, 'revenue' => 50000]; 
    }
}
 בדיקת 
 
 
 
 
 
 Cache Clear: bin/console cache:pool:clear cache.layered בקש את הדף בחר Redis (CLI): KEYS * (אתה תראה את המפתח). בדוק APCu (פאנל האינטרנט): תראה את המפתח. התוכנה תמשיך לשרת מ-APCu למשך 60 שניות. לפתור את עדר הזעזוע: סיכוי פריחה מוקדמת "Cache Stampede" (או Thundering Herd) מתרחש כאשר מפתח קערה חם נופל. פתאום, 1,000 בקשות מקבילות מפספסים את הקערה בו זמנית ופוגעות במסד הנתונים שלך כדי לחשב את אותה ערך. סימפוניה פותרת את זה מנגנוני מנעול מורכבים (כמו Semaphore) באמצעות . without Probabilistic Early Expiration איך זה עובד במקום להסתיים בדיוק בשעה 12:00:00, הקאש טוען להיות ריק מעט לפני הסוף, אבל רק עבור כמה בקשות.ככל שהסוף מתקרב, כך הסיכוי גבוה יותר לפספס. היישום אינך זקוק להגדרה חדשה; אתה צריך להשתמש הפרמטרים של החוזה $beta // $beta of 1.0 is standard. 
// Higher = recompute earlier. 
// 0 = disable. 
// INF = force recompute.
$beta = 1.0; 

$value = $this->cache->get('stock_ticker_aapl', function (ItemInterface $item) {
    // The item ACTUALLY expires in 1 hour
    $item->expiresAfter(3600);
    
    return $this->stockApi->fetchPrice('AAPL');
}, $beta);
 בדיקה מתמטית אין פקודה CLI כדי "להוכיח" את הסיכוי, אבל אתה יכול להקליט את החישובים. 
 
 
 
 להגדיר $item->expiresAfter(10). צור מעגל שמשפיע על מפתח ה-Cache הזה כל 100ms. שים לב כי השיחה חוזרת מופעלת לפני 10 שניות עברו, ובדרך כלל רק פעם אחת, כדי להבטיח כי הקצה האחורי שלך מוגן. הקופסה השחורה: הצפנה שקופה עם נתרן Caching (PII) ב Redis הוא a אם תוקף דופק את זיכרון Redis שלך, יש לו את הנתונים. Personal Identifiable Information GDPR/security risk Symfony מאפשר לך לעטוף את מתאם ה-Cache שלך ב אנחנו נשתמש ב כדי להצפין באופן גלוי את הנתונים לפני שהם עוזבים את PHP ולהחזיר אותם לאחר החיפוש. Marshaller SodiumMarshaller מבטיח זה ההרחבה היא עקבו אחרי php 8.x libsodium installed enabled - Configuration אנחנו צריכים לקשט את המרשל default.We will use a “ ” מרשלר (להדביק נתונים) מעוטר בתוך ” מרסלר (להסתיר את זה) Deflate Sodium #config/services.yaml

services:
    # 1. Generate a key: php -r "echo bin2hex(random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES));"
    # Store this in .env.local: CACHE_DECRYPTION_KEY=your_hex_key
    
    # 2. Define the Marshaller Service
    app.cache.marshaller.secure:
        class: Symfony\Component\Cache\Marshaller\SodiumMarshaller
        arguments: 
            - ['%env(hex2bin:CACHE_DECRYPTION_KEY)%']
            - '@app.cache.marshaller.deflate' # Chain encryption OVER compression

    app.cache.marshaller.deflate:
        class: Symfony\Component\Cache\Marshaller\DeflateMarshaller
        arguments: ['@default_marshaller']
        
    default_marshaller:
        class: Symfony\Component\Cache\Marshaller\DefaultMarshaller

    # 3. Use the custom marshaller in your cache adapter
    Symfony\Component\Cache\Adapter\RedisAdapter:
        arguments:
            $marshaller: '@app.cache.marshaller.secure'
 #config/packages/cache.yaml

framework:
    cache:
        pools:
            cache.secure:
                adapter: cache.adapter.redis
                # We need to point the 'default_marshaller' of this pool to our secure one?
                # Actually, defining the adapter service globally as we did above 
                # is the cleanest way if you want ALL redis caches encrypted.
                # Alternatively, use the provider syntax:
                
                # For specific pool encryption, we often have to define the service manually 
                # or use a factory because framework.yaml config is limited for complex DI.
 גישה מעודכנת לסימפוניה (הפרקטיקה הטובה ביותר): במקום להעלים את המתאם הגלובלי, להגדיר את שירות הבריכה באופן מפורש כדי להדביק את מרשלר. # config/services.yaml
services:
    app.cache.secure_pool:
        class: Symfony\Component\Cache\Adapter\RedisAdapter
        arguments:
            $redis: 'redis://%env(REDIS_HOST)%:6379'
            $marshaller: '@app.cache.marshaller.secure'
        tags: ['cache.pool']
 שימוש public function storeUserAddress(int $userId, string $address): void
{
    // This data is compressed and encrypted in Redis
    $cacheItem = $this->securePool->getItem('user_addr_' . $userId);
    $cacheItem->set($address);
    $this->securePool->save($cacheItem);
}
 בדיקת 
 
 
 
 
 
 שמור את הנתונים ב-Cache התחבר ל- Redis באמצעות CLI: redis-cli. קח את המפתח. תוצאה: תראה זבל בינארי (שורת מוצפנת), לא את כתובת הטקסט הפשוט. קבל אותו באמצעות PHP: אתה מקבל את הכתובת plaintext. תגית: Tags & Messenger הבעיה הקשה ביותר במדעי המחשב היא ביטול הקאש.היא הופכת לקשה יותר כאשר יש לך 5 שרתים אינטרנט (פודים).אם שרת A מעודכן מוצר, הקאש APCu של שרת B עדיין מחזיק את המוצר הישן. אנו פותרים את זה על ידי שידור הודעות ביטול באמצעות Symfony Messenger. האסטרטגיה 
 
 
 
 
 לכתוב ל Redis (שיתוף) קח מקומי ב- APCu (למהירות) כאשר הנתונים משתנים, שלח הודעה לאוטובוס. כל השרתים צורכים את ההודעה ומסירים את APCu המקומי שלהם עבור התווית הספציפית. - Configuration composer require symfony/messenger
 אנחנו צריכים תחבורה התומכת "Pub / Sub" (Fanout), כך שכל שרת מקבל את ההודעה. #config/packages/messenger.yaml

framework:
    messenger:
        transports:
            # Use a fanout exchange so ALL pods receive the message
            cache_invalidation: 
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    exchange:
                        type: fanout
                        name: cache_invalidation_fanout
 הקוד 1. The Invalidation Message namespace App\Message;

final readonly class InvalidateTagsMessage
{
    public function __construct(
        public array $tags
    ) {}
}
 2. The Handler This handler runs on every server. namespace App\MessageHandler;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Contracts\Cache\TagAwareCacheInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;

#[AsMessageHandler]
final readonly class InvalidateTagsHandler
{
    public function __construct(
        #[Target('cache.layered')] // Target our Chain Cache
        private TagAwareCacheInterface $cache
    ) {}

    public function __invoke(InvalidateTagsMessage $message): void
    {
        // This invalidates the local APCu layer AND the shared Redis layer
        $this->cache->invalidateTags($message->tags);
    }
}
 3. The Service Triggering the Change namespace App\Service;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Contracts\Cache\TagAwareCacheInterface;

class ProductService
{
    public function __construct(
        private TagAwareCacheInterface $cache,
        private MessageBusInterface $bus
    ) {}

    public function updateProduct(int $id, array $data): void
    {
        // 1. Update Database...
        
        // 2. Invalidate
        // We do NOT call $cache->invalidateTags() directly here.
        // Because that would only clear THIS server's APCu and the shared Redis.
        // Other servers would remain stale.
        
        $this->bus->dispatch(new InvalidateTagsMessage(["product_{$id}"]));
    }
}
 תכונה #[Cacheable] במקום לכתוב כל שיטת שירות, בואו ליצור זה מתבצע באופן אוטומטי באמצעות או . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription למטה מופיעה יישום נקי באמצעות a שמיעה, אשר יעיל וקל להגיב על. Kernel::CONTROLLER_ARGUMENTS The Attribute namespace App\Attribute;

use Attribute;

#[Attribute(Attribute::TARGET_METHOD)]
final readonly class Cacheable
{
    public function __construct(
        public string $pool = 'cache.app',
        public int $ttl = 3600,
        public ?string $key = null
    ) {}
}
 המנוי לאירוע מקשיב זה עוקב אחר שיחות מנהל, בודק את המאפיין ומנסה לשרת מהקאש. יישום פשוט זה מניח שהמעבד מחזיר תשובה סדרתית כללית (כמו JSON או מסדרה). namespace App\EventSubscriber;

use App\Attribute\Cacheable;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\ControllerEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\DependencyInjection\ServiceLocator;
use Symfony\Contracts\Cache\ItemInterface;

class CacheableSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private ServiceLocator $cachePools // Inject locator to find pools dynamically
    ) {}

    public static function getSubscribedEvents(): array
    {
        return [
            // High priority to catch request before execution
            KernelEvents::CONTROLLER => ['onKernelController', 10], 
        ];
    }

    public function onKernelController(ControllerEvent $event): void
    {
        $controller = $event->getController();

        // Handle array callables [$object, 'method']
        if (is_array($controller)) {
            $method = new \ReflectionMethod($controller[0], $controller[1]);
        } elseif (is_object($controller) && is_callable($controller)) {
            $method = new \ReflectionMethod($controller, '__invoke');
        } else {
            return;
        }

        $attributes = $method->getAttributes(Cacheable::class);
        if (empty($attributes)) {
            return;
        }

        /** @var Cacheable $cacheable */
        $cacheable = $attributes[0]->newInstance();

        if (!$this->cachePools->has($cacheable->pool)) {
            return;
        }

        $pool = $this->cachePools->get($cacheable->pool);
        
        // Generate a key based on Controller Class + Method + Request Params
        // This is a simplified key generation strategy
        $request = $event->getRequest();
        $cacheKey = $cacheable->key ?? 'ctrl_' . md5($request->getUri());

        // We cannot easily "skip" the controller execution inside a Listener 
        // using the Cache Contract pattern nicely without replacing the controller.
        // 
        // For a TRULY robust attribute implementation, one should use 
        // a "Service Decorator" logic, but for Controllers, we can replace the 
        // controller callable with a closure that wraps the cache logic.
        
        $originalController = $event->getController();
        
        $newController = function() use ($pool, $cacheKey, $cacheable, $originalController, $request) {
            return $pool->get($cacheKey, function (ItemInterface $item) use ($cacheable, $originalController, $request) {
                $item->expiresAfter($cacheable->ttl);
                
                // Execute the original controller
                // Note: We need to manually resolve arguments or pass the request
                // This part is tricky in raw PHP. 
                // In Symfony we can simply execute the original callable 
                // IF we have the resolved arguments.
                
                // SIMPLIFICATION for article:
                // Assuming controller takes Request object or no args
                return $originalController($request);
            });
        };

        $event->setController($newController);
    }
}
 אתה חייב הפולנים שלכם ב-A עבור The כדי לגשת אליהם באופן דינמי. register ServiceLocator Subscriber הקוד למעלה מצביע על שינוי באופן אידיאלי, עבור שירותים, אתה יכול להשתמש על הגדרת השירות, אבל עבור מנהלים, מעקב על האירוע הוא הדרך של הסימפוניה. Kernel execution flow #[AsDecorator] מסקנה יישום זה קל; ארכיטקטורה של אסטרטגיית קחיה שעלולה לשרוד מחלקות רשת, בדיקות ו סטיגמה היא משמעת. CacheInterface GDPR Black Friday traffic האסטרטגיות המתוארות כאן - על ידי Latency, על ידי תחרות, למען הביטחון, וכן עבור עקביות – להעביר את היישום שלך החוצה אופטימיזציות חלשות לכיוון הנדסה חזקה. Symfony מספק את הפרימיטיביות האלה מחוץ לקופסה, המאפשר לנו לפתור בעיות מערכות מפוזרות מורכבות מבלי להציג תשתית צד שלישי כבדה. Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation הפסיקו לטפל במקלדת כבסיס זמני, התייחסו אליה כאל שכבה קריטית ומאובטחת של אסטרטגיית המשכיות של הנתונים שלכם. בואו נמשיך את הדיון ארכיטקטורה PHP בעלת ביצועים גבוהים היא נוף מתפתח כל הזמן.אם אתה מתכנן מחדש מונולית מורשת או מעצב מערכת מפוזרת בסימפוניה, אשמח לשמוע על האתגרים שאתה עומד בפניהם. האם ביצעת Marshaller מותאם אישית לצרכים ספציפיים של תאימות? כיצד אתה מתמודד עם אי-אפליה של קישוריות בין הגדרות מרובות האזורים? בואו נרגע על אדריכלות, לשתף סיפורי מלחמה וליצור תוכנה טובה יותר.

Read My Stories

האודיו הזה מופק בשפת המקור של הסיפור!

אסטרטגיות קח חשובות: כיצד ליצור קח עמיד בסימפוניה

About Author

הערות

תלו תגים

מאמר זה הוצג ב

Related Stories

The TechBeat: How to Implement a Merkle Tree in Solidity (10/26/2023)

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/14/2024)

97 Stories To Learn About Quicknode

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

The TechBeat: How to Implement a Merkle Tree in Solidity (10/26/2023)

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/14/2024)

97 Stories To Learn About Quicknode

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps