À propos de l'utilisation du mappage objet-relationnel Eloquent dans le framework Laravel de PHP

Cet article présente principalement l'utilisation du mappage relationnel d'objets Eloquent dans le framework PHP Laravel, en se concentrant sur la relation entre les modèles de données d'Eloquent. Les amis dans le besoin peuvent s'y référer

Zéro, qu'est-ce qu'Eloquent <.>
Eloquent est « ORM » de Laravel, c'est-à-dire « Object Relational Mapping », le mappage relationnel d'objet. L'émergence de l'ORM vise à nous aider à rendre les opérations de base de données plus pratiques.

Eloquent permet à une 'classe Model' de correspondre à une table de base de données et encapsule de nombreuses 'fonctions' dans la couche inférieure, ce qui rend la classe Model très pratique à appeler.

Regardez le code suivant :

<?php

class Article extends \Eloquent {

protected $fillable = [];

}

'protected $fillable = [];' Cette ligne de code n'a aucune valeur ici, elle est un générateur Généré automatiquement, nous n’en parlerons pas ici.

Cette classe ne pourrait pas être plus simple. Il n'y a pas d'espace de noms spécifié ni de constructeur. Si la ligne de code dénuée de sens n'est pas incluse, ce fichier n'a que deux choses significatives : 'Article' et 'Eloquent'. C'est vrai, Eloquent est tellement génial. Il vous suffit d'hériter de la classe Eloquent, et vous pouvez faire beaucoup de choses telles que 'first() find()where() orderBy()'. orienté.

1. Utilisation de base d'Eloquent

Sans plus tarder, ci-dessous, je vais montrer directement le code de plusieurs utilisations courantes d'Eloquent.

Trouvez l'article avec l'identifiant 2 et imprimez son titre

$article = Article::find(2);

echo $article->title;

Trouvez l'article avec le titre "Je suis le titre" et imprimer l'identifiant

$article = Article::where('title', '我是标题')->first();

echo $article->id;

Interroger tous les articles et imprimer tous les titres en boucle

$articles = Article::all(); // 此处得到的 $articles 是一个对象集合，可以在后面加上 '->toArray()' 变成多维数组。

foreach ($articles as $article) {

  echo $article->title;

}

Recherchez tous les articles avec des identifiants compris entre 10 et 20 et imprimez tous les titres

$articles = Article::where(&#39;id&#39;, &#39;>&#39;, 10)->where(&#39;id&#39;, &#39;<&#39;, 20)->get();

foreach ($articles as $article) {

  echo $article->title;

}

Recherchez tous les articles et imprimez tous les titres dans une boucle, suivez update_at Tri inversé

$articles = Article::where(&#39;id&#39;, &#39;>&#39;, 10)->where(&#39;id&#39;, &#39;<&#39;, 20)->orderBy(&#39;updated_at&#39;, &#39;desc&#39;)->get();

foreach ($articles as $article) {

  echo $article->title;

}

Points d'utilisation de base

1 Chaque classe qui hérite d'Eloquent a deux articles « d'utilisation fixe » : :find($number)' 'Article::all()', le premier obtiendra un objet avec la valeur extraite de la base de données, et le second obtiendra une collection d'objets contenant l'intégralité de la base de données.

2. Toutes les méthodes intermédiaires telles que 'where()' 'orderBy()', etc. peuvent prendre en charge les appels 'statiques' et 'non-static chaining', c'est-à-dire 'Article::where( )...' et 'Article::....->where()'.

3. Tous les appels à « utilisation non fixe » nécessitent une opération pour « terminer ». Il y a deux « opérations de fin » dans ce didacticiel : « ->get() » et « - >first( ». )'.

2. Flux d'opérations intermédiaire
Le mot Builder peut être traduit littéralement par constructeur, mais « flux d'opérations intermédiaire » est plus facile à comprendre, car les opérations de base de données sont principalement des opérations en chaîne. .

Flux d'opération intermédiaire, veuillez consulter le code :

Article::where(&#39;id&#39;, &#39;>&#39;, 10)->where(&#39;id&#39;, &#39;<&#39;, 20)->orderBy(&#39;updated_at&#39;, &#39;desc&#39;)->get();

Le `::where()->where( de ceci code )->orderBy()` est le flux d’opération intermédiaire. Le flux d'opération intermédiaire est compris à l'aide d'une approche orientée objet et peut être résumé en une phrase :

Créer un objet, modifier continuellement ses propriétés, et enfin utiliser une opération pour déclencher une opération de base de données.

Comment trouver des indices sur le flux d'opération intermédiaire

Il n'y a presque aucune information précieuse dans le document sur le flux d'opération intermédiaire. Alors, comment pouvons-nous trouver cette chose ? C'est simple, utilisez le code suivant :

$builder = Article::where('title', "我是标题")->title;

Ensuite, vous verrez l'erreur suivante :

Pourquoi l'erreur se produit-elle ? Parce que `Article::where()` est toujours un objet `Builder`, pas un objet `Article`, il ne peut donc pas accéder directement au `title`.

Méthode "Terminator"

La méthode dite "Terminator" fait référence au déclenchement de l'opération finale de requête de base de données après que N méthodes de flux d'opérations intermédiaires ont traité un objet Eloquent.

`first()` `get()` `paginate()` `count()` `delete()` sont quelques-unes des méthodes "terminator" les plus couramment utilisées, elles exploiteront le flux dans le milieu Apparaît enfin, le SQL est envoyé à la base de données, les données renvoyées sont obtenues et un objet Article ou une collection d'un groupe d'objets Article est renvoyé après traitement.

Exemples d'utilisation complexe

Article::where(&#39;id&#39;, &#39;>&#39;, &#39;100&#39;)->where(&#39;id&#39;, &#39;<&#39;, &#39;200&#39;)->orWhere(&#39;top&#39;, 1)->belongsToCategory()->where(&#39;category_level&#39;, &#39;>&#39;, &#39;1&#39;)->paginate(10);

3. Relations (associations) entre modèles Relation un à un

Comme son nom l'indique, il décrit une relation biunivoque entre deux modèles. Ce type de relation ne nécessite pas de tables intermédiaires.

Supposons que nous ayons deux modèles : Utilisateur et Compte, correspondant respectivement aux utilisateurs enregistrés et aux consommateurs. Il s'agit d'une relation un-à-un. Ensuite, si nous voulons utiliser la méthode de relation un-à-un fournie par. Éloquente, la structure de la table devrait être comme ceci :

user: id ... ... account_id

account: id ... ... user_id

En supposant que nous devons interroger les informations de la table Account correspondantes dans le modèle User, le le code devrait être comme ça. `/app/models/User.php` :

<?php

class User extends Eloquent {

 

 protected $table = &#39;users&#39;;

 public function hasOneAccount()

 {

   return $this->hasOne(&#39;Account&#39;, &#39;user_id&#39;, &#39;id&#39;);

 }

}

然后，当我们需要用到这种关系的时候，该如何使用呢？如下：

$account = User::find(10)->hasOneAccount;

此时得到的 `$account` 即为 `Account` 类的一个实例。

这里最难的地方在于后面的两个 foreign_key 和 local_key 的设置，大家可以就此记住：在 User 类中，无论 hasOne 谁，第二个参数都是 `user_id`，第三个参数一般都是 `id`。由于前面的 `find(10)` 已经锁定了 id = 10，所以这段函数对应的 SQL 为： `select * from account where user_id=10`。

这段代码除了展示了一对一关系该如何使用之外，还传达了三点信息，也是我对于大家使用 Eloquent 时候的建议：

（1）. 每一个 Model 中都指定表名

（2）. has one account 这样的关系写成 `hasOneAccount()` 而不是简单的 `account()`

（3）. 每次使用模型间关系的时候都写全参数，不要省略
相应的，如果使用 belongsTo() 关系，应该这么写：

<?php

class Account extends Eloquent {

 protected $table = &#39;accounts&#39;;

 

 public function belongsToUser()

 {

  return $this->belongsTo(&#39;User&#39;, &#39;user_id&#39;, &#39;id&#39;);

 }

}

2.一对多关系

学会了前面使用一对一关系的基础方法，后面的几种关系就简单多了。

我们引入一个新的Model：Pay，付款记录。表结构应该是这样的：

user: id ... ...

pay: id ... ... user_id

User 和 Pay 具有一对多关系，换句话说就是一个 User 可以有多个 Pay，这样的话，只在 Pay 表中存在一个 `user_id` 字段即可。 `/app/models/User.php`:

<?php

class User extends Eloquent {

 

 protected $table = &#39;users&#39;;

 public function hasManyPays()

 {

  return $this->hasMany(&#39;Pay&#39;, &#39;user_id&#39;, &#39;id&#39;);

 }

}

然后，当我们需要用到这种关系的时候，该如何使用呢？如下：

$accounts = User::find(10)->hasManyPays()->get();

此时得到的 `$accounts` 即为 `Illuminate\Database\Eloquent\Collection` 类的一个实例。大家应该也已经注意到了，这里不是简单的 `-> hasOneAccount` 而是 `->hasManyPays()->get()`，为什么呢？因为这里是 `hasMany`，操作的是一个对象集合。

相应的 belongsTo() 的用法跟上面一对一关系一样：

<?php

class Pay extends Eloquent {

 protected $table = &#39;pays&#39;;

 

 public function belongsToUser()

 {

  return $this->belongsTo(&#39;User&#39;, &#39;user_id&#39;, &#39;id&#39;);

 }

}

3.多对多关系

多对多关系和之前的关系完全不一样，因为多对多关系可能出现很多冗余数据，用之前自带的表存不下了。

我们定义两个模型：Article 和 Tag，分别表示文章和标签，他们是多对多的关系。表结构应该是这样的：

article: id ... ...

tag: id ... ...

article_tag: article_id tag_id

在 Model 中使用：

<?php

class Tag extends Eloquent {

 protected $table = &#39;tags&#39;;

 

 public function belongsToManyArticle()

 {

  return $this->belongsToMany(&#39;Article&#39;, &#39;article_tag&#39;, &#39;tag_id&#39;, &#39;article_id&#39;);

 }

}

需要注意的是，第三个参数是本类的 id，第四个参数是第一个参数那个类的 id。

使用跟 hasMany 一样：

$tagsWithArticles = Tag::take(10)->get()->belongsToManyArticle()->get();

这里会得到一个非常复杂的对象，可以自行 `var_dump()`。跟大家说一个诀窍，`var_dump()` 以后，用 Chrome 右键 “查看源代码”，就可以看到非常整齐的对象/数组展开了。

在这里给大家展示一个少见用法（奇技淫巧）：

public function parent_video()

{

  return $this->belongsToMany($this, 'video_hierarchy', 'video_id', 'video_parent_id');

}

public function children_video()

{

  return $this->belongsToMany($this, 'video_hierarchy', 'video_parent_id', 'video_id');

}

对，你没有看错，可以 belongsToMany 自己。
其他关系

Eloquent 还提供 “远层一对多关联”、“多态关联” 和 “多态的多对多关联” 这另外三种用法，经过上面的学习，我们已经掌握了 Eloquent 模型间关系的基本概念和使用方法，剩下的几种不常用的方法就留到我们用到的时候再自己探索吧。

重要技巧：关系预载入
你也许已经发现了，在一对一关系中，如果我们需要一次性查询出10个 User 并带上对应的 Account 的话，那么就需要给数据库打 1 + 10 条 SQL，这样性能是很差的。我们可以使用一个重要的特性，关系预载入：http://laravel-china.org/docs/eloquent#eager-loading

直接上代码：

$users = User::with('hasOneAccount')->take(10)->get()

这样生成的 SQL 就是这个样子的：

select * from account where id in (1, 2, 3, ... ...)

这样 1 + 10 条 SQL 就变成了 1 + 1 条，性能大增。

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

如何PHP中Laravel框架实现supervisor执行异步进程

PHP的Laravel框架中的event事件操作的解析

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!