Warehousing mode in Laravel 5

The repository pattern was first introduced by Eric Evans in his Domain-Driven Design book. In fact, the repository is the application's entry point to the domain layer.

Simply put, a repository allows all of your code to use objects without knowing how the objects are persisted. The repository contains all knowledge of persistence, including mapping from tables to objects. This provides a more object-oriented view of the persistence layer and makes the mapping code more encapsulated.

The only way to get your repository to work in Laravel (as a real repository - Eric Evans Domain Driven Design Book) is to change the default ORM from Active Record to Data Mapper. The best substitute is doctrine.

doctrine ORM

Doctrine is an ORM (Object Relational Mapping) that implements the Data Mapper pattern and allows you to completely separate your application's business rules from the database's persistence layer. Doctrine uses DQL, not SQL. DQL brings you Object Query Language, which means you'll query using object terms instead of traditional relational query terms.

It allows you to write database queries in an object-oriented way and helps when you need to query the database in a way that is not possible using the default repository methods. In my opinion, DQL is the most powerful way to stay connected to your database.

Dogma and Eloquence

The Doctrine entity is just an ordinary PHP simple class that does not add any ORM inheritance overhead. Doctrine uses the same inheritance to manage multiple query requests without accessing the database, which means entity objects are present throughout the request.

Another nice feature of Doctrine is that instead of migrating files to create a database schema, the database is automatically created to reflect the metadata in entity annotations. Eloquent, on the other hand, is less complex and very easy to use.

A complete comparison between these two would require a separate article. As you can see, Doctrine objects are lighter and more abstract. However, Doctrine is only suitable for specific projects, so it may sometimes create overhead for you. I believe it's up to the programmer to choose the best ORM for the application.

Blog Application

Now it's time to create a blogging application using Laravel. First, we need to establish doctrine. There is a bridge to match existing configurations of Laravel 5. To install Doctrine 2 in a Laravel project, we run the following command:

composer require laravel-doctrine/orm

As usual, this package should be added to app/config.php , as the service provider:

LaravelDoctrine\ORM\DoctrineServiceProvider::class,

An alias should also be configured:

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

Finally, we publish the package configuration:

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

Now we are done.

Entities are an important part of the application App\Entities\Post.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;
    }
}

Now it's time to create the repository , which was described earlier. 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');
        }
    }
}

As you can see, I use Flash Assistant to manage messages (you can use Laravel's). Regarding validators, I should add that you can create your own (like I did) or use the Laravel defaults, depending on your preference.

Viewing files is the same as usual. In this example view, the file looks like 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' !!}

The above is the detailed content of Warehousing mode in Laravel 5. For more information, please follow other related articles on the PHP Chinese website!