解决PHP对象循环引用导致构造器无限循环的策略：工厂方法与实例缓存

public function __construct(int $id = null)
{
    parent::__construct($id);

    $a_id = $this->get('a_id'); // 获取关联A的ID
    if ($a_id) {
        $this->a = new A($a_id); // 在B的构造函数中创建A的实例
    }
}

public function __construct(int $id = null)
{
    parent::__construct($id);

    $this->date = new CarbonPL($this->get('date'));
    $this->initB(); // 在A的构造函数中初始化B的实例
}

private function initB()
{
    if (!$this->isReferenced()) { // 检查实例是否存在于DB
        return;
    }
    $query = B::getIDQuery();
    $query .= ' WHERE is_del IS FALSE';
    $query .= ' AND a_id = ' . $this->id;

    $ids = Helper::queryIds($query);

    foreach ($ids as $id) {
        $this->B[] = new B($id); // 在A中创建B的实例
    }
}

<?php

class A {
    private static $cache = array(); // 静态缓存，用于存储已创建的A实例

    // 将构造函数设为私有，防止外部直接实例化
    private function __construct( $id ) {
        // 父类构造函数调用，如果需要
        // parent::__construct( $id ); 

        // 假设这里是A类自身的初始化逻辑
        // 注意：这里仍然会调用initB()，但initB()将使用B的工厂方法
        $this->id = $id; // 假设id是对象的唯一标识
        $this->date = new CarbonPL($this->get('date')); 
        $this->initB(); 
    }

    // 静态工厂方法，用于获取A的实例
    public static function create_for_id( $id ) {
        if ( isset( self::$cache[ $id ] ) ) {
            // 如果缓存中已存在该ID的实例，则直接返回
            $result = self::$cache[ $id ];
        } else {
            // 否则，创建新实例并存入缓存
            $result = new A( $id );
            self::$cache[ $id ] = $result; // 将新创建的实例存入缓存
        }
        return $result;
    }

    // 假设的辅助方法，用于从数据库获取数据
    private function get(string $field) {
        // 实际应用中这里会根据ID从数据库加载数据
        // 简化示例，假设从一个模拟数据源获取
        $data = [
            1 => ['date' => '2023-01-01', 'a_id' => null],
            2 => ['date' => '2023-01-02', 'a_id' => null],
        ];
        return $data[$this->id][$field] ?? null;
    }

    private function isReferenced() {
        // 检查实例是否存在于DB的逻辑
        return true; // 简化示例
    }

    // initB() 方法现在将使用B的工厂方法
    private function initB()
    {
        if (!$this->isReferenced()) {
            return;
        }
        // 假设这里是获取关联B的ID的逻辑
        // 实际应用中，会根据A的ID查询B的ID
        $b_ids = [1, 2]; // 示例数据，假设A的实例ID为1时关联B的ID为1和2

        foreach ($b_ids as $b_id) {
            // 关键：这里不再使用 new B($id)，而是使用 B::create_for_id($id)
            $this->B[] = B::create_for_id($b_id); 
        }
    }
}

<?php

class B {
    private static $cache = array(); // 静态缓存，用于存储已创建的B实例
    public $a; // 关联的A对象
    public $id; // B的ID

    // 将构造函数设为私有
    private function __construct( $id ) {
        // parent::__construct( $id ); 
        $this->id = $id;

        $a_id = $this->get('a_id'); // 获取关联A的ID
        if ($a_id) {
            // 关键：这里不再使用 new A($a_id)，而是使用 A::create_for_id($a_id)
            $this->a = A::create_for_id($a_id); 
        }
    }

    // 静态工厂方法，用于获取B的实例
    public static function create_for_id( $id ) {
        if ( isset( self::$cache[ $id ] ) ) {
            $result = self::$cache[ $id ];
        } else {
            $result = new B( $id );
            self::$cache[ $id ] = $result;
        }
        return $result;
    }

    // 假设的辅助方法，用于从数据库获取数据
    private function get(string $field) {
        // 实际应用中这里会根据ID从数据库加载数据
        // 简化示例，假设从一个模拟数据源获取
        $data = [
            1 => ['a_id' => 1], // B的实例ID为1，关联A的实例ID为1
            2 => ['a_id' => 1], // B的实例ID为2，关联A的实例ID为1
        ];
        return $data[$this->id][$field] ?? null;
    }
}

// 获取ID为1的A实例
$instanceOfA = A::create_for_id(1);

// 获取ID为1的B实例
$instanceOfB = B::create_for_id(1);

// 此时，如果$instanceOfA在初始化时需要加载关联的B实例，
// 它会调用 B::create_for_id()。
// 如果$instanceOfB在初始化时需要加载关联的A实例，
// 它会调用 A::create_for_id()。

// 由于缓存机制，即使在A的构造函数中调用 A::create_for_id(1)，
// 也不会创建新的A实例，而是返回已存在的$instanceOfA。
// 同理，对于B也一样。