Was ist der Unterschied zwischen inversedBy und mappedBy?

Ich entwickle meine Anwendung mit Zend Framework 2 und Doctrine 2.

Während ich Anmerkungen schreibe, kann ich den Unterschied zwischen mappedByund nicht verstehen inversedBy.

Wann soll ich verwenden mappedBy?

Wann soll ich verwenden inversedBy?

Wann sollte ich keine verwenden?

Hier ist ein Beispiel:

 /**
 *
 * @ORM\OneToOne(targetEntity="\custMod\Entity\Person", mappedBy="customer")
 * @ORM\JoinColumn(name="personID", referencedColumnName="id")
 */
protected $person;

/**
 *
 * @ORM\OneToOne(targetEntity="\Auth\Entity\User")
 * @ORM\JoinColumn(name="userID", referencedColumnName="id")
 */
protected $user;

/**
 *
 * @ORM\ManyToOne (targetEntity="\custMod\Entity\Company", inversedBy="customer")
 * @ORM\JoinColumn (name="companyID", referencedColumnName="id")
 */
protected $company;

Ich habe schnell gesucht und Folgendes gefunden, bin aber immer noch verwirrt:

• Beispiel 1
• Beispiel 2
• Beispiel 3

• mappedBy muss auf der inversen Seite einer (bidirektionalen) Zuordnung angegeben werden
• inversedBy muss auf der Besitzerseite einer (bidirektionalen) Zuordnung angegeben werden

aus der Doktrinendokumentation:

• ManyToOne ist immer die Besitzerseite einer bidirektionalen Zuordnung.
• OneToMany ist immer die Kehrseite einer bidirektionalen Zuordnung.
• Die Besitzerseite einer OneToOne-Zuordnung ist die Entität mit der Tabelle, die den Fremdschlüssel enthält.

Siehe https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/unitofwork-associations.html

Die obigen Antworten reichten nicht aus, um zu verstehen, was vor sich ging. Nachdem ich mich eingehender damit befasst habe, denke ich, dass ich eine Möglichkeit habe, dies zu erklären, die für Menschen Sinn macht, die sich so schwer getan haben, es zu verstehen.

inversedBy und mappedBy werden von der INTERNAL DOCTRINE- Engine verwendet, um die Anzahl der SQL-Abfragen zu verringern, die erforderlich sind, um die benötigten Informationen abzurufen . Um klar zu sein, wenn Sie nicht inversedBy oder mappedBy hinzufügen, funktioniert Ihr Code weiterhin, wird jedoch nicht optimiert .

Schauen Sie sich zum Beispiel die folgenden Klassen an:

class Task
{
    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="task", type="string", length=255)
     */
    private $task;

    /**
     * @var \DateTime
     *
     * @ORM\Column(name="dueDate", type="datetime")
     */
    private $dueDate;

    /**
     * @ORM\ManyToOne(targetEntity="Category", inversedBy="tasks", cascade={"persist"})
     * @ORM\JoinColumn(name="category_id", referencedColumnName="id")
     */
    protected $category;
}

class Category
{
    /**
     * @var int
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     *
     * @ORM\Column(name="name", type="string", length=255)
     */
    private $name;

    /**
     * @ORM\OneToMany(targetEntity="Task", mappedBy="category")
     */
    protected $tasks;
}

Wenn Sie in diesen Klassen den Befehl zum Generieren des Schemas ausführen (z. B. bin/console doctrine:schema:update --force --dump-sql), werden Sie feststellen, dass die Kategorietabelle keine Spalte für Aufgaben enthält. (Dies liegt daran, dass es keine Spaltenanmerkung enthält.)

Das Wichtigste, was hier zu verstehen ist, ist, dass die variablen Aufgaben nur vorhanden sind, damit die interne Doktrin-Engine die Referenz darüber verwenden kann, die die Kategorie "MappedBy" angibt. Nun ... seien Sie hier nicht so verwirrt wie ich ... Kategorie bezieht sich NICHT auf den Klassennamen, sondern auf die Eigenschaft in der Task-Klasse namens 'protected $ category'.

Wie in der Tasks-Klasse erwähnt die Eigenschaft $ category, dass es sich um inversedBy = "Aufgaben" handelt. Beachten Sie, dass dies Plural ist. Dies ist NICHT DAS PLURAL DES KLASSENNAMENS , sondern nur, weil die Eigenschaft in der Kategorie 'geschützte $ Aufgaben' heißt Klasse.

Sobald Sie dies verstanden haben, wird es sehr einfach zu verstehen, was inversedBy und mappedBy tun und wie sie in dieser Situation verwendet werden.

Die Seite, die in meinem Beispiel wie 'Aufgaben' auf den Fremdschlüssel verweist, erhält immer das Attribut inversedBy, da sie wissen muss, welche Klasse (über den Befehl targetEntity) und welche Variable (inversedBy =) in dieser Klasse "rückwärts arbeiten" soll Sprechen Sie und erhalten Sie die Kategoriedaten von. Eine einfache Möglichkeit, sich daran zu erinnern, ist die Klasse, die die Foreignkey_ID haben würde, die inversedBy sein muss.

Wenn wie bei category und seiner Eigenschaft $asks (die nicht in der Tabelle enthalten ist, nur ein Teil der Klasse für Optimierungszwecke) MappedBy-Aufgaben sind, wird die Beziehung zwischen den beiden Entitäten offiziell erstellt, sodass die Doktrin jetzt sicher ist Verwenden Sie JOIN SQL-Anweisungen anstelle von zwei separaten SELECT-Anweisungen. Ohne mappedBy würde die Doctrine Engine aus der JOIN-Anweisung nicht wissen, welche Variable in der Klasse 'Task' zum Einfügen der Kategorieinformationen erstellt wird.

Hoffe das erklärt es ein bisschen besser.

In bidirektionaler Beziehung hat sowohl eine besitzende Seite als auch eine umgekehrte Seite

mappedBy : in die umgekehrte Seite einer bidirektionalen Beziehung setzen, um auf ihre eigene Seite zu verweisen

inversedBy : in die Besitzerseite einer bidirektionalen Beziehung setzen Um auf ihre inverse Seite zu verweisen

UND

Attribut mappedBy , das mit der Zuordnungsdeklaration OneToOne, OneToMany oder ManyToMany verwendet wird.

InversedBy- Attribut, das mit der OneToOne-, ManyToOne- oder ManyToMany-Zuordnungsdeklaration verwendet wird.

Hinweis : Die besitzende Seite einer bidirektionalen Beziehung die Seite, die den Fremdschlüssel enthält.

Es gibt zwei Verweise auf inversedBy und mappedBy in Doctrine Documentation: First Link , Second Link

5.9.1. Besitz und umgekehrte Seite

Für viele-zu-viele-Assoziationen können Sie auswählen, welche Entität die Eigentümerin und welche die umgekehrte Seite ist. Es gibt eine sehr einfache semantische Regel, um zu entscheiden, welche Seite aus Entwicklersicht besser geeignet ist, die besitzende Seite zu sein. Sie müssen sich nur fragen, welche Entität für das Verbindungsmanagement verantwortlich ist, und diese als Eigentümer auswählen.

Nehmen Sie ein Beispiel für zwei Entitäten, Artikel und Tag. Wann immer Sie einen Artikel mit einem Tag verbinden möchten und umgekehrt, ist meistens der Artikel für diese Beziehung verantwortlich. Wenn Sie einen neuen Artikel hinzufügen, möchten Sie ihn mit vorhandenen oder neuen Tags verbinden. Ihr Formular zum Erstellen von Artikeln wird diesen Begriff wahrscheinlich unterstützen und es ermöglichen, die Tags direkt anzugeben. Aus diesem Grund sollten Sie den Artikel als Eigentümer auswählen, da dies den Code verständlicher macht:

http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/association-mapping.html