3

我为我的模块编写了一个自定义服务。该服务提供了应验证给定令牌的公共静态函数。

现在我想实现另一个公共静态函数来检查 Doctrine-Entity 是否存在。对于这种情况，我需要服务中的对象管理器或服务定位器。

class ApiService 
{
    const KEY_LENGTH = 10;
    const USE_NUMBERS = true;
    const USE_CHARS = true;

    public static function isValid($apiKey) {
        $isValid = false;
        # more code tbd
        $isValid = self::exists($apiKey);
        return $isValid;
    }

    public static function exists($apiKey) {
    # Insert Object-Manager here

        $validator = new \DoctrineModule\Validator\ObjectExists(array(
           'object_repository' => $objectManager->getRepository('Application\Entity\User'),
           'fields' => array('email')
        )); 
    }
}

  1. 将我的函数实现为公共静态并将它们称为静态方法是“最佳实践”吗？

  2. 将对象管理器注入我的doesEntityExist()函数的最佳实践是什么？

4

2 回答 2

15

最好的方法是从您的类中完全删除静态方法。ZF2 使通过名称获取服务变得非常容易，因此对于这样的用例，您实际上不需要静态方法。

首先，清理你的服务：

namespace MyApp\Service;

use Doctrine\Common\Persistence\ObjectRepository;
use DoctrineModule\Validator\ObjectExists;

class ApiService
{
    // ...

    protected $validator;

    public function __construct(ObjectRepository $objectRepository)
    {
        $this->validator = new \DoctrineModule\Validator\ObjectExists(array(
           'object_repository' => $objectRepository,
           'fields'            => array('email')
        )); 
    }

    public function exists($apiKey)
    {
        return $this->validator->isValid($apiKey);
    }

    // ...
}

现在为它定义一个工厂：

namespace MyApp\ServiceFactory;

use MyApp\Service\ApiService;
use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class ApiServiceFactory implements FactoryInterface
{
    public function createService(ServiceLocatorInterface $serviceLocator)
    {
        $entityManager = $serviceLocator->get('Doctrine\ORM\EntityManager');
        $repository = $entityManager->getRepository('Application\Entity\User');

        return new ApiService($repository);
    }
}

然后将服务名称映射到工厂（通常在您的模块中）：

namespace MyApp;

use Zend\ModuleManager\Feature\ConfigProviderInterface;

class Module implements ConfigProviderInterface
{
    public function getConfig()
    {
        return array(
            'service_manager' => array(
                'factories' => array(
                    'MyApp\Service\ApiService'
                        => 'MyApp\ServiceFactory\ApiServiceFactory',
                ),
            ),
        );
    }
}

注意：您可能希望简单地使用闭包而不是定义单独的工厂类，但是当您不使用该服务时，拥有工厂类会给您带来小的性能提升。此外，在配置中使用闭包意味着您无法缓存合并的配置，因此请考虑使用此处建议的方法。

这是一个没有工厂类的例子（同样，考虑使用上面解释的方法）：

namespace MyApp;

use Zend\ModuleManager\Feature\ServiceProviderInterface;

class Module implements ServiceProviderInterface
{
    public function getServiceConfig()
    {
        return array(
            'factories' => array(
                'MyApp\Service\ApiService' => function ($sl) {
                    $entityManager = $serviceLocator->get('Doctrine\ORM\EntityManager');
                    $repository = $entityManager->getRepository('Application\Entity\User');

                    return new MyApp\Service\ApiService($repository);
                },
            ),
        );
    }
}

现在您可以在控制器中使用该服务：

class MyController extends AbstractActionController
{
    // ...

    public function apiAction()
    {
        $apiService = $this->getServiceLocator()->get('MyApp\Service\ApiService');

        if ( ! $apiService->isValid($this->params('api-key')) {
            throw new InvalidApiKeyException($this->params('api-key'));
        }

        // ...
    }

    // ...
}

您也可以在拥有服务管理器的任何地方检索它：

$validator = $serviceLocator->get('MyApp\Service\ApiService');

作为附加建议，请考虑简化您的服务。由于isValid已经是您的验证器的一个方法，您可以简单地返回验证器本身（为了简单起见，这里使用闭包方法）：

namespace MyApp;

use Zend\ModuleManager\Feature\ServiceProviderInterface;
use DoctrineModule\Validator\ObjectExists;

class Module implements ServiceProviderInterface
{
    public function getServiceConfig()
    {
        return array(
            'factories' => array(
                'MyApp\Validator\ApiKeyValidator' => function ($sl) {

                    $entityManager = $serviceLocator->get('Doctrine\ORM\EntityManager');
                    $repository = $entityManager->getRepository('Application\Entity\User');
                    new ObjectExists(array(
                       'object_repository' => $objectRepository,
                       'fields'            => array('email')
                    )); 
                },
            ),
        );
    }
}
于 2013-03-07T10:36:37.803 回答
0

就个人而言，我会将服务设为“服务”并将其放在 ServiceManager 中。另外我会考虑重构代码。现在，您依赖于 ObjectExists 验证器，而后者又依赖于实体存储库，而这又依赖于实体管理器。在服务之外组合验证器并从工厂注入它会简单得多。这样，如果你需要使用不同的验证器，你只需交给它一个不同的验证器。

class ApiService
{
    protected $validator;

    public function isValid($apiKey)
    {
         // other code
         $isValid = $this->exists($apiKey);
    }

    public function exists($apiKey)
    {
        return $this->getValidator()->isValid($apiKey);
    }

    public function setValidator(\Zend\Validator\AbstractValidator $validator)
    {
         $this->validator = $validator;
         return $this;
    }

    public function getValidator()
    {
        return $this->validator;
    }
}

在 Module.php 中，将服务创建为工厂方法，或者更好的是作为工厂类，但这留给你作为练习:)

public function getServiceConfig()
{
    return array(
        'factories' => array(
            'ApiService' => function($sm) {
                $em = $sm->get('Doctrine\ORM\EntityManager');
                $repo = $em->getRepository('Application\Entity\User');
                $validator = new \DoctrineModule\Validator\ObjectExists($repo, 
                   array('fields' => array('email')));
                $service = new ApiService();
                $service->setValidator($validator);
                return $service;
            },
        ),
    );
}

现在，如果您需要不同的 EntityManager、不同的 Entity 存储库，甚至是完全不同的验证器，您只需要更改上面的几行代码，而不必深入研究您的服务代码。

于 2013-03-07T10:41:58.000 回答