Avoir un personnalisé référentiel qui n'est pas associée à une entité dans Symfony 2 / Doctrine 2?

Serait possible d'avoir un custom référentiel qui n'est pas associée à une entité dans Symfony 2 et Doctrine 2? Je voudrais mettre quelques natif SQL qui ne rentre pas bien dans d'autres référentiels (on peut se référer au résumé ou d'une entité de la hiérarchie).

Comment contrôleur de code $this->getDoctrine()->getRepositoty(/* ??? */) doit être remplacé?

InformationsquelleAutor gremo | 2012-07-10

15

Il est possible d'avoir autant de dépôts que vous le souhaitez. Cependant, un seul référentiel peut être liée à l'entité gestionnaire.

Vous devez définir quelques-uns des services pour ajouter un dépôt personnalisée.
```

<service id="acme.repository.my_entity" class="Acme\FQCN\MyEntityRepository" >
    <argument type="service" id="doctrine.orm.entity_manager" />
    <argument type="service" id="acme.metadata.my_entity" />
</service>


<service id="acme.metadata.my_entity" class="Doctrine\ORM\Mapping\ClassMetaData">
    <argument>Acme\FQCN\MyEntity</argument>
</service>
```
Le référentiel de la classe devrait hériter de EntityRepository.
```
namespace Acme\FQCN;

use Doctrine\ORM\EntityRepository;

class MyEntityRepository extends EntityRepository
{
    /** 
     * If you want to inject any custom dependencies, you'd have either have to
     * add them to the construct or create setters. I'd suggest using setters
     * in which case you wouldn't need to use the constructor in this class.
     *
     * public function __construct($em, Doctrine\ORM\Mapping\ClassMetadata $class, $custom_dependency)
     * {
     *     parent::__construct($em, $class);
     * }
     *
     */
}
```
Malheureusement, vous ne serez pas en mesure de le récupérer via la doctrine de service. Au lieu de cela, le récupérer directement à partir du conteneur:
```
$this->get('acme.repository.my_entity');
```
MODIFIER

Si vous êtes à la création d'un référentiel qui ne devrait pas être lié à toutes les entités, il suffit de créer un service et d'injecter les dépendances nécessaires.
```

<service id="acme.repository.misc" class="Acme\FQCN\MiscRepsitory">
    <argument type="service" id="database_connection" />
</service>
```
Puisque vous ne l'utilisez pas tout de la Doctrine ORM caractéristiques personnalisé dans un référentiel, il n'y a pas besoin de s'étendre EntityManager.
```
namespace Acme\FQCN;

use \Doctrine\DBAL\Connection;

class MiscRepository
{
    protected $conn;

    public function __construct(Connection $conn)
    {
        $this->conn = $conn;
    }
}
```
- Désolé, j'ai été ce qui signifie que le référentiel ne doit pas être associé avec n'importe quelle entité. Alors, pourquoi les métadonnées chose?
- dans ce cas, il serait judicieux de créer un service supplémentaire et de les injecter une connexion de base de données elle-même.
- après l'injection de database_connection je devrais faire une classe qui hérite de l'objet entityrepository, ai-je le droit?
- Non, puisque vous n'êtes pas vraiment à l'aide de toute l'ORM fonctionnalités, le référentiel n'aurais pas à hériter de EntityRepository à tous.
- Des beaux. Merci pour votre aide, je vais accepter la réponse. La seule mauvaise chose de personnalisé l'espace de stockage (avec dépendances) est la nécessité de définir et transmettre les métadonnées. La création d'un service pour chaque entité, les métadonnées peuvent être assez ennuyeux.
- Venez pour penser à elle, vous n'auriez pas à définir les métadonnées. Au lieu de cela, créer le MedaData objet à l'intérieur de votre référentiel du constructeur.
InformationsquelleAutor gilden

J'ai adopté un peu différente de la solution en utilisant Symfony2 parent services.

Tout d'abord, j'ai créé un service des parents, un GenericRepository classe qui expose un couple de méthodes et rend la vie plus facile dans le cas où nous aimerions de revoir notre code dans le futur.

services.yml

acme_core.generic_repository:
    abstract: true
    class: Acme\Bundle\CoreBundle\Repository\GenericRepository
    arguments: [@doctrine.orm.entity_manager]

Acme\Bundle\CoreBundle\Repository\GenericRepository

<?php

namespace Acme\Bundle\CoreBundle\Repository;

use Doctrine\ORM\EntityManager;

/**
 * Class GenericRepository
 * @package Acme\Bundle\CoreBundle\Repository
 */
abstract class GenericRepository {
    /**
     * @var EntityManager
     */
    private $entityManager;

    /**
     * @param EntityManager $entityManager
     */
    public function __construct(EntityManager $entityManager) {
        $this->entityManager = $entityManager;
    }

    /**
     * @return EntityManager
     */
    public function getEntityManager() {
        return $this->entityManager;
    }

    /**
     * @return \Doctrine\DBAL\Connection
     */
    public function getConnection() {
        return $this->getEntityManager()->getConnection();
    }

    /**
     * @return string
     */
    abstract function getTable();
}

Maintenant, nous voulons définir un nouveau référentiel:

services.yml

# Repositories
acme_product.repository.product_batch:
    parent: acme_core.generic_repository
    class: Acme\Bundle\ProductBundle\Repository\ProductBatchRepository

Acme\Bundle\ProductBundle\Repository\ProductBatchRepository

<?php

namespace Acme\Bundle\ProductBundle\Repository;

use Acme\Bundle\CoreBundle\Repository\GenericRepository;

/**
 * Class ProductBatchRepository
 * @package Acme\Bundle\ProductBundle\Repository
 */
class ProductBatchRepository extends GenericRepository {
    /**
     * @param int $batchId
     * @return integer The number of affected rows.
     */
    public function deleteBatch($batchId) {
        $table = $this->getTable();

        return $this->getConnection()->delete($table, [
            'id' => $batchId
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function getTable() {
        return 'product_batch';
    }
}

La deleteBatch() méthode crée et exécute la requête suivante:

DELETE FROM product_batch WHERE id = ?

Enfin dans notre contrôleur:

public function deleteAction() {
    $batchId = $this->getRequest()->get('batchId');

    $affectedRows = $this->get('acme_product.repository.product_batch')->deleteBatch($batchId);

    return $this->render(/**/);
}

Pour de plus amples informations et entité gestionnaire de /connexion d'utilisation, veuillez vous référer à la documentation officielle: http://doctrine-orm.readthedocs.org/en/latest/reference/native-sql.html

InformationsquelleAutor Francesco Casula

1

Ma suggestion est de créer une plaine de la classe PHP avec les dépendances nécessaires dans le constructeur et le faire à travers le conteneur de services.

InformationsquelleAutor Stefano Sala

Vous devez vous connecter pour publier un commentaire.