Mode entrepôt dans Laravel 5

Le modèle de référentiel a été introduit pour la première fois par Eric Evans dans son livre Domain-Driven Design. En fait, le référentiel est le point d'entrée des applicationspour accéder à la couche domain.

En termes simples, un référentiel permet à tout votre code d'utiliser des objets sans savoir comment les objets sont conservés. Le référentiel contient toutes les connaissances en matière de persistance, y compris le mappage des tables vers les objets. Cela fournit une vue plus orientée objet de la couche de persistance et rend le code de mappage plus encapsulé.

La seule façon de faire fonctionner votre référentiel dans Laravel (en tant que véritable référentiel - livre Eric Evans Domain Driven Design) est de changer l'ORM par défaut d'Active Record en Data Mapper. Le meilleur substitut est la doctrine.

doctrine ORM

Doctrine est un ORM (Object Relational Mapping) qui implémente le modèle Data Mapper et vous permet de séparer complètement les règles métier de votre application de la couche de persistance de la base de données. Doctrine utilise DQL, pas SQL. DQL vous propose le langage de requête objet, ce qui signifie que vous effectuerez des requêtes en utilisant des termes objet au lieu des termes de requête relationnels traditionnels.

Il vous permet d'écrire des requêtes de base de données de manière orientée objet et vous aide lorsque vous devez interroger la base de données d'une manière qui n'est pas possible en utilisant les méthodes du référentiel par défaut. À mon avis, DQL est le moyen le plus puissant de rester connecté à votre base de données.

Dogme et Éloquence

L'entité Doctrine est juste une classe simple PHP ordinaire qui n'ajoute aucune surcharge d'héritage ORM. Doctrine utilise le même héritage pour gérer plusieurs requêtes de requête sans accéder à la base de données, ce qui signifie que les objets d'entité sont présents tout au long de la requête.

Une autre fonctionnalité intéressante de Doctrine est qu'au lieu de migrer des fichiers pour créer un schéma de base de données, la base de données est automatiquement créée pour refléter les métadonnées dans les annotations d'entité. Eloquent, en revanche, est moins complexe et très simple à utiliser.

Une comparaison complète entre ces deux nécessiterait un article séparé. Comme vous pouvez le constater, les objets Doctrine sont plus légers et plus abstraits. Cependant, Doctrine ne convient qu'à des projets spécifiques, elle peut donc parfois créer des frais généraux pour vous. Je pense que c'est au programmeur de choisir le meilleur ORM pour l'application.

Application de blog

Il est maintenant temps de créer une application de blogging utilisant Laravel. Premièrement, nous devons établir une doctrine. Il existe un pont pour correspondre aux configurations existantes de Laravel 5. Pour installer Doctrine 2 dans un projet Laravel, on exécute la commande suivante :

composer require laravel-doctrine/orm

Comme d'habitude, le forfait doit être ajouté à app/config.php , car le prestataire :

LaravelDoctrine\ORM\DoctrineServiceProvider::class,

Un alias doit également être configuré :

'EntityManager' => LaravelDoctrine\ORM\Facades\EntityManager::class

Enfin, nous publions la configuration du package :

php artisan vendor:publish --tag="config"

Maintenant, nous avons terminé.

Les entités sont une partie importante d'une application AppEntitiesPost.php :

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="posts")
 * @ORM\HasLifecycleCallbacks()
 */
class Post
{
    /**
     * @var integer $id
     * @ORM\Column(name="id", type="integer", unique=true, nullable=false)
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     *
     */
    private $id;

    /**
     * @ORM\Column(type="string")
     */
    private $title;

    /**
     * @ORM\Column(type="text")
     */
    private $body;

    public function __construct($input)
    {
        $this->setTitle($input['title']);
        $this->setBody($input['body']);
    }

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

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

    public function getTitle()
    {
        return $this->title;
    }

    public function setTitle($title)
    {
        $this->title = $title;
    }

    public function getBody()
    {
        return $this->body;
    }

    public function setBody($body)
    {
        $this->body = $body;
    }
}

Il est maintenant temps de créer le dépôt, décrit précédemment. App/Repositories/PostRepo.php  : 

namespace App\Repository;

use App\Entity\Post;
use Doctrine\ORM\EntityManager;
class PostRepo
{

    /**
     * @var string
     */
    private $class = 'App\Entity\Post';
    /**
     * @var EntityManager
     */
    private $em;


    public function __construct(EntityManager $em)
    {
        $this->em = $em;
    }


    public function create(Post $post)
    {
        $this->em->persist($post);
        $this->em->flush();
    }

    public function update(Post $post, $data)
    {
        $post->setTitle($data['title']);
        $post->setBody($data['body']);
        $this->em->persist($post);
        $this->em->flush();
    }

    public function PostOfId($id)
    {
        return $this->em->getRepository($this->class)->findOneBy([
            'id' => $id
        ]);
    }

    public function delete(Post $post)
    {
        $this->em->remove($post);
        $this->em->flush();
    }

    /**
     * create Post
     * @return Post
     */
    private function perpareData($data)
    {
        return new Post($data);
    }
}

Contrôleur :App/Http/Controllers/PostController.php  :

namespace App\Http\Controllers;
use App\Repository\PostRepo as repo;
use App\Validation\PostValidator;


class PostController extends Controller
{
    private $repo;

    public function __construct(repo $repo)
    {
        $this->repo = $repo;
    }

    public function edit($id=NULL)
    {
        return View('admin.edit')->with(['data' => $this->repo->postOfId($id)]);
    }

    public function editPost()
    {
        $all = Input::all();
        $validate = PostValidator::validate($all);
        if (!$validate->passes()) {
            return redirect()->back()->withInput()->withErrors($validate);
        }
        $Id = $this->repo->postOfId($all['id']);
        if (!is_null($Id)) {
            $this->repo->update($Id, $all);
            Session::flash('msg', 'edit success');
        } else {
            $this->repo->create($this->repo->perpare_data($all));
            Session::flash('msg', 'add success');
        }
        return redirect()->back();
    }

    public function retrieve()
    {
        return View('admin.index')->with(['Data' => $this->repo->retrieve()]);
    }

    public function delete()
    {
        $id = Input::get('id');
        $data = $this->repo->postOfId($id);
        if (!is_null($data)) {
            $this->repo->delete($data);
            Session::flash('msg', 'operation Success');
            return redirect()->back();
        } else {
            return redirect()->back()->withErrors('operationFails');
        }
    }
}

Comme vous pouvez le voir, j'utilise Flash Assistant pour gérer les messages (vous pouvez utiliser celui de Laravel). Concernant les validateurs, je dois ajouter que vous pouvez créer le vôtre (comme je l'ai fait) ou utiliser les valeurs par défaut de Laravel, selon vos préférences.

Affichez les fichiers comme d'habitude. Dans cet exemple de vue, le fichier ressemble à resources/views/admin/edit.blade.php  :

  
        
          @if (Session::has('flash_notification.message'))
            
                ×
                {!! Session::get('flash_notification.message') !!}
            
            @endif
            
          
                @if($errors->has())
                    
                        @foreach ($errors->all() as $error)
                            
                                {!! $error !!}
                            
                        @endforeach

                    
                @endif
                
                
                    
                        
                            {!! 'title' !!}

                        
                         
                    
                    
                        
                            {!! 'Body' !!}
 {!!  is_object($ListData)?$ListData->getTitle():'' !!} 

                        
                         
                    
                

                
                    
                    
                        
                             {!! 'save' !!}
                        
                    
                
                
            
        

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!