行为的依附对象

yii\base\Behavior::$owner 指向的是Behavior实例本身所依附的对象。这是行为中引用所依附对象的唯一手段了。 通过这个 $owner ，行为才能访问所依附的Component，才能将本身的方法作为事件handler绑定到Component上。

$owner 由 yii\base\Behavior::attach() 进行赋值。 也就是在将行为绑定到某个Component时， $owner 就已经名花有主了。 一般情况下，不需要你自己手动去指定 $owner 的值， 在调用yii\base\Componet::attachBehavior() 将行为与对象绑定时， Component会自动地将 $this 作为参数，调用 yii\base\Behavior::attach() 。

有一点需要格外注意，由于行为从本质来讲是一个PHP类，其方法就是类方法，就是成员函数。 所以，在行为的方法中， $this 引用的是行为本身， 试图通过 $this 来访问行为所依附的Component是行不通的。 正确的方法是通过 yii\base\Behavior::$owner 来访问Component。

行为所要响应的事件

行为与事件结合后，可以在不对类作修改的情况下，补充类在事件触发后的各种不同反应。 为此，只需要重载 yii\base\Behavior::events() 方法，表示这个行为将对类的何种事件进行何种反馈即可:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

namespace app\Components;

use yii\db\ActiveRecord;
use yii\base\Behavior;

class MyBehavior extends Behavior
{
    // 重载events() 使得在事件触发时，调用行为中的一些方法
    public function events()
    {
        // 在EVENT_BEFORE_VALIDATE事件触发时，调用成员函数 beforeValidate
        return [
            ActiveRecord::EVENT_BEFORE_VALIDATE => ‘beforeValidate‘,
        ];
    }

    // 注意beforeValidate 是行为的成员函数，而不是绑定的类的成员函数。
    // 还要注意，这个函数的签名，要满足事件handler的要求。
    public function beforeValidate($event)
    {
        // ...
    }
}

上面的代码中， events() 返回一个数组，表示所要做出响应的事件， 上例中的事件是ActiveRecord::EVENT_BEFORE_VALIDATE ，以数组的键来表示， 而数组的值则表示做好反应的事件handler，上例中是 beforeValidate() ，事件handler可以是以下形式：

• 字符串，表示行为类的方法，如上面的例就是这种情况。 这个是与事件handler不同的，事件handler中使用字符串时，是表示PHP全局函数，而这里表示行为类内部的方法。
• 一个对象或类的成员函数，以数组的形式，如 [$object, ‘methodName‘] 。这个与事件handler是一致的。
• 一个匿名函数。

对于事件响应函数的签名，要求与事件handler一样:

function ($event) {   }

具体内容，请参考 事件（Event） 的内容。

行为的绑定与解除

说到绑定与解除，这意味着这个事情有2方，行为和Component。单独一方是没有绑定或解除的说法的。 因此，这里我们先卖一关子，等后面讲绑定和解除的原理时，再来讲有关的内容。

这里你只需要知道，对于绑定和解除，Behavior 分别使用 attach() 和 detach() 来实现就OK了。

行为的绑定

行为的绑定通常是由Component来发起。有两种方式可以将一个Behavior绑定到一个 yii\base\Component。 一种是静态的方法，另一种是动态的。静态的方法在实践中用得比较多一些。 因为一般情况下，在你的代码没跑起来之前，一个类应当具有何种行为，是确定的。 动态绑定的方法主要是提供了更灵活的方式，但实际使用中并不多见。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

namespace app\models;

use yii\db\ActiveRecord;
use app\Components\MyBehavior;

class User extends ActiveRecord
{
    public function behaviors()
    {
        return [
            // 匿名的行为，仅直接给出行为的类名称
            MyBehavior::className(),

            // 名为myBehavior2的行为，也是仅给出行为的类名称
            ‘myBehavior2‘ => MyBehavior::className(),

            // 匿名行为，给出了MyBehavior类的配置数组
            [
                ‘class‘ => MyBehavior::className(),
                ‘prop1‘ => ‘value1‘,
                ‘prop3‘ => ‘value3‘,
            ],

            // 名为myBehavior4的行为，也是给出了MyBehavior类的配置数组
            ‘myBehavior4‘ => [
                ‘class‘ => MyBehavior::className(),
                ‘prop1‘ => ‘value1‘,
                ‘prop3‘ => ‘value3‘,
            ]
        ];
    }
}

1
2
3
4
5
6
7
8
9

[
    ‘as myBehavior2‘ => MyBehavior::className(),

    ‘as myBehavior3‘ => [
        ‘class‘ => MyBehavior::className(),
        ‘prop1‘ => ‘value1‘,
        ‘prop3‘ => ‘value3‘,
    ],
]

$Component->attachBehaviors([
    ‘myBehavior1‘ => new MyBehavior,  // 这是一个命名行为
    MyBehavior::className(),          // 这是一个匿名行为
]);

$behavior = $Component->getBehavior(‘myBehavior2‘);

$behaviors = $Component->getBehaviors();

绑定的内部原理

只是重载一个 yii\base\Component::behaviors() 就可以这么神奇地使用行为了？ 这只是冰山的一角，实际上关系到绑定的过程，有关的方面有：

• yii\base\Component::behaviors()
• yii\base\Component::ensureBehaviors()
• yii\base\Component::attachBehaviorInternal()
• yii\base\Behavior::attach()

4个方法中，Behavior只占其一，更多的代码，是在Component中完成的。

yii\base\Component::behaviors() 上面讲静态方法绑定行为时已经提到了，就是返回一个数组用于描述行为。 那么 yii\base\Component::ensuerBehaviors() 呢？

这个方法会在Component的诸多地方调用 __get() __set() __isset() __unset() __call()canGetProperty() hasMethod() hasEventHandlers() on() off() 等用到，看到这么多是不是头疼？一点都不复杂，一句话，只要涉及到类的属性、方法、事件这个函数都会被调用到。

这么众星拱月，被诸多凡人所需要的 ensureBehaviors() 究竟是何许人也？ 就像名字所表明的，他的作用在于“ensure” 。其实只是确保 behaviors() 中所描述的行为已经进行了绑定而已:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public function ensureBehaviors()
{
    // 为null表示尚未绑定
    // 多说一句，为空数组表示没有绑定任何行为
    if ($this->_behaviors === null) {
        $this->_behaviors = [];

        // 遍历 $this->behaviors() 返回的数组，并绑定
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

这个方法主要是对子类用的， yii\base\Compoent 没有任何预先注入的行为，所以，这个调用没有用。 但是对于子类，你可能重载了 yii\base\Compoent::behaviros() 来预先注入一些行为。 那么，这个函数会将这些行为先注入进来。

从上面的代码中，自然就看到了接下来要说的第三个东东， yii\base\Component\attachBehaviorInternal():

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

private function attachBehaviorInternal($name, $behavior)
{
    // 不是 Behavior 实例，说是只是类名、配置数组，那么就创建出来吧
    if (!($behavior instanceof Behavior)) {
        $behavior = Yii::createObject($behavior);
    }

    // 匿名行为
    if (is_int($name)) {
        $behavior->attach($this);
        $this->_behaviors[] = $behavior;

    // 命名行为
    } else {

        // 已经有一个同名的行为，要先解除，再将新的行为绑定上去。
        if (isset($this->_behaviors[$name])) {
            $this->_behaviors[$name]->detach();
        }
        $behavior->attach($this);
        $this->_behaviors[$name] = $behavior;
    }
    return $behavior;
}

首先要注意到，这是一个private成员。其实在Yii中，所有后缀为 *Internal 的方法，都是私有的。 这个方法干了这么几件事：

• 如果 $behavior 参数并非是一个 Behavior 实例，就以之为参数，用 Yii::createObject() 创建出来。
• 如果以匿名行为的形式绑定行为，那么直接将行为附加在这个类上。
• 如果是命名行为，先看看是否有同名的行为已经绑定在这个类上，如果有，用后来的行为取代之前的行为。

在 yii\base\Component::attachBehaviorInternal() 中， 以 $this 为参数调用了yii\base\Behavior::attach() 。 从而，引出了跟绑定相关的最后一个家伙 yii\base\Behavior::attach() ， 这也是前面我们讲行为的要素时没讲完的。先看看代码:

1
2
3
4
5
6
7
8

public function attach($owner)
{
    $this->owner = $owner;
    foreach ($this->events() as $event => $handler) {
        $owner->on($event, is_string($handler) ? [$this, $handler] :
            $handler);
    }
}

上面的代码干了两件事：

• 设置好行为的 $owner ，使得行为可以访问、操作所依附的对象
• 遍历行为中的 events() 返回的数组，将准备响应的事件，通过所依附类的 on() 绑定到类上

说了这么多，关于绑定，做个小结：

• 绑定的动作从Component发起；
• 静态绑定通过重载 yii\base\Componet::behaviors() 实现；
• 动态绑定通过调用 yii\base\Component::attachBehaviors() 实现；
• 行为还可以通过为 Component 配置 as 配置项进行绑定；
• 行为有匿名行为和命名行为之分，区别在于绑定时是否给出命名。 命名行为可以通过其命名进行标识，从而有针对性地进行解除等操作；
• 绑定过程中，后绑定的行为会取代已经绑定的同名行为；
• 绑定的意义有两点，一是为行为设置 $owner 。二是将行为中拟响应的事件的handler绑定到类中去。

解除行为

解除行为只需调用 yii\base\Component::detachBehavior() 就OK了:

$Component->detachBehavior(‘myBehavior2‘);

这样就可以解除已经绑定好的名为 myBehavior2 的行为了。 但是，对于匿名行为，这个方法就无从下手了。不过我们可以一不做二不休，解除所有绑定好的行为:

$Component->detachBehaviors();

这上面两种方法，都会调用到 yii\base\Behavior::detach() ，其代码如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public function detach()
{
    // 这得是个名花有主的行为才有解除一说
    if ($this->owner) {

        // 遍历行为定义的事件，一一解除
        foreach ($this->events() as $event => $handler) {
            $this->owner->off($event, is_string($handler) ? [$this,
                $handler] : $handler);
        }
        $this->owner = null;
    }
}

与 yii\base\Behavior::attach() 相反，解除的过程就是干两件事： 一是将 $owner 设置为 null ，表示这个行为没有依附到任何类上。 二是通过Component的 off() 将绑定到类上的事件hanlder解除下来。一句话，善始善终。

行为响应的事件实例

上面的绑定和解除过程，我们看到Yii费了那么大劲，主要就是为了将行为中的事件handler绑定到类中去。 在实际编程时，行为用得最多的，也是对于Compoent各种事件的响应。 通过行为注入，可以在不修改现有类的代码的情况下，更改、扩展类对于事件的响应和支持。 使用这个技巧，可以玩出很炫的花样。 而要将行为与Component的事件关联起来，就要通过 yii\base\Behavior::events() 方法。

上面Behavior基类的代码中，这个方法只是返回了一个空数组，说明不对所依附的Compoent的任何事件产生关联。 但是在实际使用时，往往通过重载这个方法来告诉Yii，这个行为将对Compoent的何种事件，使用哪个方法进行处理。

比如，Yii自带的 yii\behaviors\AttributeBehavior 类，定义了在一个 ActiveRecord 对象的某些事件发生时， 自动对某些字段进行修改的行为。 他有一个很常用的子类 yii\behaviors\TimeStampBehavior 用于将指定的字段设置为一个当前的时间戳。 常用于表示最后修改日期、上次登陆时间等场景。我们以这个行为为例，来分析行为响应事件的原理。

在 yii\behaviors\AttributeBehavior::event() 中，代码如下:

1
2
3
4
5

public function events()
{
    return array_fill_keys(array_keys($this->attributes),
        ‘evaluateAttributes‘);
}

这段代码的意思这里不作过多深入，学有余力的读者朋友可以自行研究，难度并不高。 这里，你只需要大致知道，这段代码将返回一个数组，其键值为 $this->attributes 数组的键值， 数组元素的值为成员函数evaluateAttributes 。

而在 yii\behaviors\TimeStampBehavior::init() 中，有以下的代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public function init()
{
    parent::init();

    if (empty($this->attributes)) {
        // 重点看这里
        $this->attributes = [
            BaseActiveRecord::EVENT_BEFORE_INSERT =>
                [$this->createdAtAttribute, $this->updatedAtAttribute],
            BaseActiveRecord::EVENT_BEFORE_UPDATE =>
                $this->updatedAtAttribute,
        ];
    }
}

上面的代码重点看的是对于 $this->attributes 的初始化部分。 结合上面2个方法的代码，对于yii\base\Behavior::events() 的返回数组，其格式应该是这样的:

return [
    BaseActiveRecord::EVENT_BEFORE_INSERT => ‘evaluateAttributes‘,
    BaseActiveRecord::EVENT_BEFORE_UPDATE => ‘evaluateAttributes‘,
];

数组的键值用于指定要响应的事件， 这里是 BaseActiveRecord::EVENT_BEFORE_INSERT 和BaseActiveRecord::EVENT_BEFORE_UPDATE 。 数组的值是一个事件handler，如上面的 evaluateAttributes 。

那么一旦TimeStampBehavior与某个ActiveRecord绑定，就会调用yii\behaviors\TimeStampBehavior::attach() ， 那么就会有:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 这里 $owner 是某个 ActiveRecord
public function attach($owner)
{
    $this->owner = $owner;

    // 遍历上面提到的 events() 所定义的数组
    foreach ($this->events() as $event => $handler) {

        // 调用 ActiveRecord::on 来绑定事件
        // 这里 $handler 为字符串 `evaluateAttributes`
        // 因此，相当于调用 on(BaseActiveRecord::EVENT_BEFORE_INSERT,
        // [$this, ‘evaluateAttributes‘])
        $owner->on($event, is_string($handler) ? [$this, $handler] :
            $handler);
    }
}

因此，事件 BaseActiveRecord::EVENT_BEFORE_INSERT 和 BaseActiveRecord::EVENT_BEFORE_UPDATE 就绑定到了ActiveRecord上了。当新建记录或更新记录时， TimeStampBehavior::evaluateAttributes 就会被触发。 从而实现时间戳的功能。具体可以看看 yii\behaviors\AttributeBehavior::evaluateAttributes() 和yii\behaviors\TimeStampBehavior::getValues() 的代码。这里因为只是具体功能实现，对于行为的理解关系不大。 就不把代码粘出来占用篇幅了。

属性的注入

以读取为例，如果访问 $Component->property1 ，Yii在幕后干了些什么呢？ 这个看看yii\base\Component::__get()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public function __get($name)
{
    $getter = ‘get‘ . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter();
    } else {
        // 注意这个 else 分支的内容，正是与 yii\base\Object::__get() 的
        // 不同之处
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name)) {

                // 属性在行为中须为 public。否则不可能通过下面的形式访问呀。
                return $behavior->$name;
            }
        }
    }
    if (method_exists($this, ‘set‘ . $name)) {
        throw new InvalidCallException(‘Getting write-only property: ‘ .
            get_class($this) . ‘::‘ . $name);
    } else {
        throw new UnknownPropertyException(‘Getting unknown property: ‘ .
            get_class($this) . ‘::‘ . $name);
    }
}

重点来看 yii\base\Compoent::__get() 与 yii\base\Object::__get() 的不同之处。 就是在于对于未定义getter函数之后的处理， yii\base\Object 是直接抛出异常， 告诉你想要访问的属性不存在之类。 但是yii\base\Component 则是在不存在getter之后，还要看看是不是注入的行为的属性：

• 首先，调用了 $this->ensureBehaviors() 。这个方法已经在前面讲过了，主要是确保行为已经绑定。
• 在确保行为已经绑定后，开始遍历 $this->_behaviors 。 Yii将类所有绑定的行为都保存在yii\base\Compoent::$_behaviors[] 数组中。
• 最后，通过行为的 canGetProperty() 判断这个属性， 是否是所绑定行为的可读属性，如果是，就返回这个行为的这个属性 $behavior->name 。 完成属性的读取。 至于 canGetProperty() 已经在 :ref::property 部分已经简单讲过了， 后面还会有针对性地一个介绍。

对于setter，代码类似，这里就不占用篇幅了。

方法的注入

与属性的注入通过 __get() __set() 魔术方法类似， Yii通过 __call() 魔术方法实现对行为中方法的注入:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException(‘Calling unknown method: ‘ .
        get_class($this) . "::$name()");
}

从上面的代码中可以看出，Yii还是先是调用了 $this->ensureBehaviors() 确保行为已经绑定。

然后，也是遍历 yii\base\Component::$_behaviros[] 数组。 通过 hasMethod() 方法判断方法是否存在。 如果所绑定的行为中要调用的方法存在，则使用PHP的 call_user_func_array() 调用之。 至于 hasMethod()方法，我们后面再讲。

注入属性与方法的访问控制

在前面我们针对行为中public和private、protected的成员在所绑定的类中是否可访问举出了具体例子。 这里我们从代码层面解析原因。

在上面的内容，我们知道，一个属性可不可访问，主要看行为的 canGetProperty() 和 canSetProperty() 。 而一个方法可不可调用，主要看行为的 hasMethod() 。 由于 yii\base\Behavior 继承自我们的老朋友yii\base\Object ，所以上面提到的三个判断方法， 事实上代码都在 Object 中。我们一个一个来看:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public function canGetProperty($name, $checkVars = true)
{
    return method_exists($this, ‘get‘ . $name) || $checkVars &&
        property_exists($this, $name);
}

public function canSetProperty($name, $checkVars = true)
{
    return method_exists($this, ‘set‘ . $name) || $checkVars &&
        property_exists($this, $name);
}

public function hasMethod($name)
{
    return method_exists($this, $name);
}

这三个方法真的谈不上复杂。对此，我们可以得出以下结论：

• 当向Component绑定的行为读取（写入）一个属性时，如果行为为该属性定义了一个getter (setter)，则可以访问。 或者，如果行为确实具有该成员变量即可通过上面的判断，此时，该成员变量可为 public, private, protected。 但最终只有 public 的成员变量才能正确访问。原因在上面讲注入的原理时已经交待了。
• 当调用Component绑定的行为的一个方法时，如果行为已经定义了该方法，即可通过上面的判断。 此时，这个方法可以为 public, private, protected。 但最终只有 public 的方法才能正确调用。如果你理解了上一款的原因，那么这里也就理解了。

行为与继承

首先来讲，拿行为与继承比较，从逻辑上是不对的，这两者是在完全不同的层面上的事物，是不对等的。之所以进行比较，是因为在实现的效果上，两者有的类似的地方。看起来，行为和继承都可以使一个类具有另一个类的属性和方法，从而达到扩充类的功能的目的。

相比较于使用继承的方式来扩充类功能，使用行为的方式，一是不必对现有类进行修改，二是PHP不支持多继承，但是Yii可以绑定多个行为，从而达到类似多继承的效果。

反过来，行为是绝对无法替代继承的。亚洲人，美洲人都是地球人，你可以将亚洲人和美洲人当成地球人来对待。但是，你绝对不能把一只在某些方面表现得像人的猴子，真的当成人来对待。

这里就不展开讲了。从本质上来讲，行为只是一种设计模式，是解决问题的方法学。继承则是PHP作为编程语言所提供的特性，根本不在一个层次上。

行为与特性

特性是PHP5.4之后引入的一个新feature。从实现效果看，行为与特性都达到把自身的public 变量、属性、方法注入到当前类中去的目的。在使用上，他们也各有所长，但总的原则可以按下面的提示进行把握。

倾向于使用行为的情况：

• 行为从本质上讲，也是PHP的类，因此一个行为可以继承自另一个行为，从而实现代码的复用。而特性只是PHP的一种语法，效果上类似于把特性的代码导入到了类中从而实现代码的注入，特性是不支持继承的。
• 行为可以动态地绑定、解除，而不必要对类进行修改。但是特性必须在类在使用 use 语句，要解除特性时，则要删除这个语句。换句话说，需要对类进行修改。
• 行为还以在在配置阶段进行绑定，特性就不行了。
• 行为可以用于对事件进行反馈，而特性不行。
• 当出现命名冲突时，行为会自行排除冲突，自动使用先绑定的行为。而特性在发生冲突时，需要人为干预，修改发生冲突的变量名、属性名、方法名。

倾向于使用特性的情况：

• 特性比行为在效率上要高一点，因为行为其实是类的实例，需要时间和空间进行分配。
• 特性是PHP的语法，因此，IDE的支持要好一些。目前还没有IDE能支持行为。