From $album->getTrackList() you will alwas get" AlbumTrackReference " entities back, so what about adding methods from the Track and proxy?

class AlbumTrackReference
{
    public function getTitle()
    {
        return $this->getTrack()->getTitle();
    }

    public function getDuration()
    {
        return $this->getTrack()->getDuration();
    }
}

W ten sposób Twoja pętla znacznie upraszcza, podobnie jak wszystkie inne kody związane z zapętlaniem ścieżek albumu, ponieważ wszystkie metody są po prostu proxy wewnątrz AlbumTrakcReference:

foreach ($album->getTracklist() as $track) {
    echo sprintf("\t#%d - %-20s (%s) %s\n", 
        $track->getPosition(),
        $track->getTitle(),
        $track->getDuration()->format('H:i:s'),
        $track->isPromoted() ? ' - PROMOTED!' : ''
    );
}

Btw powinieneś zmienić nazwę albumu (na przykład "AlbumTrack"). Jest to oczywiście nie tylko odniesienie, ale zawiera dodatkową logikę. Ponieważ prawdopodobnie istnieją również utwory, które nie są połączone z albumem, ale po prostu dostępne przez promo-cd lub coś, co pozwala na czystsze oddzielenie również.

Nic nie przebije ładnego przykładu

Dla osób szukających czystego kodowania przykład powiązań jeden do wielu/wiele do jednego między 3 uczestniczącymi klasami, aby zapisać dodatkowe atrybuty w relacji sprawdź tę stronę:

Ładny przykład powiązań jeden do wielu / wiele do jednego między 3 uczestniczącymi klasami

Think about your primary keys

Pomyśl także o swoim głównym kluczu. Często można używać klawiszy kompozytowych do takie związki. Doktryna natywnie to popiera. Możesz przekształcić powiązane podmioty w identyfikatory. sprawdź dokumentację dotyczącą kluczy złożonych tutaj

Myślę, że zgodziłbym się z sugestią @beberlei dotyczącą używania metod proxy. Co można zrobić, aby ten proces uprościć jest zdefiniowanie dwóch interfejsów:

interface AlbumInterface {
    public function getAlbumTitle();
    public function getTracklist();
}

interface TrackInterface {
    public function getTrackTitle();
    public function getTrackDuration();
}

Wtedy zarówno Twoje Album, jak i twoje Track mogą je zaimplementować, podczas gdy AlbumTrackReference nadal mogą zaimplementować oba, jak następuje:

class Album implements AlbumInterface {
    // implementation
}

class Track implements TrackInterface {
    // implementation
}

/** @Entity whatever */
class AlbumTrackReference implements AlbumInterface, TrackInterface
{
    public function getTrackTitle()
    {
        return $this->track->getTrackTitle();
    }

    public function getTrackDuration()
    {
        return $this->track->getTrackDuration();
    }

    public function getAlbumTitle()
    {
        return $this->album->getAlbumTitle();
    }

    public function getTrackList()
    {
        return $this->album->getTrackList();
    }
}

W ten sposób, usuwając swoją logikę, która bezpośrednio odnosi się do Track lub Album, i po prostu zastępując ją tak, aby używała TrackInterface lub AlbumInterface, możesz użyć swojej AlbumTrackReference w każdym możliwym przypadku. Co? trzeba będzie nieco odróżnić metody między interfejsami.

To nie odróżni DQL ani logiki repozytorium, ale twoje usługi zignorują fakt, że mijasz Album lub AlbumTrackReference, lub Track lub AlbumTrackReference, ponieważ Ukryłeś wszystko za interfejsem:)

Mam nadzieję, że to pomoże!

Po pierwsze, w większości zgadzam się z beberlei co do jego sugestii. Jednak możesz być projektując się w pułapkę. Wydaje się, że Twoja domena uważa tytuł za naturalny klucz dla utworu, co prawdopodobnie ma miejsce w przypadku 99% scenariuszy, z którymi się spotykasz. Co jednak, jeśli Battery na Master of the Puppets jest inną wersją (różna długość, live, acoustic, remix, remastered, itp.) niż wersja na The Metallica Collection.

W zależności w jaki sposób chcesz obsłużyć (lub zignorować) tę sprawę, możesz albo przejść do sugerowanej trasy beberlei, albo po prostu przejść z proponowaną dodatkową logiką W metoda Album:: getTracklist (). Osobiście uważam, że dodatkowa logika jest uzasadniona, aby utrzymać API w czystości, ale oba mają swoje zalety.

Jeśli chcesz dostosować mój przypadek użycia, możesz mieć utwory zawierające samo odniesienie OneToMany do innych utworów, ewentualnie $ similarTracks. W tym przypadku byłyby dwa byty dla toru Baterii , jeden dla The Metallica Collection i jeden dla Master of the Puppets. Wtedy każda podobna Jednostka ścieżki zawierałaby odniesienie do siebie. Ponadto, to by pozbyć się bieżącej klasy AlbumTrackReference i wyeliminować obecny "problem". Zgadzam się, że po prostu przenosi złożoność do innego punktu, ale jest w stanie obsłużyć bazę użytkową, której wcześniej nie był w stanie.

Prosisz o "najlepszy sposób", ale nie ma najlepszego sposobu. Istnieje wiele sposobów, a niektóre z nich już odkryłeś. Jak chcesz zarządzać i / lub enkapsulować zarządzanie asocjacjami podczas korzystania z klas asocjacyjnych zależy wyłącznie od Ciebie i Twojej konkretnej domeny, nikt nie może pokazać ci "najlepszego sposobu", obawiam się.

Poza tym pytanie można by znacznie uprościć, usuwając z równania doktryny i relacyjne bazy danych. Istota pytania sprowadza się do pytania o tym, jak radzić sobie z klasami asocjacyjnymi w plain OOP.

Miałem konflikt z tabelą join zdefiniowaną w klasie asocjacji ( z dodatkowymi polami niestandardowymi ) adnotacją i tabelą join zdefiniowaną w adnotacji wielu do wielu.

Definicje mapowania w dwóch obiektach z bezpośrednią relacją wiele do wielu wydają się skutkować automatycznym tworzeniem tabeli łączenia za pomocą adnotacji 'joinTable'. Jednak tabela join została już zdefiniowana przez adnotację w swojej podstawowej klasie encji i chciałem, aby użyła tego Asocjacja własnych definicji pól klasy entity w celu rozszerzenia tabeli join o dodatkowe pola niestandardowe.

Wyjaśnienie i rozwiązanie jest zidentyfikowane przez fmaz008 powyżej. W mojej sytuacji to właśnie dzięki temu postowi na forum "pytanie o adnotację do doktryny ". Ten post zwraca uwagę na dokumentację doktrynalną dotyczącą wielu związków jednokierunkowych . Spójrz na notatkę dotyczącą podejścia polegającego na używaniu "klasy jednostek asocjacyjnych", zastępując w ten sposób wiele do wielu adnotacji mapowanie bezpośrednio między dwoma głównymi klasami encji z adnotacją jeden do wielu w głównych klasach encji i dwie adnotacje "wiele do jednego" w klasie encji asocjacyjnej. Jest przykład podany w tym poście na forum Modele asocjacyjne z dodatkowymi polami :

public class Person {

  /** @OneToMany(targetEntity="AssignedItems", mappedBy="person") */
  private $assignedItems;

}

public class Items {

    /** @OneToMany(targetEntity="AssignedItems", mappedBy="item") */
    private $assignedPeople;
}

public class AssignedItems {

    /** @ManyToOne(targetEntity="Person")
    * @JoinColumn(name="person_id", referencedColumnName="id")
    */
private $person;

    /** @ManyToOne(targetEntity="Item")
    * @JoinColumn(name="item_id", referencedColumnName="id")
    */
private $item;

}

To naprawdę przydatny przykład. Brakuje w doktrynie dokumentacji 2.

Dla funkcji proxy można wykonać:

class AlbumTrack extends AlbumTrackAbstract {
   ... proxy method.
   function getTitle() {} 
}

class TrackAlbum extends AlbumTrackAbstract {
   ... proxy method.
   function getTitle() {}
}

class AlbumTrackAbstract {
   private $id;
   ....
}

I

/** @OneToMany(targetEntity="TrackAlbum", mappedBy="album") */
protected $tracklist;

/** @OneToMany(targetEntity="AlbumTrack", mappedBy="track") */
protected $albumsFeaturingThisTrack;

To, o czym mówisz, to metadane, dane o danych. Miałem ten sam problem w projekcie, nad którym obecnie pracuję i musiałem poświęcić trochę czasu, próbując go rozgryźć. To zbyt wiele informacji, aby pisać tutaj, ale poniżej znajdują się dwa linki, które mogą okazać się przydatne. Odwołują się do frameworka Symfony, ale opierają się na doktrynie ORM.

Http://melikedev.com/2010/04/06/symfony-saving-metadata-during-form-save-sort-ids/

Http://melikedev.com/2009/12/09/symfony-w-doctrine-saving-many-to-many-mm-relationships/

Powodzenia i miłych odniesień do Metalliki!

Rozwiązanie jest w dokumentacji doktryny. W FAQ możesz zobaczyć to:

Http://docs.doctrine-project.org/en/2.1/reference/faq.html#how-can-i-add-columns-to-a-many-to-many-table

A tutorial jest tutaj:

Http://docs.doctrine-project.org/en/2.1/tutorials/composite-primary-keys.html

Więc nie robisz już manyToMany, ale musisz utworzyć dodatkowy byt i umieścić manyToOne na swoich dwóch bytach.

Dodaj dla @f00bar komentarz:

To proste, trzeba po prostu zrobić coś takiego:

Article  1--N  ArticleTag  N--1  Tag

Więc tworzysz artykuł encji

ArticleTag:
  type: entity
  id:
    id:
      type: integer
      generator:
        strategy: AUTO
  manyToOne:
    article:
      targetEntity: Article
      inversedBy: articleTags
  fields: 
    # your extra fields here
  manyToOne:
    tag:
      targetEntity: Tag
      inversedBy: articleTags

Mam nadzieję, że to pomoże

Jednokierunkowa. Po prostu dodaj inversedBy: (obca Nazwa kolumny), aby była dwukierunkowa.

# config/yaml/ProductStore.dcm.yml
ProductStore:
  type: entity
  id:
    product:
      associationKey: true
    store:
      associationKey: true
  fields:
    status:
      type: integer(1)
    createdAt:
      type: datetime
    updatedAt:
      type: datetime
  manyToOne:
    product:
      targetEntity: Product
      joinColumn:
        name: product_id
        referencedColumnName: id
    store:
      targetEntity: Store
      joinColumn:
        name: store_id
        referencedColumnName: id

Możesz być w stanie osiągnąć to, co chcesz z dziedziczenie tabeli klas gdzie zmienisz AlbumTrackReference na AlbumTrack:

class AlbumTrack extends Track { /* ... */ }

I getTrackList() zawierałyby AlbumTrack obiekty, które następnie można by używać tak, jak chcesz:

foreach($album->getTrackList() as $albumTrack)
{
    echo sprintf("\t#%d - %-20s (%s) %s\n", 
        $albumTrack->getPosition(),
        $albumTrack->getTitle(),
        $albumTrack->getDuration()->format('H:i:s'),
        $albumTrack->isPromoted() ? ' - PROMOTED!' : ''
    );
}

Będziesz musiał to dokładnie zbadać, aby upewnić się, że nie cierpisz z powodu wydajności.

Twoja obecna konfiguracja jest prosta, wydajna i łatwa do zrozumienia, nawet jeśli niektóre semantyki nie pasują do ciebie.

Podczas pobierania wszystkich utworów z albumu w klasie album, wygenerujesz jeszcze jedno zapytanie o jeszcze jeden rekord. To z powodu metody proxy. Jest jeszcze jeden przykład mojego kodu (patrz Ostatni post w temacie): http://groups.google.com/group/doctrine-user/browse_thread/thread/d1d87c96052e76f7/436b896e83c10868#436b896e83c10868

Czy jest jakaś inna metoda, aby to rozwiązać? Czy jedno połączenie nie jest lepszym rozwiązaniem?

Oto rozwiązanie opisane w dokumentacji Doctrine2

<?php
use Doctrine\Common\Collections\ArrayCollection;

/** @Entity */
class Order
{
    /** @Id @Column(type="integer") @GeneratedValue */
    private $id;

    /** @ManyToOne(targetEntity="Customer") */
    private $customer;
    /** @OneToMany(targetEntity="OrderItem", mappedBy="order") */
    private $items;

    /** @Column(type="boolean") */
    private $payed = false;
    /** @Column(type="boolean") */
    private $shipped = false;
    /** @Column(type="datetime") */
    private $created;

    public function __construct(Customer $customer)
    {
        $this->customer = $customer;
        $this->items = new ArrayCollection();
        $this->created = new \DateTime("now");
    }
}

/** @Entity */
class Product
{
    /** @Id @Column(type="integer") @GeneratedValue */
    private $id;

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

    /** @Column(type="decimal") */
    private $currentPrice;

    public function getCurrentPrice()
    {
        return $this->currentPrice;
    }
}

/** @Entity */
class OrderItem
{
    /** @Id @ManyToOne(targetEntity="Order") */
    private $order;

    /** @Id @ManyToOne(targetEntity="Product") */
    private $product;

    /** @Column(type="integer") */
    private $amount = 1;

    /** @Column(type="decimal") */
    private $offeredPrice;

    public function __construct(Order $order, Product $product, $amount = 1)
    {
        $this->order = $order;
        $this->product = $product;
        $this->offeredPrice = $product->getCurrentPrice();
    }
}