Welcome back! As you continue to enhance your enterprise-ready Symfony application, it’s essential to manage errors effectively. Efficient error management not only improves user satisfaction but also simplifies the debugging process.

While Symfony’s default error handling is quite comprehensive, customizing error responses to fit your application’s requirements can provide better user experience and more insightful debugging information. In this lesson, you’ll discover how to build a custom ExceptionListener to handle exceptions and generate custom JSON responses.

By the end of this lesson, you will be capable of implementing a bespoke error handler in Symfony. The pivotal element here is a class named ExceptionListener, which intercepts exceptions and creates a customized JSON response.

To build the Exception Listener, begin by establishing the necessary directory and file structure. Within your src/ directory, create a new folder titled EventListener. Inside this folder, generate a PHP file named ExceptionListener.php.

Here is the complete code for the ExceptionListener class:

php
Copy to clipboard
1<?php
2
3namespace App\EventListener;
4
5use Symfony\Component\HttpKernel\Event\ExceptionEvent;
6use Symfony\Component\HttpFoundation\JsonResponse;
7
8class ExceptionListener
9{
10    public function onKernelException(ExceptionEvent $event)
11    {
12        $exception = $event->getThrowable();
13        $response = new JsonResponse([
14            'error' => $exception->getMessage(),
15            'code' => $exception->getCode(),
16            'message' => 'This error was intercepted by our custom exception handler',
17        ]);
18
19        $event->setResponse($response);
20    }
21}

The onKernelException method extracts the exception and constructs a JsonResponse with the error message, code, and a custom text. The getThrowable() method retrieves the exception instance that was thrown during HTTP request processing. The setResponse() method assigns the newly created JsonResponse to replace the default error response. ExceptionEvent represents the event triggered when an exception occurs during HTTP request processing. This allows the listener to intercept the exception and produce a customized response.

To enable Symfony to recognize our new exception listener, we need to declare it in services.yaml. Open config/services.yaml and append the following configuration:

YAML
Copy to clipboard
1services:
2    _defaults:
3        autowire: true
4        autoconfigure: true
5
6    App\:
7        resource: '../src/'
8        exclude:
9            - '../src/DependencyInjection/'
10            - '../src/Entity/'
11            - '../src/Kernel.php'
12
13    # Registering the ExceptionListener to manage exceptions
14    App\EventListener\ExceptionListener:
15        tags:
16            - { name: kernel.event_listener, event: kernel.exception, method: onKernelException }

The App\EventListener\ExceptionListener: line enlists ExceptionListener as an event listener. The tags section indicates it should listen for kernel.exception events and invoke the onKernelException method.

To verify our custom exception listener, simulate a scenario where a client tries to access a non-existent route. This action will raise an exception in your Symfony application, which our ExceptionListener will catch and return a customized JSON response.

Here’s an example of the JSON response you should receive if you attempt to access a non-existent route:

JSON
Copy to clipboard
1{
2    "error":" No route found for \u0022GET http:\/\/localhost:3000\/non-existent-route\u0022",
3    "code": 0,
4    "message": "This error was intercepted by our custom exception handler"
5}

When an exception arises, our ExceptionListener's onKernelException method captures it and generates this custom JSON response. This response will include:

• error: The exception's error message.
• code: The error code associated with the exception.
• message: A custom message indicating that our exception handler caught the error.

In this lesson, you learned how to enhance your Symfony application by creating a custom exception handler. You built an ExceptionListener class to capture exceptions and return tailored JSON responses, configured it in services.yaml, and tested it by triggering exceptions. Now, apply these concepts through the provided practice exercises to reinforce your understanding.