Este artículo ha sido consultado en 6,262 ocasiones.
Nota: Este documento es sólo un apoyo al manual principal de CakePHP .
CakePHP es un framework que implementa el patrón de diseño MVC. Para quienes han trabajdo con Ruby on Rails (RoR), muchas cosas de CakePHP les resultarán muy familiares. La Wikipedia señala:
Modelo Vista Controlador (MVC) es un patrón de arquitectura de software que separa los datos de una aplicación, la interfaz de usuario, y la lógica de control en tres componentes distintos. El patrón MVC se ve frecuentemente en aplicaciones web, donde la vista es la página (X)HTML y el código que provee de datos dinámicos a la página.
- Modelo: la lógica de la aplicación además del acceso a datos (SQL, LDAP, XML, ActiveRecord, ORM) e integridad de la información.
- Vista: la interfaz para el usuario: WML para celulares y PDAs, pero más frecuentemente, (X)HTML para los navegadores
- Controlador: recibe el input del usuario (generalmente un link o un formulario ) y lo pasa, a veces al Modelo, a veces a la Vista Veamos la siguiente gráfica:
1) El usuario da click sobre la liga http://server.org/tasks/index
2) El dispatcher (despachador) de CakePHP llama y ejecuta el controlador tasks_controller.php el cual (como se indica en el URL) tiene un método index()
3) Este método index() del controlador llama al modelo Task que hace una consulta a la base de datos SQL
4) El modelo regresa el resultado al controlador
5) El controlador ha concluido su trabajo y le pasa los datos a la vista
6) La vista se integra con el layout HTML
7) El usuario ve el resultado de pinchar sobre http://server.org/tasks/index
Podría parecer complicado, pero no lo es, luego de algunos días de trabajar con CakePHP esta secuencia muestra su bien pensada lógica y uno se empieza a preguntar "¿Cómo pude trabajar de la otra manera durante tanto tiempo?".
Son muchas las ventajas del patrón MVC: sólidez, diseño, coherencia, modularidad, pero quizás las más importante es que hace mucho más fácil el mantenimiento y la cooperación entre varios desarrolladores. Algunas de las características de CakePHP:
- Compatible con PHP4 y PHP5
- Buena implementación de ActiveRecord
- Despachador de clases por URL (mejor apariencia)
- Plantillas rápidas y flexibles
- Ayudas (helpers) para AJAX, Javascript, HTML Formas y más (<- hace el trabajo menos tedioso)
- Trabaja desde cualquier directorio sin moverle a Apache
- Poderoso y sencillo sistema de validación
- Andamiaje en el CRUD (Scaffolding)
- Listas de control de acceso
- Data Sanitization (para evitar hackeos)
- Seguridad, Sesiones, y manejo de llamado a componentes
- Caché en las vistas
Como señalamos en el diagrama, en CakePHP la llamada al controlador, el método y sus variables se activan mediante el URL, por ejemplo, en lugar de un feo:
http://project.myserver.org/index.php?controller=pages&method=show&order=DESC&limit=15
En cakePHP sería:
http://project.myserver.org/pages/show/DESC/15
Este URL quiere decir que hay un controlador "pages", el cual posee un método (o función) "show" y estamos pasándole dos valores, DESC y 15. En CakePHP, esta clase sería así:
Archivo app/controllers/pages_controller.php
class PagesController extends AppController
{
public function show($order = null, $limit = null)
{
$conditions = null;
$fields = array("id", "title", "body", "created");
$ORrder = "Page.created " . $order;
$data = $this->Page->findAll($conditions, $fields, $ORder, $limit, null, 1); // $this->Page es el modelo
$this->set('data', $data); // le paso la variable "$data" a la vista para que muestre el resultado
}
}
?>
Helpers
Los helpers son una solución de CakePHP para dar un formato completo, correcto y válido a las etiquetas (tags) HTML o XHTML, todo ello sin el engorro de escribir todo el tag. Generalmente los helpers comienzan con $html-> o $form-> para los tags normales o $ajax-> en el caso de los helpers de Ajax.
Una de las mejores características de CakePHP es que es fácilmente extendible, es decir, tu puedes crear tus propios helpers, pero eso lo veremos después.
Por ejemplo, para construir una liga de todos los días con el helper $html->link():
$ html ->link('Ir a las frases', '/quotes/index', array('class'=>'small', 'title'=>'Describe liga') ); ?>
Lo que resulta en:
< a href="/quotes/index" title="Describe liga" clas="small"> Ir a las frases < / a >
Para imprimir una imagen:
$ html -> image('ruta/my_image.jpg', array("alt"=>"My Images", "title"=>"My Images"); ?>
Es importante señalar que $html->image() busca las imágenes en app/webroot/img/. Por supuesto estos elementos de liga e imagen se pueden mezclar para construir una liga usando una imagen:
$html ->link(html->image('ruta/myimages.jpg', array("alt"=>"My Images", "title"=>"My Images")),
'/quotes/index', array("class"=>"linksmall"), false, false, null );
Por otro lado, para construir un formulario en una vista de CakePHP:
archivo: app/views/pages/add.thtml
echo $form -> create('Page'); ?>
echo $ html ->div('my_css_class', 'New Page');
echo $html->labelTag('Page/title', 'Title:' );
echo $form->input('Page/title', array("size" => 50, "maxlength" => 120, "class"=>"formas"));
echo $html->tagErrorMsg('Page/title', 'Title is required.');
echo $form->submit('Send', array("class"=>"b_formas"));
Nótese que en este formulario ya estamos considerando el modelo pues se incluye la validación: $html->tagErrorMsg('Page/title', 'Title is required.'); que señala que CakePHP está considerando este campo del formulario como un campo obligatorio. Una vez más los usuarios de Ruby on Rails se sentirán en casa pues es la misma sintaxis.
Notemos también que los tags cortos de PHP, por seguridad, se evitan en el código de CakePHP. Si usamos lo Helpers, es casi seguro que podemos señalar nuestras páginas como páginas bien hechas: 
Instalación de CakePHP
La instalación es rápida y muy sencilla:
$sudo apt-get install apache2 libapache2-mod-php5 postgresql-8.1 php5 php5-pgsql
nos cambiamos al usuario www-data, nos vamos al directorio del webserver:
$cd /var/www/
en este directorio debemos descargar CakePHP. En estos días la versión estable es la 1.1.13. Descomprimimos:
$tar -jxvf cake_1.1.13.4205.tar.bz2
Renombramos:
$mv cake_1.1.13.405 project
Veremos dentro de /var/www/project cuatro directorios, app, cake, docs, vendor. El directorio cake nunca lo tocamos pues contiene las librerías estáticas del framework, vendor es donde debemos poner las librerías extras que no son parte de CakePHP, por ejemplo las librerías PEAR. Docs... bueno, son los docs. En realidad, es en app donde trabajaremos. Dentro del directorio app esta el directorio webroot, este es el root de la aplicación, es decir, a partir de aqui es lo que está visible para los internautas. Al ponernos en:
http://myserver.org/project/app/webroot/
ya podemos ver a CakePHP:
No obstante, lo mejor (por comodidad, seguridad y profesionalismo) es hacer que webroot sea realmente el webroot. Para configurar una instancia de CakePHP en Apache2, tecleamos:
$sudo mcedit /etc/apache2/sites-available/project.myserver.org
Y adentro ponemos:
ServerAdmin sergio@myserver.org
ServerName project.myserver.org
DocumentRoot /var/www/project/cake/app/webroot
ErrorLog /var/morg/chipotle/log/apache.log
Options FollowSymLinks
AllowOverride all
Order allow,deny
Allow from all
Lo guardamos y salimos. Creamos la liga simbólica:
$sudo ln -s /etc/apache2/sites-available/project.myserver.org /etc/apache2/sites-enabled/project.myserver.org
Por supuesto hay que crear el directorio para que Apache2 pueda escribir los logs que le corresponden a CakePHP:
$mkdir /var/www/project/logs
Reiniciamos:
$sudo /etc/init.d/apache2 restart
Y ya podemos ver a CakePHP en:
http://project.myserver.org
Ahora, como usuario postgres creamos nuestra base de datos PostgreSQL ( I like pgsql ;-) ):
$createdb -E UNICODE DBCENTAURO
Editamos:
$mcedit app/config/database.php.default
Con F12 salvamos este archivo como database.php, debemos editar para tener algo así:
< ? php
class DATABASE_CONFIG
{
var $default = array('driver' => 'postgres',
'connect' => 'pg_connect',
'host' => 'localhost',
'login' => 'postgres',
'password' => '456TY456x',
'database' => 'DBCENTAURO',
'prefix' => '');
var $test = array('driver' => 'mysql',
'connect' => 'mysql_connect',
'host' => 'localhost',
'login' => 'user',
'password' => 'password',
'database' => 'project_name-test',
'prefix' => '');
}
?>
La base de datos $test no la vamos a utilizar en este momento. El archivo pg_hba.conf de PostgreSQL debe estar configurado para aceptar conexiones del localhost. Ahora el recargar la página debes ver el mensaje "Cake is able to connect to the database".
Mi primer MVC
Ahora crearemos nuestro primer MVC. Primero (dentro de PostgreSQL) crearemos la tabla quotes y le agregaremos algunos registros. Por convención, en CakePHP las tablas tienen nombre en plural:
CREATE TABLE quotes (
id serial PRIMARY KEY,
quote varchar(150) NOT NULL,
author varchar(50) NOT NULL
);
INSERT INTO quotes ("quote", "author") VALUES ('Yo no hablo de venganzas ni perdones, el olvido es la única venganza y el único perdón.', 'Borges');
INSERT INTO quotes ("quote", "author") VALUES ('Uno no es lo que es por lo que escribe, sino por lo que ha leído.', 'Borges');
INSERT INTO quotes ("quote", "author") VALUES ('Creo que parte de mi amor a la vida se lo debo a mi amor a los libros.', 'Bioy Casares');
INSERT INTO quotes ("quote", "author") VALUES ('Ven a dormir conmigo: no haremos el amor, él nos hará.', 'Julio Cortazar');
Ahorea creamos el modelo para esta tabla:
Archivo: app/models/quote.php
< ? php
class Quote extends AppModel
{
public $name = 'Quote';
public $validate = array(
'quote' => VALID_NOT_EMPTY,
'author' => VALID_NOT_EMPTY
); }
?>
Nota: en los siguientes ejemplos usaré especificaciones como "private", "restricted", "public" que, como ya sabes, son exclusivas de la POO de PHP5, si estas programando en PHP4, omítelas.
El array $validate de los modelos (en este caso Quote), indican que campos son obligatorios en la tabla.
Por convención, los archivos del modelo se nombran en singular así como también la clase, en este caso: quote.php y Quote.
Ahora creamos el controlador:
Archivo: app/controllers/quotes_controller.php
class QuotesController extends AppController
{
public function index() {
$this->pageTitle = 'Estas son las frases'; // el titulo de la pagina
$data = $this->Quote->findAll(); // hacemos una consulta a la BD usando el modelo
$this->set('data', $data); // Le paso el resultado de la consulta a la vista
}
}
?>
Esta clase sólo posee un método: index(), si no hay indicación de método en el URL este es el método que CakePHP ejecuta por omisión. Cada método del controlador tiene una vista que presenta el XHTML al usuario, el nombre del método del controlador es el mismo que el de su vista, si el método se llama index(), el archivo de la vista debe llamarse index.thtml, si el método es listado() la vista es listado.thtml, etcétera. En este caso:
archivo: app/views/quotes/index.thtml
Quotes
echo $html->link('Nueva frase', '/quotes/add/')
foreach ($data as $val)
{
echo $html->link('Editar', '/quotes/edit/'.$val['Quote']['id']);
echo $val['Quote']['quote'];
echo $val['Quote']['author'];
echo $html->link('Borrar', '/quotes/delete/'.$val['Quote']['id']);
Ya tenemos nuestro MVC. Si ahora con Firefox nos colocamos en http://project.myserver.org/quotes/index veremos el listado de nuestras frases en PostgreSQL. Así de simple y potente es desarrollar con este framework. Al trabajar con CakePHP, debemos acostumbrarnos a consultar constantemente las clases de su API, pues así sabemos exactamente que métodos y atributos tiene cada clase padre, pues en CakePHP sólo creamos y trabajamos con clases hijas.
El layout
El layout es el template general del sitio, el layout por omisión debes colocarlo en app/views/layout/default.thtml, puede ser tan simple como:
Archivo: app/views/layout/default.thtml < ? php echo $this->renderElement('footer'); ?>
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
css("estilos"); ?>
< ? php echo $content_for_layout ?>
Nota que la hoja de estilos app/webroot/css/estilos.css se incluye con $html->css("estilos"). La variable $title_for_layout debe ser colocada en el método del controlador:
$this->pageTitle = 'Mi titulo';
La variable $content_for_layout es el resultado de la vista. $this->renderElement() es un método de CakePHP para colocar pequeños bloques dentro del layout, sólo hay que poner el elemento dentro del directorio /app/views/elements/. En este caso yo tengo footer.thtml, que tiene la información típica del footer y que varios layouts comparten.
Puedes tener tantos layouts como te hagan falta, sólo debes indicar en el controlador cuál vas a usar con la variable:
$this->layout = 'ruby';
Pero por omisión CakePHP busca default.thtml.
Última actualización: 2007-04-29 10:57:00-05
