与 OOP 概念作斗争

Question

我真的为反复出现的 OOP/数据库概念而苦恼。

请允许我用伪 PHP 代码解释问题。

假设您有一个“用户”类，它在其构造函数中从users 表中加载其数据：

class User {
    public $name;
    public $height;

    public function __construct($user_id) {
        $result = Query the database where the `users` table has `user_id` of $user_id
        $this->name= $result['name'];
        $this->height = $result['height'];
    }
}

简单，很棒。

现在，我们有一个“组”类，它从groups 表中加载其数据，并与groups_users 表连接，并根据返回的user_ids 创建user 对象：

class Group {
    public $type;
    public $schedule;
    public $users;

    public function __construct($group_id) {
        $result = Query the `groups` table, joining the `groups_users` table,
                    where `group_id` = $group_id
        $this->type = $result['type'];
        $this->schedule = $result['schedule'];

        foreach ($result['user_ids'] as $user_id) {
            // Make the user objects
            $users[] = new User($user_id);
        }
    }
}

一个组可以有任意数量的用户。

美丽、优雅、令人惊叹……在纸上。然而，实际上，创建一个新的组对象...

$group = new Group(21);  // Get the 21st group, which happens to have 4 users

...执行 5 个查询而不是 1 个。（组 1 个，每个用户 1 个。）更糟糕的是，如果我创建一个 community 类，其中有很多组，每个组中有很多用户，运行了非常多的查询！

不适合我的解决方案

多年来，我解决这个问题的方法是不以上述方式编码，而是在制作group 时，例如，我会将groups 表加入groups_users 表也到users 表，并在group 对象中创建一个类似用户对象的数组数组（从不使用/触摸user 类）：

class Group {
    public $type;
    public $schedule;
    public $users;

    public function __construct($group_id) {
        $result = Query the `groups` table, joining the `groups_users` table,
                    **and also joining the `users` table,**
                    where `group_id` = $group_id
        $this->type = $result['type'];
        $this->schedule = $result['schedule'];

        foreach ($result['users'] as $user) {
            // Make user arrays
            $users[] = array_of_user_data_crafted_from_the_query_result;
        }
    }
}

...但是，当然，如果我创建一个“社区”类，在其构造函数中，我需要将communities 表与communities_groups 表与groups 表与@ 连接起来987654344@ 表与users 表。

...如果我创建一个“城市”类，在其构造函数中，我需要将cities 表与cities_communities 表与communities 表与communities_groups 表与groups 表与groups_users 表与users 表。

真是一场彻头彻尾的灾难！

我必须在具有一百万个查询的漂亮 OOP 代码 VS 之间做出选择吗？ 1 查询并为每个超集手动编写这些连接？没有系统可以自动执行此操作吗？

我正在使用 CodeIgniter，并研究了无数其他 MVC，以及在其中构建的项目，如果不求助于我概述的两种有缺陷的方法之一，我找不到任何使用模型的好例子。

这似乎是以前从未做过的。

我的一位同事正在编写一个框架来实现这一点 - 您创建一个包含数据模型的类。其他更高模型可以包含该单个模型，它会制作和自动化表连接以创建包含对象实例化的更高模型较低的模型，全部在一个单个查询中。他声称他以前也从未见过这样做的框架或系统。

请注意： 我确实总是使用单独的类来实现逻辑和持久性。 （VO 和 DAO - 这是 MVC 的全部要点）。为了简单起见，我只是在这个思想实验中将两者结合起来，在类似 MVC 的架构之外。请放心，无论逻辑和持久性如何分离，此问题都会持续存在。我相信 this article，由 James 在这个问题下面的 cmets 中介绍给我，似乎表明我提出的解决方案（我多年来一直在关注）实际上是开发人员目前为解决这个问题所做的。然而，这个问题试图找到自动化该精确解决方案的方法，因此并不总是需要为每个超集手动编码。据我所知，这在 PHP 之前从未做过，我同事的框架将是第一个这样做的，除非有人能指出我这样做的。

而且，当然，我从不在构造函数中加载数据，我只在实际需要数据时调用我创建的 load() 方法。然而，这与这个问题无关，因为在这个思想实验中（以及在我需要自动化的现实情况中），我总是需要预先加载 的数据所有孩子的子集尽可能远，并且不根据需要在未来某个时间点延迟加载它们。思想实验很简洁——它没有遵循最佳实践是一个有争议的问题，试图解决其布局的答案同样没有抓住重点。

编辑：为清楚起见，这是一个数据库架构。

CREATE TABLE `groups` (
  `group_id` int(11) NOT NULL,  <-- Auto increment
  `make` varchar(20) NOT NULL,
  `model` varchar(20) NOT NULL
)

CREATE TABLE `groups_users` ( <-- Relational table (many users to one group)
  `group_id` int(11) NOT NULL,
  `user_id` int(11) NOT NULL
)


CREATE TABLE `users` (
  `user_id` int(11) NOT NULL, <-- Auto increment
  `name` varchar(20) NOT NULL,
  `height` int(11) NOT NULL,
)

（还要注意，我最初使用了wheels 和cars 的概念，但那是愚蠢的，这个例子更清楚。）

解决方案：

我最终找到了一个可以做到这一点的 PHP ORM。它是Laravel's Eloquent。您可以指定模型之间的关系，它会使用如下语法智能地构建优化查询以进行预加载：

Group::with('users')->get();

这是一个绝对的救生员。我不必编写一个查询。它也不能使用连接，它可以智能地根据外键进行编译和选择。

Answer 1

假设您有一个“轮子”类，它从其构造函数中的轮子表中加载其数据

构造函数不应该做任何工作。相反，它们应该只包含分配。否则你很难测试实例的行为。

现在，我们有一个“汽车”类，它从与 cars_wheels 表连接的汽车表中加载其数据，并根据返回的 wheel_ids 创建车轮对象：

没有。这有两个问题。

您的Car 类不应同时包含用于实现“汽车逻辑”和“持久性逻辑”的代码。否则你会破坏SRP。轮子是类的依赖项，这意味着轮子应该作为构造函数的参数注入（很可能 - 作为轮子的集合，或者可能是一个数组）。

相反，您应该有一个映射器类，它可以从数据库中检索数据并将其存储在WheelCollection 实例中。还有一个汽车映射器，它将数据存储在Car 实例中。

$car = new Car;
$car->setId( 42 );
$mapper = new CarMapper( $pdo );
if ( $mapper->fetch($car) ) //if there was a car in DB
{
    $wheels = new WheelCollection;
    $otherMapper = new WheelMapper( $pdo );

    $car->addWheels( $wheels );
    
    $wheels->setType($car->getWheelType());
    // I am not a mechanic. There is probably some name for describing 
    // wheels that a car can use
    $otherMapper->fetch( $wheels );
}

类似的东西。在这种情况下，映射器负责执行查询。您可以为它们提供多个来源，例如：拥有一个检查缓存的映射器，如果失败，则仅从 SQL 中提取数据。

我真的必须在具有一百万个查询的漂亮 OOP 代码 VS 之间做出选择吗？ 1 查询和恶心，un-OOP 代码？

不，丑陋来自active record 模式仅适用于最简单的用例（其中几乎没有关联的逻辑，具有持久性的美化值对象）。对于任何重要的情况，最好应用data mapper 模式。

..如果我创建一个“城市”类，在其构造函数中，我需要将城市表与 city_dealerships 表与经销商表与经销商_汽车表与汽车表与带有轮子的汽车轮表连接起来表。

仅仅因为您需要有关“莫斯科每个经销商的可用服务”的数据并不意味着您需要创建Car 实例，而且您肯定不会关心那里的车轮。网站的不同部分将具有不同的运营规模。

另一件事是您应该停止将类视为表抽象。 没有规定“类和表之间必须有 1:1 的关系”。

再次以Car 为例。如果您看一下，拥有单独的Wheel（甚至WheelSet）课程只是愚蠢的。相反，您应该只拥有一个已包含所有部分的 Car 类。

$car = new Car;
$car->setId( 616 );

$mapper = new CarMapper( $cache );
$mapper->fetch( $car );

映射器不仅可以从“Cars”表中轻松获取数据，还可以从“Wheel”和“Engines”等表中轻松获取数据并填充$car 对象。

底线：停止使用活动记录。

_{P.S. 另外，如果你关心代码质量，你应该开始阅读PoEAA 的书。或者至少开始看lectures listed here。}

我的 2 美分

Answer 2

Rails 中的 ActiveRecord 实现了延迟加载的概念，即推迟数据库查询，直到您真正需要数据。因此，如果您实例化一个my_car = Car.find(12) 对象，它只会查询该行的汽车表。如果稍后你想要my_car.wheels，那么它会查询wheels 表。

我对上面的伪代码的建议是不要在构造函数中加载每个关联的对象。汽车构造函数应该只查询汽车，并且应该有一个方法来查询它的所有车轮，还有一个方法来查询它的经销商，它只查询经销商并推迟收集所有其他经销商的汽车，直到你特别说了什么喜欢my_car.dealership.cars

后记

ORM 是数据库抽象层，因此必须调整它们以便于查询而不是微调。它们允许您快速构建查询。如果稍后您决定需要微调查询，那么您可以切换到发出原始 sql 命令或尝试以其他方式优化您要获取的对象数量。当您开始进行性能调整时，这是 Rails 中的标准做法 - 寻找使用原始 sql 发出时效率更高的查询，并寻找在您需要对象之前避免急切加载（与延迟加载相反）的方法。

Answer 3

一般来说，我建议使用一个构造函数来有效地获取查询行或较大查询的一部分。如何做到这一点取决于您的 ORM。这样，您可以获得高效的查询，但您可以在事后构造其他模型对象。

一些 ORM（django 的模型，我相信一些 ruby​​ ORM）试图巧妙地构造查询，并且可能能够为您自动执行此操作。诀窍是弄清楚何时需要自动化。我个人对 PHP ORM 不熟悉。