Hello World

What exactly does that mean? It means that the controller and the view (ie. the template) are very dependant on each other in some situations.

The problem

You have a page which displays a list of products. The products are fetched from the database and assigned to the template in the controller.

Now, say you wanted to display the product list in an another page. You need to combine the product list template to the other template and combine code from the product list controller to the other controller.


This causes some extra work when you want to reorganize a page. It's not necessarily a bad problem, but a problem is a problem. In the optimal case you would only need to combine the template. For example like this:

You have a template that just displays a list of products and nothing else. There is no other HTML code in the template. This would be easy to re-use on multiple pages, right?

It would - but the problem is that you would need to assign the required template variables on all the pages where you want to use this small piece of templating.




There are some problems with this approach, though. The problem arises when you need to access your models from the templates. As you probably know, the parent template doesn't necessarily know about the other models than the one it needs, so you need some kind of a method to instantiate the models inside the template. Sure, you could probably go for some kind of global variable that holds it, but that's not a very good approach as it wouldn't be very reusable etc.

Solutions?

Let the template access the model/db.

Instead of always accessing the model in the controller, you could let the view access the model and therefore the view would be more "pluggable" to other pieces of views.

There are some things that you need to consider on this though: The parent view does not necessarily know about the other models than it needs so you need a method to pass the other views the models they need.


One approach with the current version of Zend Framework is using the view helpers. You can make a view helper, grab the database from the front controller in the helper, instantiate the model and instantiate a new view.

Something like this:

class Zend_View_Helper_MyHelper
{
  public function myHelper()
  {
    //Get the db parameter from the front controller
    $db = Zend_Controller_Front::getInstance()->getParam('db');
    
    //Fetch data from the model
    $model = new MyModel($db);
    $data = $model->GetData();

    //Display the data with a new view
    $view = new Zend_View();
    $view->assign('data',$data);
    $view->render('template.phtml');
  }
}

There's one thing here though... The creation of the view. If you need to pass the view some configuration, for example if you're using Smarty as the template engine you'd need to pass it the compiled template dir as a parameter, you'll run into problems.

You would have to put the configuration you want to every view helper you create like this... or you could create a view factory. The view factory should just create the view always with the same parameters. This way you can just edit the factory class in case you need to change some configuration settings. I'm not going to go into details about the implementation of that here, but you can go read about the Factory pattern at Patterns For PHP for some guidance.


I will return to this topic on an another post where I will show you how you can use view helpers from Smarty templates and how you could implement the view factory.