Annotations de référence Symfony2

Table des matières

Référence
@Column
@ChangeTrackingPolicy
@DiscriminatorColumn
@DiscriminatorMap
@Entity
@GeneratedValue
@HasLifecycleCallbacks
@Index
@Id
@InheritanceType
@JoinColumn
@JoinColumns
@JoinTable
@ManyToOne
@ManyToMany
@MappedSuperclass
@OneToOne
@OneToMany
@OrderBy
@PostLoad
@PostPersist
@PostRemove
@PostUpdate
@PrePersist
@PreRemove
@PreUpdate
@SequenceGenerator
@Table
@UniqueConstraint
@Version

Référence

http://docs.doctrine-project.org/projects/doctrine-orm/en/2.1/reference/annotations-reference.html#annref-postremove

Dans ce chapitre, une référence des annotations de doctrine 2 est donnée avec de brèves explications sur leur contexte et leur utilisation.

@Column

Marque une variable d'instance annoté comme "persistante". Il est à l'intérieur de variables d'instance le commentaire PHP DocBlock. Toute valeur à l'intérieur de cette variable sera sauvegardés et chargée de la base de données dans le cadre du cycle de vie des variables d'instance entité de classe.

Les attributs obligatoires:

Attributs optionnels:

De plus vous devriez vous rappeler que l'attribut «Type» gère le projet de conversion entre PHP et base de données des valeurs. Si vous utilisez cet attribut sur ​​une colonne qui est utilisée pour les jointures entre les tables, vous devriez aussi jeter un oeil à @JoinColumn .

Exemples:

<?php
/**
 * @Column(type="string", length=32, unique=true, nullable=false)
 */
protected $username;

/**
 * @Column(type="string", columnDefinition="CHAR(2) NOT NULL")
 */
protected $country;

/**
 * @Column(type="decimal", precision=2, scale=1)
 */
protected $height;

@ChangeTrackingPolicy

Le suivi des modifications d'annotation de police permet de spécifier comment Doctrine2 UnitOfWork détecte les changements dans les propriétés des entités durant le flush(). Par défaut, chaque entité est vérifiée conformément à une stratégie implicite différé, ce qui signifie que le flush d'UnitOfWork compare toutes les propriétés d'une entité à un instantané précédemment stockées. Cela fonctionne hors de la boîte, mais vous voudrez peut-être ajuster le rendement de chasse où l'utilisation d'une autre politique de suivi des modifications pourrait être une option intéressante.

Les détails sur toutes les politiques disponibles sur le suivi des modifications peut être trouvée dans la section de configuration.

Exemple:

<?php
/**
 * @Entity
 * @ChangeTrackingPolicy("DEFERRED_IMPLICIT")
 * @ChangeTrackingPolicy("DEFERRED_EXPLICIT")
 * @ChangeTrackingPolicy("NOTIFY")
 */
class User {}

@DiscriminatorColumn

Cette annotation est une annotation requise pour la super classe la plus haute d'une hiérarchie d'héritage. Il précise les détails de la colonne qui enregistre le nom de la classe, où l'entité est réellement instancié ainsi.

Les attributs obligatoires:

Attributs optionnels:

@DiscriminatorMap

La carte discriminateur est une annotation requise sur la classe top-most/super dans une hiérarchie d'héritage. Elle prend un tableau comme argument pour la classe qui définit ce qui doit être enregistré en vertu de laquelle du nom de la base. Les clés sont la valeur et les valeurs données sont des classes, que ce soit entièrement ou en tant que noms de classes non qualifiés, selon que les classes soient dans le namespace ou non.

<?php
/**
 * @Entity
 * @InheritanceType("JOINED")
 * @DiscriminatorColumn(name="discr", type="string")
 * @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
 */
class Person
{
    // ...
}

@Entity

Nécessaire d'annotation pour marquer une classe PHP comme entité. Doctrine gère la persistance de toutes les classes marquées comme entité.

Attributs optionnels:

Exemple:

<?php
/**
 * @Entity(repositoryClass="MyProject\UserRepository")
 */
class User
{
    //...
}

@GeneratedValue

Indique quelle stratégie est utilisée pour générer des identifiants pour une variable d'instance qui est annotée par @Id . Cette annotation est facultative et n'a de sens que lorsqu'il est utilisé en conjonction avec @Id.

Si cette annotation n'est pas spécifié avec @Id, la stratégie NONE est utilisé par défaut.

Les attributs obligatoires:

Exemple:

<?php
/**
 * @Id
 * @Column(type="integer")
 * @generatedValue(strategy="IDENTITY")
 */
protected $id = null;

@HasLifecycleCallbacks

Annotation qui doit être mis sur le DocBlock entité classe PHP pour notifier à Doctrine que cette entité a les annotations entity life-cycle callback mis sur au moins une de ses méthodes. Utiliser @PostLoad, @PrePersist, @PostPersist, @PreRemove, @PostRemove, @PreUpdate ou @PostUpdate. Sans cette annotation marqueur Doctrine ignorera les rappels.

<?php
/**
 * @Entity
 * @HasLifecycleCallbacks
 */
class User
{
    /**
     * @PostPersist
     */
    public function sendOptinMail() {}
}

@Index

Les annotations sont utilisées à l'intérieur de l'annotation @Table sur le niveau de l'entité de classe. Il permet de faire allusion au SchemaTool pour générer un indice de base de données sur les colonnes du tableau spécifié. Elle n'a de sens que dans le contexte SchemaTool génération de schéma.

Les attributs obligatoires:

Exemple:

<?php
/**
 * @Entity
 * @Table(name="ecommerce_products",indexes={@index(name="search_idx", columns={"name", "email"})})
 */
class ECommerceProduct
{
}

@Id

La variable d'instance annotée sera marquée comme identification de l'entité, la clé primaire dans la base de données. Cette annotation est un marqueur seulement et n'a pas d'attributs obligatoires ou facultatifs. Pour les entités qui ont des colonnes multiples d'identifiants chaque colonne doit être marqués avec @Id.

Exemple:

<?php
/**
 * @Id
 * @Column(type="integer")
 */
protected $id = null;

@InheritanceType

Dans une hiérarchie d'héritage vous avez à utiliser cette annotation sur la super classe la plus haute pour définir la stratégie qui doit être utilisé pour l'héritage. Actuellement une seule table et l'Héritage de Table de classe sont pris en charge.

Cette annotation est toujours utilisée en conjonction avec les annotations @DiscriminatorMap et @DiscriminatorColumn.

Exemples:

<?php
/**
 * @Entity
 * @InheritanceType("SINGLE_TABLE")
 * @DiscriminatorColumn(name="discr", type="string")
 * @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
 */
class Person
{
    // ...
}

/**
 * @Entity
 * @InheritanceType("JOINED")
 * @DiscriminatorColumn(name="discr", type="string")
 * @DiscriminatorMap({"person" = "Person", "employee" = "Employee"})
 */
class Person
{
    // ...
}

@JoinColumn

Cette annotation est utilisé dans le contexte des relations de @ManyToOne , @OneToOne et dans le contexte de @JoinTable imbriquée dans une @ManyToMany. Cette annotation n'est pas nécessaire. Si le nom des attributs n'est pas précisé et que referencedColumnName sont déduites de la table et des noms de clef primaire.

Les attributs obligatoires:

Attributs optionnels:

Exemple:

<?php
/**
 * @OneToOne(targetEntity="Customer")
 * @JoinColumn(name="customer_id", referencedColumnName="id")
 */
private $customer;

@JoinColumns

Un tableau de @JoinColumn pour les relations @ManyToOne ou @OneToOne avec une entité qui a des identifiants multiples.

@JoinTable

L'utilisation de @OneToMany ou @ManyToMany sur le côté possédant la relation, nécessite de spécifier l'annotation @JoinTable qui décrit les détails de la base de données table de jointure. Si vous ne spécifiez pas @JoinTable sur ces relations par défaut la cartographie raisonnables s'applique à l'aide de la table concernée et les noms de colonnes.

Les attributs obligatoires:

Exemple:

<?php
/**
 * @ManyToMany(targetEntity="Phonenumber")
 * @JoinTable(name="users_phonenumbers",
 *      joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
 *      inverseJoinColumns={@JoinColumn(name="phonenumber_id", referencedColumnName="id", unique=true)}
 * )
 */
public $phonenumbers;

@ManyToOne

Définit la variable d'instance annotée contient une référence qui décrit une relation many-to-one entre deux entités.

Les attributs obligatoires:

Attributs optionnels:

Exemple:

<?php
/**
 * @ManyToOne(targetEntity="Cart", cascade={"all"}, fetch="EAGER")
 */
private $cart;

@ManyToMany

Définit une variable d'instance est titulaire d'une relation many-to-many entre deux entités. @JoinTable est une annotation facultative qui a des configurations par défaut en utilisant la table et les noms des deux entités connexes.

Les attributs obligatoires:

Attributs optionnels:

Pour les relations bidirectionnelles ManyToMany chaque côté peut être le côté propriétaire (le côté qui définit le @JoinTable et / ou ne pas faire usage de l'attribut mappedBy, utilisant ainsi une jointure par défaut de table).

Exemple:

<?php
/**
 * Owning Side
 *
 * @ManyToMany(targetEntity="Group", inversedBy="features")
 * @JoinTable(name="user_groups",
 *      joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
 *      inverseJoinColumns={@JoinColumn(name="group_id", referencedColumnName="id")}
 *      )
 */
private $groups;

/**
 * Inverse Side
 *
 * @ManyToMany(targetEntity="User", mappedBy="groups")
 */
private $features;

@MappedSuperclass

Un mappés est une super classe abstraite ou concrète qui fournit l'état d'une entité persistante et d'information pour la cartographie de ses sous-classes, mais qui n'est pas en soi une entité. Cette annotation est spécifiée sur le bloc de documentation de classe et n'a aucun des attributs supplémentaires.

L'annotation @MappedSuperclass ne peut pas être utilisé en conjonction avec @Entity. Voir la section Mapping de l'héritage pour plus de détails sur les restrictions de superclasses mappée .

Attributs optionnels:

Exemple:

<?php
/** @MappedSuperclass */
class MappedSuperclassBase
{
    // ... fields and methods
}

/** @Entity */
class EntitySubClassFoo extends MappedSuperclassBase
{
    // ... fields and methods
}

@OneToOne

L'annotation @OneToOne fonctionne presque exactement comme le @ManyToOne avec une option supplémentaire qui peut être spécifié. La configuration par défaut pour @JoinColumn utilisant la table de l'entité cible et primaire noms de colonnes clés s'appliquent ici aussi.

Les attributs obligatoires:

Attributs optionnels:

Exemple:

<?php
/**
 * @OneToOne(targetEntity="Customer")
 * @JoinColumn(name="customer_id", referencedColumnName="id")
 */
private $customer;

@OneToMany

Les attributs obligatoires:

Attributs optionnels:

Exemple:

<?php
/**
 * @OneToMany(targetEntity="Phonenumber", mappedBy="user", cascade={"persist", "remove", "merge"}, orphanRemoval=true)
 */
public $phonenumbers;

@OrderBy

Annotations en option qui peut être spécifiée avec un @ManyToMany ou @OneToMany annotation à préciser par quels critères la collection devrait être extraites de la base de données en utilisant une clause ORDER BY.

Cette annotation nécessite une seule valeur non attribuée avec un extrait de DQL:

Exemple:

<?php
/**
 * @ManyToMany(targetEntity="Group")
 * @OrderBy({"name" = "ASC"})
 */
private $groups;

L'extrait de DQL OrderBy est seulement autorisée à se composer des des noms de domaine non cotées et d'une option de position ASC/DESC. Plusieurs champs sont séparés par une virgule (,) Les noms des champs référencés existent sur la classe targetEntity @ManyToMany ou @OneToMany annotation.

@PostLoad

Marque une méthode sur l'entité appelait par un événement @postPersist. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PostPersist

Marque une méthode sur l'entité appelait par un événement @PostPersist. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PostRemove

Marque une méthode sur l'entité appelait par un événement @postRemove. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PostUpdate

Marque une méthode sur l'entité appelait par un événement @PostUpdate. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PrePersist

Marque une méthode sur l'entité appelait par un événement @PrePersist. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PreRemove

Marque une méthode sur l'entité appelait par un événement @preRemove. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@PreUpdate

Marque une méthode sur l'entité appelait par un événement @PreUpdate. Fonctionne uniquement avec @HasLifecycleCallbacks dans l'entité de classe PHP DocBlock.

@SequenceGenerator

Pour l'utiliser avec @GeneratedValue (stratégie = "séquences") cette annotation permet de spécifier des détails sur la séquence, comme la taille de l'incrément et les valeurs initiales de la séquence.

Les attributs obligatoires:

Attributs optionnels:

<?php
/**
 * @Id
 * @GeneratedValue(strategy="SEQUENCE")
 * @Column(type="integer")
 * @SequenceGenerator(sequenceName="tablename_seq", initialValue=1, allocationSize=100)
 */
protected $id = null;

@Table

Annotation décrit la table d'une entité persistante. Il est placé sur le DocBlock entité classe PHP et est facultatif. Si cela n'est pas spécifié, le nom de table par défaut sera le nom de classe d'entités non qualifiés.

Les attributs obligatoires:

Attributs optionnels:

<?php
/**
 * @Entity
 * @Table(name="user",
 *      uniqueConstraints={@UniqueConstraint(name="user_unique",columns={"username"})},
 *      indexes={@Index(name="user_idx", columns={"email"})}
 * )
 */
class User { }

@UniqueConstraint

Les annotations sont utilisées à l'intérieur de l'annotation @Table sur le niveau de l'entité de classe. Il permet à SchemaTool de générer une base de données unique sur les colonnes de la table spécifiée. Elle n'a de sens que dans le contexte SchemaTool génération de schéma.

Les attributs obligatoires:

Exemple:

<?php
/**
 * @Entity
 * @Table(name="ecommerce_products",uniqueConstraints={@UniqueConstraint(name="search_idx", columns={"name", "email"})})
 */
class ECommerceProduct
{
}

@Version

Marqueur d'annotation qui définit une colonne spécifiée comme attribut version utilisée dans un scénario de verrouillage optimiste. Il ne fonctionne que sur les @Column annotations qui ont le type integer ou datetime. La combinaison de @Version avec @Id n'est pas supporté.

Exemple:

<?php
/**
 * @column(type="integer")
 * @version
 */
protected $version;