Grundlagen der objektrelationalen Zuordnung (ORM): Doctrine ORM verstehen

Grundlagen der objektrelationalen Zuordnung (ORM): Doctrine ORM verstehen

Wenn wir Anwendungen entwickeln, müssen wir mit der Datenbank arbeiten, um Daten zu speichern und abzurufen. Es ist jedoch unpraktisch, den ursprünglichen Datenbankabfragecode direkt zu verwenden. Wir müssen eine Zuordnungsbeziehung zwischen Objekten und Daten herstellen. Dies ist die Rolle von ORM. ORM ordnet Objekte und Datenbanktabellen automatisch zu und konvertiert sie, was eine einfache Datenmanipulation ermöglicht und die Wartung unseres Codes erleichtert.

Doctrine ORM ist eines der beliebtesten ORM-Frameworks in PHP. Es verwendet eine einfache, aber effektive Methode zum Zuordnen von PHP-Objekten und Datenbanktabellen und stellt eine benutzerfreundliche API für CRUD-Operationen bereit.

In diesem Artikel werden einige Grundkenntnisse von Doctrine ORM vorgestellt, einschließlich Konfiguration, Entität, Zuordnung, Abfrage usw.

Konfiguration

Bevor wir beginnen, müssen wir Doctrine ORM installieren. Es kann über Composer mit dem folgenden Befehl installiert werden:

composer require doctrine/orm

Als nächstes müssen wir in unserer PHP-Datei Doctrine initialisieren. Dies kann durch den folgenden Code erfolgen:

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);

Im obigen Code geben wir zunächst den Pfad zur Entitätsdatei an. Anschließend haben wir die Datenbankverbindungsparameter wie Treiber, Benutzername, Passwort und Datenbankname angegeben. Schließlich verwenden wir die Funktion Setup::createAnnotationMetadataConfiguration(), um die Metadaten zu konfigurieren, und verwenden dann die Funktion EntityManager::create(), um den Entity-Manager zu erstellen.

Entität

Tatsächlich sind Modell und Entität dasselbe. Wir müssen eine Entitätsklasse erstellen, um die Datenbanktabelle abzubilden. Diese Klasse muss die DoctrineORMMappingClassMetadata-Klasse erben und die Annotationen DoctrineORMMappingEntity und DoctrineORMMappingTable verwenden.

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
}

Im obigen Code haben wir eine User-Entitätsklasse definiert, die die Datenbanktabelle mit dem Namen „users“ zuordnet. Es hat drei Attribute: $id, $name und $email. Annotationen teilen Doctrine ORM mit, wie diese Eigenschaften zuzuordnen sind. Beispielsweise ist die Eigenschaft $id der Primärschlüssel und wird automatisch inkrementiert, die Eigenschaft $name wird einer Datenbankspalte vom Typ varchar zugeordnet, die Eigenschaft $email wird dem Typ varchar zugeordnet und muss innerhalb der Datenbanktabelle eindeutig sein.

Zuordnung

Nachdem wir die Entität definiert haben, müssen wir Doctrine ORM mitteilen, wie die Entität der Datenbanktabelle zugeordnet werden soll. Wir können XML, Kommentare oder YAML verwenden, um Zuordnungsbeziehungen zu definieren.

Hier verwenden wir Annotationen, um die Zuordnungsbeziehung zu definieren. Im folgenden Code definieren wir beispielsweise eine Zuordnungsbeziehung, um die Benutzerentität der Datenbanktabelle zuzuordnen: users

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

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

Im obigen Code definieren wir eine Viele-zu-Eins-Beziehung (viele-zu-eins). Alle Mapping-Beziehungsdefinitionen müssen mit Anmerkungen gekennzeichnet werden.

Query

Doctrine ORM bietet eine Reihe benutzerfreundlicher Abfrage-APIs, mit denen wir CRUD-Operationen problemlos durchführen können. Der folgende Code zeigt beispielsweise, wie eine Entität mithilfe von Doctrine abgefragt wird:

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

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

Im obigen Code verwenden wir die Variable $entityManager, um eine Benutzer-Repository-Instanz abzurufen. Anschließend rufen wir alle Benutzerinstanzen mit der Methode findAll() ab und geben den Benutzernamen jeder Instanz aus.

Zusammenfassung

Dieser Artikel stellt die Grundlagen von Doctrine ORM vor, einschließlich Konfiguration, Entitäten, Zuordnung und Abfragen. ORM ist ein sehr leistungsfähiges Tool, das die Codierung datenbankbezogener Funktionen erheblich vereinfachen kann. Ich hoffe, dass dieser Artikel Ihnen hilft, ORM zu verstehen, und ich hoffe, dass Sie mehr über Doctrine ORM erfahren und mit der Verwendung beginnen können.

Das obige ist der detaillierte Inhalt vonGrundlagen der objektrelationalen Zuordnung (ORM): Doctrine ORM verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!