As a PHP developer, you might have sầu come across the term ORM. ORM is a way khổng lồ work with databases in the same way you work with classes & objects. If you were to delve deeper inlớn how web applications are designed & built, after doing some exploring in their ORM you would find two well-known patterns: Active Record & Data Mapper.
Bạn đang xem: Doctrine là gì
Active Record refers lớn mapping an object khổng lồ a database row. Indeed, each row in the database is tied khổng lồ an object. When you retrieve a row from the database you can update, delete or save using the object itself. That’s how Eloquent và Paris work, & how it’s done in Ruby on Rails.
On the other hand, Data Mapper is a layer of software which separates the in-memory objects from the database. With Data Mapper the in-memory objects needn’t know that there is even a database present. They need no Squốc lộ interface balkanpoliticalclub.net or knowledge of the database schema. One such solution is Doctrine.
What Is Doctrine?
Doctrine is an ORM which implements the data mapper pattern & allows you khổng lồ make a clean separation of the application’s business rules from the persistence layer of the database.
Some of the advantages I discovered while using Doctrine with Laravel are:
Faster & easier lớn use. Entities are just plain PHP.. objects. Doctrine utilizes a “balkanpoliticalclub.net first” approach, so you can create entities first, và then generate a database for them automatically. The reverse case is also possible, but I bởi vì not recommover it. Supports annotations, XML and YAML for schema. Dquốc lộ (a replacement for SQL) abstracts your tables away. Doctrine events allow you to lớn easily hook onto specific database events & perform certain actions. Repositories are more faithful lớn the repository pattern. Transactional write-behind methodology lets Doctrine have sầu less interaction with the Database until the flush() method is called.Of course, Doctrine has disadvantages too, but it is up to lớn the programmer khổng lồ choose the right ORM.
Doctrine DQL
Dquốc lộ stands for Doctrine Query Language. DQL brings you object query language, which means that instead of a traditional relational query, you have sầu queries in object size.
Dquốc lộ allows you khổng lồ write database queries in an object-oriented way, which is helpful when you need khổng lồ query the database in a way which cannot be achieved (or is very difficult) using the mặc định repository methods.
Sample DQL Query:
SELECT b.id as ItemId, b.title as ItemTitle , b.url as ItemUrl FROM AlirezaDomainIdentityEntitiesMenu u WHERE u.id =:id
Doctrine Filters
Doctrine allows you to lớn limit query results with Filters. For example, you may want khổng lồ edit only the information of the logged-in user or make sure the current client’s data was returned from the database. A filter is an automatic solution for remembering specific conditions for all your queries.Xem thêm: Những Điều Cơ Bản Về Kỹ Thuật Câu Lure Là Gì ? Chọn Cần Và Mồi Câu Phù Hợp
Doctrine provides SQL level limitations, so there is no need khổng lồ maintain the clause in multiple repositories of your project. This enhances security và makes your balkanpoliticalclub.net easier khổng lồ read.
Let’s look at an example:
/** *
JoinColumn(name="user_id", referencedColumnName="id") **/ private $user;As you can see in the User entity, the result of JoinColumn is limited to lớn only items with the condition of WHERE user_id = :user_id.
Setting Up Doctrine 2
To mix up Doctrine, there is a bridge khổng lồ allow for matching with Laravel 5’s existing configuration. To install Doctrine 2 within our Laravel project, we run the following command:
composer require laravel-doctrine/ormAs usual, the package should be added khổng lồ the app/config.php, as the service provider:
LaravelDoctrineORMDoctrineServiceProvider::class,The alias should also be configured:
"EntityManager" => LaravelDoctrineORMFacadesEntityManager::classFinally, we publish the package configuration with:
php artisan vendor:publish --tag="config"Doctrine needs no database configuration & uses the current Laravel configuration, but if you want khổng lồ override it you should change the Doctrine config tệp tin in Config/doctrine.php:
"managers" => < "default" => < "dev" => env("APP_DEBUG"), "meta" => env("DOCTRINE_METADATA", "annotations"), "connection" => env("DB_CONNECTION", "mysql"), "namespaces" => < "App" >,That’s all there is to it.
What Is an Entity?
“Entity” refers to lớn an object which has a distinct identity. An entity must have a specific identifier which is quality throughout the entire system, such as a customer or a student. There would be other objects, such as email addresses, which are not entities, but value objects.
Let’s create a Post Entity App/Entity/Post.php:
namespace AppEntity;use DoctrineORMMapping as ORM;/** *
ORMColumn(type="text") */ private $body; public function __construct($input) $this->setTitle($input<"title">); $this->setBody($input<"body">); 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->toàn thân = $body; }The class properties should be the same as the fields in the database table, or you can define them with the
Colum("name"="myfield") annotation.
What Is a Repository?
The repository allows all your balkanpoliticalclub.net khổng lồ use objects without needing lớn know how the objects are persisted. The repository contains all the knowledge of persistence, including mapping from tables to lớn objects. This provides a more object-oriented view of the persistence layer và makes the mapping balkanpoliticalclub.net more encapsulated.
Now it’s time to lớn create the Repository in App/Repository/PostRepo.php:
namespace AppRepository;use AppEntityPost;use DoctrineORMEntityManager;class PostRepo /** *
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 prepareData($data) return new Post($data); The Doctrine EntityManager works as the access point for the complete management of your entities.Then, create the Controller App/Http/Controllers/PostController.php:
namespace AppHttpControllers;use AppRepositoryPostRepo as repo;use AppValidationPostValidator;class PostController extends Controller private $repo; public function __construct(repo $repo) $this->repo = $repo; public function edit($id=NULL) return View("admin.index")->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"); View và routing are the same as usual.
I prefer lớn create my own Validator based on Laravel’s Validator class. Here’s the Validator AppValidationPostValidator.php:
namespace AppValidation;use Validator;class PostValidator public static function validate($input) $rules = < "title" => "Required