Recreate the cache with a job

To address the issue of high memory usage when recreating the cache for thousands of products, you can utilize Laravel's job dispatching system to handle each product cache creation in a separate process. This can be achieved by dispatching individual jobs for each product, which will allow Laravel to manage them independently and avoid memory exhaustion.

Here's a step-by-step solution:

1. Create a Job for Caching a Single Product:

   First, create a new job that will handle caching for a single product. You can use the php artisan make:job CacheProduct command to generate a job class.

   namespace App\Jobs;
   
   use Illuminate\Bus\Queueable;
   use Illuminate\Contracts\Queue\ShouldQueue;
   use Illuminate\Foundation\Bus\Dispatchable;
   use Illuminate\Queue\InteractsWithQueue;
   use Illuminate\Queue\SerializesModels;
   use App\Models\Product;
   use Illuminate\Support\Facades\Cache;
   
   class CacheProduct implements ShouldQueue
   {
       use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
   
       protected $productId;
   
       public function __construct($productId)
       {
           $this->productId = $productId;
       }
   
       public function handle()
       {
           $product = Product::find($this->productId);
   
           if ($product) {
               Cache::remember('product_show_' . $product->id, 60 * 60 * 24, function () use ($product) {
                   return [
                       "id" => $product->id,
                       "title" => $product->title,
                       "content" => $product->content,
                       "excerpt" => $product->excerpt,
                       // Add other fields as necessary
                   ];
               });
           }
       }
   }
   

2. Dispatch Jobs for Each Product:

   Modify your existing job to dispatch a CacheProduct job for each product. This will ensure that each product's cache is created in a separate process.

   namespace App\Jobs;
   
   use Illuminate\Bus\Queueable;
   use Illuminate\Contracts\Queue\ShouldQueue;
   use Illuminate\Foundation\Bus\Dispatchable;
   use Illuminate\Queue\InteractsWithQueue;
   use Illuminate\Queue\SerializesModels;
   use App\Models\Product;
   use App\Jobs\CacheProduct;
   
   class CacheAllProducts implements ShouldQueue
   {
       use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
   
       public function handle()
       {
           Product::where('status', 'publish')->chunk(15, function ($products) {
               foreach ($products as $product) {
                   CacheProduct::dispatch($product->id);
               }
           });
       }
   }
   

3. Configure Queue Worker:

   Ensure that your queue worker is running to process these jobs. You can start a queue worker using the following command:

   php artisan queue:work
   

   You might also want to configure a supervisor to manage your queue workers in a production environment.

4. Schedule the Job:

   Finally, schedule the CacheAllProducts job to run every 12 hours in your App\Console\Kernel.php file:

   protected function schedule(Schedule $schedule)
   {
       $schedule->job(new \App\Jobs\CacheAllProducts)->everyTwelveHours();
   }
   

By dispatching individual jobs for each product, you can significantly reduce memory usage and ensure that the cache is rebuilt efficiently without impacting the user experience.