如何使用数据表和数据映射器？ 他们有必要吗？

Question

I have had experience with frameworks before, but never really got into models much. I don't know if this is the case for all frameworks or just zend, but currently I am learning Zend Framework.

I have been crawling through sample applications and trying to read huge articles, but I couldn't find a short and clear answer to what confuses me.

What is the relationship between the 3 classes? (model, modelmapper, datatable)

Let's say I have a database table called users and it has 3 fields userID, userName, userPassword What would be an example code?

and is it necessary to build the model part of my application in this way? Would it be a bad practice if I just had functions to retrieve data from the database and return results as arrays?

Please consider that this is a very simple application that has users,their image galleries, and messaging functionality.

Thanks in advance.

Answer 1

For simple application and to get your feet wet in ZF start out by just using the DbTable models that tie your database table to the database adapter. This is not best practice, buit is easy and will get you started.

using the Zend_Tool cli the command will have this format
zf create db-table name actual-table-name module force-overwrite ,
which will translate to:

zf create db-table Users users

db this will create a file named Users.php at /application/models/DbTable/ and it will look like:

<?php

class Application_Model_DbTable_Users extends Zend_Db_Table_Abstract
{
    protected $_name = 'users'; //name of table, does not have to match name of class
}

now to use this in a controller to fetchAll is as simple as:

<?php

class IndexController extends Zend_Controller_Action {

   public function indexAction(){
       $db = new Application_Model_DbTable_Users();//instantiate model
       $result = $db->fetchAll();//perform query, see Zend_Db_Table_Abstract for API
       $this->view->users = $result;//send to view
    } 
} 

just by making this one little class you will have access to the functionality of your chosen database adapter. You can also build methods in the DbTable model to customize your access needs.

<?php

class Application_Model_DbTable_Users extends Zend_Db_Table_Abstract
{
    protected $_name = 'users'; //name of table, does not have to match name of class

    public function getUser($id) {
       $select = $this->select();//see Zend_Db_Select for info, provides more secure interface for building queries.
       $select->where('id = ?', $id);//can be chained

       $result = $this->fetchRow($select);//returns a row object, if array is needed use ->toArray()
       return $result;
    }
} 

This method would be used in a similar manner to the fetchAll() method:

<?php

class IndexController extends Zend_Controller_Action {

   public function indexAction(){
       $id = $this->getRequest()->getParam('id');//assumes the id is set somehow and posted
       $db = new Application_Model_DbTable_Users();//instantiate model
       $result = $db->getUser($id);//perform query, see Zend_Db_Table_Abstract for API
       //$this->view->user = $result;//send to view as object
       $this->view->user = $result->toArray();//send to view as an array
    } 
} 

Hope this get you started, don't forget to read the manual

Answer 2

In general and in contrast to many other frameworks, Zend Framework does not force you to use a specific model architecture. So you are free to use whatever architecture suits best for your application. So the usage of an object-relational mapper is only one possible approach out of many.

But to answer your specific question: The reason why a mapper is used is simply because the information stored in a relational database cannot be translated 1:1 into an object model. This is called the Object-relational impedance mismatch and is described in all detail on the corresponding Wikipedia article.

For your example application let's consider the relation between messages and users . Let's assume you have two tables with the columns given in parentheses:

users (id, username, email, password)
messages (recipient: users.id, sender: users.id, message)

Which would correspond to the "dumb" objects User and Message . Now you want to load a specific message. The Object Message provides the methods getRecipient() and getSender() which both should return an instance of User . But if you read a specific row in the database, it will return an array and not the object with all the references to the other objects you need. This is exactly where the mapper comes in: It takes care that the "flat" result from the database is converted into an object and that all necessary references to other objects are made available.

Finally, another important function is to separate the persistence from the plain model. Let's assume that one day you want to switch from a classical relational database engine to a XML storage. You don't have to touch the business logic at all as long if your new persistence layer can provide the necessary objects.

Answer 3

I'd like to confirm what I understood.

Application_Model_User and Application_Model_Message have only variables and their setter and getter methods. Basically they are storage models.

Application_Model_MessageMapper has functions like getSender that may return an instance of Application_Model_User Also Mappers use db-table classes to retrieve data.

Now I can do something like this in my controller;

$id = $this->getRequest()->getParam('id'); // I received the message ID
$messageMapper = new Application_Model_MessageMapper(); 
$message = $messageMapper->getMessageByID($id); // this method uses Application_Model_DbTable_Message to fetch data, 
// then creates an object type of Application_Model_Message to set its fields and return.

$sender = $messageMapper->getSender($message);  // returns an instance of Application_Model_User after doing the necessary processes.

So Mappers talk to db-table classes, fetch data from them, and set that data into a model object to return.

Have I understood this correctly so far? If so, I will just start working on the project, and learn more as I go.

I still don't know how to use these db-table classes with linking tables which are needed for many to many relationships, but I think I'll figure it out eventually if I got the base.

Please indicate anything I misunderstood.