yii2-Active Record 详解(下)

AR的生命周期

理解AR的生命周期对于你操作数据库非常重要。生命周期通常都会有些典型的事件存在。对于开发AR的behaviors来说非常有用。

当你实例化一个新的AR对象时,我们将获得如下的生命周期:

  1. constructor
  2. yii\db\ActiveRecord::init(): 会触发一个 yii\db\ActiveRecord::EVENT_INIT 事件

当你通过 yii\db\ActiveRecord::find() 方法查询数据时,每个AR实例都将有以下生命周期:

  1. constructor
  2. yii\db\ActiveRecord::init(): 会触发一个 yii\db\ActiveRecord::EVENT_INIT 事件
  3. yii\db\ActiveRecord::afterFind(): 会触发一个 yii\db\ActiveRecord::EVENT_AFTER_FIND 事件

当通过 yii\db\ActiveRecord::save() 方法写入或者更新数据时, 我们将获得如下生命周期:

  1. yii\db\ActiveRecord::beforeValidate(): 会触发一个 yii\db\ActiveRecord::EVENT_BEFORE_VALIDATE 事件
  2. yii\db\ActiveRecord::afterValidate(): 会触发一个 yii\db\ActiveRecord::EVENT_AFTER_VALIDATE 事件
  3. yii\db\ActiveRecord::beforeSave(): 会触发一个 yii\db\ActiveRecord::EVENT_BEFORE_INSERT 或 yii\db\ActiveRecord::EVENT_BEFORE_UPDATE 事件
  4. 执行实际的数据写入或更新
  5. yii\db\ActiveRecord::afterSave(): 会触发一个 yii\db\ActiveRecord::EVENT_AFTER_INSERT 或 yii\db\ActiveRecord::EVENT_AFTER_UPDATE 事件

最后,当调用 yii\db\ActiveRecord::delete() 删除数据时, 我们将获得如下生命周期:

  1. yii\db\ActiveRecord::beforeDelete(): 会触发一个 yii\db\ActiveRecord::EVENT_BEFORE_DELETE 事件
  2. 执行实际的数据删除
  3. yii\db\ActiveRecord::afterDelete(): 会触发一个 yii\db\ActiveRecord::EVENT_AFTER_DELETE 事件

查询关联的数据

使用 AR 方法也可以查询数据表的关联数据(如,选出表A的数据可以拉出表B的关联数据)。 有了 AR, 返回的关联数据连接就像连接关联主表的 AR 对象的属性一样。

建立关联关系后,通过 $customer->orders 可以获取 一个 Order 对象的数组,该数组代表当前客户对象的订单集。

定义关联关系使用一个可以返回 yii\db\ActiveQuery 对象的 getter 方法, yii\db\ActiveQuery对象有关联上下文的相关信息,因此可以只查询关联数据。

例如:

class Customer extends \yii\db\ActiveRecord
{
    public function getOrders()
    {
        // 客户和订单通过 Order.customer_id -> id 关联建立一对多关系
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}

class Order extends \yii\db\ActiveRecord
{
    // 订单和客户通过 Customer.id -> customer_id 关联建立一对一关系
    public function getCustomer()
    {
        return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
    }
}

以上使用了 yii\db\ActiveRecord::hasMany() 和 yii\db\ActiveRecord::hasOne() 方法。 以上两例分别是关联数据多对一关系和一对一关系的建模范例。 如,一个客户有很多订单,一个订单只归属一个客户。 两个方法都有两个参数并返回 yii\db\ActiveQuery 对象。

  • $class:关联模型类名,它必须是一个完全合格的类名。
  • $link: 两个表的关联列,应为键值对数组的形式。 数组的键是 $class 关联表的列名, 而数组值是关联类 $class 的列名。 基于表外键定义关联关系是最佳方法。

建立关联关系后,获取关联数据和获取组件属性一样简单, 执行以下相应getter方法即可:

// 取得客户的订单
$customer = Customer::findOne(1);
$orders = $customer->orders; // $orders 是 Order 对象数组

以上代码实际执行了以下两条 SQL 语句:

SELECT * FROM customer WHERE id=1;
SELECT * FROM order WHERE customer_id=1;

提示:再次用表达式 $customer->orders将不会执行第二次 SQL 查询, SQL 查询只在该表达式第一次使用时执行。 数据库访问只返回缓存在内部前一次取回的结果集,如果你想查询新的 关联数据,先要注销现有结果集:unset($customer->orders);

有时候需要在关联查询中传递参数,如不需要返回客户全部订单, 只需要返回购买金额超过设定值的大订单, 通过以下getter方法声明一个关联数据 bigOrders

class Customer extends \yii\db\ActiveRecord
{
    public function getBigOrders($threshold = 100)
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id'])
            ->where('subtotal > :threshold', [':threshold' => $threshold])
            ->orderBy('id');
    }
}

hasMany() 返回 yii\db\ActiveQuery 对象,该对象允许你通过 yii\db\ActiveQuery 方法定制查询。

如上声明后,执行 $customer->bigOrders 就返回 总额大于100的订单。使用以下代码更改设定值:

$orders = $customer->getBigOrders(200)->all();

>注意:关联查询返回的是 yii\db\ActiveQuery 的实例,如果像特性(如类属性)那样连接关联数据, 返回的结果是关联查询的结果,即 yii\db\ActiveRecord 的实例, 或者是数组,或者是 null ,取决于关联关系的多样性。如,$customer->getOrders() 返回 ActiveQuery实例,而 $customer->orders 返回Order 对象数组 (如果查询结果为空则返回空数组)。

中间关联表

有时,两个表通过中间表关联,定义这样的关联关系, 可以通过调用 yii\db\ActiveQuery::via() 方法或 yii\db\ActiveQuery::viaTable() 方法来定制 yii\db\ActiveQuery 对象 。

举例而言,如果 order 表和 item 表通过中间表 order_item 关联起来, 可以在 Order 类声明 items 关联关系取代中间表:

class Order extends \yii\db\ActiveRecord
{
    public function getItems()
    {
        return $this->hasMany(Item::className(), ['id' => 'item_id'])
            ->viaTable('order_item', ['order_id' => 'id']);
    }
}

两个方法是相似的,除了 yii\db\ActiveQuery::via() 方法的第一个参数是使用 AR 类中定义的关联名。 以上方法取代了中间表,等价于:

class Order extends \yii\db\ActiveRecord
{
    public function getOrderItems()
    {
        return $this->hasMany(OrderItem::className(), ['order_id' => 'id']);
    }

    public function getItems()
    {
        return $this->hasMany(Item::className(), ['id' => 'item_id'])
            ->via('orderItems');
    }
}

延迟加载和即时加载(又称惰性加载与贪婪加载)

如前所述,当你第一次连接关联对象时, AR 将执行一个数据库查询 来检索请求数据并填充到关联对象的相应属性。 如果再次连接相同的关联对象,不再执行任何查询语句,这种数据库查询的执行方法称为“延迟加载”。如:

// SQL executed: SELECT * FROM customer WHERE id=1
$customer = Customer::findOne(1);
// SQL executed: SELECT * FROM order WHERE customer_id=1
$orders = $customer->orders;
// 没有 SQL 语句被执行
$orders2 = $customer->orders; //取回上次查询的缓存数据

延迟加载非常实用,但是,在以下场景中使用延迟加载会遭遇性能问题:

// SQL executed: SELECT * FROM customer LIMIT 100
$customers = Customer::find()->limit(100)->all();

foreach ($customers as $customer) {
    // SQL executed: SELECT * FROM order WHERE customer_id=...
    $orders = $customer->orders;
    // ...处理 $orders...
}

假设数据库查出的客户超过100个,以上代码将执行多少条 SQL 语句? 101 条!第一条 SQL 查询语句取回100个客户,然后, 每个客户要执行一条 SQL 查询语句以取回该客户的所有订单。

为解决以上性能问题,可以通过调用 yii\db\ActiveQuery::with() 方法使用即时加载解决。

// SQL executed: SELECT * FROM customer LIMIT 100;
//               SELECT * FROM orders WHERE customer_id IN (1,2,...)
$customers = Customer::find()->limit(100)
    ->with('orders')->all();

foreach ($customers as $customer) {
    // 没有 SQL 语句被执行
    $orders = $customer->orders;
    // ...处理 $orders...
}

如你所见,同样的任务只需要两个 SQL 语句。 >须知:通常,即时加载 N 个关联关系而通过 via() 或者 viaTable() 定义了 M 个关联关系, 将有 1+M+N 条 SQL 查询语句被执行:一个查询取回主表行数, 一个查询给每一个 (M) 中间表,一个查询给每个 (N) 关联表。 注意:当用即时加载定制 select() 时,确保连接 到关联模型的列都被包括了,否则,关联模型不会载入。如:

$orders = Order::find()->select(['id', 'amount'])->with('customer')->all();
// $orders[0]->customer 总是空的,使用以下代码解决这个问题:
$orders = Order::find()->select(['id', 'amount', 'customer_id'])->with('customer')->all();

有时候,你想自由的自定义关联查询,延迟加载和即时加载都可以实现,如:

$customer = Customer::findOne(1);
// 延迟加载: SELECT * FROM order WHERE customer_id=1 AND subtotal>100
$orders = $customer->getOrders()->where('subtotal>100')->all();

// 即时加载: SELECT * FROM customer LIMIT 100
//          SELECT * FROM order WHERE customer_id IN (1,2,...) AND subtotal>100
$customers = Customer::find()->limit(100)->with([
    'orders' => function($query) {
        $query->andWhere('subtotal>100');
    },
])->all();

逆关系

关联关系通常成对定义,如:Customer 可以有个名为 orders 关联项, 而 Order 也有个名为customer 的关联项:

class Customer extends ActiveRecord
{
    ....
    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}

class Order extends ActiveRecord
{
    ....
    public function getCustomer()
    {
        return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
    }
}

如果我们执行以下查询,可以发现订单的 customer 和 找到这些订单的客户对象并不是同一个。连接 customer->orders 将触发一条 SQL 语句 而连接一个订单的 customer 将触发另一条 SQL 语句。

// SELECT * FROM customer WHERE id=1
$customer = Customer::findOne(1);
// 输出 "不相同"
// SELECT * FROM order WHERE customer_id=1
// SELECT * FROM customer WHERE id=1
if ($customer->orders[0]->customer === $customer) {
    echo '相同';
} else {
    echo '不相同';
}

为避免多余执行的后一条语句,我们可以为 customer或 orders 关联关系定义相反的关联关系,通过调用 yii\db\ActiveQuery::inverseOf() 方法可以实现。

class Customer extends ActiveRecord
{
    ....
    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id'])->inverseOf('customer');
    }
}

现在我们同样执行上面的查询,我们将得到:

// SELECT * FROM customer WHERE id=1
$customer = Customer::findOne(1);
// 输出相同
// SELECT * FROM order WHERE customer_id=1
if ($customer->orders[0]->customer === $customer) {
    echo '相同';
} else {
    echo '不相同';
}

以上我们展示了如何在延迟加载中使用相对关联关系, 相对关系也可以用在即时加载中:

// SELECT * FROM customer
// SELECT * FROM order WHERE customer_id IN (1, 2, ...)
$customers = Customer::find()->with('orders')->all();
// 输出相同
if ($customers[0]->orders[0]->customer === $customers[0]) {
    echo '相同';
} else {
    echo '不相同';
}

>注意:相对关系不能在包含中间表的关联关系中定义。 即是,如果你的关系是通过yii\db\ActiveQuery::via() 或 yii\db\ActiveQuery::viaTable()方法定义的, 就不能调用yii\db\ActiveQuery::inverseOf()方法了。

JOIN 类型关联查询

使用关系数据库时,普遍要做的是连接多个表并明确地运用各种 JOIN 查询。 JOIN SQL语句的查询条件和参数,使用 yii\db\ActiveQuery::joinWith() 可以重用已定义关系并调用 而不是使用 yii\db\ActiveQuery::join() 来实现目标。

// 查找所有订单并以客户 ID 和订单 ID 排序,并贪婪加载 "customer" 表
$orders = Order::find()->joinWith('customer')->orderBy('customer.id, order.id')->all();
// 查找包括书籍的所有订单,并以 `INNER JOIN` 的连接方式即时加载 "books" 表
$orders = Order::find()->innerJoinWith('books')->all();

以上,方法 yii\db\ActiveQuery::innerJoinWith() 是访问 INNER JOIN 类型的 yii\db\ActiveQuery::joinWith() 的快捷方式。

可以连接一个或多个关联关系,可以自由使用查询条件到关联查询, 也可以嵌套连接关联查询。如:

// 连接多重关系
// 找出24小时内注册客户包含书籍的订单
$orders = Order::find()->innerJoinWith([
    'books',
    'customer' => function ($query) {
        $query->where('customer.created_at > ' . (time() - 24 * 3600));
    }
])->all();
// 连接嵌套关系:连接 books 表及其 author 列
$orders = Order::find()->joinWith('books.author')->all();

代码背后, Yii 先执行一条 JOIN SQL 语句把满足 JOIN SQL 语句查询条件的主要模型查出, 然后为每个关系执行一条查询语句, bing填充相应的关联记录。

yii\db\ActiveQuery::joinWith() 和 yii\db\ActiveQuery::with() 的区别是 前者连接主模型类和关联模型类的数据表来检索主模型, 而后者只查询和检索主模型类。 检索主模型

由于这个区别,你可以应用只针对一条 JOIN SQL 语句起效的查询条件。 如,通过关联模型的查询条件过滤主模型,如前例, 可以使用关联表的列来挑选主模型数据,

当使用 yii\db\ActiveQuery::joinWith() 方法时可以响应没有歧义的列名。 In the above examples, we use item.id and order.id to disambiguate the id column references 因为订单表和项目表都包括 id 列。

当连接关联关系时,关联关系默认使用即时加载。你可以 通过传参数 $eagerLoading 来决定在指定关联查询中是否使用即时加载。

默认 yii\db\ActiveQuery::joinWith() 使用左连接来连接关联表。 你也可以传 $joinType 参数来定制连接类型。 你也可以使用 yii\db\ActiveQuery::innerJoinWith()。

以下是 INNER JOIN 的简短例子:

// 查找包括书籍的所有订单,但 "books" 表不使用即时加载
$orders = Order::find()->innerJoinWith('books', false)->all();
// 等价于:
$orders = Order::find()->joinWith('books', false, 'INNER JOIN')->all();

有时连接两个表时,需要在关联查询的 ON 部分指定额外条件。 这可以通过调用 yii\db\ActiveQuery::onCondition() 方法实现:

class User extends ActiveRecord
{
    public function getBooks()
    {
        return $this->hasMany(Item::className(), ['owner_id' => 'id'])->onCondition(['category_id' => 1]);
    }
}

在上面, yii\db\ActiveRecord::hasMany() 方法回传了一个 yii\db\ActiveQuery 对象, 当你用 yii\db\ActiveQuery::joinWith() 执行一条查询时,取决于正被调用的是哪个 yii\db\ActiveQuery::onCondition(), 返回 category_id 为 1 的 items

当你用 yii\db\ActiveQuery::joinWith() 进行一次查询时,“on-condition”条件会被放置在相应查询语句的 ON 部分, 如:

// SELECT user.* FROM user LEFT JOIN item ON item.owner_id=user.id AND category_id=1
// SELECT * FROM item WHERE owner_id IN (...) AND category_id=1
$users = User::find()->joinWith('books')->all();

注意:如果通过 yii\db\ActiveQuery::with() 进行贪婪加载或使用惰性加载的话,则 on 条件会被放置在对应 SQL语句的 WHERE 部分。 因为,此时此处并没有发生 JOIN 查询。比如:

// SELECT * FROM user WHERE id=10
$user = User::findOne(10);
// SELECT * FROM item WHERE owner_id=10 AND category_id=1
$books = $user->books;

关联表操作

AR 提供了下面两个方法用来建立和解除两个关联对象之间的关系:

  • yii\db\ActiveRecord::link()
  • yii\db\ActiveRecord::unlink()

例如,给定一个customer和order对象,我们可以通过下面的代码使得customer对象拥有order对象:

$customer = Customer::findOne(1);
$order = new Order();
$order->subtotal = 100;
$customer->link('orders', $order);

yii\db\ActiveRecord::link() 调用上述将设置 customer_id 的顺序是 $customer 的主键值,然后调用 yii\db\ActiveRecord::save() 要将顺序保存到数据库中。

作用域

当你调用yii\db\ActiveRecord::find() 或 yii\db\ActiveRecord::findBySql()方法时,将会返回一个yii\db\ActiveQuery实例。之后,你可以调用其他查询方法,如 yii\db\ActiveQuery::where(),yii\db\ActiveQuery::orderBy(), 进一步的指定查询条件。

有时候你可能需要在不同的地方使用相同的查询方法。如果出现这种情况,你应该考虑定义所谓的作用域。作用域是本质上要求一组的查询方法来修改查询对象的自定义查询类中定义的方法。 之后你就可以像使用普通方法一样使用作用域。

只需两步即可定义一个作用域。首先给你的model创建一个自定义的查询类,在此类中定义的所需的范围方法。例如,给Comment模型创建一个 CommentQuery类,然后在CommentQuery类中定义一个active()的方法为作用域,像下面的代码:

namespace app\models;

use yii\db\ActiveQuery;

class CommentQuery extends ActiveQuery
{
    public function active($state = true)
    {
        $this->andWhere(['active' => $state]);
        return $this;
    }
}

重点:

  1. 类必须继承 yii\db\ActiveQuery (或者是其他的 ActiveQuery ,比如 yii\mongodb\ActiveQuery)。
  2. 必须是一个public类型的方法且必须返回 $this 实现链式操作。可以传入参数。
  3. 检查 yii\db\ActiveQuery 对于修改查询条件是非常有用的方法。

其次,覆盖yii\db\ActiveRecord::find() 方法使其返回自定义的查询对象而不是常规的yii\db\ActiveQuery。对于上述例子,你需要编写如下代码:

namespace app\models;

use yii\db\ActiveRecord;

class Comment extends ActiveRecord
{
    /**
     * @inheritdoc
     * @return CommentQuery
     */
    public static function find()
    {
        return new CommentQuery(get_called_class());
    }
}

就这样,现在你可以使用自定义的作用域方法了:

$comments = Comment::find()->active()->all();
$inactiveComments = Comment::find()->active(false)->all();

你也能在定义的关联里使用作用域方法,比如:

class Post extends \yii\db\ActiveRecord
{
    public function getActiveComments()
    {
        return $this->hasMany(Comment::className(), ['post_id' => 'id'])->active();

    }
}

或者在执行关联查询的时候使用(on-the-fly 是啥?):

$posts = Post::find()->with([
    'comments' => function($q) {
        $q->active();
    }
])->all();

默认作用域

如果你之前用过 Yii 1.1 就应该知道默认作用域的概念。一个默认的作用域可以作用于所有查询。你可以很容易的通过重写yii\db\ActiveRecord::find()方法来定义一个默认作用域,例如:

public static function find()
{
    return parent::find()->where(['deleted' => false]);
}

注意,你之后所有的查询都不能用 yii\db\ActiveQuery::where(),但是可以用 yii\db\ActiveQuery::andWhere() 和 yii\db\ActiveQuery::orWhere(),他们不会覆盖掉默认作用域。(译注:如果你要使用默认作用域,就不能在 xxx::find()后使用where()方法,你必须使用andXXX()或者orXXX()系的方法,否则默认作用域不会起效果,至于原因,打开where()方法的代码一看便知)

事务操作

当执行几个相关联的数据库操作的时候

TODO: FIXME: WIP, TBD, https://github.com/yiisoft/yii2/issues/226

, yii\db\ActiveRecord::afterSave(), yii\db\ActiveRecord::beforeDelete() and/or yii\db\ActiveRecord::afterDelete() 生命周期周期方法(life cycle methods 我觉得这句翻译成“模板方法”会不会更好点?)。开发者可以通过重写yii\db\ActiveRecord::save()方法然后在控制器里使用事务操作,严格地说是似乎不是一个好的做法 (召回”瘦控制器 / 肥模型”基本规则)。

这些方法在这里(如果你不明白自己实际在干什么,请不要使用他们),Models:

class Feature extends \yii\db\ActiveRecord
{
    // ...

    public function getProduct()
    {
        return $this->hasOne(Product::className(), ['id' => 'product_id']);
    }
}

class Product extends \yii\db\ActiveRecord
{
    // ...

    public function getFeatures()
    {
        return $this->hasMany(Feature::className(), ['product_id' => 'id']);
    }
}

重写 yii\db\ActiveRecord::save() 方法:

class ProductController extends \yii\web\Controller
{
    public function actionCreate()
    {
        // FIXME: TODO: WIP, TBD
    }
}

(译注:我觉得上面应该是原手册里的bug)

在控制器层使用事务:

class ProductController extends \yii\web\Controller
{
    public function actionCreate()
    {
        // FIXME: TODO: WIP, TBD
    }
}

作为这些脆弱方法的替代,你应该使用原子操作方案特性。

class Feature extends \yii\db\ActiveRecord
{
    // ...

    public function getProduct()
    {
        return $this->hasOne(Product::className(), ['product_id' => 'id']);
    }

    public function scenarios()
    {
        return [
            'userCreates' => [
                'attributes' => ['name', 'value'],
                'atomic' => [self::OP_INSERT],
            ],
        ];
    }
}

class Product extends \yii\db\ActiveRecord
{
    // ...

    public function getFeatures()
    {
        return $this->hasMany(Feature::className(), ['id' => 'product_id']);
    }

    public function scenarios()
    {
        return [
            'userCreates' => [
                'attributes' => ['title', 'price'],
                'atomic' => [self::OP_INSERT],
            ],
        ];
    }

    public function afterValidate()
    {
        parent::afterValidate();
        // FIXME: TODO: WIP, TBD
    }

    public function afterSave($insert)
    {
        parent::afterSave($insert);
        if ($this->getScenario() === 'userCreates') {
            // FIXME: TODO: WIP, TBD
        }
    }
}

Controller里的代码将变得很简洁:

class ProductController extends \yii\web\Controller
{
    public function actionCreate()
    {
        // FIXME: TODO: WIP, TBD
    }
}

控制器非常简洁:

class ProductController extends \yii\web\Controller
{
    public function actionCreate()
    {
        // FIXME: TODO: WIP, TBD
    }
}

乐观锁(Optimistic Locks)

TODO

被污染属性

当你调用yii\db\ActiveRecord::save()用于保存活动记录(Active Record)实例时,只有被污染的属性才会被保存。一个属性是否认定为被污染取决于它的值自从最后一次从数据库加载或者最近一次保存到数据库后到现在是否被修改过。注意:无论活动记录(Active Record)是否有被污染属性,数据验证始终会执行。

活动记录(Active Record)会自动维护一个污染数据列表。它的工作方式是通过维护一个较旧属性值版本,并且将它们与最新的进行比较。你可以通过调用yii\db\ActiveRecord::getDirtyAttributes()来获取当前的污染属性。你也可以调用yii\db\ActiveRecord::markAttributeDirty()来显示的标记一个属性为污染属性。

如果你对最近一次修改前的属性值感兴趣,你可以调用yii\db\ActiveRecord::getOldAttributes() 或 yii\db\ActiveRecord::getOldAttribute()。

另见

发表评论

电子邮件地址不会被公开。 必填项已用*标注