PHP数据库访问最佳实践：类结构与代码优化方案咨询

嘿，别道歉呀！作为业余开发者能自己琢磨这么多细节、做足研究，已经超棒了——咱们一步步来拆解你的问题，帮你理清思路。

先聊聊三个选项的优劣势 #

选项1：DatabaseObject + DatabaseObjectArray（Active Record变体） #

这个思路很直观，属于Active Record模式的延伸——每个数据表对应一个模型子类，模型自己负责加载（load()）和存储（store()）数据，而DatabaseObjectArray专门处理批量对象的加载和迭代。

• 优点：逻辑贴近数据表，新手容易上手，DatabaseObjectArray继承ArrayObject后天然支持foreach等迭代操作，不用额外处理集合逻辑。
• 缺点：确实可能出现重复代码，比如条件组装、SQL生成的逻辑，可能在DatabaseObject和DatabaseObjectArray里各写一遍。

选项2：Database类 + DatabaseObject接口（Data Mapper模式） #

这个更偏向Data Mapper模式，核心是把「数据访问逻辑」和「实体类」分开：实体类只负责存储数据和业务逻辑（实现DatabaseObject接口），所有数据库操作都交给Database类处理。

• 优点：关注点分离清晰，实体类不会被数据库操作代码污染，重复的CRUD逻辑可以集中在Database类里，维护起来更方便。
• 缺点：需要自己处理批量对象的集合（不过返回数组的话foreach本来就支持，也可以封装一个简单的集合类），初期需要写的基础代码可能多一点。

选项3：DatabaseAccess trait #

trait是PHP里用来复用代码的好工具，它不属于上面两种模式，而是可以作为补充——把通用的数据库操作逻辑（比如条件组装、PDO调用）封装成trait，不管是选项1的两个基类，还是选项2的实体类，都可以引入这个trait来减少重复代码，非常灵活。

SQL语句该放在哪里？ #

这完全取决于你选的模式：

• 如果选选项1：SQL逻辑应该放在DatabaseObject基类里。每个子类只需要指定表名、字段、主键这些属性，基类负责通用的SELECT/INSERT/UPDATE语句生成。DatabaseObjectArray可以复用基类的条件组装和SQL生成逻辑，不用重复写。
• 如果选选项2：SQL逻辑完全放在Database类里。实体类只需要提供从数组填充自身、或者导出数据的方法，Database类负责生成SQL、执行查询，再把结果映射到实体对象。

要不要扩展PDO？重复代码怎么处理？ #

不建议直接扩展PDO类——PDO的职责是数据库连接和基础查询执行，你的业务模型/数据访问层应该依赖PDO，而不是继承它（违反单一职责原则，会把连接逻辑和业务CRUD逻辑混在一起）。

对于你提到的$conditions数组、addCondition()方法这类通用逻辑，应该抽离出来：

• 如果选选项1：把条件组装、PDO调用的逻辑放在DatabaseObject基类里，DatabaseObjectArray可以通过依赖基类或者引入trait来复用这部分代码（比如上面说的DatabaseAccess trait）。
• 如果选选项2：把条件组装逻辑作为Database类的一部分（比如做一个内置的QueryBuilder），所有实体的查询都复用这部分代码。

给你举个选项1 + trait的简化示例，看看怎么避免重复代码：

第一步：封装DatabaseAccess trait #

trait DatabaseAccess {
    protected $conditions = [];
    protected $pdo;

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function addCondition($key, $value, $operator = '=') {
        $this->conditions[] = [
            'key' => $key,
            'value' => $value,
            'operator' => $operator
        ];
    }

    // 组装WHERE子句
    protected function buildWhereClause() {
        if (empty($this->conditions)) return '';
        $clauses = [];
        foreach ($this->conditions as $cond) {
            $clauses[] = "`{$cond['key']}` {$cond['operator']} ?";
        }
        return 'WHERE ' . implode(' AND ', $clauses);
    }

    // 获取条件值（用于PDO参数绑定）
    protected function getConditionValues() {
        return array_column($this->conditions, 'value');
    }
}

第二步：定义DatabaseObject基类 #

abstract class DatabaseObject {
    use DatabaseAccess;

    // 子类必须实现的抽象方法，指定表名、字段、主键
    abstract protected function getTableName();
    abstract protected function getFields();
    abstract protected function getPrimaryKey();

    protected $data = [];

    // 加载单个对象
    public function load() {
        $table = $this->getTableName();
        $fields = implode(', ', $this->getFields());
        $where = $this->buildWhereClause();
        $values = $this->getConditionValues();

        $stmt = $this->pdo->prepare("SELECT $fields FROM `$table` $where LIMIT 1");
        $stmt->execute($values);
        $this->data = $stmt->fetch(PDO::FETCH_ASSOC);
        return $this;
    }

    // 存储（新增/更新）对象
    public function store() {
        $table = $this->getTableName();
        $fields = $this->getFields();
        $primaryKey = $this->getPrimaryKey();

        if (empty($this->data[$primaryKey])) {
            // 新增逻辑
            $placeholders = rtrim(str_repeat('?, ', count($fields)), ', ');
            $stmt = $this->pdo->prepare("INSERT INTO `$table` (`" . implode('`, `', $fields) . "`) VALUES ($placeholders)");
            $stmt->execute(array_map(fn($f) => $this->data[$f], $fields));
            $this->data[$primaryKey] = $this->pdo->lastInsertId();
        } else {
            // 更新逻辑
            $setClauses = implode(', ', array_map(fn($f) => "`$f` = ?", $fields));
            $stmt = $this->pdo->prepare("UPDATE `$table` SET $setClauses WHERE `$primaryKey` = ?");
            $stmt->execute(array_merge(array_map(fn($f) => $this->data[$f], $fields), [$this->data[$primaryKey]]));
        }
        return $this;
    }

    // 魔术方法，方便访问数据
    public function __get($key) {
        return $this->data[$key] ?? null;
    }

    public function __set($key, $value) {
        if (in_array($key, $this->getFields())) {
            $this->data[$key] = $value;
        }
    }
}

第三步：定义DatabaseObjectArray类 #

class DatabaseObjectArray extends ArrayObject {
    use DatabaseAccess;

    protected $objectClass;

    public function __construct(string $objectClass, PDO $pdo) {
        parent::__construct();
        $this->objectClass = $objectClass;
        $this->pdo = $pdo;
    }

    // 加载批量对象
    public function load() {
        $objectPrototype = new $this->objectClass($this->pdo);
        $table = $objectPrototype->getTableName();
        $fields = implode(', ', $objectPrototype->getFields());
        $where = $this->buildWhereClause();
        $values = $this->getConditionValues();

        $stmt = $this->pdo->prepare("SELECT $fields FROM `$table` $where");
        $stmt->execute($values);
        
        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $obj = new $this->objectClass($this->pdo);
            foreach ($row as $key => $value) {
                $obj->$key = $value;
            }
            $this->append($obj);
        }
        return $this;
    }
}

第四步：实现具体的模型子类（比如User） #

class User extends DatabaseObject {
    protected function getTableName() {
        return 'users';
    }

    protected function getFields() {
        return ['id', 'name', 'email'];
    }

    protected function getPrimaryKey() {
        return 'id';
    }
}

使用示例 #

// 初始化PDO连接
$pdo = new PDO('mysql:host=localhost;dbname=your_db', 'username', 'password');
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

// 加载单个用户
$user = new User($pdo);
$user->addCondition('email', 'test@example.com');
$user->load();
echo $user->name;

// 加载多个用户（名字包含John的）
$users = new DatabaseObjectArray(User::class, $pdo);
$users->addCondition('name', '%John%', 'LIKE');
$users->load();
foreach ($users as $u) {
    echo $u->email . '<br>';
}

最后给个总结建议 #

• 如果你喜欢直观、上手快的模式，选选项1 + trait，既保持了Active Record的易用性，又用trait解决了重复代码的问题；
• 如果你希望代码结构更清晰、关注点分离，选选项2，把数据访问逻辑全放在Database类里，实体类只做纯粹的业务载体；
• 无论选哪种，都不要直接扩展PDO，而是通过依赖注入的方式使用PDO；
• SQL逻辑尽量集中封装，避免在多个地方重复写，trait或者基类都是很好的复用方式。

内容的提问来源于stack exchange，提问作者J. Doe