Introduction to Controllers in Symfony MVC Architecture

Introduction to Controllers in Symfony

Welcome to the fourth lesson of our course on building an image generation service with Symfony! So far, we've built several key components of our application: the PromptManager for formatting user inputs, the ImageManager for storing and processing images, and the ImageGeneratorService that connects to an external API to generate images. Now, we're ready to add another important layer to our application architecture: the controller . In Symfony applications, controllers play a crucial role in the model-view-controller (MVC) pattern. They act as intermediaries between the service layer (which contains our business logic) and the presentation layer (which handles user interactions). The controller's primary responsibilities include: Receiving and validating input from the user interface. Calling the appropriate service methods with validated inputs. Handling errors that might occur during processing. Formatting responses in a consistent way before sending them back to the user. In our image generation application, the controller will receive text prompts from users, validate them, pass them to our ImageGeneratorService, and then format the responses (either successful image data or error messages) before sending them back. By adding this controller layer, we're further improving the separation of concerns in our application. The service layer can focus purely on business logic (generating images), while the controller handles the specifics of HTTP requests and responses. This makes our code more maintainable, testable, and easier to extend in the future.

Setting Up the Image Generator Controller

Let's start by creating our controller class. In Symfony, controllers are typically placed in the src/Controller directory. We'll create a new file called ImageGeneratorController.php in this directory. This controller will depend on our ImageGeneratorService to perform the actual image generation. Here's how we'll set up the basic structure of our controller: PHP<?php namespace App\Controller; use App\Service\ImageGeneratorService; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpFoundation\Request; class ImageGeneratorController extends AbstractController { private ImageGeneratorService $imageGeneratorService; public function __construct(ImageGeneratorService $imageGeneratorService) { $this->imageGeneratorService = $imageGeneratorService; } } In this code, we're creating a controller class that extends Symfony's AbstractController, which provides several helper methods for common controller tasks. We're also importing the necessary classes for handling HTTP requests and responses. The controller's constructor receives an instance of the ImageGeneratorService through dependency injection. Symfony's service container will automatically create and inject this dependency when the controller is instantiated. This approach follows the principle of dependency injection, making our code more modular and easier to test. Our controller will be responsible for two main operations: Generating a new image based on user input. Retrieving all previously generated images. For each of these operations, we'll create a dedicated method in our controller class. These methods will handle input validation, error handling, and response formatting, ensuring that our API provides a consistent interface to clients.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Implementing the Image Generation Endpoint

Now, let's implement the method for generating images. This method will receive user input, validate it, call the service to generate an image, and format the response:

PHP

public function generateImage(Request $request): JsonResponse
{
    $data = json_decode($request->getContent(), true);
    $userInput = $data['user_input'] ?? null;

    if (!$userInput) {
        return $this->json(['error' => 'User input is required'], 400);
    }

    try {
        $base64Image = $this->imageGeneratorService->generateImage($userInput);
        return $this->json(['image' => $base64Image]);
    } catch (\Throwable $e) {
        return $this->json(['error' => $e->getMessage()], 500);
    }
}

Let's break down what's happening in this method:

We extract the user input from the request body using Symfony's Request object. We use json_decode to parse the JSON body and extract the user_input field. If the input is missing or empty, we return an error response with a 400 status code (Bad Request). user_input is the canonical request field used throughout our application and by the frontend.

If the input is valid, we enter a try-catch block. Within the try block, we call the generateImage method of our service, passing the user input. This method will format the prompt, call the external API, and return the base64-encoded image data.

If the image generation is successful, we return a JSON response with an image key containing the base64 string. This response will have a default status code of 200 (OK).

If an exception occurs during image generation, we catch it in the catch block and return an error response with a 500 status code (Internal Server Error). The response includes the error message from the exception.

Notice how we're using HTTP status codes to indicate the nature of the response. This is a standard practice in RESTful APIs:

200: Success.
400: Client error (invalid input).
500: Server error (something went wrong on our end).

By returning both a response body and a status code, we provide clients with all the information they need to handle the response appropriately.

Manual Validation of the Controller

Now that we've implemented our controller, let's validate it to make sure it works correctly. In Symfony, we can create a command to test our controller functionality. Let's create a new command in src/Command/TestImageControllerCommand.php:

PHP

<?php

namespace App\Command;

use App\Controller\ImageGeneratorController;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\HttpFoundation\Request;

#[AsCommand(
    name: 'app:test-image-controller',
    description: 'Tests the ImageGeneratorController functionality',
)]
class TestImageControllerCommand extends Command
{
    private ImageGeneratorController $controller;

    public function __construct(ImageGeneratorController $controller)
    {
        parent::__construct();
        $this->controller = $controller;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $output->writeln('Testing image generation...');
        
        // Create a mock request with user input
        $request = new Request([], [], [], [], [], [], json_encode(['user_input' => 'Luxury Tech Conference 2025']));
        
        // Call the controller method
        $response = $this->controller->generateImage($request);
        $content = json_decode($response->getContent(), true);
        
        if (isset($content['error'])) {
            $output->writeln("Error: {$content['error']}");
        } else {
            $output->writeln("Generated Image:");
            $output->writeln(substr($content['image'], 0, 100) . '...');
        }
        
        // Test getting all images
        $output->writeln("\nTesting get all images...");
        $allImagesResponse = $this->controller->getImages();
        $allImagesContent = json_decode($allImagesResponse->getContent(), true);
        
        $output->writeln("All Images via Controller:");
        $output->writeln(json_encode($allImagesContent, JSON_PRETTY_PRINT));
        
        return Command::SUCCESS;
    }
}

In this command, we're injecting our ImageGeneratorController and using it to perform two operations:

First, we create a mock Request object with a sample user_input value and call the generateImage method. We check if the response contains an error key, which would indicate that something went wrong. If there's no error, we print a portion of the base64-encoded image data.

Then, we call the getImages method to retrieve all stored images. We print the JSON representation of the response, which includes all previously generated images.

To run this command, you would use:

php bin/console app:test-image-controller

When running this command with a properly configured application, you would see output similar to:

Testing image generation...
Generated Image:
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M9QDwADhg...

Testing get all images...
All Images via Controller:
{
    "images": [
        {
            "id": 0,
            "prompt": "# ROLE\nLead graphic designer\n\n# THEME...",
            "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwC..."
        }
    ]
}

The base64 string would be much longer in a real application, but it's truncated here for readability. This string represents the encoded image data that can be used directly in an HTML <img> tag.

Verifying Error Handling Behavior

Let's also test the error handling by creating another command that tests various error scenarios. Create a new file src/Command/TestControllerErrorsCommand.php:

PHP

<?php

namespace App\Command;

use App\Controller\ImageGeneratorController;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\HttpFoundation\Request;

#[AsCommand(
    name: 'app:test-controller-errors',
    description: 'Tests error handling in the ImageGeneratorController',
)]
class TestControllerErrorsCommand extends Command
{
    private ImageGeneratorController $controller;

    public function __construct(ImageGeneratorController $controller)
    {
        parent::__construct();
        $this->controller = $controller;
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        // Test with empty input
        $output->writeln('Testing with empty input...');
        $emptyRequest = new Request([], [], [], [], [], [], json_encode(['user_input' => '']));
        $emptyResponse = $this->controller->generateImage($emptyRequest);
        
        $output->writeln("Status Code: {$emptyResponse->getStatusCode()}");
        $output->writeln("Response: {$emptyResponse->getContent()}");
        
        // Test with missing user_input field
        $output->writeln("\nTesting with missing user_input field...");
        $missingInputRequest = new Request([], [], [], [], [], [], json_encode([]));
        $missingInputResponse = $this->controller->generateImage($missingInputRequest);
        
        $output->writeln("Status Code: {$missingInputResponse->getStatusCode()}");
        $output->writeln("Response: {$missingInputResponse->getContent()}");
        
        return Command::SUCCESS;
    }
}

This command tests two error scenarios:

Providing an empty user_input.
Not providing a user_input field at all.

To run this command, you would use:

php bin/console app:test-controller-errors

This would produce output like:

Testing with empty input...
Status Code: 400
Response: {"error":"User input is required"}

Testing with missing user_input field...
Status Code: 400
Response: {"error":"User input is required"}

This confirms that our controller correctly validates input and returns appropriate error responses with status codes.

In a real-world Symfony application, you would typically use PHPUnit and Symfony's testing tools to create functional tests for your controllers. These tests would simulate HTTP requests to your application and verify the responses. However, for the purpose of this lesson, we're using commands to manually test the controller functionality.

Summary and Practice Preview

In this lesson, we've built the ImageGeneratorController, which serves as an intermediary between our service layer and the Symfony routing system. This controller handles input validation, error management, and response formatting, providing a clean, consistent interface for clients to interact with our image generation service.

Let's review what we've learned:

We understood the role of controllers in Symfony's MVC architecture and how they fit into our application.
We created a controller class that extends AbstractController and depends on our ImageGeneratorService.
We implemented methods for generating images and retrieving previously generated ones.
We added input validation and error handling to ensure robust operation.
We tested our controller using Symfony commands to verify that it works correctly.

The ImageGeneratorController is a crucial component of our application architecture. It abstracts away the details of how images are generated and stored, presenting a clean, consistent API to clients. This separation of concerns makes our code more maintainable, testable, and easier to extend.

In the next lesson, we'll explore Symfony's routing system in more detail and create a complete web API for image generation. We'll define routes that clients can call to generate images and retrieve previously generated ones, and we'll see how Symfony's routing system maps HTTP requests to controller actions.

In the upcoming practice exercises, you'll have the opportunity to work with the ImageGeneratorController, testing its functionality with different inputs and exploring how it handles various scenarios. You'll also get to experiment with error handling and see how the controller formats responses for different types of requests.

With the ImageGeneratorController in place, we're one step closer to having a complete image generation web application. In the next lesson, we'll see how to expose our controller's functionality through HTTP endpoints using Symfony's powerful routing system.

Introduction to Controllers in Symfony MVC Architecture