# How to Implement Queue in Laravel 9
Tags: webdev, beginners, programming, laravel
Published: 2023-09-14 11:18:59

# Introduction
Queues are an essential part of many web applications, especially when it comes to handling tasks that are time-consuming or need to be processed asynchronously. Laravel, a popular PHP framework, provides an elegant and efficient way to work with queues. In this blog post, we'll explore how to implement a queue in Laravel 9, the latest version as of my last knowledge update in September 2021.

## What is a Queue?

Before diving into Laravel's queue implementation, let's briefly understand what a queue is and why it's important in web development.

A queue is a data structure that follows the "first in, first out" (FIFO) principle, where the first item added to the queue is the first one to be processed. In the context of web development, queues are used to manage and process tasks or jobs asynchronously. These tasks can include sending emails, processing large data sets, generating reports, and more. By using queues, you can improve the performance and responsiveness of your application since time-consuming tasks can be delegated to background processes.

## Setting Up Laravel 9

Before you can implement a queue in Laravel 9, you need to have a Laravel project up and running. You can create a new Laravel project using Composer with the following command:

```bash
composer create-project laravel/laravel my-project
```

Once your project is set up, navigate to the project directory:

```bash
cd my-project
```

## Configuring the Queue System

Laravel supports multiple queue drivers, including Redis, RabbitMQ, and Amazon SQS. For this tutorial, we'll use the database queue driver, which stores the queued jobs in your application's database.

1. **Database Configuration**: Start by configuring your database connection in the `.env` file, which is located in the root directory of your Laravel project. Update the following lines with your database credentials:

   ```env
   DB_CONNECTION=mysql
   DB_HOST=127.0.0.1
   DB_PORT=3306
   DB_DATABASE=your_database_name
   DB_USERNAME=your_database_username
   DB_PASSWORD=your_database_password
   ```

2. **Queue Configuration**: Next, you need to configure the queue connection to use the database driver. Open the `config/queue.php` file and set the `connection` option to `'database'`:

   ```php
   'default' => env('QUEUE_CONNECTION', 'database'),
   ```

   Ensure that the `queue` table exists in your database. You can create it by running the following Artisan command:

   ```bash
   php artisan queue:table
   php artisan migrate
   ```

## Creating a Queue Job

Now that your Laravel project is configured to use the database queue driver, you can create a job that will be processed asynchronously. Laravel provides a convenient way to generate job classes using Artisan:

```bash
php artisan make:job ProcessTask
```

This command will generate a job class named `ProcessTask` in the `app/Jobs` directory.

Open the `app/Jobs/ProcessTask.php` file, and you will see a `handle` method. This method contains the code that will be executed when the job is processed. You can add your task logic here.

```php
<?php

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use App\Mail\WelcomeUserEmail;
use Illuminate\Support\Facades\Mail;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Contracts\Queue\ShouldBeUnique;

class SendWelcomeUserEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;


    protected $user;
    protected $password;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct($user,$password)
    {
        $this->user = $user;
        $this->password = $password;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        Mail::to($this->user['email'])
                ->send(new WelcomeUserEmail($this->user,$this->password)); 
    }
}
```

## Dispatching Jobs to the Queue

To dispatch a job to the queue, you can use the `dispatch` method. For example, you can dispatch the `ProcessTask` job like this:

```php
ProcessTask::dispatch();
```

You can also pass data to the job's constructor by chaining the `with` method:

```php
ProcessTask::dispatch()->withData($data);
```

## Starting the Queue Worker

To process the queued jobs, you need to start the Laravel queue worker. Open a terminal window and run the following command:

```bash
php artisan queue:work
```

This command will start a worker process that listens for incoming jobs and processes them as they arrive.

Alternatively, you may run the queue:listen command. When using the queue:listen command, you don’t have to manually restart the worker when you want to reload your updated code or reset the application state.
```bash
php artisan queue:listen
```
That’s it. Now your welcome mail will be delivered after the response was delivered to the browser. The mail process work in the background.

## Monitoring the Queue

Laravel provides a simple and easy-to-use dashboard for monitoring your queues. You can access the dashboard by running the following command:

```bash
php artisan horizon
```

Horizon is an official Laravel package that provides real-time monitoring for your queues, including job metrics, job retries, and more.

## Conclusion

Queues are a powerful tool for improving the performance and responsiveness of your Laravel applications. With Laravel 9, you can easily implement queues using various drivers, including the database driver, as demonstrated in this tutorial. By offloading time-consuming tasks to a queue, you can ensure that your application remains fast and responsive to user requests.

Now that you know how to implement a queue in Laravel 9, you can explore more advanced features and queue drivers to tailor your application to your specific needs. Happy coding!