Tenho um aplicativo MVC com um Modelo de Domínio bem definido, com entidades, repositórios e uma camada de serviç

Para evitar instanciar minhas classes de serviço dentro de meus controladores e, assim, bagunçar meus controladores com uma lógica que não combina com eles, criei um auxiliar que funciona como uma espécie de Localizador de Serviço, mas depois de ler um pouco, percebi que muitos desenvolvedores:

http: //blog.tfnico.com/2011/04/dreaded-service-locator-pattern.htmhttp: //blog.ploeh.dk/2010/02/03/ServiceLocatorIsAnAntiPattern.asphttp: //underground.infovark.com/2010/06/18/the-service-locator-pattern-is-the-new-global-variablehttp: //www.andyfrench.info/2011/05/service-locator-anti-pattern_17.htm

Diga que o Localizador de Serviço é realmente um antipadrão. Mas acho que minha implementação não é um anti-padrã

A razão pela qual eles consideram o Localizador de Serviço um antipadrão, é porque ele oculta dependências, no entanto, eu injeto a única dependência (o Entity Manager, e essa dependência provavelmente não será alterada, porque está na assinatura da interface do Serviço) exigido por uma classe de serviço, no momento em que instancio o Localizador de Serviço.

Aqui está o meu código:

<?php

namespace App\Controller\Action\Helper;
use Zend_Controller_Action_Helper_Abstract as Helper,
    Doctrine\ORM\EntityManager;

/**
 * Service Locator Helper
 * @author JCM
 */
class Service extends Helper {

    /**
     * The actual EntityManager
     * @var \Doctrine\ORM\EntityManager
     */
    private $entityManager;

    /**
     * Services Namespace
     * @var string
     */
    private $ns;

    /**
     * @param EntityManager $entityManager
     * @param string $ns The namespace where to find the services
     */
    public function __construct( EntityManager $entityManager, $ns )
    {
        $this->entityManager = $entityManager;
        $this->ns = $ns;
    }

    /**
     * @param string $serviceName
     * @param array $options
     * @param string $ns
     */
    public function direct( $serviceName, array $options = array(), $ns = null )
    {
        $ns = ( (!$ns) ? $this->ns : $ns ) . '\\';
        $class = $ns . $serviceName;

        return new $class( $this->entityManager, $options );
    }

    /**
     * @param EntityManager $entityManager
     */
    public function setEntityManager( EntityManager $entityManager )
    {
        $this->entityManager = $entityManager;
    }

    /**
     * @return \Doctrine\ORM\EntityManager
     */
    public function getEntityManager()
    {
        return $this->entityManager;
    }

    /**
     * @param string $name
     */
    public function __get( $name )
    {
        return $this->direct( $name );
    }
}

Registrando o Action Helper com o Front Controller:

//inside some method in the bootstrap
HelperBroker::addHelper( new App\Controller\Action\Helper\Service( $entityManager, '\App\Domain\Service' ) );

E como eu uso esse auxiliar nos meus controladores:

//Some Controller
$myService = $this->_helper->service( 'MyService' ); //returns an instance of the class App\Domain\Service\MyService
$result = $myService->doSomethingWithSomeData( $this->getRequest()->getPost() );
//etc...

A minha implementação está correta? Realmente é um anti-padrão? Quais são os possíveis problemas que eu posso enfrentar?Como posso refatorar meu código para eliminar esse anti-padrão, mas continuar com a funcionalidad