深入理解Yii2.0 AcitveReocrd事件和关联操作

abstract class BaseActiveRecord extends Model implements ActiveRecordInterface
{
    const EVENT_INIT = 'init';                      // 初始化对象时触发
    const EVENT_AFTER_FIND = 'afterFind';           // 执行查询结束时触发
    const EVENT_BEFORE_INSERT = 'beforeInsert';     // 插入之前触发
    const EVENT_AFTER_INSERT = 'afterInsert';       // 插入结束时触发
    const EVENT_BEFORE_UPDATE = 'beforeUpdate';     // 更新记录前触发
    const EVENT_AFTER_UPDATE = 'afterUpdate';       // 更新记录后触发
    const EVENT_BEFORE_DELETE = 'beforeDelete';     // 删除记录前触发
    const EVENT_AFTER_DELETE = 'afterDelete';       // 删除记录后触发
    // ... ...
}

class Model extends Component implements IteratorAggregate, ArrayAccess, Arrayable
{
    const EVENT_BEFORE_VALIDATE = 'beforeValidate';     // 在验证之前触发
    const EVENT_AFTER_VALIDATE = 'afterValidate';       // 在验证之后触发
    // ... ...
}

public function init()
{
    parent::init();
    // 这里触发EVENT_INIT事件
    $this->trigger(self::EVENT_INIT);
}

// 该方法为ActiveQuery将查询到的内容 $rows 填充到ActiveReocrd中去的方法
public function populate($rows)
{
    if (empty($rows)) {
        return [];
    }
    $models = $this->createModels($rows);
    if (!empty($this->join) && $this->indexBy === null) {
        $models = $this->removeDuplicatedModels($models);
    }
    if (!empty($this->with)) {
        $this->findWith($this->with, $models);
    }
    if (!$this->asArray) {
        // 重点在这个foreach里面的afterFind()，
        // afterFind()不干别的，就是专门调用
        // $this->trigger(self::EVENT_AFTER_FIND) 来触发事件的。
        foreach ($models as $model) {
            $model->afterFind();
        }
    }
    return $models;
}

public function validate($attributeNames = null, $clearErrors = true)
{
    if ($clearErrors) {
        $this->clearErrors();
    }

    // 这里的 beforeValidate() 会调用
    // $this->trigger(self::EVENT_BEFORE_VALIDATE, $event)
    // 来触发 EVENT_BEFORE_VALIDATE 事件。
    if (!$this->beforeValidate()) {
        return false;
    }
    // 下面是后续的验证代码，这里不用过多关注
    $scenarios = $this->scenarios();
    $scenario = $this->getScenario();
    if (!isset($scenarios[$scenario])) {
        throw new InvalidParamException("Unknown scenario: $scenario");
    }
    if ($attributeNames === null) {
        $attributeNames = $this->activeAttributes();
    }
    foreach ($this->getActiveValidators() as $validator) {
        $validator->validateAttributes($this, $attributeNames);
    }

    // 这里的 afterValidate() 会调用
    // $this->trigger(self::EVENT_AFTER_VALIDATE)
    // 来触发 EVENT_AFTER_VALIDATE 事件。
    $this->afterValidate();
    return !$this->hasErrors();
}

public function beforeValidate()
{
    // 创建一个 ModelEvent，并交给 trigger 在触发事件时使用
    $event = new ModelEvent;
    $this->trigger(self::EVENT_BEFORE_VALIDATE, $event);
    return $event->isValid;
}

public function save($runValidation = true, $attributeNames = null)
{
    // insert() 和 update() 具体实现由ActiveRecord定义
    if ($this->getIsNewRecord()) {
        return $this->insert($runValidation, $attributeNames);
    } else {
        return $this->update($runValidation, $attributeNames) !== false;
    }
}

// updateInternal() 由 update() 调用，
// 类似的有deleteInternal() ，由ActiveRecord定义，这里略去。
protected function updateInternal($attributes = null)
{
    // beforeSave() 会触发相应的before事件
    // 而且如果beforeSave()返回false，就可以中止更新过程。
    if (!$this->beforeSave(false)) {
        return false;
    }
    $values = $this->getDirtyAttributes($attributes);

    // 没有字段有修改，那么实际上是不需要更新的。
    // 因此，直接调用afterSave()来触发相应的after事件。
    if (empty($values)) {
        $this->afterSave(false, $values);
        return 0;
    }

    // 以下为实际更新操作，不必细究。
    $condition = $this->getOldPrimaryKey(true);
    $lock = $this->optimisticLock();
    if ($lock !== null) {
        $values[$lock] = $this->$lock + 1;
        $condition[$lock] = $this->$lock;
    }
    $rows = $this->updateAll($values, $condition);
    if ($lock !== null && !$rows) {
        throw new StaleObjectException('The object being updated is outdated.');
    }
    $changedAttributes = [];
    foreach ($values as $name => $value) {
        $changedAttributes[$name] = isset($this->_oldAttributes[$name]) ? $this->_oldAttributes[$name] : null;
        $this->_oldAttributes[$name] = $value;
    }
    // 重点看这里，触发了事件
    $this->afterSave(false, $changedAttributes);
    return $rows;
}

// 下面的beforeSave()和afterSave() 会根据判断是更新操作还是插入操作，
// 以此来决定是触发 INSERT 事件还是 UPDATE 事件。
public function beforeSave($insert)
{
    $event = new ModelEvent;
    // $insert 为 true 时，表示当前是插入操作，是个新记录，要触发INSERT事件
    // $insert 为 false时，表示当前是更新操作，是个旧记录，要触发UPDATE事件
    $this->trigger($insert ? self::EVENT_BEFORE_INSERT : self::EVENT_BEFORE_UPDATE, $event);
    return $event->isValid;
}

public function afterSave($insert, $changedAttributes)
{
    // $insert 为 true 时，表示当前是插入操作，是个新记录，要触发INSERT事件
    // $insert 为 false时，表示当前是更新操作，是个旧记录，要触发UPDATE事件
    $this->trigger($insert ? self::EVENT_AFTER_INSERT : self::EVENT_AFTER_UPDATE, new AfterSaveEvent([
        'changedAttributes' => $changedAttributes
    ]));
}

class Post extends \yii\db\ActiveRecord {
    // 第一步：定义自己的事件
    const EVENT_BEFORE_MARK_DELETE = 'beforeMarkDelete';
    const EVENT_AFTER_MARK_DELETE = 'afterMarkDelete';

    // 第二步：定义Event Handler
    public function onBeforeMarkDelete () {
        // ... do sth ...
    }

    // 第三步：在初始化阶段绑定事件和Event Handler
    public function init()
    {
        parent::init();
        $this->trigger(self::EVENT_INIT);
        // 完成绑定
        $this->on(self::EVENT_BEFORE_MARK_DELETE, [$this, 'onBeforeMarkDelete']);
    }

    // 第四步：触发事件
    public function beforeSave($insert) {
        // 注意，重载之后要调用父类同名函数
        if (parent::beforeSave($insert)) {
            $status = $this->getDirtyAttributes(['status']);
            // 这个判断意会即可
            if (!empty($status) && $status['status'] == self::STATUS_DELETE) {
                // 触发事件
                $this->trigger(self::EVENT_BEFORE_MARK_DELETE);
            }
            return true;
        } else {
            return false;
        }
    }
}

class Post extends \yii\db\ActiveRecord {
    // 不需要定义自己的事件
    //const EVENT_BEFORE_MARK_DELETE = 'beforeMarkDelete';
    //const EVENT_AFTER_MARK_DELETE = 'afterMarkDelete';

    // 不需要定义Event Handler
    //public function onBeforeMarkDelete () {
        // ... do sth ...
    //}

    // 不需要绑定事件和Event Handler
    //public function init()
    //{
    //    parent::init();
    //    $this->trigger(self::EVENT_INIT);
    //    $this->on(self::EVENT_BEFORE_MARK_DELETE, [$this, 'onBeforeMarkDelete']);
    //}

    // 只需要重载
    public function beforeSave($insert) {
        // 注意，重载之后要调用父类同名函数
        if (parent::beforeSave($insert)) {
            $status = $this->getDirtyAttributes(['status']);
            // 这个判断意会即可
            if (!empty($status) && $status['status'] == self::STATUS_DELETE) {
                // 不需要触发事件
                //$this->trigger(self::EVENT_BEFORE_MARK_DELETE);
                // 但是需要把原来 Event Handler的内容放到这里来
                // ... do sth ...
            }
            return true;
        } else {
            return false;
        }
    }
}

class ActiveRecord extends BaseActiveRecord
{
    // 定义插入、更新、删除操作，及表示3合1的ALL
    const OP_INSERT = 0x01;
    const OP_UPDATE = 0x02;
    const OP_DELETE = 0x04;
    const OP_ALL = 0x07;

    // 需要事务支持时，重载这个方法。
    public function transactions()
    {
        return [];
    }

    // ... ...
}

public function transactions() {
    return [
        'addComment' => self::OP_INSERT,
    ];
}

// $operation就是预定义的OP_INSERT 等3种单一操作类型
public function isTransactional($operation)
{
    // 获取当前的scenario
    $scenario = $this->getScenario();
    $transactions = $this->transactions();
    return isset($transactions[$scenario]) && ($transactions[$scenario] & $operation);
}

public function insert($runValidation = true, $attributes = null)
{
    if ($runValidation && !$this->validate($attributes)) {
        Yii::info('Model not inserted due to validation error.', __METHOD__);
        return false;
    }
    // 这里调用了 isTransactional()，判断当前场景下，
    // 插入操作是否需要事务支持
    if (!$this->isTransactional(self::OP_INSERT)) {
        // 无需事务支持，那就直接insert了事
        return $this->insertInternal($attributes);
    }
    // 以下是需要事务支持的情况，那就启用事务
    $transaction = static::getDb()->beginTransaction();
    try {
        $result = $this->insertInternal($attributes);
        if ($result === false) {
            $transaction->rollBack();
        } else {
            $transaction->commit();
        }
        return $result;
    } catch (\Exception $e) {
        $transaction->rollBack();
        throw $e;
    }
}

class Comment extends \yii\db\ActiveRecord {
    // 通过重载afterSave来“响应”事件
    public function afterSave($insert) {
        if (parent::beforeSave($insert)) {
            // 新增一个评论
            if ($insert) {
                // 关联Post的操作，评论计数字段＋1
                $post = Post::find($this->postId);
                $post->comment_counter += 1;
                $post->save(false);
            }
        }
    }
}