【问题标题】：PHP constructor and a bounce of fields dependant on each otherPHP构造函数和相互依赖的字段反弹
【发布时间】：2012-06-01 09:24:46
【问题描述】：

MyClass 有多个字段，其中每个值取决于另一个实例值，最后取决于DependencyClass。一个很简单的例子：

解决方案 A（使用构造函数）

public class MyClass
{
    private $myField1, $myField2;

    public function MyClass(DependencyClass $dependency)
    {
        $value = $dependency->getValue();
        $value++; // Computations on dependency value

        $this->myField1 = $value + 3;
        $this->myField2 = $value - 1;
    }

    public function getMyField1()
    {
        return $this->myField1;
    }

    public function getMyField2()
    {
        return $this->myField2;
    }
}

我的问题是，类构造函数是我应该放置此计算逻辑的正确位置吗？或者更适合做一些代码重复，例如：

解决方案 B（仅用于依赖的构造函数）

public class MyClass
{
    private $dependency;

    public function MyClass(DependencyClass $dependency)
    {
        $this->dependency= $dependency
    }

    public function getMyField1()
    {
        $value = $this->dependecy->getValue();
        $value++; // Computations on dependency value

        return $value + 3;
    }

    public function getMyField2()
    {
        $value = $this->dependecy->getValue();
        $value++; // Computations on dependency value

        return $value - 1;
    }
}

或使MyClass 仅是一个容器，而用户是一个外部汇编程序类，例如：

解决方案 C（外部汇编器）

Class Assembler
{
    public getMyClass()
    {
        $dependency = new Dependency();
        $value      = $dependency->getValue();
        $value++; // Computations on dependency value

        $myClass = new MyClass();
        $myClass->setMyField1($value + 3);
        $myClass->setMyField2($value - 1);

        return $myClass;
    }

}

【问题讨论】：

我会说这取决于一点，但是解决方案 B 对我来说是最直接的，当您的代码增长时这通常会很好。另外，我认为您已经大大简化了示例，并且这样做可能会丢失问题。

标签： php design-patterns object constructor

【解决方案1】：

答案是“视情况而定”。你想完成什么？

使用解决方案 A 和 B，您已将与 Dependency 的耦合和计算作为 MyClass 对象的固有部分：MyClass 不存在于 Dependency 中，它总是以某种方式使用 Dependency。另一方面，解决方案 C 将 MyClass 与 Dependency 完全解耦，使 MyClass 成为一个不起眼的数据对象。

所以问题是，在给定时刻你面临的任何更具体的情况下，哪一个是有意义的。您希望 MyClass 中的数据将来能够以多种方式构建，还是希望始终从 Dependency 中创建？

【讨论】：

【解决方案2】：

这取决于您的情况和需求。

如果您的计算很简单并且总是使用，我会将它们放在 ctor 中。（解决方案 A）

如果其中一个计算很复杂和/或并不总是使用，我会选择访问器中的“惰性评估”，并让访问器在计算结果后缓存结果。（解决方案 B，但我会添加结果缓存）。

我建议不要使用解决方案 C。它实际上只是不同范围内的构造函数，因此您的类的凝聚力较低。它隐藏了对另一个类的依赖。这使得测试变得困难，因为其他类不能被模拟或存根。类的存在几乎没有理由——它几乎与只读数组相同。

【讨论】：