Issue #3: Impossible to match an interface I see the benefit in using interfaces for repositories, so I can swap out my implementation (for testing purposes or other). My understanding of interfaces is that they define a contract that an implementation must follow. This is great until you start adding additional methods to your repositories like findAllInCountry(). Now I need to update my interface to also have this method, otherwise, other implementations may not have it, and that could break my application. By this feels insane...a case of the tail wagging the dog.

我的直觉告诉我，这可能需要一个实现查询优化方法和泛型方法的接口。对性能敏感的查询应该有针对性的方法，而不频繁或轻量级的查询则由通用处理程序处理，这可能会使控制器做更多的杂耍。

泛型方法将允许实现任何查询，因此将防止在过渡期间发生破坏性更改。目标方法允许您在有意义时优化调用，并且它可以应用于多个服务提供者。

这种方法类似于硬件实现执行特定的优化任务，而软件实现只做简单的工作或灵活的实现。

根据我的经验，以下是对你们问题的一些回答:

问:我们如何处理收回我们不需要的土地?

答:从我的经验来看，这实际上可以归结为处理完整实体与临时查询。

一个完整的实体类似于一个User对象。它有属性和方法等。它是代码库中的一等公民。

一个特别查询返回一些数据，但除此之外我们什么都不知道。当数据在应用程序中传递时，是在没有上下文的情况下完成的。它是用户吗?附带一些订单信息的用户?我们真的不知道。

我更喜欢与完整的实体一起工作。

你是对的，你经常会带回你不使用的数据，但你可以通过各种方式解决这个问题:

积极地缓存实体，这样您只需从数据库中支付一次读取代价。 花更多的时间建模你的实体，这样它们之间就有了很好的区别。(考虑将一个大实体分成两个小实体，等等) 考虑拥有多个版本的实体。你可以有一个User用于后端，也可以有一个UserSmall用于AJAX调用。一个可能有10个属性，一个有3个属性。

使用临时查询的缺点:

You end up with essentially the same data across many queries. For example, with a User, you'll end up writing essentially the same select * for many calls. One call will get 8 of 10 fields, one will get 5 of 10, one will get 7 of 10. Why not replace all with one call that gets 10 out of 10? The reason this is bad is that it is murder to re-factor/test/mock. It becomes very hard to reason at a high level about your code over time. Instead of statements like "Why is the User so slow?" you end up tracking down one-off queries and so bug fixes tend to be small and localized. It's really hard to replace the underlying technology. If you store everything in MySQL now and want to move to MongoDB, it's a lot harder to replace 100 ad-hoc calls than it is a handful of entities.

问:我的存储库中会有太多的方法。

答:除了整合通话之外，我还没有找到其他解决办法。存储库中的方法调用实际映射到应用程序中的功能。特性越多，特定于数据的调用就越多。您可以向后推功能，并尝试将类似的调用合并为一个。

一天结束的时候，复杂性必须存在于某个地方。使用存储库模式，我们将其推入存储库接口，而不是制造一堆存储过程。

有时我不得不告诉自己，“好吧，它必须在某个地方让步!”没有银弹。”

我只能对我们(在我的公司)处理此事的方式发表评论。首先，性能对我们来说不是太大的问题，但拥有干净/适当的代码才是。

首先，我们定义模型，例如使用ORM创建UserEntity对象的UserModel。当一个UserEntity从一个模型中加载时，所有字段都被加载。对于引用外部实体的字段，我们使用适当的外部模型来创建各自的实体。对于这些实体，数据将按需加载。现在你的第一反应可能是…??? !!让我给你们举个例子一个小例子

class UserEntity extends PersistentEntity
{
    public function getOrders()
    {
        $this->getField('orders'); //OrderModel creates OrderEntities with only the ID's set
    }
}

class UserModel {
    protected $orm;

    public function findUsers(IGetOptions $options = null)
    {
        return $orm->getAllEntities(/*...*/); // Orm creates a list of UserEntities
    }
}

class OrderEntity extends PersistentEntity {} // user your imagination
class OrderModel
{
    public function findOrdersById(array $ids, IGetOptions $options = null)
    {
        //...
    }
}

In our case $db is an ORM that is able to load entities. The model instructs the ORM to load a set of entities of a specific type. The ORM contains a mapping and uses that to inject all the fields for that entity in to the entity. For foreign fields however only the id's of those objects are loaded. In this case the OrderModel creates OrderEntitys with only the id's of the referenced orders. When PersistentEntity::getField gets called by the OrderEntity the entity instructs it's model to lazy load all the fields into the OrderEntitys. All the OrderEntitys associated with one UserEntity are treated as one result-set and will be loaded at once.

这里的神奇之处在于，我们的模型和ORM将所有数据注入到实体中，而实体只是为PersistentEntity提供的通用getField方法提供包装器函数。总而言之，我们总是加载所有的字段，但引用外部实体的字段在必要时才加载。仅仅加载一堆字段并不是真正的性能问题。然而，加载所有可能的外国实体将是一个巨大的性能下降。

现在，根据where子句加载一组特定的用户。我们提供了一个面向对象的类包，允许您指定可以粘在一起的简单表达式。在示例代码中，我将其命名为GetOptions。它是一个选择查询的所有可能选项的包装器。它包含where子句、group by子句和其他所有内容的集合。我们的where子句相当复杂，但你显然可以很容易地做出一个更简单的版本。

$objOptions->getConditionHolder()->addConditionBind(
    new ConditionBind(
        new Condition('orderProduct.product', ICondition::OPERATOR_IS, $argObjProduct)
    )
);

该系统最简单的版本是将查询的WHERE部分作为字符串直接传递给模型。

我很抱歉回答这么复杂。我试着尽可能快速和清晰地总结我们的框架。如果你有任何其他问题，请随时问他们，我会更新我的答案。

编辑:另外，如果你真的不想马上加载某些字段，你可以在ORM映射中指定一个延迟加载选项。因为所有字段最终都是通过getField方法加载的，所以当调用该方法时，您可以在最后一分钟加载一些字段。这在PHP中不是一个很大的问题，但我不建议其他系统也这样做。

这是我见过的一些不同的解决方案。每一种都有利弊，但这是由你来决定的。

问题#1:字段太多

This is an important aspect especially when you take in to account Index-Only Scans. I see two solutions to dealing with this problem. You can update your functions to take in an optional array parameter that would contain a list of a columns to return. If this parameter is empty you'd return all of the columns in the query. This can be a little weird; based off the parameter you could retrieve an object or an array. You could also duplicate all of your functions so that you have two distinct functions that run the same query, but one returns an array of columns and the other returns an object.

public function findColumnsById($id, array $columns = array()){
    if (empty($columns)) {
        // use *
    }
}

public function findById($id) {
    $data = $this->findColumnsById($id);
}

问题2:方法太多

一年前，我曾短暂地与Propel ORM合作过，这是基于我对那次经历的记忆。Propel提供了基于现有数据库模式生成类结构的选项。它为每个表创建两个对象。第一个对象是一个很长的访问函数列表，类似于您当前列出的;findByAttribute (attribute_value美元)。下一个对象继承自第一个对象。您可以更新此子对象以构建更复杂的getter函数。

另一个解决方案是使用__call()将未定义的函数映射到可操作的函数。你的__call方法将能够将findById和findByName解析为不同的查询。

public function __call($function, $arguments) {
    if (strpos($function, 'findBy') === 0) {
        $parameter = substr($function, 6, strlen($function));
        // SELECT * FROM $this->table_name WHERE $parameter = $arguments[0]
    }
}

我希望这能有所帮助。

   class Criteria {}
   class Select {}
   class Count {}
   class Delete {}
   class Update {}
   class FieldFilter {}
   class InArrayFilter {}
   // ...

   $crit = new Criteria();  
   $filter = new FieldFilter();
   $filter->set($criteria, $entity, $property, $value);
   $select = new Select($criteria);
   $count = new Count($criteria);
   $count->getRowCount();
   $select->fetchOne(); // fetchAll();

所以我认为

我认为graphQL在这种情况下是一个很好的候选者，它可以在不增加数据存储库复杂性的情况下提供大规模查询语言。

但是，如果您现在不想使用graphQL，还有另一种解决方案。通过使用DTO，其中一个对象用于在进程之间传输数据，在本例中是在服务/控制器和存储库之间。

上面已经给出了一个优雅的答案，但我将尝试给出另一个例子，我认为它更简单，可以作为一个新项目的起点。

如代码所示，对于CRUD操作，我们只需要4个方法。find方法将用于通过传递对象参数来列出和读取。 后端服务可以基于URL查询字符串或特定参数构建已定义的查询对象。

如果需要，查询对象(SomeQueryDto)也可以实现特定的接口。并且很容易在不增加复杂性的情况下进行扩展。

<?php

interface SomeRepositoryInterface
{
    public function create(SomeEnitityInterface $entityData): SomeEnitityInterface;
    public function update(SomeEnitityInterface $entityData): SomeEnitityInterface;
    public function delete(int $id): void;

    public function find(SomeEnitityQueryInterface $query): array;
}

class SomeRepository implements SomeRepositoryInterface
{
    public function find(SomeQueryDto $query): array
    {
        $qb = $this->getQueryBuilder();

        foreach ($query->getSearchParameters() as $attribute) {
            $qb->where($attribute['field'], $attribute['operator'], $attribute['value']);
        }

        return $qb->get();
    }
}

/**
 * Provide query data to search for tickets.
 *
 * @method SomeQueryDto userId(int $id, string $operator = null)
 * @method SomeQueryDto categoryId(int $id, string $operator = null)
 * @method SomeQueryDto completedAt(string $date, string $operator = null)
 */
class SomeQueryDto
{
    /** @var array  */
    const QUERYABLE_FIELDS = [
        'id',
        'subject',
        'user_id',
        'category_id',
        'created_at',
    ];

    /** @var array  */
    const STRING_DB_OPERATORS = [
        'eq' => '=', // Equal to
        'gt' => '>', // Greater than
        'lt' => '<', // Less than
        'gte' => '>=', // Greater than or equal to
        'lte' => '<=', // Less than or equal to
        'ne' => '<>', // Not equal to
        'like' => 'like', // Search similar text
        'in' => 'in', // one of range of values
    ];

    /**
     * @var array
     */
    private $searchParameters = [];

    const DEFAULT_OPERATOR = 'eq';

    /**
     * Build this query object out of query string.
     * ex: id=gt:10&id=lte:20&category_id=in:1,2,3
     */
    public static function buildFromString(string $queryString): SomeQueryDto
    {
        $query = new self();
        parse_str($queryString, $queryFields);

        foreach ($queryFields as $field => $operatorAndValue) {
            [$operator, $value] = explode(':', $operatorAndValue);
            $query->addParameter($field, $operator, $value);
        }

        return $query;
    }

    public function addParameter(string $field, string $operator, $value): SomeQueryDto
    {
        if (!in_array($field, self::QUERYABLE_FIELDS)) {
            throw new \Exception("$field is invalid query field.");
        }
        if (!array_key_exists($operator, self::STRING_DB_OPERATORS)) {
            throw new \Exception("$operator is invalid query operator.");
        }
        if (!is_scalar($value)) {
            throw new \Exception("$value is invalid query value.");
        }

        array_push(
            $this->searchParameters,
            [
                'field' => $field,
                'operator' => self::STRING_DB_OPERATORS[$operator],
                'value' => $value
            ]
        );

        return $this;
    }

    public function __call($name, $arguments)
    {
        // camelCase to snake_case
        $field = strtolower(preg_replace('/(?<!^)[A-Z]/', '_$0', $name));

        if (in_array($field, self::QUERYABLE_FIELDS)) {
            return $this->addParameter($field, $arguments[1] ?? self::DEFAULT_OPERATOR, $arguments[0]);
        }
    }

    public function getSearchParameters()
    {
        return $this->searchParameters;
    }
}

使用示例:

$query = new SomeEnitityQuery();
$query->userId(1)->categoryId(2, 'ne')->createdAt('2020-03-03', 'lte');
$entities = $someRepository->find($query);

// Or by passing the HTTP query string
$query = SomeEnitityQuery::buildFromString('created_at=gte:2020-01-01&category_id=in:1,2,3');
$entities = $someRepository->find($query);