Symfony Entity

last modified March 4, 2025

Symfony Entity tutorial shows how to create entities in Symfony application.

Symfony

Symfony is one of the leading PHP frameworks. It is a set of reusable PHP components and a PHP framework for web projects. Symfony was published as free software in 2005. Symfony was inspired by Django, RoR, and Spring frameworks.

Entity

An entity is a lightweight domain object which is to be persisted. Typically, an entity represents a table in a relational database, and each entity instance corresponds to a row in the table.

A repository is an abstraction of the persistence functionality. It allows to store, retrieve and search for entity objects. In essence, a repository is a collection of entity objects.

Symfony entity example

In the following example, we work with the City entity.

$ symfony new syment --version=7.2 --webapp
$ cd syment

We create a new Symfony 7.2 project with the --webapp option, which includes common bundles for web applications, and navigate to the project directory.

$ php bin/console --version
Symfony 7.2.0 (env: dev, debug: true)

We work with Symfony 7.2.0 version.

$ composer require symfony/orm-pack

We install the Doctrine ORM pack, which includes annotations and other necessary dependencies. The annot package is no longer needed separately as it's bundled with symfony/orm-pack.

$ composer require --dev orm-fixtures maker

We install the fixtures and maker bundles for development purposes. Fixtures load fake data into the database, and the maker bundle assists with scaffolding.

DATABASE_URL="sqlite:///%kernel.project_dir%/var/ydb.db"

In the .env file, we define the database URL. We use SQLite for simplicity in this example.

$ php bin/console doctrine:database:create

The doctrine:database:create command creates a new database based on the provided URL.

$ php bin/console make:entity

Using the make:entity command, we create a new City entity. This generates src/Entity/City.php and src/Repository/CityRepository.php. We add two properties: name (string, 255 characters) and population (integer).

<?php

namespace App\Entity;

use App\Repository\CityRepository;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: CityRepository::class)]
#[ORM\Table(name: 'cities')]
class City
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $name = null;

    #[ORM\Column]
    private ?int $population = null;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): static
    {
        $this->name = $name;
        return $this;
    }

    public function getPopulation(): ?int
    {
        return $this->population;
    }

    public function setPopulation(int $population): static
    {
        $this->population = $population;
        return $this;
    }
}

This is the City entity updated for Symfony 7.2. We use PHP 8 attribute syntax (e.g., #[ORM\Entity]) instead of PHPDoc annotations. The entity maps to the cities table.

<?php

namespace App\Repository;

use App\Entity\City;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;

/**
 * @extends ServiceEntityRepository<City>
 *
 * @method City|null find($id, $lockMode = null, $lockVersion = null)
 * @method City|null findOneBy(array $criteria, array $orderBy = null)
 * @method City[]    findAll()
 * @method City[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class CityRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, City::class);
    }
}

The CityRepository remains largely the same but uses modern PHP type hints and docblock notation.

$ php bin/console make:migration

We generate a migration with make:migration to version the database schema changes.

$ php bin/console doctrine:migrations:migrate

This applies the migration, creating a file like Version20250304120000.php (timestamp will vary).

<?php

declare(strict_types=1);

namespace DoctrineMigrations;

use Doctrine\DBAL\Schema\Schema;
use Doctrine\Migrations\AbstractMigration;

final class Version20250304120000 extends AbstractMigration
{
    public function getDescription(): string
    {
        return 'Create cities table';
    }

    public function up(Schema $schema): void
    {
        $this->addSql('CREATE TABLE cities (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, 
          name VARCHAR(255) NOT NULL, population INTEGER NOT NULL)');
    }

    public function down(Schema $schema): void
    {
        $this->addSql('DROP TABLE cities');
    }
}

The migration file now includes a description and simplified SQLite-specific SQL.

$ php bin/console make:fixtures

We create a CityFixtures class with make:fixtures to load sample data.

<?php

namespace App\DataFixtures;

use App\Entity\City;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;

class CityFixtures extends Fixture
{
    public function load(ObjectManager $manager): void
    {
        $cities = [
            ['name' => 'Bratislava', 'population' => 432000],
            ['name' => 'Budapest', 'population' => 1759000],
            ['name' => 'Prague', 'population' => 1280000],
            ['name' => 'Warsaw', 'population' => 1748000],
            ['name' => 'Los Angeles', 'population' => 3971000],
            ['name' => 'New York', 'population' => 8550000],
            ['name' => 'Edinburgh', 'population' => 464000],
            ['name' => 'Berlin', 'population' => 3671000],
        ];

        foreach ($cities as $data) {
            $city = new City();
            $city->setName($data['name']);
            $city->setPopulation($data['population']);
            $manager->persist($city);
        }

        $manager->flush();
    }
}

The CityFixtures class is updated with a more concise structure using an array and a loop.

$ php bin/console doctrine:fixtures:load

This command loads the fixture data into the cities table.

<?php

namespace App\Controller;

use App\Repository\CityRepository;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class CityController extends AbstractController
{
    #[Route('/cities', name: 'cities')]
    public function index(CityRepository $cityRepository): JsonResponse
    {
        $cities = $cityRepository->findAll();

        if (empty($cities)) {
            return new JsonResponse(['message' => 'No data found'], Response::HTTP_NOT_FOUND);
        }

        return $this->json($cities);
    }
}

The CityController uses the new #[Route] attribute syntax and returns a JsonResponse directly. The response handling is streamlined.

$ symfony serve

We start the Symfony development server.

$ curl localhost:8000/cities
[{"id":1,"name":"Bratislava","population":432000},
{"id":2,"name":"Budapest","population":1759000},
{"id":3,"name":"Prague","population":1280000},
{"id":4,"name":"Warsaw","population":1748000},
{"id":5,"name":"Los Angeles","population":3971000},
{"id":6,"name":"New York","population":8550000},
{"id":7,"name":"Edinburgh","population":464000},
{"id":8,"name":"Berlin","population":3671000}]

We test the endpoint with curl and retrieve the JSON data.

In this tutorial, we worked with an entity in a Symfony 7.2 application using modern PHP and Symfony features.

List all Symfony tutorials.