Sauvegarder les entities dans une API REST au lieu de DB en utilisant la Doctrine 2

vous pouvez utiliser https://github.com/doctrine/rest pour construire un client REST, qui parle au serveur cible. La partie essentielle ici est la mise en correspondance de l'API entity (local) vers L'API REST (target).

En bref: Doctrine2 (local DB) -> Reste de client (entité reste de la cartographie) -> Request (serveur cible)

Doctrine / Rest fournit également l'autre voie autour: un serveur de doctrine Rest, pour exposer vos entités locales via REST (demande à votre serveur). Mais ce n'est pas ce que vous cherchez.

DoctrineRestDriver fait exactement ce que vous recherchez. https://github.com/CircleOfNice/DoctrineRestDriver

Configuration De La Doctrine:

doctrine: dbal: driver_class: "Circle\DoctrineRestDriver\Driver" host: "http://www.your-url.com/api" port: 80 user: "Circle" password: "CantRenember"

Construire l'entité:

/**
 * This annotation marks the class as managed entity:
 *
 * @ORM\Entity
 *
 * You can either only use a resource name or the whole url of
 * the resource to define your target. In the first case the target 
 * url will consist of the host, configured in your options and the 
 * given name. In the second one your argument is used as it is.
 * Important: The resource name must begin with its protocol.
 *
 * @ORM\Table("products|http://www.yourSite.com/api/products")
 */
class Product {

    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

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

    public function getId() {
        return $this->id;
    }

    public function setName($name) {
        $this->name = $name;
        return $this;
    }

    public function getName() {
        return $this->name;
    }
}

supposons que nous ayons utilisé la valeur http://www.yourSite.com/api/products pour l'annotation @Table de l'entité de produit.

Contrôleur:

<?php

namespace CircleBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\HttpFoundation\Response;

class UserController extends Controller {

    /**
     * Sends the following request to the API:
     * POST http://www.yourSite.com/api/products HTTP/1.1
     * {"name": "Circle"}
     *
     * Let's assume the API responded with:
     * HTTP/1.1 200 OK
     * {"id": 1, "name": "Circle"}
     *
     * Response body is "1"
     */
    public function createAction() {
        $em     = $this->getDoctrine()->getManager();
        $entity = new CircleBundle\Entity\Product();
        $entity->setName('Circle');
        $em->persist($entity);
        $em->flush();

        return new Response($entity->getId());
    }

    /**
     * Sends the following request to the API by default:
     * GET http://www.yourSite.com/api/products/1 HTTP/1.1
     *
     * which might respond with:
     * HTTP/1.1 200 OK
     * {"id": 1, "name": "Circle"}
     *
     * Response body is "Circle"
     */
    public function readAction($id = 1) {
        $em     = $this->getDoctrine()->getManager();
        $entity = $em->find('CircleBundle\Entity\Product', $id);

        return new Response($entity->getName());
    }

    /**
     * Sends the following request to the API:
     * GET http://www.yourSite.com/api/products HTTP/1.1
     *
     * Example response:
     * HTTP/1.1 200 OK
     * [{"id": 1, "name": "Circle"}]
     *
     * Response body is "Circle"
     */
    public function readAllAction() {
        $em       = $this->getDoctrine()->getManager();
        $entities = $em->getRepository('CircleBundle\Entity\Product')->findAll();

        return new Response($entities->first()->getName());
    }

    /**
     * After sending a GET request (readAction) it sends the following
     * request to the API by default:
     * PUT http://www.yourSite.com/api/products/1 HTTP/1.1
     * {"name": "myName"}
     *
     * Let's assume the API responded the GET request with:
     * HTTP/1.1 200 OK
     * {"id": 1, "name": "Circle"}
     *
     * and the PUT request with:
     * HTTP/1.1 200 OK
     * {"id": 1, "name": "myName"}
     *
     * Then the response body is "myName"
     */
    public function updateAction($id = 1) {
        $em     = $this->getDoctrine()->getManager();
        $entity = $em->find('CircleBundle\Entity\Product', $id);
        $entity->setName('myName');
        $em->flush();

        return new Response($entity->getName());
    }

    /**
     * After sending a GET request (readAction) it sends the following
     * request to the API by default:
     * DELETE http://www.yourSite.com/api/products/1 HTTP/1.1
     *
     * If the response is:
     * HTTP/1.1 204 No Content
     *
     * the response body is ""
     */
    public function deleteAction($id = 1) {
        $em     = $this->getDoctrine()->getManager();
        $entity = $em->find('CircleBundle\Entity\Product', $id);
        $em->remove($entity);
        $em->flush();

        return new Response();
    }
}

vous pouvez même utiliser DQL ou requêtes natives.

je pense que vous n'êtes pas dans la bonne direction.

Je ne suis pas prêt à creuser dans la documentation maintenant, mais je comprends la pile de doctrine comme:

ORM - > DQL (doctrine query language) - >dbal- > Some database sql

et le point pour la mise en œuvre vous la fonctionnalité dans DBAL comme pilote de base de données personnalisé.

je pense que créer repos commun-pilote réelle caractéristique intéressante et il fera l'intégration facile avec des tiers service.

Je n'en suis pas sûr, mais vous pouvez essayer d'utiliser lifecycle callback events pour que les entités exécutent une logique persistante via REST.

je voulais faire une chose similaire, donc j'ai construit cette bibliothèque pour aider à exposer les entités de doctrine comme des ressources reposantes. Il a une bonne quantité de fonctionnalités, et vous permet de définir exactement ce que vous voulez avoir exposé à la fois par pull (GET) et push (POST/PUT/PATCH) méthodes.

http://leedavis81.github.io/drest /

https://github.com/leedavis81/drest

j'Espère que ça aide