<?php

namespace Illuminate\Database\Eloquent;

....

abstract class Model implements ArrayAccess, Arrayable, Jsonable, JsonSerializable, QueueableEntity, UrlRoutable
{
    // 组合复用 Trait
    use Concerns\HasAttributes,
            Concerns\HasEvents,
            Concerns\HasGlobalScopes,
            Concerns\HasRelationships,
            Concerns\HasTimestamps,
            Concerns\HidesAttributes,
            Concerns\GuardsAttributes,
            ForwardsCalls;
    
    ....
    
    public function __construct(array $attributes = [])
    {
        // 注册 boot 方法:一个模型类的 boot 方法只能被触发一次
        $this->bootIfNotBooted();
        // 对象级别的触发 bootTraits() 注册的全局钩子函数，即：每次新 new 对象都会被触发
        $this->initializeTraits();
        ...
    }

    protected function bootIfNotBooted()
    {
        if (! isset(static::$booted[static::class])) {
            static::$booted[static::class] = true;
            // 在模型 boot 方法执行前触发，适合放一些前置准备工作
            $this->fireModelEvent('booting', false);
            // 模型「类级别」第一次被加载时调用
            static::boot();
            // `boot()` 后指定，适合放一些「收尾逻辑，如：数据库新增/更新后促发缓存删除」
            $this->fireModelEvent('booted', false);
        }
    }
    
    protected static function boot()
    {
        // 可以去看看 Model.php 内的 bootTraits() 方法
        static::bootTraits();
    }
}

public static function addGlobalScope($scope, Closure $implementation = null)
{
    if (is_string($scope) && ! is_null($implementation)) {
        return static::$globalScopes[static::class][$scope] = $implementation;
    } elseif ($scope instanceof Closure) {
        return static::$globalScopes[static::class][spl_object_hash($scope)] = $scope;
    } elseif ($scope instanceof Scope) {
        return static::$globalScopes[static::class][get_class($scope)] = $scope;
    }

    throw new InvalidArgumentException('Global scope must be an instance of Closure or Scope.');
}

protected static function bootTraits()
{
    $class = static::class;

    $booted = [];

    static::$traitInitializers[$class] = [];
    
    foreach (class_uses_recursive($class) as $trait) {
        $method = 'boot'.class_basename($trait);
        // boot{Trait} 的钩子是静态调用触发的，而且同一模型的静态调用只会触发 1 次
        if (method_exists($class, $method) && ! in_array($method, $booted)) {
            forward_static_call([$class, $method]);

            $booted[] = $method;
        }

        // initialize{Trait} 钩子被注册到全局的 $traitInitializers 钩子中，是跟随 `initializeTraits` 方法对象级别触发的
        if (method_exists($class, $method = 'initialize'.class_basename($trait))) {
            static::$traitInitializers[$class][] = $method;

            static::$traitInitializers[$class] = array_unique(
                static::$traitInitializers[$class]
            );
        }
    }
}

protected function initializeTraits()
{
    // 依次遍历 Trait 钩子
    foreach (static::$traitInitializers[static::class] as $method) {
        $this->{$method}();
    }
}

<?php
namespace ERC\xxx\xxxDb;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;

class Order extends Model 
{
    // ...其它属性和其它代码逻辑
    
    public static function boot()
    {
        parent::boot();
        self::addGlobalScope('order_id_to_string', function (Builder $builder) {
            $whereBindingsIndex = 0;
            foreach ($builder->getQuery()->wheres as $where) {
                if (isset($where['column']) && $where['column'] === 'order_id') {
                    // 等值查询
                    if (isset($where['value'])) {
                        $builder->getQuery()->bindings['where'][$whereBindingsIndex] = (string)$where['value'];
                        $whereBindingsIndex++;
                    }
                    // in 查询、not in 查询拦截
                    if (isset($where['values'])) {
                        foreach ($where['values'] as $v) {
                            $builder->getQuery()->bindings['where'][$whereBindingsIndex] = (string)$v;
                            $whereBindingsIndex++;
                        }
                    }
                } else {
                    if (isset($where['value'])) {
                        $whereBindingsIndex++;
                    } elseif (isset($where['values'])) {
                        $whereBindingsIndex = $whereBindingsIndex + count($where['values']) - 1;
                    }
                }
            }
        });
    }
}

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Cache;

class User extends Model
{
    protected static function booted()
    {
        
        $forgetUserCache = function ($user) {
            Cache::forget('user_' . $user->id);
        };
        // 调用 `creating` 注册一个模型事件监听，事件触发为 $forgetUserCache
        static::creating($forgetUserCache);
        // 调用 `updating` 注册一个模型事件，事件触发为 $forgetUserCache
        static::updating($forgetUserCache);
    }
}

public function getObservableEvents()
{
    return array_merge(
        [
            'retrieved', 'creating', 'created', 'updating', 'updated',
            'saving', 'saved', 'restoring', 'restored', 'replicating',
            'deleting', 'deleted', 'forceDeleted',
        ],
        $this->observables
    );
}

DB::enableQueryLog();

Order::whereIn('order_id', [123, 456, 789])->orWhere(function ($query) {
    return $query->where('order_id', '=', 110);
})->get(['id', 'order_id']);

echo '<pre>';
var_export(DB::getQueryLog());

array (
  0 => 
  array (
    'query' => 'select `id`, `order_id` from `xxx_db`.`order_tbl` where `order_id` in (?, ?, ?) or (`order_id` = ?)',
    'bindings' => 
    array (
      0 => '123',
      1 => '456',
      2 => '789',
      3 => 110,
    ),
    'time' => 89.45,
  ),
)

class OrderBuilder extends \Illuminate\Database\Eloquent\Builder {
    public function where($column, $operator = null, $value = null, $boolean = 'and')
    {
        if ($column === 'order_id') {
            $value = (string)$value;
        }
        return parent::where($column, $operator, $value, $boolean);
    }

    public function whereIn($column, $values, $boolean = 'and', $not = false)
    {
        if ($column === 'order_id') {
            foreach ($values as $key => $value) {
                $values[$key] = (string)$value;
            }
        }
        return parent::whereIn($column, $values, $boolean, $not);
    }
}

class BaseOrderModel extends \Illuminate\Database\Eloquent\Model
{
    public function newEloquentBuilder($query) 
    {
        return new OrderBuilder($query);
    }
}