zf2 factories for populating controller with domain objects - zend-framework2

Question

I have two different ways of loading my controller with it's domain model. I'd be interested in hearing which is better.
First method - traditional.
A controller factory injects the required service into the controller constructor. Within the controller action, the model is loaded based on the request param:
ClientAppointmentsControllerFactory.php
class ClientAppointmentsControllerFactory implements FactoryInterface
{
public function createService(ServiceLocatorInterface $serviceLocator) {
$serviceManager = $serviceLocator->getServiceLocator();
$controller = new ClientAppointmentsController($serviceManager->get('Service\ClientAppointments'));
return $controller;
}
}
ClientAppointmentsController.php
class ClientAppointmentsController extends AbstractActionController
{
public function __construct(AppointmentFactory $appointmentFactory){
$this->appointmentFactory = $appointmentFactory;
}
public function indexAction() {
$viewModel = $this->acceptableViewModelSelector($this->acceptCriteria);
$appointments = $this->appointmentFactory->getClientAppointments($this->params()->fromRoute('clientId'));
$viewModel->setVariables([
'appointments' => $appointments
]);
return $viewModel;
}
}
Second Method - Accessing request/route parameters in factory
This seems a bit cleaner to me, as now the controller has no dependency on the service layer, and just expects (from whatever source) an array of loaded objects to pass to the view. I think this still fits the definition of a factory, since it is creating the controller with it's required dependencies, although is now actively creating them instead of passing this onto the controller to do:
ClientAppointmentsControllerFactory.php
class ClientAppointmentsControllerFactory implements FactoryInterface
{
public function createService(ServiceLocatorInterface $serviceLocator) {
$getRequestParam = function($param) use($serviceLocator){
$serviceManager = $serviceLocator->getServiceLocator();
$request = $serviceManager->get('Request');
$router = $serviceManager->get('Router');
$match = $router->match($request); // \Zend\Mvc\Router\RouteMatch
$result = $match->getParam($param);
return $result;
};
$serviceManager = $serviceLocator->getServiceLocator();
$clientService = $serviceManager->get('Service\ClientAppointments');
$appointments = $clientService->fetchByClientId($getRequestParam('clientId));
$controller = new ClientAppointmentsController($appointments);
return $controller;
}
}
ClientAppointmentsController.php
class ClientAppointmentsController extends AbstractActionController
{
/**
* #param Array $appointments Array of Appointment objects
*/
public function __construct(Array $appointments){
$this->appointments = $appointments
}
public function indexAction() {
$viewModel = $this->acceptableViewModelSelector($this->acceptCriteria);
$viewModel->setVariables([
'appointments' => $this->appointments
]);
return $viewModel;
}
Which is better?
(I also have an idea of a mutable factory floating around.)

Answer 1

IMO, the second is not good at all, because it mixes creation logic with business logic. This means a business logic error will preclude a factory from working.
The first one is better, but not good, because you have got now business logic in the controller.
I would suggest moving business logic into a business model OR to a controller plugin.