对于数据库实现来说，这是一个好的PHP OOP结构吗? - Is this a good PHP OOP structure for a Database Implementation?

我有一系列的类:

abstract class Database extends PDO {}
abstract class OracleDatabase extends Database {}
abstract class MySQLDatabase extends Database {}
abstract class MSSQLDatabase extends Database {}

然后，当我想要一个数据库连接的实例时，我创建一个扩展OracleDatabase, MySQLDatabase或MSSQLDatabase的新类，这取决于数据库的位置…例如

class MyAppDatabase extends OracleDatabase {}

首先，这是一个好的设计吗?我读到过使用接口比扩展抽象类更好，但我不确定如何在不复制代码的情况下做到这一点。

我确实意识到PDO的全部意义在于摆脱DB特定的代码，但是我仍然需要不同的功能，比如DB对象括号(例如在Oracle中，你使用双引号;在MySQL中，你使用反引号)，数据类型检测(user_tab_columns vs INFORMATION_SCHEMA)，等等。

和-如果我想创建一个名为Updater的类，它允许客户端创建一组多个"更新"到一个特定的表-使用相同的字段set和WHERE子句，但不同的值?我不认为我能从Database类继承，所以我只是让它成为一个独立的类，"有"一个数据库对象?

class Updater {
    private $db;
    private $table;
    private $setFields;
    private $whereFields;
    private $updates;
    function __construct($db, $table, $setFields, $whereFields) {
        if (!($db instanceof Database)) {
            if (is_scalar($db)) {
                $type = gettype($db);
            } else {
                $type = get_class($db);
            }
            throw new Exception("Expected Database object; " . $type . " found.");
        }
        $this->db = $db;
        // ensure $table is a table in the database
        // ensure $setFields and $whereFields are columns in the table
        $this->table = $table;
        $this->setFields = $setFields;
        $this->whereFields = $whereFields;
        $this->updates = array();
    }

    function addUpdate($setValues, $whereValues)  {
        // ensure $setValues is an array and has the same cardinality as
        //     $this->setFields
        // ensure $whereValues is an array and has the same cardinality as
        //     $this->whereFields
        array_push($this->updates,
            array(
                'setValues'=>$setValues,
                'whereValues' => $whereValues
            )
        );
    }
    function doUpdate() {   // without error handling
        $escTable = $this->db->bracket($table);
        $setTemplate = array();
        foreach ($this->setFields as $setField) {
            $escField = $this->db->bracket($setField);
            $colonField = makeColonField($setField);   // :fieldName
            $setting = "$escField = $colonField";
            array_push($setTemplate, $setting);
        }
        $csvSetTemplate = implode(", ", $setTemplate);
        $whereTemplate = array();
        foreach ($this->whereFields as $whereField) {
            $escField = $this->db->bracket($whereField);
            $colonField = makeColonField($setField);   // :fieldName
            $setting = "$escField = $colonField";
            array_push($whereTemplate, $setting);
        }
        $andedWhereTemplates = implode(" AND ", $whereTemplate);
        $sql = "UPDATE $escTable SET $csvSetTemplate WHERE $andedWhereTemplates";
        $sth = $this->db->prepare($sql);
        foreach ($this->updates as $update) {
            $setValues   = $update['setValues'];
            $whereValues = $update['whereValues'];
            $params = array();
            for ($i=0; $i<count($setValues); $i++) {
                $setField = $this->setFields[$i];
                $setValue = $setValues[$i];
                $colonField = makeColonField($setField);
                $params[$colonField] = $setValue;
            }
            for ($i=0; $i<count($whereValues); $i++) {
                $whereField = $this->whereFields[$i];
                $whereValue = $whereValues[$i];
                $colonField = makeColonField($whereField);
                $params[$colonField] = $whereValue;
            }
            $sth->execute($params);
        }
    }
}

这是一个好的解决方案吗?

首先，我建议在这种情况下使用抽象类更好，因为在不同的rdbms之间通常有许多共同之处，您可以使用抽象类编写一些通用方法来更清楚地解决问题。

还有另一种方法:

class Database extends PDO {
    private $engine; //this is a DBEngine
}
interface DBEngine  
{
}
class MySQLEngine implements DBEngine
{
}
class MSSQLEngine implements DBEngine
{
}
...

在这种情况下，您可以使用接口，因为通用的方法是在数据库中实现的，每个引擎只是实现在rdbms之间具有不同行为的方法。

这被称为适配器模式，您可以在CodeIgniter的源代码中阅读一些相关内容:http://ellislab.com/codeigniter.

对于第二个问题，您可以在类Database中实现update方法。

换句话说，使"update"成为类Database的公共成员。

我更倾向于有一个数据库包装类，然后注入一个"提供者"(一个提供者是MySQL, Oracle或其他数据库引擎)，然后通过你的包装类与你的数据库交互。

您将有一个引导文件来设置这些，然后将新创建的数据库对象实例传递给应用程序。

这叫做依赖注入。理论上，您可以轻松地将数据库引擎切换到另一个数据库引擎，或者甚至注入一个测试数据库并使用相同的应用程序。

一个简短的，即兴写的例子:

<?php
class Database
{    
    private $database;
    public function setProvider(DatabaseProvider $database)
    {
        $this->database = $database;
    }
    public function select($table, $fields = array(), $conditions = array(), $order = array())
    {
        $this->database->select($table, $fields, $conditions, $order);
    }
    public function insert($table, $values)
    {
        $this->database->insert($table, $values);
    }
    public function delete($table, $conditions = array())
    {
        $this->database->delete($table, $conditions);
    }
}

然后是一个示例提供商:

<?php
class MySQL implements DatabaseProvider
{
    public function __construct($config)
    {
        // create PDO instance with settings in $config
        $this->connection = new PDO();
    }
    public function select($table, $fields = array(), $conditions = array(), $order = array())
    {
        // build SELECT statement based on table, and other parameters passed
        // return result set
    }
    // and so on...
}

您的MySQL实例将在您的引导文件中创建，您还将在其中传递您的连接设置。

显然，上面不是一个完整的例子，但应该足以让你开始充实自己的解决方案。

示例目录结构，很大程度上受到Symfony 2的启发。

/app
    /config
        database.xml
/src
    /VendorName
        /AppName
            /Database
                /Provider
                    DatabaseInterface.php
                    MSSQL.php
                    MySQL.php
                    Oracle.php
            Database.php
        Application.php
        Bootstrap.php