Dieser Artikel stellt hauptsächlich die Verwendung der eloquenten objektbezogenen Zuordnung im Laravel-Framework von PHP vor und konzentriert sich auf die Beziehung zwischen den Datenmodellen von Eloquent. Freunde in Not können darauf verweisen
Null, was ist eloquent
Eloquent ist Laravels „ORM“, also „Object Relational Mapping“, objektrelationale Zuordnung. Das Aufkommen von ORM soll uns dabei helfen, den Datenbankbetrieb komfortabler zu gestalten.
Eloquent ermöglicht einer „Model-Klasse“ die Entsprechung zu einer Datenbanktabelle und kapselt viele „Funktionen“ auf der untersten Ebene, was den Aufruf der Model-Klasse sehr einfach macht.
Sehen Sie sich den folgenden Code an:
<?php
class Article extends \Eloquent {
protected $fillable = [];
}Nach dem Login kopieren
'protected $fillable = [];' Diese Codezeile hat hier keinen Wert und wird automatisch generiert von den Generator, wir werden hier nicht darauf eingehen.
Diese Klasse könnte nicht einfacher sein. Es gibt keinen angegebenen Namespace und keinen Konstruktor. Wenn die bedeutungslose Codezeile nicht enthalten ist, enthält diese Datei nur zwei sinnvolle Dinge: „Artikel“ und „Eloquent“. Das ist richtig, Eloquent ist so großartig, dass Sie nur die Eloquent-Klasse erben müssen, und Sie können viele, viele Dinge tun, wie zum Beispiel „first() find() where() orderBy()“. orientiert.
1. Grundlegende Verwendung von Eloquent
Ohne weitere Umschweife werde ich im Folgenden direkt den Code mehrerer häufiger Verwendungen von Eloquent zeigen.
Suchen Sie den Artikel mit der ID 2 und drucken Sie seinen Titel aus
$article = Article::find(2);
echo $article->title;
Nach dem Login kopieren
Suchen Sie den Artikel mit dem Titel „Ich bin der Titel“ und drucken Sie ihn aus id
$article = Article::where('title', '我是标题')->first();
echo $article->id;
Nach dem Login kopieren
Alle Artikel abfragen und alle Titel in einer Schleife ausdrucken
$articles = Article::all(); // 此处得到的 $articles 是一个对象集合，可以在后面加上 '->toArray()' 变成多维数组。
foreach ($articles as $article) {
echo $article->title;
}Nach dem Login kopieren
Finde die ID in 10 Alle Artikel zwischen ~20 und drucke alle Titel
$articles = Article::where('id', '>', 10)->where('id', '<', 20)->get();
foreach ($articles as $article) {
echo $article->title;
}Nach dem Login kopieren
Alle Artikel abfragen und alle Titel in einer Schleife ausdrucken, in umgekehrter Reihenfolge sortiert nach aktualisiert_at
$articles = Article::where('id', '>', 10)->where('id', '<', 20)->orderBy('updated_at', 'desc')->get();
foreach ($articles as $article) {
echo $article->title;
}Nach dem Login kopieren
Grundlegende Verwendungspunkte
1. Jede Klasse, die Eloquent erbt, hat zwei 'feste Verwendungen' 'Article::find($number)' ' Artikel: :all()', ersterer erhält ein Objekt mit dem aus der Datenbank entnommenen Wert und letzterer erhält eine Sammlung von Objekten, die die gesamte Datenbank enthalten.
2. Alle Zwischenmethoden wie „where()“, „orderBy()“ usw. können sowohl „statische“ als auch „nichtstatische Verkettung“-Aufrufe unterstützen, also „Article::where( )...' und 'Article::....->where()'.
3. Alle „nicht festen Nutzung“-Aufrufe erfordern eine Operation zum „Enden“. In diesem Tutorial gibt es zwei „End-Operationen“: „->get()“ und „- >first(“ )'.
2. Zwischenoperationsablauf
Das Wort Builder kann wörtlich mit Konstruktor übersetzt werden, aber „Zwischenoperationsablauf“ ist einfacher zu verstehen, da es sich bei Datenbankoperationen meist um Kettenoperationen handelt.
Zwischenbetriebsablauf, siehe Code:
Article::where('id', '>', 10)->where('id', '<', 20)->orderBy('updated_at', 'desc')->get();
Nach dem Login kopieren
`::where()->where()- dieses Codes >orderBy()` ist der Zwischenoperationsablauf. Der Zwischenoperationsablauf wird unter Verwendung eines objektorientierten Ansatzes verstanden und kann in einem Satz zusammengefasst werden:
Erstellen Sie ein Objekt, ändern Sie kontinuierlich seine Eigenschaften und verwenden Sie schließlich eine Operation, um eine Datenbankoperation auszulösen.
Wie findet man Hinweise zum Zwischenbetriebsablauf?
Das Dokument enthält fast keine wertvollen Informationen zum Zwischenbetriebsablauf. Wie finden wir diese Sache? Es ist ganz einfach, verwenden Sie den folgenden Code:
$builder = Article::where('title', "我是标题")->title;
Nach dem Login kopieren
Dann sehen Sie den folgenden Fehler:
Warum tritt der Fehler auf? Da „Article::where()“ immer noch ein „Builder“-Objekt und kein „Article“-Objekt ist, kann es nicht direkt auf „title“ zugreifen.
Methode „Terminator“
Die sogenannte „Terminator“-Methode bezieht sich auf das Auslösen der endgültigen Datenbankabfrageoperation, nachdem N Zwischenoperationsflussmethoden ein Eloquent-Objekt verarbeitet haben.
`first()` `get()` `paginate()` `count()` `delete()` sind einige der am häufigsten verwendeten „Terminator“-Methoden, sie bedienen den Stream im Mitte Schließlich wird die SQL an die Datenbank gesendet, die zurückgegebenen Daten werden abgerufen und nach der Verarbeitung wird ein Artikelobjekt oder eine Sammlung einer Gruppe von Artikelobjekten zurückgegeben.
Beispiele für komplexe Verwendung
Article::where('id', '>', '100')->where('id', '<', '200')->orWhere('top', 1)->belongsToCategory()->where('category_level', '>', '1')->paginate(10);
Nach dem Login kopieren
3. Beziehungen (Assoziationen) zwischen Modellen
1 Der Name deutet darauf hin, dass es sich um eine Eins-zu-eins-Beziehung zwischen zwei Modellen handelt. Für diese Art von Beziehung sind keine Zwischentabellen erforderlich.
Angenommen, wir haben zwei Modelle: Benutzer und Konto, die jeweils einer Eins-zu-Eins-Beziehung entsprechen. Wenn wir dann die Eins-zu-Eins-Beziehungsmethode verwenden möchten Eloquent, die Tabellenstruktur sollte wie folgt aussehen:
user: id ... ... account_id
account: id ... ... user_id
Nach dem Login kopieren
Unter der Annahme, dass wir die entsprechenden Kontotabelleninformationen im Benutzermodell abfragen müssen, sollte der Code so sein so was. `/app/models/User.php`:
<?php
class User extends Eloquent {
protected $table = 'users';
public function hasOneAccount()
{
return $this->hasOne('Account', 'user_id', 'id');
}
}Nach dem Login kopieren
然后，当我们需要用到这种关系的时候，该如何使用呢？如下：
$account = User::find(10)->hasOneAccount;
Nach dem Login kopieren
此时得到的 `$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 = 'accounts';
public function belongsToUser()
{
return $this->belongsTo('User', 'user_id', 'id');
}
}Nach dem Login kopieren
2.一对多关系
学会了前面使用一对一关系的基础方法，后面的几种关系就简单多了。
我们引入一个新的Model：Pay，付款记录。表结构应该是这样的：
user: id ... ...
pay: id ... ... user_id
Nach dem Login kopieren
User 和 Pay 具有一对多关系，换句话说就是一个 User 可以有多个 Pay，这样的话，只在 Pay 表中存在一个 `user_id` 字段即可。 `/app/models/User.php`:
<?php
class User extends Eloquent {
protected $table = 'users';
public function hasManyPays()
{
return $this->hasMany('Pay', 'user_id', 'id');
}
}Nach dem Login kopieren
然后，当我们需要用到这种关系的时候，该如何使用呢？如下：
$accounts = User::find(10)->hasManyPays()->get();
Nach dem Login kopieren
此时得到的 `$accounts` 即为 `Illuminate\Database\Eloquent\Collection` 类的一个实例。大家应该也已经注意到了，这里不是简单的 `-> hasOneAccount` 而是 `->hasManyPays()->get()`，为什么呢？因为这里是 `hasMany`，操作的是一个对象集合。
相应的 belongsTo() 的用法跟上面一对一关系一样：
<?php
class Pay extends Eloquent {
protected $table = 'pays';
public function belongsToUser()
{
return $this->belongsTo('User', 'user_id', 'id');
}
}Nach dem Login kopieren
3.多对多关系
多对多关系和之前的关系完全不一样，因为多对多关系可能出现很多冗余数据，用之前自带的表存不下了。
我们定义两个模型：Article 和 Tag，分别表示文章和标签，他们是多对多的关系。表结构应该是这样的：
article: id ... ...
tag: id ... ...
article_tag: article_id tag_id
Nach dem Login kopieren
在 Model 中使用：
<?php
class Tag extends Eloquent {
protected $table = 'tags';
public function belongsToManyArticle()
{
return $this->belongsToMany('Article', 'article_tag', 'tag_id', 'article_id');
}
}Nach dem Login kopieren
需要注意的是，第三个参数是本类的 id，第四个参数是第一个参数那个类的 id。
使用跟 hasMany 一样：
$tagsWithArticles = Tag::take(10)->get()->belongsToManyArticle()->get();
Nach dem Login kopieren
这里会得到一个非常复杂的对象，可以自行 `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');
}Nach dem Login kopieren
对，你没有看错，可以 belongsToMany 自己。
其他关系
Eloquent 还提供 “远层一对多关联”、“多态关联” 和 “多态的多对多关联” 这另外三种用法，经过上面的学习，我们已经掌握了 Eloquent 模型间关系的基本概念和使用方法，剩下的几种不常用的方法就留到我们用到的时候再自己探索吧。
重要技巧：关系预载入
你也许已经发现了，在一对一关系中，如果我们需要一次性查询出10个 User 并带上对应的 Account 的话，那么就需要给数据库打 1 + 10 条 SQL，这样性能是很差的。我们可以使用一个重要的特性，关系预载入：http://laravel-china.org/docs/eloquent#eager-loading
直接上代码：
$users = User::with('hasOneAccount')->take(10)->get()
Nach dem Login kopieren
这样生成的 SQL 就是这个样子的：
select * from account where id in (1, 2, 3, ... ...)
Nach dem Login kopieren
这样 1 + 10 条 SQL 就变成了 1 + 1 条，性能大增。
以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！
相关推荐：
如何PHP中Laravel框架实现supervisor执行异步进程
PHP的Laravel框架中的event事件操作的解析
Das obige ist der detaillierte Inhalt vonÜber die Verwendung der objektrelationalen Eloquent-Zuordnung im Laravel-Framework von PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
