Lagermodus in Laravel 5

Das Repository-Muster wurde erstmals von Eric Evans in seinem Buch „Domain-Driven Design“ eingeführt. Tatsächlich ist das Repository der Einstiegspunkt für Anwendungen, um auf die Domänenebene zuzugreifen.

Einfach ausgedrückt: Ein Repository ermöglicht es Ihrem gesamten Code, Objekte zu verwenden, ohne zu wissen, wie die Objekte beibehalten werden. Das Repository enthält sämtliches Wissen zur Persistenz, einschließlich der Zuordnung von Tabellen zu Objekten. Dies bietet eine objektorientiertere Ansicht der Persistenzschicht und macht den Zuordnungscode stärker gekapselt.

Die einzige Möglichkeit, Ihr Repository in Laravel zum Laufen zu bringen (als echtes Repository – Eric Evans Domain Driven Design-Buch), besteht darin, das Standard-ORM von Active Record in Data Mapper zu ändern. Der beste Ersatz ist die Lehre.

Doktrin ORM

Doctrine ist ein ORM (Object Relational Mapping), das das Data Mapper-Muster implementiert und es Ihnen ermöglicht, die Geschäftsregeln Ihrer Anwendung vollständig von der Persistenzschicht der Datenbank zu trennen. Doctrine verwendet DQL, nicht SQL. DQL bietet Ihnen die Object Query Language, was bedeutet, dass Sie Abfragen mithilfe von Objektbegriffen anstelle herkömmlicher relationaler Abfragebegriffe durchführen.

Es ermöglicht Ihnen das objektorientierte Schreiben von Datenbankabfragen und hilft, wenn Sie die Datenbank auf eine Weise abfragen müssen, die mit den Standard-Repository-Methoden nicht möglich ist. Meiner Meinung nach ist DQL die leistungsstärkste Möglichkeit, mit der Datenbank in Verbindung zu bleiben.

Dogma und Beredsamkeit

Die Doctrine-Entität ist nur eine gewöhnliche einfache PHP-Klasse, die keinen ORM-Vererbungsaufwand verursacht. Doctrine verwendet dieselbe Vererbung, um mehrere Abfrageanfragen zu verwalten, ohne auf die Datenbank zuzugreifen, was bedeutet, dass Entitätsobjekte in der gesamten Anfrage vorhanden sind.

Eine weitere nette Funktion von Doctrine ist, dass anstelle der Migration von Dateien zum Erstellen eines Datenbankschemas die Datenbank automatisch erstellt wird, um die Metadaten in Entitätsanmerkungen widerzuspiegeln. Eloquent hingegen ist weniger komplex und sehr einfach zu bedienen.

Ein vollständiger Vergleich zwischen diesen beiden würde einen separaten Artikel erfordern. Wie Sie sehen können, sind Doctrine-Objekte leichter und abstrakter. Allerdings ist Doctrine nur für bestimmte Projekte geeignet und kann daher manchmal zu Mehraufwand für Sie führen. Ich glaube, dass es Sache des Programmierers ist, das beste ORM für die Anwendung auszuwählen.

Blog-App

Jetzt ist es an der Zeit, mit Laravel eine Blogging-Anwendung zu erstellen. Zuerst müssen wir die Lehre etablieren. Es gibt eine Brücke, die zu bestehenden Konfigurationen von Laravel 5 passt. Um Doctrine 2 in einem Laravel-Projekt zu installieren, führen wir den folgenden Befehl aus:

composer require laravel-doctrine/orm

Wie üblich sollte das Paket zu app/config.php hinzugefügt werden, als Dienstleister:

LaravelDoctrine\ORM\DoctrineServiceProvider::class,

Es sollte auch ein Alias ​​konfiguriert werden:

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

Abschließend veröffentlichen wir die Paketkonfiguration:

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

Jetzt sind wir fertig.

Entitäten sind ein wichtiger Teil einer Anwendung 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;
    }
}

Jetzt ist es an der Zeit, das zuvor beschriebene Repository zu erstellen. 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);
    }
}

Controller: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');
        }
    }
}

Wie Sie sehen, verwende ich Flash Assistant zum Verwalten von Nachrichten (Sie können den von Laravel verwenden). In Bezug auf Validatoren sollte ich hinzufügen, dass Sie je nach Wunsch Ihre eigenen erstellen können (wie ich es getan habe) oder die Laravel-Standardeinstellungen verwenden können.

Dateien wie gewohnt anzeigen. In dieser Beispielansicht sieht die Datei wie folgt aus: 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' !!}
                        
                    
                
                
            
        

Das obige ist der detaillierte Inhalt vonLagermodus in Laravel 5. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!