علاء عامر

تحسين الأداء في Laravel: دليل شامل للـ Performance Optimization

تحسين الأداء في Laravel: دليل شامل للـ Performance Optimization

دليل تخصصي من علاء عامر – مطور ومصمم مواقع وتطبيقات محترف

تحسين أداء Laravel أساسي لبناء تطبيقات سريعة وقابلة للتطوير. تعلم أحدث استراتيجيات الأداء والتحسين.

2️⃣ Caching Strategy الشامل

Multi-Level Caching:

<?php
// app/Services/CacheService.php
namespace App\Services;

use Illuminate\Support\Facades\{Cache, Redis};
use Illuminate\Database\Eloquent\Model;

class CacheService
{
    const CACHE_PREFIXES = [
        'posts' => 'posts:',
        'users' => 'users:',
        'categories' => 'categories:',
        'stats' => 'stats:',
        'search' => 'search:'
    ];

    const CACHE_DURATIONS = [
        'short' => 300,      // 5 دقائق
        'medium' => 3600,    // ساعة
        'long' => 86400,     // يوم
        'permanent' => 604800 // أسبوع
    ];

    /**
     * تخزين مؤقت للمقالات مع استراتيجية متقدمة
     */
    public function cachePost(int $postId, callable $callback, string $duration = 'medium'): mixed
    {
        $key = self::CACHE_PREFIXES['posts'] . $postId;

        return Cache::tags(['posts', "post.{$postId}"])
            ->remember($key, self::CACHE_DURATIONS[$duration], $callback);
    }

    /**
     * تخزين مؤقت للاستعلامات المعقدة
     */
    public function cacheQuery(string $key, callable $callback, array $tags = [], string $duration = 'medium'): mixed
    {
        return Cache::tags($tags)
            ->remember($key, self::CACHE_DURATIONS[$duration], $callback);
    }

    /**
     * تخزين مؤقت للإحصائيات
     */
    public function cacheStats(string $type, callable $callback): mixed
    {
        $key = self::CACHE_PREFIXES['stats'] . $type;

        return Cache::tags(['stats'])
            ->remember($key, self::CACHE_DURATIONS['long'], $callback);
    }

    /**
     * تخزين مؤقت للبحث
     */
    public function cacheSearch(string $term, array $filters, callable $callback): mixed
    {
        $key = self::CACHE_PREFIXES['search'] . md5($term . serialize($filters));

        return Cache::tags(['search'])
            ->remember($key, self::CACHE_DURATIONS['short'], $callback);
    }

    /**
     * محو cache متقدم
     */
    public function invalidatePost(int $postId): void
    {
        // محو cache المقال المحدد
        Cache::tags("post.{$postId}")->flush();

        // محو cache المقالات المرتبطة
        Cache::tags(['posts', 'homepage', 'categories'])->flush();

        // محو cache البحث
        Cache::tags(['search'])->flush();
    }

    /**
     * محو cache المستخدم
     */
    public function invalidateUser(int $userId): void
    {
        Cache::tags("user.{$userId}")->flush();
        Cache::forget(self::CACHE_PREFIXES['users'] . $userId);
    }

    /**
     * Warm up cache للبيانات المهمة
     */
    public function warmUpCache(): void
    {
        // تحميل المقالات الشائعة
        $this->cacheQuery('popular_posts', function () {
            return \App\Models\Post::popular(7)->limit(10)->get();
        }, ['posts', 'popular'], 'long');

        // تحميل التصنيفات
        $this->cacheQuery('all_categories', function () {
            return \App\Models\Category::with('posts_count')->get();
        }, ['categories'], 'permanent');

        // تحميل إحصائيات الموقع
        $this->cacheStats('site_stats', function () {
            return [
                'total_posts' => \App\Models\Post::published()->count(),
                'total_users' => \App\Models\User::active()->count(),
                'total_views' => \App\Models\Post::sum('views_count'),
            ];
        });
    }

    /**
     * Redis cache للبيانات السريعة
     */
    public function setRedisCache(string $key, mixed $value, int $seconds = 3600): void
    {
        Redis::setex($key, $seconds, serialize($value));
    }

    public function getRedisCache(string $key): mixed
    {
        $value = Redis::get($key);
        return $value ? unserialize($value) : null;
    }

    /**
     * Rate limiting cache
     */
    public function checkRateLimit(string $identifier, int $maxAttempts = 60, int $decayMinutes = 1): bool
    {
        $key = 'rate_limit:' . $identifier;
        $attempts = (int) Redis::get($key);

        if ($attempts >= $maxAttempts) {
            return false;
        }

        Redis::multi();
        Redis::incr($key);
        Redis::expire($key, $decayMinutes * 60);
        Redis::exec();

        return true;
    }
}

// app/Http/Middleware/CacheHeaders.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class CacheHeaders
{
    public function handle(Request $request, Closure $next, ...$options)
    {
        $response = $next($request);

        if ($request->method() === 'GET' && $response->getStatusCode() === 200) {
            $cacheType = $options[0] ?? 'default';

            switch ($cacheType) {
                case 'static':
                    $response->header('Cache-Control', 'public, max-age=31536000'); // سنة
                    break;
                case 'dynamic':
                    $response->header('Cache-Control', 'public, max-age=3600'); // ساعة
                    break;
                case 'private':
                    $response->header('Cache-Control', 'private, max-age=300'); // 5 دقائق
                    break;
                default:
                    $response->header('Cache-Control', 'public, max-age=1800'); // 30 دقيقة
            }

            $response->header('ETag', md5($response->getContent()));
        }

        return $response;
    }
}

View Caching المتقدم:

<?php
// app/Services/ViewCacheService.php
namespace App\Services;

use Illuminate\Support\Facades\{View, Cache};

class ViewCacheService
{
    /**
     * تخزين مؤقت للـ Views
     */
    public function cacheView(string $view, array $data = [], int $duration = 3600): string
    {
        $key = 'view:' . $view . ':' . md5(serialize($data));

        return Cache::remember($key, $duration, function () use ($view, $data) {
            return View::make($view, $data)->render();
        });
    }

    /**
     * Fragment caching للأجزاء المعقدة
     */
    public function cacheFragment(string $name, callable $callback, int $duration = 3600): string
    {
        $key = 'fragment:' . $name;

        return Cache::remember($key, $duration, $callback);
    }
}

// استخدام في Blade Templates
// resources/views/components/cached-sidebar.blade.php
@php
$cacheService = app(\App\Services\ViewCacheService::class);
@endphp

{!! $cacheService->cacheFragment('sidebar', function() {
    return view('partials.sidebar', [
        'categories' => \App\Models\Category::withCount('posts')->get(),
        'popular_posts' => \App\Models\Post::popular()->limit(5)->get(),
        'recent_posts' => \App\Models\Post::recent()->limit(5)->get()
    ])->render();
}, 3600) !!}

4️⃣ Front-end Optimization

Asset Optimization:

<?php
// webpack.mix.js - تحسين الأصول
const mix = require('laravel-mix');

mix.js('resources/js/app.js', 'public/js')
   .sass('resources/sass/app.scss', 'public/css')
   .options({
       processCssUrls: false,
       postCss: [
           require('autoprefixer'),
           require('cssnano')({
               preset: ['default', { discardComments: { removeAll: true } }]
           })
       ]
   })
   .version()
   .sourceMaps(false, 'source-map');

// تحسين الصور
mix.copy('resources/images', 'public/images')
   .then(() => {
       // ضغط الصور
       const imagemin = require('imagemin');
       const imageminPngquant = require('imagemin-pngquant');
       const imageminMozjpeg = require('imagemin-mozjpeg');

       imagemin(['public/images/*.{jpg,png}'], {
           destination: 'public/images/optimized',
           plugins: [
               imageminMozjpeg({ quality: 80 }),
               imageminPngquant({ quality: [0.6, 0.8] })
           ]
       });
   });

// Code splitting
mix.extract(['vue', 'axios', 'lodash']);

if (mix.inProduction()) {
    mix.options({
        terser: {
            terserOptions: {
                compress: {
                    drop_console: true,
                }
            }
        }
    });
}

CDN Integration:

<?php
// app/Services/CDNService.php
namespace App\Services;

class CDNService
{
    private array $cdnDomains;
    private bool $enabled;

    public function __construct()
    {
        $this->cdnDomains = config('cdn.domains', []);
        $this->enabled = config('cdn.enabled', false);
    }

    public function asset(string $path): string
    {
        if (!$this->enabled || empty($this->cdnDomains)) {
            return asset($path);
        }

        // توزيع الأصول على domains متعددة
        $domainIndex = crc32($path) % count($this->cdnDomains);
        $domain = $this->cdnDomains[$domainIndex];

        return rtrim($domain, '/') . '/' . ltrim($path, '/');
    }

    public function image(string $path, array $transformations = []): string
    {
        $url = $this->asset($path);

        if (!empty($transformations)) {
            $params = http_build_query($transformations);
            $url .= '?' . $params;
        }

        return $url;
    }
}

// Helper function
if (!function_exists('cdn_asset')) {
    function cdn_asset(string $path): string {
        return app(\App\Services\CDNService::class)->asset($path);
    }
}

// config/cdn.php
return [
    'enabled' => env('CDN_ENABLED', false),
    'domains' => [
        'https://cdn1.yoursite.com',
        'https://cdn2.yoursite.com',
        'https://cdn3.yoursite.com',
    ],
];

💡 Performance Monitoring

Advanced Performance Tracking:

<?php
// app/Middleware/PerformanceMonitor.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\{DB, Log, Redis};

class PerformanceMonitor
{
    public function handle(Request $request, Closure $next)
    {
        $startTime = microtime(true);
        $startMemory = memory_get_usage(true);

        // تسجيل بداية الطلب
        $requestId = uniqid();
        $request->attributes->set('request_id', $requestId);

        // تشغيل query logging
        DB::enableQueryLog();

        $response = $next($request);

        $endTime = microtime(true);
        $endMemory = memory_get_usage(true);

        $metrics = [
            'request_id' => $requestId,
            'url' => $request->fullUrl(),
            'method' => $request->method(),
            'execution_time' => round(($endTime - $startTime) * 1000, 2), // ms
            'memory_usage' => round(($endMemory - $startMemory) / 1024 / 1024, 2), // MB
            'peak_memory' => round(memory_get_peak_usage(true) / 1024 / 1024, 2),
            'queries_count' => count(DB::getQueryLog()),
            'response_size' => strlen($response->getContent()),
            'status_code' => $response->getStatusCode(),
            'user_id' => auth()->id(),
            'ip' => $request->ip(),
            'timestamp' => now()->toISOString(),
        ];

        // تحليل الاستعلامات البطيئة
        $slowQueries = collect(DB::getQueryLog())
            ->where('time', '>', 100) // أبطأ من 100ms
            ->count();

        if ($slowQueries > 0) {
            $metrics['slow_queries_count'] = $slowQueries;
        }

        // إرسال البيانات للتحليل
        $this->sendMetrics($metrics);

        // إضافة headers للتشخيص
        $response->headers->set('X-Execution-Time', $metrics['execution_time'] . 'ms');
        $response->headers->set('X-Memory-Usage', $metrics['memory_usage'] . 'MB');
        $response->headers->set('X-Queries-Count', $metrics['queries_count']);

        return $response;
    }

    private function sendMetrics(array $metrics): void
    {
        // إرسال للـ Redis للتحليل السريع
        Redis::lpush('performance_metrics', json_encode($metrics));
        Redis::ltrim('performance_metrics', 0, 1000); // الاحتفاظ بآخر 1000 طلب

        // تسجيل الطلبات البطيئة
        if ($metrics['execution_time'] > 1000) { // أبطأ من ثانية
            Log::warning('Slow request detected', $metrics);
        }

        // إرسال للـ monitoring service (مثل New Relic, DataDog)
        if (config('monitoring.enabled')) {
            $this->sendToMonitoringService($metrics);
        }
    }

    private function sendToMonitoringService(array $metrics): void
    {
        // إرسال البيانات لخدمة المراقبة الخارجية
    }
}

الخطوة التالية

تعلم Deployment و DevOps في Laravel لنشر تطبيقاتك بكفاءة عالية.

📩 هل تحتاج مساعدة في تحسين أداء تطبيقك؟