Bases du mappage relationnel objet (ORM) : comprendre la doctrine ORM

Bases du mappage relationnel objet (ORM) : comprendre la doctrine ORM

Lorsque nous développons des applications, nous devons opérer sur la base de données pour stocker et récupérer des données. Cependant, il n'est pas pratique d'utiliser directement le code de requête de base de données d'origine. Nous devons établir une relation de cartographie entre les objets et les données. C'est le rôle de l'ORM. ORM mappe et convertit automatiquement les objets et les tables de base de données, permettant une manipulation facile des données, rendant notre code plus facile à maintenir.

Doctrine ORM est l'un des frameworks ORM les plus populaires en PHP. Il utilise une méthode simple mais efficace pour mapper les objets PHP et les tables de base de données, fournissant ainsi une API facile à utiliser pour les opérations CRUD.

Cet article présentera quelques connaissances de base de Doctrine ORM, notamment la configuration, l'entité, le mappage, la requête, etc.

Configuration

Avant de commencer, nous devons installer Doctrine ORM. Il peut être installé via Composer, en utilisant la commande suivante :

composer require doctrine/orm

Ensuite, dans notre fichier PHP, nous devons initialiser Doctrine. Cela peut être fait via le code suivant :

use DoctrineORMToolsSetup;
use DoctrineORMEntityManager;

require_once "vendor/autoload.php";

$paths = array("path/to/entity-files");
$isDevMode = false;

// the connection configuration
$dbParams = array(
    'driver'   => 'pdo_mysql',
    'user'     => 'your_database_user',
    'password' => 'your_database_password',
    'dbname'   => 'your_database_name',
);

$config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode);
$entityManager = EntityManager::create($dbParams, $config);

Dans le code ci-dessus, nous spécifions d'abord le chemin d'accès au fichier d'entité. Nous avons ensuite spécifié les paramètres de connexion à la base de données tels que le pilote, le nom d'utilisateur, le mot de passe et le nom de la base de données. Enfin, nous utilisons la fonction Setup::createAnnotationMetadataConfiguration() pour configurer les métadonnées, puis utilisons la fonction EntityManager::create() pour créer le gestionnaire d'entités.

Entity

En fait, Model et Entity sont la même chose. Nous devons créer une classe d'entité pour mapper la table de la base de données. Cette classe doit hériter de la classe DoctrineORMMappingClassMetadata et utiliser les annotations DoctrineORMMappingEntity et DoctrineORMMappingTable.

use DoctrineORMMapping as ORM;

/**
 * @ORMEntity
 * @ORMTable(name="users")
 */
class User
{
    /**
     * @ORMId
     * @ORMGeneratedValue
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="string")
     */
    private $name;

    /**
     * @ORMColumn(type="string", length=100, unique=true)
     */
    private $email;

    // ... getters and setters
}

Dans le code ci-dessus, nous avons défini une classe d'entité User qui mappera la table de base de données nommée "users". Il possède trois attributs : $id, $name et $email. Les annotations indiquent à Doctrine ORM comment mapper ces propriétés, par exemple la propriété $id est la clé primaire et est auto-incrémentée, la propriété $name est mappée à une colonne de base de données de type varchar, la propriété $email est mappée au type varchar et doit être unique dans la table de la base de données.

Mapping

Après avoir défini l'entité, nous devons indiquer à Doctrine ORM comment mapper l'entité à la table de la base de données. Nous pouvons utiliser XML, des commentaires ou YAML pour définir des relations de mappage.

Ici, nous utilisons l'annotation pour définir la relation de mappage. Par exemple, dans le code ci-dessous, nous définissons une relation de mappage pour mapper l'entité User à la table de la base de données : users

/**
 * @ORMEntity
 * @ORMTable(name="users")
 */
class User
{
    // properties ...

    // many-to-one association
    /**
     * @ORMManyToOne(targetEntity="Department")
     * @ORMJoinColumn(name="department_id", referencedColumnName="id")
     */
    private $department;
}

Dans le code ci-dessus, nous définissons une relation plusieurs-à-un (plusieurs-à-un). Toutes les définitions de relations de mappage doivent être marquées d’annotations.

Query

Doctrine ORM fournit un ensemble d'API de requête faciles à utiliser qui nous permettent d'effectuer facilement des opérations CRUD. Par exemple, le code suivant montre comment interroger une entité à l'aide de Doctrine :

$userRepository = $entityManager->getRepository('User');
$users = $userRepository->findAll();

foreach ($users as $user) {
    echo sprintf("-%s
", $user->getName());
}

Dans le code ci-dessus, nous utilisons la variable $entityManager pour obtenir une instance de référentiel utilisateur. Nous récupérons ensuite toutes les instances User à l’aide de la méthode findAll(), en imprimant le nom d’utilisateur de chaque instance.

Résumé

Cet article présente les bases de Doctrine ORM, y compris la configuration, les entités, le mappage et les requêtes. ORM est un outil très puissant qui peut grandement simplifier le codage des fonctions liées aux bases de données. J'espère que cet article vous aidera à comprendre ORM, et j'espère que vous pourrez en apprendre davantage sur Doctrine ORM et commencer à l'utiliser.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!