Modelo Vista Control Ad or

POO y MVC en PHP
El paradigma de la Programacin Orientada a Objetos en

PHP y el patrn de arquitectura de Software MVC
por
Eugenia Bahit
http://eugeniabahit.blogspot.com
AVISO LEGAL
POO y MVC en PHP de Eugenia
a!it se distribuye bajo una "icencia
Creati#e Commons $tribucin%
&oComercial%Sin'eri#adas ()*
+nported)
Usted es libre de:
Compartir, copiar, distribuir, ejecutar y comunicar p-blicamente la obra)
Bajo las ondiiones si!"ientes:
Atrib"i#n$ 'ebe reconocer los cr.ditos de la obra de la manera
especificada por el autor o el licenciante /pero no de una manera que sugiera
que tiene su apoyo o que apoyan el uso que !ace de su obra0)
%o Co&erial$ &o puede utili1ar esta obra para fines comerciales)
Sin Obras 'eri(adas$ &o se puede alterar, transformar o generar una obra
deri#ada a partir de esta obra)
M)s in*or&ai#n de esta lienia en:
!ttp233creati#ecommons)org3licenses3by%nc%nd34)53ar3
POO y MVC en PHP + E"!enia Ba,it
-ndie de ontenidos
Antes de comenzar con el libro............................................................................................................................................... 6
Objetivo del libro....................................................................................................................................................................6
Requisitos previos.............................................................................................................................................................6
A quines est dirigido este libro...............................................................................................................................6
!l por qu de este libro " #i $edicatoria........................................................................................................................6
%ontenido del libro.................................................................................................................................................................&
!structura del libro...........................................................................................................................................................&
!ntender el contenido di'erenciado ............................................................................................................................&
#arco te(rico )contenido propio*............................................................................................................................+
#arco te(rico )cita de terceros*...............................................................................................................................+
!jemplo prctico )c(digo 'uente*.............................................................................................................................+
#et'oras )comparaci(n con la vida real*..............................................................................................................+
,ugerencias de estilo..................................................................................................................................................+
!jercicios de autoevaluaci(n.....................................................................................................................................-
.rogramaci(n real.......................................................................................................................................................-
Respuestas a preguntas 'recuentes........................................................................................................................-
Introduccin a la programacin orientada a objetos (POO).........................................................................................
!lementos de la .OO...........................................................................................................................................................//
%lase..................................................................................................................................................................................//
Objeto...............................................................................................................................................................................//
#todo.............................................................................................................................................................................//
!vento " #ensaje............................................................................................................................................................//
.ropiedades " atributos................................................................................................................................................//
%aracter0sticas conceptuales de la .OO........................................................................................................................../1
Abstracci(n....................................................................................................................................................................../1
!ncapsulamiento............................................................................................................................................................/1
#odularidad...................................................................................................................................................................../1
Ocultaci(n )aislamiento*.............................................................................................................................................../1
.olimor'ismo.................................................................................................................................................................../1
2erencia............................................................................................................................................................................/1
Recolecci(n de basura.................................................................................................................................................../1
Programacin Orientada a Objetos en P!P "................................................................................................................... #
%lases " Objetos en .2. 3................................................................................................................................................../4
$e'inici(n de %lases......................................................................................................................................................./4
$eclaraci(n de %lases abstractas................................................................................................................................/4
2erencia de %lases........................................................................................................................................................./3
$eclaraci(n de %lases 'inales !n .2........................................................................................................................../3
5u tipo de clase declarar.............................................................................................................................................../3
Objetos en .2. 3................................................................................................................................................................./3
6nstanciar una clase......................................................................................................................................................../3
.ropiedades en .2. 3........................................................................................................................................................./6
.ropiedades p7blicas...................................................................................................................................................../6
.ropiedades privadas...................................................................................................................................................../6
$
.ropiedades protegidas................................................................................................................................................/6
.ropiedades estticas..................................................................................................................................................../&
Accediendo a las propiedad de un objeto......................................................................................................................./&
Acceso a variables desde el mbito de la clase........................................................................................................./&
Acceso a variables desde el e8terior de la clase......................................................................................................./&
%onstantes de %lase............................................................................................................................................................./+
#todos en .2. 3................................................................................................................................................................/+
#todos p7blicos9 privados9 protegidos " estticos.............................................................................................../-
#todos abstractos......................................................................................................................................................./-
#todos mgicos en .2. 3..........................................................................................................................................1:
!l #todo #gico ;;construct)*............................................................................................................................1:
!l mtodo mgico ;;destruct)*..............................................................................................................................1:
Otros mtodos mgicos...........................................................................................................................................1/
Ejercicios Pr%cticos.................................................................................................................................................................. &&
,oluciones a los ejercicios / " 1.........................................................................................................................................13
!jercicio <=/....................................................................................................................................................................13
!jercicio <=1....................................................................................................................................................................13
Programacin 'eal Orientada a Objetos en P!P............................................................................................................. &6
Archivos 'uente del A># de ?suarios..............................................................................................................................16
Archivo db;abstract;model.php..................................................................................................................................16
Archivo usuarios;model.php........................................................................................................................................1&
Archivo abm;e8ample.php...........................................................................................................................................1+
!8plicando el c(digo en el conte8to de la .OO: @a mejor 'orma de aprender " comprender..............................1-
Respuestas a .reguntas Arecuentes sobre el c(digo..............................................................................................1-
/. Respuestas a preguntas 'recuentes de la clase $>Abstract#odel............................................................1-
1. Respuestas a preguntas sobre la clase ?suario..............................................................................................B:
B. Respuestas a preguntas sobre el archivo de instancias................................................................................B/
Introduccin al patrn Ar(uitectnico )*+..................................................................................................................... $$
6ntroducci(n a la Arquitectura de ,o'tCare....................................................................................................................BB
5u es la arquitectura de so'tCare.........................................................................................................................BB
Dendencias de la Arquitectura de ,o'tCare..............................................................................................................BB
%aracter0sticas de la Arquitectura de ,o'tCare: Atributos de calidad.................................................................B4
Atributos de calidad que pueden observarse durante la ejecuci(n del so'tCare........................................B4
Atributos de calidad inherentes al proceso de desarrollo del so'tCare........................................................B4
$e lo general a lo particular: del estilo arquitect(nico al patr(n de diseEo.............................................................B3
Relaci(n " $i'erencia.....................................................................................................................................................B3
!l .atr(n Arquitect(nico modeloFvistaFcontrolador )#G%* ........................................................................................B3
Aclarciones previas.........................................................................................................................................................B3
5u es el patr(n #G%.................................................................................................................................................B6
%(mo 'unciona el patr(n #G%..................................................................................................................................B6
El Patrn )*+ en P!P............................................................................................................................................................. #,
!l modelo...............................................................................................................................................................................4:
6nter'aces en .2.: un nuevo concepto para crear modelos..................................................................................4:
$i'erencia entre 6nter'aces " %lases abstractas..................................................................................................4/
#
@o que <O deben hacer las inster'aces................................................................................................................41
@a vista....................................................................................................................................................................................41
Gista: la inter'aH gr'ica.................................................................................................................................................4B
@a @(gica de la Gista.......................................................................................................................................................44
.rimer paso: crear un diccionario de datos..........................................................................................................44
,egundo paso: obtener la plantilla 2D#@............................................................................................................44
Dercer paso: reemplaHar el contenido ..................................................................................................................44
%uarto paso: mostrar el contenido 'inal al usuario............................................................................................43
!l controlador.......................................................................................................................................................................43
.rimer paso: identi'icar el modelo........................................................................................................................4+
,egundo paso: invocar al modelo e'ectuando los cambios adecuados..........................................................4-
Dercer paso: enviar la in'ormaci(n a la vista........................................................................................................4-
Ejercicios Pr%cticos.................................................................................................................................................................. ",
,oluciones a los ejercicios B " 4.........................................................................................................................................3B
!jercicio <=B....................................................................................................................................................................3B
!jercicio <=4....................................................................................................................................................................3B
Programacin 'eal +on el patrn )*+............................................................................................................................... "#
!structura de directorios....................................................................................................................................................34
Archivos del #odelo ...........................................................................................................................................................33
Archivo ./core/db;abstract;model.php......................................................................................................................33
#odi'icaciones incorporadas..................................................................................................................................33
%(digo 'uente del archivo.......................................................................................................................................33
Archivo ./usuarios/model.php......................................................................................................................................36
#odi'icaciones incorporadas..................................................................................................................................36
%(digo 'uente del archivo.......................................................................................................................................36
Archivos de la Gista..............................................................................................................................................................3+
Archivos de la I?6...........................................................................................................................................................3+
Archivo ./site;media/html/usuario;template.html............................................................................................3-
Archivo ./site;media/html/usuario;agregar.html..............................................................................................3-
Archivo ./site;media/html/usuario;borrar.html.................................................................................................6:
Archivo ./site;media/html/usuario;buscar.html.................................................................................................6:
Archivo ./site;media/html/usuario;modi'icar.html...........................................................................................6:
Archivo ./site;media/css/base;template.css.......................................................................................................6:
Archivo ./usuarios/vieC.php.........................................................................................................................................61
!l controlador.......................................................................................................................................................................6B
Archivo ./usuarios/controller.php................................................................................................................................6B
Archivos de con'iguraci(n complementarios.................................................................................................................63
Archivo ./usuarios/constants.php................................................................................................................................63
Archivo .htaccess............................................................................................................................................................63
-ota .inal................................................................................................................................................................................... 66
"
Antes de comenzar con el libro
Antes de comenHar con la lectura puntual sobre .OO " #G% en .2.9 hago meritorio
notar ciertas cuestiones que considero deben contemplarse a 'in de lograr un mejor
entendimiento de lo e8puesto.
Objetivo del libro
!l objetivo de este libro9 es dar una introducci(n general a conceptos bsicos de la
programaci(n como lo son9 el paradigma de la programacin orientada a objetos " el
patrn ar(uitectnico )*+ (modelo/ 0ista/ controlador)9 a la veH de intentar introducir
estos conceptos9 en la programaci(n espec0'ica del lenguaje P!P.
Requisitos previos
.ara poder entender este libro9 los requisitos previos que debe tener el lector9 no son
muchos. Recomiendo que se tengan conocimientos b%sicos del lenguaje P!P as0 como
la 1acilidad para entender cdigo !2)3 b%sico )se utiliHar 2D#@ Dransitional 4.: en
algunos ejemplos9 evitando el uso de J2D#@9 a 'in de que programadores sin e8periencia
en el diseEo " maquetado de sitios Keb9 puedan comprender ms 'cilmente los
ejemplos utiliHados*.
A quines est dirigido este libro?
!ste libro est dirigido principalmente9 a programadores P!P que quieran salir de la
programaci(n estructurada para insertarse en la programaci(n orientada a objetos "9 a
programadores de otros lenguajes que quieran comenHar a insertarse en la .OO en
.2. " que cuenten con m4nimos conocimientos de este lenguaje.
El por qu? de este libro y Mi Dedicatoria
#i 'rase de cabecera es el por qu de las cosas es relativo ya que no tiene forma de ser
comprobado. As0 que se me hace mu" di'0cil e8plicar un Lpor quM. ,olo puedo decir
5cmo6 'ue que se me ocurri( escribirlo.
.erd0 la cuenta de la cantidad de programadores con los que he trabajado. 2an sido
much0simos en los 7ltimos /3 aEos de mi vida. #e ha tocado trabajar con e7celentes
programadores " con unos pocos no tan buenos. .ero ha" algo9 que he notado en una
gran parte de progrmadores9 con los que tal veH9 no me ha tocado trabajar en 'orma
directa9 pero s09 tener que continuar desarrollando algo "a empeHado por ellos o
modi'icarlo. N sto que he notado " me ha llamado mucho la atenci(n9 es que:
,e usan elementos de la programaci(n orientada a objetos9 con la 'alsa creencia
de que escribiendo una LclaseM "a se est programando orientado a objetos
,e desconoce por completo o no se logra entender del todo9 la di'erencia entre
Lestilo arquitect(nicoM9 Lpatr(n arquitect(nicoM " Lpatr(n de diseEoM9 provocando
en consecuencia9 el desaprovechamiento o mal uso9 de patrones arquitect(nicos
6
como #G% desencadenando as09 en una arquitectura de so'tCare de'iciente
@as alternativas que me quedaban eran dos:
/. <o hacer nada
1. Dransmitir a otros programadores9 todo lo que hab0a aprendido9 para que
pudiesen implementarlo si ese 'uese su deseo
.or l(gica " sin dudarlo ni tener que pensarlo demasiado9 eleg0 la segunda opci(n.
.orque esto" segura que el conocimiento debe ser transmitido " no se debe escatimar
en su di1usin. .ues no me interesa hacerme eco de la competiti0idad que invade
varios mbitos de la vida. .or el contrario9 pre1iero seguir el ejemplo de a(uellos/ mis
colegas/ (ue lo han brindado todo al saber general. N es por ello9 que este libro/ lo
dedico a todos ellos9 a los creadores de )astros8el9eb.com
" .oros8el9eb.com " en

especial9 a mis dos grandes colegas9 de quienes he aprendido gran parte de lo que ho"
se:
a la barcelonesa !elena !eidenreich )aOa: tunait
&
*9 gran colaboradora del 'oro
Pava,cript de A$K
" al madrileEo )iguel :ngel :l0arez9 'undador " director del portal de
programaci(n9 8esarrollo9eb.com
$
.
Contenido del libro
A 'in de lograr cumplir con los objetivos propuestos9 este libro ha sido diseEado con una
estructura esquemtica " seguiendo normas de estilo a 'in de di'erenciar su contenido.
Estructura del libro
!ste libro se encuentra dividido en # cap4tulos donde dos de ellos9 introducen a
conceptos bsicos de la .OO " el patr(n #G% )en general* " los otros dos9 colocan a la
.OO " al patr(n #G% en el conte8to del lenguaje .2..
Entender el contenido dierenciado
!ste libro no pretende ser un compendio de conceptos meramente te(ricos. A 'in de
alcanHar un abordaje ms preciso " 'cilmente entendible9 se ha divido el libro en ;
tipi1icaciones de contenido di'erenciadas:
. marco terico )contenido propio " citas de terceros*
&. ejemplo pr%ctico )c(digo 'uente de ejemplo*
$. met%1oras )comparaci(n con ejemplos de la vida real Q tomando esta tcnica de
un principio bsico de !8treme .rogramming*
#. sugerencias de estilo )reglas de estilo sugeridas para la programaci(n en .2.*
6 !ttp233www)maestrosdelweb)com3
4 t"nait nos ofrece una de las mejores colecciones de cdigos .a(aSri/t, en su sitio 7eb !ttp233tunait)com3ja#ascript3
( !ttp233www)desarrolloweb)com Portal de desarrollo 0eb y /ro!ra&ai#n, de la comunidad !ispanoparlante
;
". ejercicios de autoe0aluacin
6. programacin real )ejemplos con c(digos 'uente reales*
;. preguntas a respuestas 1recuentes
#arco te(rico )contenido propio*
De8to general del libro.
#arco te(rico )cita de terceros*
@as citas presentan el siguiente 'ormato:
Esto es una cita textual de terceros. La fuente se encuentra al pie de pgina.
!jemplo prctico )c(digo 'uente*
!l c(digo 'uente se encuentra con una tipogra'0a monoespaciada " con la sinta8is del
lenguaje coloreada
4
.
class Usuario {
# Propiedades
public $nombre;
# Mtodos
public function set_usuario() {
$this->nombre = 'Juan';
}
}
#et'oras )comparaci(n con la vida real*
A 'in de ejempli'icar con 'acilidad un concepto netamente te(rico9 se darn ejemplos
utiliHando hechos de la vida cotideana9 que puedan asemejarse al concepto que se est
e8plicando. !stas met'oras9 se presentarn con un diseEo como el siguiente:
!sto es una met%1ora.
,i no tengo el 0cono9 so" un ejemplo de la vida
real9 pero no so" una met'ora.
,ugerencias de estilo
A di'erencia de otros lenguajes de programaci(n como ."thon9 por ejemplo9 .2. no
tiene una gu0a de prcticas recomendadas o sugerencias de estilo. !sto9 hace que muchas
veces9 cada programador le de al c(digo 'uente un LtoqueM caracter0stico. ,i bien es un
rasgo de personalidad tal veH admirable9 en la prctica9 provoca que sea di'0cil modi'icar
el c(digo 'uente escrito previamente por otro programador.
A 'in de proponer una alternativa para solucionar este inconveniente " basndome en el
principio de Lpropiedad colectivaM de E7treme Programming as0 como en la tcnica de
8 Este libro !a sido editado utili1ando O/enO**ie 0riter 1$2 con el plug%in COOoder para el coloreado de sinta9is
<
establecimiento de pautas de estilo que hagan un c(digo homogneo9 a lo largo del libro
ir sugiriendo algunas reglas de estilo seg7n surjan9 cu"o 'inalidad tiende a:
/. hacer los c(digos 'uente ms intuitivosR
1. escribir c(digos 'uente 'cilmente legibles.
@as =ugerencias de Estilo presenta un 'ormato similar al siguiente:
'eglas de estilo
sugeridas
!sto es una regla de estilo
sugerida en re'erencia al tema
que se est tratando.
!jercicios de autoevaluaci(n
Al 'inal de los cap0tulos 66 " 6G9 ha" una breve serie de ejercicios9 cu"a 'inalidad9 es la de
asimilar los conocimientos adquiridos en los cap0tulos anteriores. @as soluciones a dichos
ejercicios9 se encuentran al 'inal de cada uno de ellos.
.rogramaci(n real
Dras los ejercicios presentados al 'inaliHar los cap0tulos 66 " 6G9 se
podr encontrar c(digo 'uente de casos reales. $ichos c(digos9
pretenden dar al lector9 una noci(n ms prctica de los temas que
se han tratado9 aplicndola a la vida cotideana de un desarrollador.
@os encontrars 'cilmente identi'icando el 0cono de .2. como el
que se muestra a la iHquierda de este prra'o.
Respuestas a preguntas 'recuentes
Aqu0 encontrars todas las preguntas sobre los c(digos 'uente que se
encuentren en la secci(n Lprogramaci(n realM. $icha secci(n9 se
encuentra identi'icada con el icono que se muestra a la derecha de
este prra'o.
!echa estas aclaraciones/ ahora...
>A programar?
@
CAP-3ULO I
:ntroduccin a la Programacin Orientada a Objetos /POO0
,
Introduccin a la programacin orientada a objetos (POO)
@a .OO es un paradigma de programacin )o tcnica de programaci(n* que utiliHa
objetos e interacciones en el diseEo de un sistema.
Ele!entos de la "OO
@a .OO est compuesta por una serie de elementos que se detallan a continuaci(n.
Clase
?na clase es un modelo que se utiliHa para crear objetos que comparten un mismo
comportamiento9 estado e identidad.
)et%1ora
Persona es la met'ora de una clase )la abstracci(n de
Puan9 .edro9 Ana " #ar0a*9 cu"o comportamiento
puede ser caminar9 correr9 estudiar9 leer9 etc. .uede
estar en estado despierto9 dormido9 etc. ,us
caracter0sticas )propiedades* pueden ser el color de ojos9
color de pelo9 su estado civil9 etc.
class Persona {
# Propiedades
# Mtodos
}
Objeto
!s una entidad provista de mtodos o mensajes a los cuales responde )comportamiento*R
atributos con valores concretos )estado*R " propiedades )identidad*.
$persona = new Persona();
/*
El objeto, ahora, es $persona,
que se ha creado siguiendo el modelo de la clase Persona
*/
Mtodo
!s el algoritmo asociado a un objeto que indica la capacidad de lo que ste puede hacer.
function caminar() {
#...
}
Evento y Mensaje
?n e0ento es un suceso en el sistema mientras que un mensaje es la comunicaci(n del
suceso dirigida al objeto.
"ropiedades y atributos
@as propiedades " atributos9 son 0ariables que contienen datos asociados a un objeto.
$nombre = 'Juan';
$edad = '2 a!os';
$a"tura = '#$% mts';

Caracter#sticas conceptuales de la "OO
@a .OO debe guardar ciertas caracter0sticas que la identi'ican " di'erencian de otros
paradigmas de programaci(n. $ichas caracter0sticas se describen a continuaci(n.
Abstracci$n
Aislaci(n de un elemento de su conte8to. $e'ine las caracter0sticas esenciales de un
objeto.
Encapsula!iento
Re7ne al mismo nivel de abstracci(n9 a todos los elementos que puedan considerarse
pertenecientes a una misma entidad.
Modularidad
%aracter0stica que permite dividir una aplicaci(n en varias partes ms pequeEas
)denominadas m(dulos*9 independientes unas de otras.
Ocultaci$n %aisla!iento&
@os objetos estn aislados del e8terior9 protegiendo a sus propiedades para no ser
modi'icadas por aquellos que no tengan derecho a acceder a las mismas.
"oli!oris!o
!s la capacidad que da a di'erentes objetos9 la posibilidad de contar con mtodos9
propiedades " atributos de igual nombre9 sin que los de un objeto inter'ieran con el de
otro.
'erencia
!s la relaci(n e8istente entre dos o ms clases9 donde una es la principal )madre* " otras
son secundarias " dependen )heredan* de ellas )clases LhijasM*9 donde a la veH9 los objetos
heredan las caracter0sticas de los objetos de los cuales heredan.
Recolecci$n de basura
!s la tcnica que consiste en destruir aquellos objetos cuando "a no son necesarios9
liberndolos de la memoria.
&
CAP-3ULO II
Programacin Orientada a Objetos en PHP 5
$
Programacin Orientada a Objetos en PHP 5
!n este cap0tulo veremos como aplicar los conceptos de la .OO en el entorno del
lenguaje .2. 3S.
Clases y Objetos en "'" (
Deinici$n de Clases
,eg7n el )anual O1icial de P!P9 una +lase es:
[] una coleccin de variables y funciones ue traba!an con estas variables. Las variables se
definen utili"ando var y las funciones utili"ando function [...]
#
.ara de'inir una clase9 el )anual O1icial de P!P9 contin7a diciendo:
[] La definicin bsica de clases comien"a con la palabra clave class$ seguido por un
nombre de clase$ continuado por un par de llaves ue encierran las definiciones de las
propiedades y m%todos pertenecientes a la clase. El nombre de clase puede ser cualuier
etiueta vlida ue no sea una palabra reservada de &'&. (n nombre vlido de clase
comien"a con una letra o un guin ba!o$ seguido de la cantidad de letras$ n)meros o guiones
ba!os ue sea. []
*
Geamos un ejemplo de de1inicin de clase:
class &ombre'e(i)"ase {
#...
}
'eglas de Estilo
sugeridas
?tiliHar +amel+ase para el
nombre de las clases.
@a lla0e de apertura en la misma l4nea que el
nombre de la clase9 permite una mejor
legibilidad del c(digo.
Declaraci$n de Clases abstractas
@as clases abstractas son aquellas que no necesitan ser instanciadas pero sin embargo9
ser%n heredadas en algAn momento. ,e de'inen anteponiendo la palabra clave abstract
a class:
abstract class &ombre'e(i)"ase*bstracta {
#...
}
!ste tipo de clases9 ser la que contenga mBtodos abstractos )que veremos ms
adelante* " generalmente9 su 'inalidad9 es la de declarar clases LgenricasM que necesitan
ser declaradas pero a las cuales9 no se puede otorgar una de'inici(n precisa )de eso9 se
encargarn las clases que la hereden*.
5 ;uente de la cita2 !ttp233p!p)net3manual3es3<eyword)class)p!p
= ;uente de la cita2 !ttp233www)p!p)net3manual3es3language)oop5)basic)p!p
#
'erencia de Clases
@os objetos pueden heredar propiedades C mBtodos de otros objetos. .ara ello9 .2.
permite la Le8tensi(nM )herencia* de clases9 cu"a caracter0stica representa la relaci(n
e8istente entre di'erentes objetos. .ara de'inir una clase como e8tenci(n de una clase
LmadreM se utiliHa la palabra clave extends.
class &ombre'e(i)"ase(adre {
#...
}
class &ombre'e(i)"ase+i,a extends &ombre'e(i)"ase(adre {
/* esta clase hereda todos los mtodos y propiedades de
la clase madre ombre!eMi"laseMadre
*/
}
Declaraci$n de Clases inales En "'"
.2. 3 incorpora clases 'inales que no pueden ser heredadas por otra. ,e de'inen
anteponiendo la palabra clave final.
final class &ombre'e(i)"ase-ina" {
#esta clase no podr# ser heredada
}
)u tipo de clase declarar?
2asta aqu09 han quedado en claro9 cuatro tipos de clases di'erentes: Instanciables9
astractas9 heredadas " 1inales. %(mo saber qu tipo de clase declarar Dodo
depender9 de lo que necesitemos hacer. !ste cuadro9 puede servirnos como gu0a bsica:
-ecesito... Instanciable Abstracta !eredada .inal
%rear una clase que pueda ser instanciada "/o heredada J
%rear una clase cu"o objeto guarda relaci(n con los mtodos "
propiedades de otra clase
J
%rear una clase que solo sirva de modelo para otra clase9 sin
que pueda ser instanciada
J
%rear una clase que pueda instanciarse pero que no pueda ser
heredada por ninguna otra clase
J
Objetos en "'" (
?na veH que las clases han sido declaradas9 ser necesario crear los objetos " utiliHarlos9
aunque hemos visto que algunas clases9 como las clases abstractas son solo modelos
para otras9 " por lo tanto no necesitan instanciar al objeto.
*nstanciar una clase
.ara instanciar una clase9 solo es necesario utiliHar la palabra clave new. !l objeto ser
creado9 asignando esta instancia a una variable )la cual9 adoptar la 'orma de objeto*.
@(gicamente9 la clase debe haber sido declarada antes de ser instanciada9 como se
muestra a continuaci(n:
"
# declaro la clase
class Persona {
#...
}
# creo el objeto instanciando la clase
$persona = new Persona();
'eglas de Estilo
sugeridas
?tiliHar nombres de variables
)objetos* descriptivos9 siempre en letra
min7scula9 separando palabras por guiones
bajos. .or ejemplo si el nombre de la clase es
-ombre8e)i+lase como variable utiliHar
DnombreEdeEmiEclase. !sto permitir una
ma"or legibilidad del c(digo.
"ropiedades en "'" (
@as propiedades representan ciertas caracter0sticas del objeto en s0 mismo. ,e de'inen
anteponiendo la palabra clave var al nombre de la variable )propiedad*:
class Persona {
var $nombre;
var $edad;
var $.enero;
}
@as propiedades pueden goHar de di'erentes caracter0sticas9 como por ejemplo9 la
visibilidad: pueden ser pAblicas/ pri0adas o protegidas. %omo veremos ms adelante9 la
visiblidad de las propiedades9 es aplicable tambin a la visibilidad de los mtodos.
"ropiedades p+blicas
@as propiedades p7blicas se de'inen anteponiendo la palabra clave public al nombre de
la variable. Tstas9 pueden ser accedidas desde cual(uier parte de la aplicacin9 sin
restricci(n.
class Persona {
public $nombre;
public $.enero;
}
"ropiedades privadas
@as propiedades privadas se de'inen anteponiendo la palabra clave private al nombre de
la variable. Tstas solo pueden ser accedidas por la clase (ue las de1ini.
class Persona {
public $nombre;
public $.enero;
private $edad;
}
"ropiedades protegidas
@as propiedades protegidas pueden ser accedidas por la propia clase (ue la de1ini/ as4
como por las clases (ue la heredan9 pero no9 desde otras partes de la aplicaci(n. Tstas9
se de'inen anteponiendo la palabra clave protected al nombre de la variable:
6
class Persona {
public $nombre;
public $.enero;
private $edad;
protected $pasaporte;
}
"ropiedades estticas
@as propiedades estticas representan una caracter0stica de LvariabilidadM de sus datos9
de gran importancia en .2. 3. ?na propiedad declarada como esttica9 puede ser
accedida sin necesidad de instanciar un objeto. " su valor es esttico )es decir9 no
puede variar ni ser modi'icado*. Tsta9 se de'ine anteponiendo la palabra clave static al
nombre de la variable:
class Persona*Positi/o extends Persona {
public static $tipo_san.re = '*0';
}
Accediendo a las propiedad de un objeto
.ara acceder a las propiedad de un objeto9 e8isten varias maneras de hacerlo. Dodas ellas9
dependern del mbito desde el cual se las invoque as0 como de su condici(n "
visibilidad.
Acceso a variables desde el !bito de la clase
,e accede a una propiedad no est%tica dentro de la clase9 utiliHando la pseudoFvariable
$this siendo esta pseudoFvariable una re'erencia al objeto mismo:
return $this->nombre;
%uando la variable es est%tica9 se accede a ella mediante el operador de resoluci(n de
mbito9 doble dosFpuntos FF anteponiendo la palabra clave self o parent seg7n si trata de
una variable de la misma clase o de otra de la cual se ha heredado9 respectivamente:
print self11$/ariab"e_estatica_de_esta_c"ase;
print parent11$/ariab"e_estatica_de_c"ase_madre;
Acceso a variables desde el e,terior de la clase
,e accede a una propiedad no est%tica con la siguiente sint8is: $ob,eto->/ariab"e
<(tese adems9 que este acceso depender de la visibilidad de la variable. .or lo tanto9
solo variables p7blicas pueden ser accedidas desde cualquier mbito 'uera de la clase o
clases heredadas.
# creo el objeto instanciando la clase
$persona_a_positi/o = new Persona*Positi/o();
# accedo a la $ariable NO esttica
print $persona_a_positi/o->nombre;
;
.ara acceder a una propiedad p7blica " est%tica el objeto no necesita ser instanciado9
permitiendo as09 el acceso a dicha variable mediante la siguiente sint8is:
Clase::$variable_esttica
# accedo a la $ariable esttica
print Persona*Positi/o11$tipo_san.re;
Constantes de Clase
Otro tipo de LpropiedadM de una clase9 son las
constantes9 aquellas que mantienen su 0alor de
1orma permanente C sin cambios. A di'erencia
de las propiedades estticas9 las constantes solo
pueden tener una 0isibilidad pAblica.
.uede declararse una constante de clase como
cualquier constante normal en .2. 3. !l acceso a
constantes es e8actamente igual que al de otras
propiedades.
'eglas de Estilo
sugeridas
?tiliHar
-O)B'EE8EE+O-=2A-2E en letra
#ANU,%?@A9 a"uda a di'erenciar rpidamente
constantes de variables9 haciendo ms legible
el c(digo.
const (2_)3&45*&56 = '6ste es e" /a"or est7tico de mi constante';
Mtodos en "'" (
%abe recordar9 para quienes vienen de la
programaci(n estructurada9 que el mtodo de
una clase9 es un algoritmo igual al de una 'unci(n.
@a 7nica di'erencia entre mtodo " 'unci(n9 es
que llamamos mBtodo a las 1unciones de una
clase )en la .OO*9 mientras que llamamos
'unciones9 a los algoritmos de la programaci(n
estructurada.
'eglas de Estilo
sugeridas
?tiliHar
nombresEdeE1uncionesEdescripti0os9 en
letra min7scula9 separando palabras por
guiones bajos9 a"uda a comprender mejor el
c(digo 'uente hacindolo ms intuitivo "
legible.
@a 'orma de declarar un mtodo es anteponiendo la palabra clave function al nombre del
mtodo9 seguido por un par parntesis de apertura " cierre " llaves que encierren el
algoritmo:
# declaro la clase
class Persona {
#propiedades
#mtodos
function donar_san.re() {
#...
}
}
Al igual que cualquier otra 'unci(n en .2.9 los mtodos recibirn los parmetros
necesarios indicando aquellos requeridos9 dentro de los parntisis:
<
# declaro la clase
class Persona {
#propiedades
#mtodos
function donar_san.re($destinatario) {
#...
}
}
Mtodos p+blicos- privados- protegidos y estticos
@os mtodos9 al igual que las propiedades9 pueden ser pAblicos/ pri0ados/ protegidos o
est%ticos. @a 'orma de declarar su visibilidad tanto como las caracter0sticas de sta9 es
e8actamente la misma que para las propiedades.
static function a() { }
protected function b() { }
private function c() { }
# etc...
Mtodos abstractos
A di'erencia de las propiedades9 los mtodos9 pueden ser abstractos como sucede con
las clases.
!l )anual O1icial de P!P9 se re'iere a los mtodos abstractos9 describindolos de la
siguiente 'orma:
[] Los m%todos definidos como abstractos simplemente declaran la estructura del m%todo$
pero no pueden definir la implementacin. +uando se ,ereda de una clase abstracta$ todos
los m%todos definidos como abstract en la definicin de la clase parent deben ser redefinidos
en la clase c,ild- adicionalmente$ estos m%todos deben ser definidos con la misma visibilidad
.o con una menos restrictiva/. &or e!emplo$ si el m%todo abstracto est definido como
protected$ la implementacin de la funcin puede ser redefinida como protected o public$
pero nunca como private. []
0
.ara entender mejor los mtodos abstractos9 podr0amos decir que a grandes rasgos9 los
mBtodos abstractos son a(uellos (ue se declaran inicialmente en una clase abstracta/
sin especi1icar el algoritmo (ue implementar%n9 es decir9 que solo son declarados pero
no contienen un Lc(digoM que espec0'ique qu harn " c(mo lo harn.
Dal veH9 te preguntes G+u%l es la utilidad de de1inir mBtodos abstractos C clases
abstractasH .ara responder a esta pregunta9 vo" en'ocarme en un caso de la vida real9 en
el cual estuve trabajando hace poco tiempo.
Ejemplo
,e trataba de hacer un sistema de gesti(n
in'ormtica9 para las 'armacias de los 2ospitales
del Iobierno de la %iudad de >uenos Aires. ?n
punto 'undamental9 era pensar en los insumos
'armacuticos como Lun todo abstractoM. .or
qu Aundamentalmente9 porque si bien e8isten
insumos 'armacuticos de todo tipo " especie9
cada uno de ellos9 comparte caracter0sticas
comunes9 que por s0 solas no pueden de'inirse
con precisi(n. .or ejemplo9 todos los insumos
> ;uente de la cita2 !ttp233www)p!p)net3manual3es3language)oop5)abstract)p!p
@
'armacuticos requieren de un tipo de
conservaci(n especial. Algunos requieren
re'rigeraci(n a determinada temperatura que
solo puede ser satis'echa conservndolos en una
heladeraR otros requieren conservarse en un
ambiente secoR otros9 no pueden tomar contacto
con el e8terior9 a 'in de conservar su capacidad
estrilR etc. .od0a de'inirse con e8actitud una
clase 6nsumo @a respuesta a esa pregunta9 es
justamente su pregunta ret(rica ir0as a la
'armacia a pedirle al 'armacutico Ldeme un
insumo de 3:: mgM 6nsumo9 representa la
entidad LabstractaM " para eso9 sirven las clases
abstractas. %on ellas declaramos aquellos
LobjetosM que no pueden ser de'inidos con
presici(n pero aseguramos all09 todas aquellas
caracter0sticas que dichos objetos9 guardarn
entre s0. $eclarar un mtodo conservar;insumo)*
como abstracto9 servir0a para luego de'inir con
e8actitud9 en una clase heredada9 el algoritmo
e8acto que determinado insumo necesitar0a para
procesar su conservaci(n. !s as0 entonces9 que
una clase 6nsumoRe'rigerado heredar0a de
6nsumo9 " rede'inir0a el mtodo
conservar;insumo)* indicando un algoritmo que
solicitara la temperatura a la cual deb0a
conservarse en heladera9 etc.
Mtodos !gicos en "'" (
.2. 39 nos trae una gran cantidad de autoFdenominados 5mBtodos m%gicos6. !stos
mtodos9 otorgan una 'uncionalidad preFde'inida por .2.9 que pueden aportar valor a
nuestras clases " ahorrarnos grandes cantidades de c(digo. @o que muchos
programadores consideramos9 a"uda a convertir a .2. en un lenguaje orientado a
objetos9 cada veH ms robusto.
!ntre los mtodos mgicos9 podemos encontrar los siguientes:
!l #todo #gico __construct()
!l mtodo __construct() es aquel que ser invocado de manera automtica9 al
instanciar un objeto. ,u 'unci(n es la de ejecutar cualquier inicialiHaci(n que el objeto
necesite antes de ser utiliHado.
# declaro la clase
class Producto {
#de%ino algunas propiedades
public $nombre;
public $precio;
protected $estado;
#de%ino el mtodo set&estado&producto'(
protected function set_estado_producto($estado) {
$this->estado = $estado;
}
# constructor de la clase
function __construct() {
$this->set_estado_producto('en uso');
}
}
!n el ejemplo anterior9 el constructor de la clase se encarga de de'inir el estado del producto como Len
usoM9 antes de que el objeto ).roducto* comience a utiliHarse. ,i se agregaran otros mtodos9 stos9 podrn
hacer re'erencia al estado del producto9 para determinar si ejecutar o no determinada 'unci(n. .or
ejemplo9 no podr0a mostrarse a la venta un producto Len uso por el sistemaM9 "a que a ste9 se le podr0a
estar modi'icando el precio.
!l mtodo mgico __destruct()
!l mtodo __destruct() es el encargado de liberar de la memoria9 al objeto cuando "a
no es re'erenciado. ,e puede aprovechar este mtodo9 para realiHar otras tareas que se
&,
estimen necesarias al momento de destruir un objeto.
# declaro la clase
class Producto {
#de%ino algunas propiedades
public $nombre;
public $precio;
protected $estado;
#de%ino el mtodo set&estado&producto'(
protected function set_estado_producto($estado) {
$this->estado = $estado;
}
# constructor de la clase
$this->set_estado_producto('en uso');
}
# destructor de la clase
function __destruct() {
$this->set_estado_producto('"iberado');
print '6" ob,eto ha sido destruido';
}
}
Otros mtodos mgicos
.2. nos o'rece otros mtodos mgicos tales como __ca""$ __ca""4tatic$
__.et$ __set$ __isset$ __unset$ __s"eep$ __8a9eup$ __to4trin.$
__in/o9e$ __set_state : __c"one;
.uede verse una descripci(n " ejemplo de su uso9 en el sitio Keb o'icial de .2.:
!ttp233www)p!p)net3manual3es3language)oop5)magic)p!p
&
Ejercicios Prcticos
.ara practicar lo que hemos visto hasta ahora9 les propongo hacer algunos ejercicios9 a
'in de asimilar los conocimientos de los cap0tulos 6 " 66.
Ejercicio N1: Sobre la programacin orientada a objetos
1.1) Qu es la Programacin !rientada a !bjetos"
a) Un patrn de diseo de software
b) Un paradigma de programacin
c) La nica forma en la que se puede programar en PHP
d) Ninguna de las anteriores
1.#) $ul de las siguientes opciones% responde mejor a los
elementos &ue 'orman parte de la P!!"
a) Clases, obetos, m!todos, atributos " propiedades
b) #tributos, e$entos " funciones
c) %!todos, inmutabilidad, abstraccin, funciones " prototipos
e) &ariables, constantes " funciones
1.() $ul de las siguientes a'irmaciones es )*+S* con respecto a
las caracter,sticas de la P!!"
a) La abstraccin " el polimorfismo son caracter'stica esenciales de la
programacin orientada a obetos
b) (ncapsulamiento es sinnimo de aislamiento
c) (n la P)), la modularidad, es la caracter'stica que permite di$idir
una aplicacin, en partes m*s pequeas, con independencia unas de las
otras
&&
Ejercicio N#: Sobre la P!! en P-P
#.1) .ado el siguiente cdigo:
<=php
>ina" c"ass 2temProducto {
#...
}
c"ass Producto e?tends 2temProducto {
#...
}
=>
Qu crees &ue 'allar,a al intentar ejecutarlo"
a) +temProducto fallar* "a que est* ,eredando de otra clase
b) No fallar'a nada
c) Producto no puede ,eredar de +temProducto "a que esta clase ,a
sido declarada como clase final
#.#) $ul crees &ue ser la salida del siguiente cdigo"
<=php
c"ass )"iente {
static pub"ic $nombre_comp"eto = ')"iente desconocido';
protected $id = #@@#;
}
print )"iente11$nombre_comp"eto;
print )"iente11$id;
=>
a) Cliente desconocido -..-
b) Cliente desconocido
c) /e imprimir'a Cliente desconocido pero fallar'a luego el acceso a 0id
"a que es una propiedad protegida
#.() $ul crees &ue ser la salida del siguiente cdigo"
<=php
c"ass )"iente {
&$
>unction __construct() {
se">11$nombre = 'Juan PAreB';
}
}
print )"iente11$nombre_comp"eto;
=>
a) Cliente desconocido
b) 1uan P!re2
E/plica por&u 0as elegido esa respuesta:
#.1) 2eniendo en cuenta el siguiente cdigo:
<=php
c"ass )"iente {
}
=>
$ul de las siguientes opciones% estimas &ue ser,a la
apropiada para imprimir en pantalla% la propiedad
3nombre4completo3
a) print )"iente11nombre_comp"eto;
b) print )"iente11$nombre_comp"eto;
c) $c"iente = ne8 )"iente();
print $c"iente->nombre_comp"eto;
d) $c"iente = ne8 )"iente();
print $c"iente->$nombre_comp"eto;
&#
.oluciones a los ejercicios / y 0
Ejercicio 12/
Pregunta .F respuesta b
Pregunta .&F respuesta a
Pregunta .$F respuesta b
Ejercicio 120
Pregunta &.F respuesta c
Pregunta &.&F respuesta c
Pregunta &.$F respuesta a
porue a las propiedades estticas no se les puede modificar su valor
Pregunta &.#F respuesta b
&"
Programacin Real Orientada a Objetos en PHP
Geremos ahora9 un ejemplo basado en la realidad de un programador.
!n este caso9 se trata de un AB) de usuarios.
Ntese ue los m%todos respectivos ,an sido resumidos no encontrndose en %stos$
algoritmos de validacin de datos. 1e e!emplifica todo auello ue es relevante en la
&22.
Arc3ivos uente del A4M de 5suarios
Arc3ivo db_abstract_model.php
<=php
abstract class 'C*bstract(ode" {
private static $db_host = '"oca"host';
private static $db_user = 'usuario';
private static $db_pass = 'contrase!a';
protected $db_name = 'm:db';
protected $Duer:;
protected $ro8s = arra:();
private $conn;
# mtodos abstractos para )*M de clases que hereden
abstract protected function .et();
abstract protected function set();
abstract protected function edit();
abstract protected function de"ete();

# los siguientes mtodos pueden de%inirse con e+actitud
# y no son abstractos
# "onectar a la base de datos
private function open_connection() {
$this->conn = new m:sD"i(self11$db_host$ self11$db_user$
self11$db_pass$ $this->db_name);
}
# !esconectar la base de datos
private function c"ose_connection() {
$this->conn->c"ose();
}
# Ejecutar un query simple del tipo ,-E./, !E0E/E, 1P!)/E
protected function e?ecute_sin."e_Duer:() {
$this->open_connection();
$this->conn->Duer:($this->Duer:);
$this->c"ose_connection();
}
# /raer resultados de una consulta en un )rray
protected function .et_resu"ts_>rom_Duer:() {
$resu"t = $this->conn->Duer:($this->Duer:);
8hi"e ($this->ro8sEF = $resu"t->>etch_assoc());
$resu"t->c"ose();
&6
arra:_pop($this->ro8s);
}
}
=>
Arc3ivo usuarios_model.php
<=php
reDuire_once('db_abstract_mode";php');
class Usuario extends 'C*bstract(ode" {
public $nombre;
public $ape""ido;
public $emai";
private $c"a/e;
protected $id;
$this->db_name = 'boo9_e?amp"e';
}
public function .et($user_emai"='') {
i>($user_emai" G= '')1
$this->Duer: = H
46I6)5 id$ nombre$ ape""ido$ emai"$ c"a/e
-J3( usuarios
K+6J6 emai" = '$user_emai"'
H;
$this->.et_resu"ts_>rom_Duer:();
endi>;
i>(count($this->ro8s) == #)1
>oreach ($this->ro8sE@F as $propiedad=>$/a"or)1
$this->$propiedad = $/a"or;
end>oreach;
endi>;
}
public function set($user_data=arra:()) {
i>(arra:_9e:_e?ists('emai"'$ $user_data))1
$this->.et($user_dataE'emai"'F);
i>($user_dataE'emai"'F G= $this->emai")1
>oreach ($user_data as $campo=>$/a"or)1
$$campo = $/a"or;
end>oreach;
$this->Duer: = H
2&46J5 2&53 usuarios
(nombre$ ape""ido$ emai"$ c"a/e)
L*IU64
('$nombre'$ '$ape""ido'$ '$emai"'$ '$c"a/e')
H;
$this->e?ecute_sin."e_Duer:();
endi>;
endi>;
}
public function edit($user_data=arra:()) {
>oreach ($user_data as $campo=>$/a"or)1
$$campo = $/a"or;
&;
end>oreach;
$this->Duer: = H
UP'*56 usuarios
465 nombre='$nombre'$
ape""ido='$ape""ido'$
c"a/e='$c"a/e'
K+6J6 emai" = '$emai"'
H;
}
public function de"ete($user_emai"='') {
$this->Duer: = H
'6I656 -J3( usuarios
H;
}
unset($this);
}
}
=>
Arc3ivo abm_example.php
<=php
reDuire_once('usuarios_mode";php');
# /raer los datos de un usuario
$usuario# = new Usuario();
$usuario#->.et('userMemai";com');
print $usuario#->nombre ; ' ' ; $usuario#->ape""ido ; ' e?iste<br>';
# "rear un nue$o usuario
$ne8_user_data = arra:(
'nombre'=>'*"berto'$
'ape""ido'=>'Jacinto'$
'emai"'=>'a"bert2@@@Mmai";com'$
'c"a/e'=>',acaranda'
);
$usuario2 = new Usuario();
$usuario2->set($ne8_user_data);
$usuario2->.et($ne8_user_dataE'emai"'F);
print $usuario2->nombre ; ' ' ; $usuario2->ape""ido ; ' ha sido creado<br>';
# Editar los datos de un usuario e+istente
$edit_user_data = arra:(
'nombre'=>'Nabrie"'$
'ape""ido'=>'IopeB'$
'emai"'=>'marconiMmai";com'$
'c"a/e'=>'OP2%Q'
);
$usuarioR = new Usuario();
$usuarioR->edit($edit_user_data);
$usuarioR->.et($edit_user_dataE'emai"'F);
print $usuarioR->nombre ; ' ' ; $usuarioR->ape""ido ; ' ha sido editado<br>';
# Eliminar un usuario
&<
$usuarioQ = new Usuario();
$usuarioQ->.et('"eiMmai";com');
$usuarioQ->de"ete('"eiMmai";com');
print $usuarioQ->nombre ; ' ' ; $usuarioQ->ape""ido ; ' ha sido e"iminado';
=>
E,plicando el c$digo en el conte,to de la "OO6 7a !ejor or!a de aprender y co!prender
!n principio tenemos $ archi0os:
1 archivos son VclasesV de dos modelos de objetos.
/ archivo9 es el que realiHa las instancias creando la cantidad de
objetos necesaria.
Respuestas a "reguntas 8recuentes sobre el c$digo
/. Respuestas a preguntas 'recuentes de
la clase 8BAbstract)odel
. GPor (uB la clase est% de1inida como
abstractaH
?na base de datos9 puede tener varios
mtodos9 como insertar datos/ editar datos/
eliminar datos o simplemente consultar
datos. !l algoritmo de cada uno de esos
mtodos no puede de1inirse con e7actitud
por qu .orque cada dato que se inserte9
modi'icque9 elimine o consulte9 variar en
in'inidad de aspectos: desde los tipos de
datos hasta las tablas " los campos a los que
se deba acceder9 etc.
>asados en el principio de modularidad de la
.OO9 es necesario tener en cuenta9 que 2ON9
necesito un A># de usuarios9 pero maEana9
este requisito puede ampliarse "9 debo dejar
todo preparado para que el sistema pueda ser
escalable " modular )otros m(dulos pueden
ser requeridos en el 'uturo*.
,i solo contemplara los mtodos de inserci(n9
edici(n9 consulta " eliminaci(n de usuarios en
esta clase9 estar0a cometiendo dos errores
imperdonable:
/. <o estar0a respetando el principio de
modularidad de la .OO
1. @os mtodos mencionados no son a
caso mtodos de un nuevo objeto
llamado ?suario
.or otro lado9 por cuestiones de seguridad9
se hac0a necesario no permitir instanciar esta
clase desde ning7n lugar de la aplicaci(n "
controlar con mucha precauci(n9 el acceso a
sus mtodos " propiedades9 "a que una base
de datos9 es el ValmaV de toda aplicaci(n.
.& GPara (uB declarar propiedades
est%ticasH
!n principio9 tanto el host como el usuario C
contraseIa de la base de datos9 en esta
aplicaci(n9 son 7nicos. <o var0an. $e all09 que
como caracter0stica se les asign( ser
est%ticos9 a 'in de9 por cuestiones de
seguridad9 no puedan ser modi'icados
dinmicamente )tengamos en cuenta que una
clase abstracta debe ser heredada s4 o s4
para ser utilizada*.
.$ GPor (uB propiedades est%ticas C no
constantes de claseH
.orque a las constantes9 aunque l(gicamente
guardan en s0 mismas la condici(n de
VestticasV en el sentido de que Vno pueden
ser modi'icadasV9 pueden ser accedidas desde
cualquier clase que herede de la clase que las
declare. .ues entonces9 la pregunta es GPara
(uB (uerr4a una clase JhijaJ conocer el host/
usuario C contraseIa de una base de datosH
!s una cuesti(n ntamente de seguridad9 "a
que a una constante no se la puede de'inir
como pri0ada " si se la quiere ocultar a las
clases VhijasV9 no quedar otra alternativa que
declararlas como propiedades estticas.
&@
.# GPor (uB propiedades est%ticas C a la
0ez pri0adasH
)ver respuestas anteriores*
." G+on (uB sentido declarar las
propiedades como protegidasH
!s simple. Algunos m(dulos pueden necesitar
utiliHar una base de datos di'erente. Dodos los
m(dulos9 necesitarn ueries personaliHados
para sus consultas. N l(gicamente9 todos
necesitarn acceder " conocer los resultados
de los datos arrojados por una consulta. !s
decir9 que tanto la propiedad dbEname como
(uerC C roKs9 deben tener permisos para ser
le0das " modi'icadas9 pero WOjoX ,olo por las
clases hijas de $>Abstract#odel 5u sentido
tendr0a permitir a un programador acceder a
estas propiedades si puede ser la clase hija9
quien las controle
.6 GPor (uB los mBtodos open C
closeEconnection son pri0adosH
.ues porque la clase es la 7nica con permiso
para abrir " cerrar cone8iones a la base de
datos. !s una cuesti(n de control " seguridad.
,i necesitas insertar datos9 consultarlos o
hacer con ellos otras actividades9 tienes
mtodos protegidos pero no privados9 que te
permiten hacerlo.
.; GPor (uB los mBtodos de consulta C
ejecucin son protegidos C no pAblicosH
%onsultar una base de datos9 modi'icar o
eliminar sus datos9 as0 como insertar nuevos9
no puede ser una tarea que se deje librada al
aHar " al libre acceso de cualquiera. !s
necesario VprotegerV los datos a 'in de
resguardar su integridad "9 la 'orma de
hacerlo9 es VprotegerV los mtodos que se
encuentran al servicio de dichos datos.
.< GPor (uB haC mBtodos declarados
como abstractos C adem%s protegidosH
!sta pregunta9 en gran parte9 la responde la
respuesta de la pregunta /./. !l hecho de que
se de'inan como abstractos9 es porque
necesariamente $!>!< ser mtodos comunes
a toda clase que los hereden. .ero solo la
clase hija9 podr de'inirlos )reFde'inirlos
tcnicamente hablando* "a que tal cual se
e8plic( en la pregunta /./.9 solo ellas conocen
los requerimientos espec0'icos.
,e declaran adems como protegidos9 por una
cuesti(n de seguridad )Vpor las dudasV para
que solo puedan ser vistos por clases
heredadas*. !sto9 da lugar a las clases hijas9 a
que modi'iquen su visibilidad de acuerdo al
criterio de cada una de ellas.
1. Respuestas a preguntas sobre la clase
Lsuario
&. GPor (uB la clase Lsuario es una
e7tensin de 8BAbstract)odelH
@a clase usuario D6!<! necesariamente que
heredar de $>Abstract#odel "a que $!>!
utiliHar sus mtodos )propios " de'inidos para
acceder a la base de datos* " rede'inir
obligadamente aquellos declarados como
abstractos9 a 'in de continuar un modelo de
administraci(n de los A># )altas9 bajas "
modi'icaciones*.
&.& G+on (uB 1in nombre/ apellido e eM
mail son propiedades pAblicas mientras
(ue cla0e es pri0ada C id/ protegidaH
Pensemos esto como en la 0ida realF tu
nombre9 apellido e eFmail9 puede ser
necesario para cientos de VtrmitesV "
acciones de tu vida diaria " no andas por la
vida negndolos a todo quien te los pida.
.odr0amos decir9 que no tiene nada de malo
(ue 1acilites pAblicamente estos datos/ a
(uien decidas.
Ahora bien Gle das tu contraseIa a
cual(uieraH ,i lo haces9 deja de hacerlo. 3a
contraseIa es un dato (ue debe ser pri0ado.
<adie puede tener acceso a l. !s una
cuesti(n de seguirdad.
!l n7mero de I8/ ser4a como tu nAmero de
documento o pasaporte. !s un dato que
debes mantener protegido pero que en
algunos casos9 te ser requerido " necesitars
darlo obligadamente. .or ejemplo9 no podr0as
negarte a mostrar tu pasaporte en
migraciones. ,in embargo9 $!>!, negarte a
decirle el .6< de tu tarjeta de crdito a
cualquier persona.
$,
&.$ GPor (uB se utiliza el mBtodo
EEconstruct() para modi1icar el nombre
de la base de datosH GPor (uB no se
encarga la clase madre de modi1icar ese
0alorH
!l nombre de la base de datos9 es algo que
variar de acuerdo al mdulo que lo est
trabajando. ,eguramente9 de e8istir en el
'uturo una clase llamada .roducto9 sta9
sobreescribir el valor de db_name.
#odi'icarlo automticamente utiliHando un
cosntructor9 nos asegura instanciar el objeto
con un valor de propiedad adecuado.
&.# GPor (uB se utiliza re(uireEonce C no
includeEonceH
@a di'erencia entre include " require es que
require9 si no puede incluir el archivo al que se
est importando9 'rena la ejecuci(n del script9
siendo que include9 solo arroja un error9
pero contin7a la ejecuci(n. Al tratarse de una
clase que VrequiereV s0 o s09 de su clase madre9
no tendr0a sentido permitir que se contin7e
ejecutando9 si no ha podido cargarse el
archivo.
B. Respuestas a preguntas sobre el
archi0o de instancias
$. GPor (uB el archi0o tiene cuatro
instancias al mismo objetoH
!s necesario hacer notar que si bien los
objetos comparten propiedades C mBtodos
en comAn/ no todos son idBnticos. !s decir9
todos los seres humanos tenemos ciertas
caracter0sticas en com7n " realiHamos
acciones similares. .ero cada uno de nosotros9
tiene una Anica identidad. .or eso9 no puede
decirse que se instancia cuadro veces el
mismo objeto9 porque en realidad9 son cuatro
objetos di'erentes donde cada uno de ellos9
tiene una identidad propia.
$
CAP-3ULO III
:ntroduccin al patrn arquitectnico MVC
$&
Introduccin al patrn Arquitectnico M!
#G%9 son las siglas de modeloM0istaMcontrolador )o en ingls9 modelFvieCFcontroller*9
que es uno de los tantos patrones de ar(uitectura de so1tKare.
Antes de abordar de lleno este patr(n9 vamos a intentar hacer una introducci(n a la
arquitectura de so'tCare9 desmembrndola de lo general hacia lo particular9 para al 'in
llegar al detalle9 procurando entender e8actamente de que se trata9 en el conte8to
adecuado.
.robablemente9 este cap4tulo sea el m%s complejo )" mucho ms e8tenso en relaci(n al
%ap0tulo 6*. .ero si quieres poder aplicar de 'orma decuada el patr(n #G%9 debes hacer el
es'uerHo de seguirlo con especial inters " actitud LentuciastaM.
*ntroducci$n a la Arquitectura de .ot9are
)u es la arquitectura de sot9are?
!s necesario aclarar9 que no e8iste una de'inici(n 7nica9 e8acta9 abarcativa e inequ0voca
de Larquitectura de so'tCareM. @a bibliogra'0a sobre el tema es tan e8tensa como la
cantidad de de'iniciones que en ella se puede encontrar. .or lo tanto tratar9 no de
de'inir la arquitectura de so'tCare9 sino ms bien9 de introducir a un concepto simple "
sencillo que permita comprender el punto de vista desde el cual9 este libro abarca a la
arquitectura de so'tCare pero9 sin nimo de que ello represente Luna de'inici(n msM.
3 grandes rasgos$ puede decirse ue la Arquitectura de
Software es la forma en la que se orani!an los
componentes de un sistema" interact#an y se relacionan
entre s$ y con el contexto" aplicando normas y principios
de dise%o y calidad" que fortale!can y fomenten la
usabilidad a la ve! que de&an preparado el sistema" para
su propia evolucin'
Dal veH ests pensando ...al fin y al cabo$ me ,a" dado una definicin ms.... @a respuesta
es s0. .robablemente no pude contenerme de hacerlo Q no lo niego F. .ero9 no debes
tomar lo anterior como una de1inicin9 sino como la 1orma en la (ue en este libro/ se
abarca la ar(uitectura de so1tKare.
:endencias de la Arquitectura de .ot9are
,i bien no puede decirse o mejor dicho9 no es mu" acadmico decirlo9 vo" a tomarme el
atrevimiento de mencionar solo dos tendencias ar(uitectnicas9 claramente
di'erenciadas entre s0:
@a Ar(uitectura de =o1tKare Orientada a Objetos )como Lingenir0aM de sistemas*
@a Ar(uitectura Estructurada )como LdesarrolloM de una aplicaci(n*
%omo podemos ver9 en este libro9 es a la primera a la cual nos en'ocamos.
$$
A 'in de satis'acer la inquietud de curiosos )" de paso9 no ocultar que e8isten*9 vo" a
mencionar la e8istencia de otras dos corrientes: la ar(uitectura basada en patrones " la
ar(uitectura basada en procesos C metodolog4as.
.ersonalmente9 no las considero como cuatro corrientes .or qu .orque
independientemente de cual te agrade ms9 si la A, orientada o objetos o la A,
estructural9 implican necesariamente dos corrientes que deben aplicarse de 'orma
optativa )o utiliHas una o la otra pero no las dos simultneamente*9 mientras que la A,
basada en patrones " la A, basada en procesos9 pueden utiliHarse como complemento de
las dos primeras. .ero esto9 es mera 1iloso14a propia9 con la cual9 no he encontrado
demasiado consenso. .ues no los aburrir con ello e iremos a lo prctico.
Caracter#sticas de la Arquitectura de .ot9are6 Atributos de calidad
@a +alidad del =o1tKare puede de'inirse como los atributos impl4citamente re(ueridos
en un sistema (ue deben ser satis1echos. %uando estos atributos son satis'echos9
puede decirse )aunque en 'orma objetable*9 que la calidad del so'tCare es satis'actoria.
!stos atributos9 se gestan desde la arquitectura de so'tCare que se emplea9 "a sea
cumpliendo con aquellos requeridos durante la ejecuci(n del so'tCare9 como con
aquellos que 'orman parte del proceso de desarrollo de ste.
Atributos de calidad que pueden
observarse durante la ejecucin del
so'tCare
. 8isponibilidad de uso
&. +on1idencialidad9 puesto que se
debe evitar el acceso no autoriHado
al sistema
B. %umplimiento de la .uncionalidad
requerida
#. 8esempeIo del sistema con
respecto a 'actores tales como la
capacidad de respuesta
". +on1iabilidad dada por la
constancia operativa " permanente
del sistema
6. =eguridad e7terna evitando la
prdida de in'ormaci(n debido a
errores del sistema
;. =eguridad interna siendo capaH de
impedir ataques9 usos no
autoriHados9 etc.
Atributos de calidad inherentes al
proceso de desarrollo del so'tCare
<. %apacidad de +on1igurabilidad que
el sistema otorga al usuario a 'in de
realiHar ciertos cambios
@. Integrabilidad de los m(dulos
independientes del sistema
,. Integridad de la in'ormaci(n
asociada
. %apacidad de Interoperar con
otros sistemas )interoperabilidad*
&. %apacidad de permitir ser
)odi1icable a 'uturo
)modi'icabilidad*
$. ,er 'cilmente )antenible
)mantenibilidad*
#. %apacidad de Portabilidad9 es decir
que pueda ser ejecutado en
diversos ambientes tanto de
so'tCare como de hardCare
". Dener una estructura que 'acilite la
'eusabilidad de la misma en
'uturos sistemas
6. #antener un diseEo arquitect(nico
Escalable que permita su
ampliaci(n )escalabilidad*
;. Aacilidad de ser =ometido a
Pruebas que aseguren que el
sistema 'alla cuando es lo que se
espera )testeabilidad*
$#
De lo general a lo particular6 del estilo arquitect$nico al patr$n de dise;o
!8iste una di'erencia entre Estilo Ar(uitectnico/ Patrn Ar(uitectnico C Patrn de
8iseIo9 que debe marcarse a 'in de evitar las grandes con'usiones que inevitablemente9
conclu"en en el mal entendimiento " en los resultados poco satis'actorios. Tstos9 son los
que en de'initiva9 aportarn LcalidadM al sistema resultante. !n lo sucesivo9 trataremos de
establecer la di'erencia entre estos tres conceptos9 viendo como los mismos9 se
relacionan entre s09 'ormando parte de un todo: la arquitectura de so'tCare.
Relaci$n y Dierencia
!stilo Arquitect(nico9 .atr(n Arquitect(nico " .atr(n de $iseEo9 representan9 de lo
general a lo particular9 los niveles de abstracci(n que componen la Arquitectura de
,o'tCare. !n este sentido9 puede decirse que:
El Estilo Ar(uitectnico es el encargado de:
$escribir la estructura general de un sistema9 independientemente de otros
estilos
$e'inir los componentes del sistema9 su relaci(n e interactividad
!jemplos : flu!o de datos$ llamada y retorno$ etc.
El Patrn Ar(uitectnico es el nivel en el cual la arquitectura de so'tCare:
$e'ine la estructura bsica de un sistema9 pudiendo estar relacionado con otros
patrones
Representa una plantilla de construccin que provee un conjunto de
subsistemas aportando las normas para su organi"acin
E!emplos 4 +apas$ 56+$ 7uber8as y 9iltros$ &i"arra$ etc.
El Patrn de 8iseIo es el tercer nivel de abstracci(n de la arquitectura de
so'tCare9 cu"a 'inalidad es la de precisar en detalle los subsistemas y componentes
de la aplicaci(n
!jemplos : &roxy$ +ommand$ 9actory$ etc..
El "atr$n Arquitect$nico !odelo<vista<controlador %M=C&
2abiendo dejado en claro de qu hablamos e8actamente cuando nos re'erimos a Lpatr(n
arquitect(nicoM9 estamos en condiciones de ahondar en los detalles del patr(n #G%.
Aclarciones previas
Antes de caer inmersos en el conocimiento
sobre el patr(n #G%9 quiero dejar en claro
que en este libro9 no har re'erencia a ning7n
'rameCorO.
!l objeti0o de ()) y *+, en (-( no es el de
1ormar a programadores en el uso de
1rameKorNs9 sino que el mismo9 parte de una
clara pregunta a caso los 'rameCorOs no han
sido desarrollados por programadores
Denemos la alternativa de utiliHar 'rameCorOs
para ahorrar tiempo de programaci(n o9 si
realmente nos apasiona programar/
ad(uirimos los conocimientos necesarios/
tenemos la capacidad C nos animamos/
podemos crear nuestros propios
1rameKorNs. $e hecho9 no se trata de
rein0entar la rueda/ sino de crear una/
adaptada a nuestras necesidades. N si lo que
$"
necesitamos es una rueda para acoplar a un
mueble que acabamos de crear cul ser0a el
sentido de intentar modi'icar una rueda de
cami(n si tenemos todas las herramientas
necesarias para ser LcreadoresM " no
Lmodi'icadoresM
%laro que esto9 depende de la pasi(n9 gusto9
capacidad " por qu no9 de la ambici(n de
cada uno. !l tiempo9 es discutible. .ues puede
demandarte ms tiempo modi'icar algo que
"a e8iste9 que crearlo. ,i quieres reparar un
mueble te llevar ms tiempo repararlo que ir
a comprar uno nuevo. N si eres ebanista9
seguramente te llevar menos tiempo hacer
un nuevo mueble que ir a comprarlo. .ues
sabes e8actamente lo que necesitas " como
hacerlo " eso9 har que ahorres el tiempo de
recorrer todas las muebler0as " termines
comprando Lel mueble que ms se asemeje al
que quieresM. !l mueble9 ser similar9 pero no
e8actamente igual al que tu imaginaste. $e
todas 'ormas9 la alternativa de modi'icar9
siempre la tienes... al igual que tambin tienes
la de crear. Dodo depender del criterio de
elecci(n que apliques " sea cual sea9 tu
elecci(n ser la correcta9 justamente porque
habrs LelegidoM " eso9 es lo ms importante.
)u es el patr$n M=C?
!l patr(n #G% es un patrn de ar(uitectura de so1tKare encargado de separar la
lgica de negocio de la inter1az del usuario " es el ms utiliHado en aplicaciones Keb9
"a que 'acilita la 'uncionalidad9 mantenibilidad " escalabilidad del sistema9 de 'orma
simple " sencilla9 a la veH que permite no me"clar lengua!es de programacin en el mismo
cdigo.
#G% divide las aplicaciones en tres niveles de abstracci(n:
)odeloF representa la l(gica de negocios. !s el encargado de accesar de 'orma
directa a los datos actuando como LintermediarioM con la base de datos. @o que en
nuestro ejemplo de programaci(n orientada a objetos9 ser0an las clases
$>Abstract#odel " ?suario.
*istaF es la encargada de mostrar la in'ormaci(n al usuario de 'orma gr'ica "
Lhumanamente legibleM.
+ontroladorF es el intermediario entre la vista " el modelo. !s quien controla las
interacciones del usuario solicitando los datos al modelo " entregndolos a la vista
para que sta9 lo presente al usuario9 de 'orma Lhumanamente legibleM.
C$!o unciona el patr$n M=C?
!l 1uncionamiento b%sico del patrn )*+9 puede resumirse en:
!l usuario realiza una peticin
!l controlador captura el e0ento )puede hacerlo mediante un manejador de
eventos Q ,andler F9 por ejemplo*
2ace la llamada al modelo/modelos correspondientes )por ejemplo9 mediante
una llamada de retorno Q callbac: ;* e'ectuando las modi'icaciones pertinentes
sobre el modelo
!l modelo ser% el encargado de interactuar con la base de datos9 "a sea en
'orma directa9 con una capa de abstracci(n para ello9 un Keb ,ervice9 etc. "
retornar esta in'ormaci(n al controlador
$6
!l controlador recibe la in1ormacin C la en04a a la 0ista
@a vista9 procesa esta in'ormaci(n pudiendo hacerlo desde el en'oque que
veremos en este libro9 creando una capa de abstracci(n para la l(gica )quien se
encargar de procesar los datos* " otra para el diseEo de la inter'aH gr'ica o I?6.
3a lgica de la 0ista/ una 0ez procesados los datos/ los 5acomodar%6 en base al
diseIo de la OLI M layout P C los entregar% al usuario de 'orma Lhumanamente
legibleM.
.uncionamiento del patrn modelo/vista/controlador
$;
2asta qu09 hemos hablado de estilos arquitect(nicos9 nos hemos introducido en uno de
los patrones arquitect(nicos )#G%* pero9 en todo esto Gen (uB momento inter0ienen
los patrones de diseIoH
!s aqu0 donde debemos notar que stos9 intervienen en la 'orma en la que cada capa
)modelo9 vista " controlador*9 LdiseEaM su estructura. !l controlador decidir )aunque en
realidad9 nosotros lo haremos* si utiliHar un ,andler para manejar los eventos del
usuario. !n ese caso9 estar0a optando por un patrn de diseIo. ,i para llamar al modelo9
utiliHa un callbac:9 estar0a utiliHando otro9 " as0 en lo sucesivo.
.ersonalmente9 sugiero que9 a no ser que se trate de sistemas realmente robustos "
complejos9 no se compliquen demasiado P por ahora M en LaplicarM todos " cada uno de
los patrones de diseEo que encuentren en el camino. @a 'orma de hacerlo bien9 es:
,encilleH " simplicidad
Acil mantenibilidad
.racticidad para evolucionar
,i se tienen en cuenta estas tres premisas9 el resultado de un c(digo limpio9 legible " 'cil
de interpretar para cualquier programador9 estar -:Y asegurado.
$<
CAP-3ULO IV
El patrn MVC en PHP
$@
"l Patrn M! en PHP
.ara que el concepto de modeloFvistaFcontrolador nos queda ms claro9 vamos a ir
analiHndolo con ejemplos concretos9 en el lenguaje que impulsa este libro: .2..
Al 'inal de este cap0tulo9 vamos a encontrar ejercicios prcticos de autoevaluaci(n "
luego9 continuaremos trans'ormando " ampliando nuestro primer ejemplo del %ap0tulo 669
siguiendo el patr(n arquitect(nico #G%9 con sus correspondientes comentarios "
aclaraciones.
El !odelo
%on respecto al modelo9 no tenemos demasiada novedad. !l modelo9 no es ms que el
conjunto de clases con las que hemos trabajado hasta ahora9 inclu"endo entre ellas9 la
capa de abstracci(n de la base de datos.
*nteraces en "'"6 un nuevo concepto para crear !odelos
!n esta etapa9 podemos ampliar las re'erencias de .2.9 incorporando un nuevo
concepto: las inter1aces.

!l )anual O1icial de P!P describe las inter'aces de la siguiente 'orma:
Las interfaces de ob!etos permiten crear cdigo con el cual especificar u% m%todos deben
ser implementados por una clase$ sin tener ue definir cmo estos m%todos son manipulados.
Las interfaces son definidas utili"ando la palabra clave interface$ de la misma forma ue con
clases estndar$ pero sin m%todos ue tengan su contenido definido. 7odos los m%todos
declarados en una interfa" deben ser public$ ya ue %sta es la naturale"a de una interfa".
<
[...]
?na inter'ace se de'ine utiliHando la palabra clave interface " se la implementa utiliHando
la palabra clave implements.
!n varias ocasiones9 las inter'aces nos servirn para ampliar los modelos.
Oeneramos la inter1aceF
interface Postre {
public function set_in.redientes();
}
Implementamos la inter1aceF
class CiBcochue"o implements Postre {
var $in.redientes = arra:();
public function set_in.redientes() {
$this->in.redientes = arra:('harina'=>'2 taBas'$ '"eche'=>'# taBa'$
? ;uente de la cita2 !ttp233p!p)net3manual3es3language)oop5)interfaces)p!p
#,
'aBucar'=>'# taBa'$ 'hue/o'=>#
);
}
}
E7tendemos una clase ((ue por de1ecto/ implementar% la inter1ace)F
class CiBcochue"oLaini""a extends CiBcochue"o {
$this->in.redientesE'escencia de /aini""a'F = 'a .usto';
}
parent11set_in.redientes();
$this->set_in.redientes();
}
}
2ambiBn podemos crear otra clase (ue implemente la inter1aceF
class *">a,or implements Postre {
$this->in.redientes = arra:('5apas de maiBena' => 2$
'du"ce de "eche'=>'# cda; sopera'$
'coco ra""ado'=>'# cdta; de te');
}
$this->set_in.redientes();
}
}
$i'erencia entre 6nter'aces " %lases abstractas
.robablemente te preguntes Gcu%l es la di1erencia entre una inter1ace C una clase
abstractaH %reme: todos nos lo hemos preguntado alguna veH :*
!n principio9 e8iste una di1erencia conceptual que a niveles LprcticosM tal veH no es del
todo clari'icadora. !sta di'erencia9 radica en que las clases abstractas" no de&an de ser
clases" las cuales representan la abstraccin de un ob&eto siuiendo un orden de
relacin &erarqu$ca entre ellas0 %lase > hereda de %lase A " %lase % hereda de %lase >9
pero no puede tener herencias m7ltiples9 es decir no puede heredar de ms de una clase9
"a que ellas9 guardan una relaci(n de orden jerrquico entre s0.
class * { }
class C extends class * { } #correcto
class ) extends class C { } #correcto
class ' { } #correcto
class 6 extends class *$ class ' { } # incorrecto!!! no se puede hacer!!!
# lo correcto ser2a3
class ' extends class * { }
class 6 extends class ' { }
#
A di'erencia de las clases abstractas9 conceptualmente9 las interfaces son solo un
con&unto de mtodos caracter$sticos de diversas clases9 independientemente de la
relaci(n que dichas clases mantengan entre s0. $e hecho9 una misma clase9 puede
implementar m7ltiples inter'aces:
interface * { }
interface C { }
interface ) { }
class (i)"ase implements *$ C$ ) { }
<o obstante la di'erencia conceptual9 podemos establecer claras di1erencias pr%cticas9
que nos a"udarn a asimilar mejor estos conceptos:
3as inter1aces no pueden de1inir propiedades )de hecho9 no poseen propiedades
porque a di'erencia de las clases abstractas no tienen relaci(n con un objeto9 "
solo los objetos tienen propiedades*
3as inter1aces no pueden tener mBtodos de1inidos con su algoritmo
correspondiente )solo pueden declarar los mtodos pero no pueden indicar el
LquM ni el Lc(moM hacerlo9 mientras que las clases abstractas9 s0 pueden*
3as inter1aces no pueden instanciarse por(ue no tienen re1erencias asociadas a
objetos9 mientras que las clases abstractas no pueden instanciarse9 porque sus
objetos son Lentes abstractosM que necesitan de una clase no abstracta para
de'inirse con e8actitud " poder ser instanciados.
2odos los mBtodos declarados en una inter1ace deben ser pAblicos9 puesto que
la 'inalidad de una inter'ace9 es brindar un Lmbito p7blico de un modeloM. @as
clases abstractas9 pueden tener mtodos abstractos tanto p7blicos como
protegidos )aquellos que debern ser obligatoriamente rede'enidos por las clases
que la hereden* " mtodos privados que solo ella utilice.
@o que <O deben hacer las inster'aces
3as inter1aces no puedenF
2ener el mismo nombre (ue una clase ).2. las interpreta como una clase ms.
%rear una inter'ace con el mismo nombre que una clase9 ser0a interpretado por
.2. como una LreFdeclaraci(n de claseM*
$i'erentes inter'aces no pueden tener nombres de mBtodos idBnticos si sern
implementadas por la misma clase
7a vista
%omo hemos visto anteriormente9 la vista representa la inter'aH gr'ica del usuario )I?6*9
es decir9 es la encargada de mostrar la in'ormaci(n al usuario de manera Lhumanamente
legibleM.
A tal 'in9 divideremos la vista en dos subFcapas: la I?6 propiamente dicha " su l(gica.
#&
=ista6 la intera> grica
Ieneralmente9 en la prctica9 no somos los programadores quienes nos hemos de
encargar de la I?6. !s tarea que corresponde a diseEadores Keb o gr'icos9 seg7n
aplique.
%omo LarquitectosM9 debemos tener preparada la estructura de nuestra aplicaci(n9 para
que diseEadores puedan trabajar libremente en la I?69 sin tener que acceder al c(digo
.2.. !n este libro9 0eremos adems9 como e0itar por completo (ue los diseIadores
tengan (ue implementar cdigo P!P en sus OLI " que programadores9 tengamos que
implementar c(digo 2D#@ en nuestras l(gicas.
!n principio9 la parte gr%1ica de las vistas )archivos 2D#@9 imgenes9 %,,9 etc.*9 deber%
tener un directorio reser0ado solo para ella. $e esta 'orma9 obtenemos varias ventajas
de trabajar con el patr(n #G%:
3os archi0os est%ticos )2D#@9 %,,9 imgenes e incluso Pava,cript* pueden
almacenarse en un ser0idor independiente con todos los bene'icios que esto
conlleva )al igual que sucede con las bases de datos9 los archivos estticos tambin
pueden independiHarse*
-os aseguramos de (ue el cdigo est%tico )aquel desarrollado por diseEadores*9
no 5rompa6 el nAcleo de la aplicacin
Permitimos a los diseIadores trabajar cmodamente en la libertad de aplicar
todos los conocimientos " herramientas inherentes a su rea de conocimiento9 sin
la presi(n de tener que implementar un lenguaje de programaci(n que
desconocen9 les es poco 'amiliar o simplemente9 la herramienta que utiliHan para
diseEar9 suele daEarles el c(digo noFesttico
!n segundo lugar9 cada plantilla Q template F o archivo 2D#@9 deber% hacer re1erencia
5est%tica6 a los datos (ue se (uieran reemplazar din%micamente. .ara esto9 no ser
necesario implementar c(digo que no sea 2D#@.
Geremos aqu0 como hacer re'erencia a estos datos9 " ms adelante9 veremos como la
l(gica de la vista se encargar de renderiHarlos.
,upongamos que tenemos una plantilla 2D#@9 donde lo que necesitamos reemplaHar de
manera dinmica9 es: t4tulo de la p%gina/ NeCKords C descripcin. @a mejor manera de
re'erenciar a estos datos9 'acilitando la tarea a un diseEador9 es haciendo una re'erencia
te8tual a stos. .ara que a la veH9 los programadores logremos di'erenciar que all0 se
inclu"en datos dinmicos9 una buena prctica9 es encerrar esa re'erencia te8tual entre
llaves.
Geamos un ejemplo:
<G'3)5SP6 HTML PUCI2) H-TTKR)TT'5' +5(I Q;@# 5ransitiona"TT6&H
Hhttp1TT888;8R;or.T5JThtm"QT"oose;dtdH>
<html "an.=HesH>
<head>
<meta http-eDui/=H)ontent-5:peH content=Hte?tThtm"; charset=ut>-UH>
<tit"e>T!tulo de la "#ina$<Ttit"e>
#$
<meta name=Htit"eH content=HT!tulo de la "#ina$H>
<meta name=H9e:8ordsH content=H%e&words$H>
<meta name=HdescriptionH content=Hdescripci'n$H>
<"in9 t:pe=Hte?tTcssH re"=Hst:"esheetH hre>=HcssTtemp"ate;cssH>
<Thead>
<bod&>
<div id=Hpa.eH>
<div id=HcabH>
<im# a"t=Hhome pa.eH src=Him.T"o.o;.i>H><Ta>
<Tdiv>
<div id=HcontenidoH>
<h(>T!tulo de la "#ina$<Th(>
<Tdiv>
<Tdiv>
<Tbod&>
<Thtml>
%omo podemos ver9 en la plantilla 2D#@ solo ha" c(digo 2D#@. .ara un diseEador9 ser
una tarea sencilla.
Geremos en el siguiente paso9 como la l(gica de la vista9 se encargar de reemplaHar
estos datos.
7a 7$gica de la =ista
Denemos la plantilla que cre( nuestro diseEador. !s hora de reemplaHar dinmicamente
los datos re'erenciados. 2aremos esto9 paso a paso9 como si de una receta de cocina se
tratara.
Primer pasoF crear un diccionario de datos
!l diccionario de datos es el que contendr9 literalmente hablando9 un diccionario9
indicando cuales re'erencias deben ser reemplaHadas por cules datos9 en 'orma
dinmica.
$diccionario = arra:(
'5Vtu"o de "a P7.ina'=>'P33 : (L) en P+P'$
'9e:8ords'=>'poo$ m/c$ php$ arDuitectura de so>t8are'$
'description'=>'6" paradi.ma de "a pro.ramaciWn orientada a ob,etos con e"
patrWn arDuitectWnico (L) en P+P'
);
=egundo pasoF obtener la plantilla 2D#@
.ara traer la plantilla 2D#@9 vamos a utiliHar la 'unci(n file_#et_contents)* de .2.9
" almacenar el contenido de ella9 en una variable.
$temp"ate = >i"e_.et_contents('TcarpetaTtemp"ate;htm"');
2ercer pasoF reemplaHar el contenido
!n el ante7ltimo paso9 reemplaHaremos los datos9 utiliHando el bucle foreach de .2.
para recorrer el diccionario9 " la 'unci(n str_replace)* de .2.9 para reemplaHar los
##
mismos.
>oreach ($diccionario as $c"a/e=>$/a"or) {
$temp"ate = str_rep"ace('{';$c"a/e;'}'$ $/a"or$ $temp"ate);
}
+uarto pasoF mostrar el contenido 'inal al usuario
.or 7ltimo9 imprimiremos el resultado obtenido en pantalla.
print $temp"ate;
N con esto9 habremos concluido la l(gica de la vista9 obteniendo en el navegador del
usuario9 la siguiente salida )vista de c(digo 'uente*:
<html "an.=HesH>
<head>
<tit"e>P33 : (L) en P+P<Ttit"e>
<meta name=Htit"eH content=HP33 : (L) en P+PH>
<meta name=H9e:8ordsH content=Hpoo$ m/c$ php$ arDuitectura de so>t8areH>
<meta name=HdescriptionH content=H6" paradi.ma de "a pro.ramaciWn orientada a
ob,etos con e"
patrWn arDuitectWnico (L) en P+PH>
<"in9 t:pe=Hte?tTcssH re"=Hst:"esheetH hre>=HcssTtemp"ate;cssH>
<Thead>
<bod&>
<div id=Hpa.eH>
<div id=HcabH>
<im# a"t=Hhome pa.eH src=Him.T"o.o;.i>H><Ta>
<Tdiv>
<div id=HcontenidoH>
<h(>P33 : (L) en P+P<Th(>
<Tdiv>
<Tdiv>
<Tbod&>
<Thtml>
El controlador
!l controlador9 aunque muchos de ustedes no lo crean9 es quien tal veH9 lleva Lla peor
parteM. !n muchas ocasiones9 es complicado programar el controlador de manera
previsible para que pueda evolucionar9 " generalmente9 es sometido a re'actoriHaciones
constantes9 incluso ma"ores que las que puede su'rir el modelo.
Recordemos que el controlador9 es quien debe interactuar con el modelo " con la vista.
.ara hacerlo9 deber previamente reconocer " manejar los distintos eventos del usuario9
para saber:
/. A qu modelo / modelos invocar
1. 5u " cules propiedades o atributos del modelo/modelos modi'icar o parmetros
#"
deber entregar a sus mtodos
B. A qu vista entregar la in'ormaci(n
W.obre hombreX @e toca una tarea e8tenuante. Geamos paso a paso9 como a"udar a este
pobre LcontrollerFmanM en su tarea.
,upongamos entonces9 que tenemos dos modelos:
3rc,ivo models'php
class (ode"oUno {
var $propiedad;
function a($parametro) {
$this->propiedad = $parametro;
}
}
class (ode"o'os {
var $propiedad_#;
var $propiedad_2;
function b($param#$ $param2) {
$this->propiedad_# = $param#;
$this->propiedad_2 = $param2;
}
}
N a la veH9 tenemos dos vistas:
7emplate vista12'html
<html "an.=HesH>
<head>
<tit"e>Lista (ode"o #<Ttit"e>
<Thead>
<bod&>
<div id=Hpa.eH>
<p>6" /a"or de "a <b>propiedad<Tb> es <b>{propiedad}<Tb><Tp>
<Tdiv>
<Tbod&>
<Thtml>
7emplate vista13'html
#6
<html "an.=HesH>
<head>
<tit"e>Lista (ode"o 2<Ttit"e>
<Thead>
<bod&>
<div id=Hpa.eH>
<p>6" /a"or de <b>propiedad_#<Tb> es <b>{propiedad_#}<Tb> mientras Due e"
de <b>propiedad_2<Tb> es <b>{propiedad_2}<Tb><Tp>
<Tdiv>
<Tbod&>
<Thtml>
N la l(gica de stas9 es la siguiente:
3rc,ivo view'php
function set_identi>icadores($/ista) {
$identi>icadores = arra:();
i>($/ista) {
s8itch ($/ista) {
case '/ista_#'1
$identi>icadores = arra:('propiedad');
brea9;
case '/ista_2'1
$identi>icadores = arra:('propiedad_#'$ 'propiedad_2');
brea9;
}
return $identi>icadores;
}
}
function armar_diccionario($/ista$ $data) {
$diccionario = arra:();
$identi>icadores = set_identi>icadores($/ista);
i>($identi>icadores) {
>oreach ($identi>icadores as $identi>icador) {
i>(arra:_9e:_e?ists($identi>icador$ $data)) {
$diccionarioE$identi>icadorF = $dataE$identi>icadorF;
}
}
}
return $diccionario;
}
function render_data($/ista$ $data) {
$htm" = '';
i>(($/ista)XX($data)) {
$diccionario = armar_diccionario($/ista$ $data);
i>($diccionario) {
$htm" = >i"e_.et_contents('htm"T';$/ista;';htm"');
>oreach ($diccionario as $c"a/e=>$/a"or) {
$htm" = str_rep"ace('{';$c"a/e;'}'$ $/a"or$ $htm");
}
}
#;
}
print $htm";
}
!ntonces9 nuestro controlador proceder de la siguiente 'orma:
Primer pasoF identi'icar el modelo
.ara esto9 el controlador previamente9 tendr que reconocer el evento que ejecuta el
usuario " saber como manejarlo. .ara ello9 la 'orma de pensarlo Lin'ormticamenteM
ser0a:
si usuario Qe0entoR entonces Qrealizar accinR
!n nuestro caso9 los eventos admitidos9 sern llamdas por ?R@ mediante el mtodo
Z;I!D.
.rimero9 identi'icar el evento respondiendo a las siguientes preguntas:
e8iste el evento de llamada mediante LZ;I!DM
,i e8iste a qu evento9 el usuario9 quiere que responda
.ara esto9 utiliHar la siguiente 'unci(n:
function capturar_e/ento() {
$/ista = '';
i>($_N65) {
i>(arra:_9e:_e?ists('/ista'$ $_N65)) {
$/ista = $_N65E'/ista'F;
}
}
return $/ista;
}
$evolviendo as09 el evento capturado a travs de la variable LZvistaM.
%on el evento Len la manoM9 se ocupar ahora de identi'icar el modelo:
function identi>icar_mode"o($/ista) {
i>($/ista) {
s8itch ($/ista) {
case '/ista_#'1
$mode"o = '(ode"oUno';
brea9;
case '/ista_2'1
$mode"o = '(ode"o'os';
brea9;
default1
e?it();
}
}
return $mode"o;
}
#<
=egundo pasoF invocar al modelo e'ectuando los cambios adecuados
<uestro controlador9 "a sabe a que modelo recurrir. Ahora9 solo resta invocarlo "
modi'icarlo si es necesario:
function in/ocar_mode"o($mode"o) {
i>($mode"o) {
reDuire_once('mode"s;php');
$data = new $mode"o();
sett:pe($data$ 'arra:');
return $data;
}
#las modi%icaciones al modelo se har2an aqu2
}
2ercer pasoF enviar la in'ormaci(n a la vista
Ainalmente9 nuestro controlador9 enviar la in'ormaci(n obtenida del modelo9 a la vista.
.ara hacerlo9 utiliHar una 'unci(n donde preparar esta in'ormaci(n para al 'in enviarla:
function en/iar_data() {
$/ista = capturar_e/ento();
i>($/ista) {
$mode"o = identi>icar_mode"o($/ista);
i>($mode"o) {
$data = in/ocar_mode"o($mode"o);
i>($data) {
reDuire_once('/ie8;php');
render_data($/ista$ $data);
}
}
}
}
!l controlador9 solo deber llamar a su propia 'unci(n enviar;data)* " la vista
automticamente9 estar en condiciones de mostrar los resultados en pantalla al usuario:
en/iar_data();
,i el usuario ingresara en la ?R@ http://servidor/controller.php no ver nada en pantalla.
,i ingresara en http://servidor/controller.phpvista[vista;1 ver lo siguiente:
Ahora9 es momento de autoFevaluar lo que hemos aprendido " luego9 completar nuestro
primer ejemplo para 'inaliHar nuestro aprendiHaje.
#@
Ejercicios Prcticos
Geamos cuanto aprendimos sobre los cap0tulos 666 " 6G.
Ejercicio N(: $onceptos de *r&uitectura% 56$ 7 P-P
(.1) Qu es 56$"
a) Un patrn de diseo
b) Un patrn arquitectnico
c) Un paradigma de programacin
d) Un estilo arquitectnico
(.#) $ul de las siguientes opciones% corresponde a atributos de
calidad impl,citos en la ar&uitectura de so't8are"
a) Polimorfismo, ,erencia, encapsulamiento " disponibilidad
b) Herencia, abstraccin, seguridad " aislamiento
c) 3isponibilidad, funcionalidad, seguridad, interoperabilidad "
portabilidad
d) 4odas las anteriores
(.() 9ndica 6 :;erdadero) o ) :'also) seg<n corresponda
a) 5 6 Un patrn arquitectnico es el encargado de describir la
arquitectura general de un sistema
b) 5 6 Un patrn arquitectnico representa una plantilla de construccin
que pro$ee un conunto de subsistemas " su forma de organi2acin
c) 5 6 (stilo arquitectnico " patrn arquitectnico son dos ni$eles de
abstraccin diferentes de la arquitectura de software
d) 5 6 (n %&C, el modelo es un intermediario entre la $ista " el
controlador
",
e) 5 6 (n %&C el controlador es el encargado de capturar los e$entos
del usuario
f) 5 6 (n %&C es recomendable me2clar cdigo PHP " H4%L
g) 5 6 Una interface en PHP es lo mismo que una clase abstracta
,) 5 6 Las clases abstractas en PHP cuplen la misma funcin que las
interfaces
i) 5 6 Una interface solo debe declarar los m!todos pero !stos, no
deben estar codificados
) 5 6 Las propiedades declaradas en las interfaces deben tener
$isibilidad pblica
(.1) $ul de las siguientes a'irmaciones es ;erdadera"
a) Las interfaces no pueden definir propiedades
b) 4odos los m!todos declarados en una interface deben ser pblicos
c) Las interfaces no pueden instanciarse porque no tienen referencias
asociadas a obetos
d) Las interfaces no pueden tener m!todos definidos con su algoritmo
correspondiente
e) 4odas las opciones son correctas
(.=) En 56$% el usuario reali>a una peticin 7 el 4444444444444
captura el e;ento% identi'icando el 4444444444444 al &ue debe
in;ocar 7 al cual reali>ar las modi'icaciones. +uego% en;,a esta
in'ormacin a 4444444444444.
"
Ejercicio N1: ?e;isando cdigo
1.1) $ul de las siguientes declaraciones es incorrectas"
a) class Naseosa extends Cebida implements Producto$ Cebida4in*"coho"
b) class Naseosa extends Cebida4in*"coho"$ CebidaNasi>icada implements Cebida$
Producto
d) class Naseosa implements Cebida
1.#) $ul es el error del siguiente cdigo"
interface Producto { }
class Producto implements Producto { }
a) La clase no puede tener el mismo nombre que la interface
b) Ni la clase ni la interface tienen cdigo
c) No ,a" errores
1.() $ul es el error en el siguiente cdigo"
interface Producto { }
class Cebida extends Producto { }
a) Ni la clase ni la interface tienen cdigo
b) 3onde utili2a 7e8tends7 deber'a utili2ar 7implements7
c) No ,a" errores
"&
.oluciones a los ejercicios ? y @
Ejercicio 12?
Pregunta $.F respuesta b
Pregunta $.&F respuesta c
Pregunta $.$F
A B + 8 E . O ! I S
*erdadera J J J J
.alse J J J J J J
Pregunta $.#F respuesta e
Pregunta $."F
!n #G%9 el usuario realiHa una petici(n " el controlador captura el evento9 identi'icando el modelo al que
debe invocar " al cual realiHar las modi'icaciones. @uego9 env0a esta in'ormaci(n a la vista.
Ejercicio 12@
Pregunta #.F respuesta b
Pregunta #.&F respuesta a
Pregunta #.$F respuesta c
"$
Programacin Real !on el patrn M!
Gamos a retormar ahora9 nuestro ejemplo del AB) de usuarios que
comenHamos a programar en el cap0tulo 66. .rocederemos a ampliarlo "
adaptarlo9 seguiendo la estructura del patr(n #G%.
Ntese ue los m%todos respectivos ,an sido resumidos no encontrndose en %stos$
extensos algoritmos de validacin de datos. 1e e!emplifica todo auello ue es relevante
en la &22 ba!o el el patrn aruitectnico 56+.
Estructura de directorios
Na estamos en una etapa ms avanHada9 donde no basta con crear archivos. <uestro
primer ejemplo de Vprogramaci(n realV del cap0tulo 669 ser ampliadoR agregaremos ms
archivos " se hace necesario organiHarlos de 'orma tal9 que pueda respetarse la sencilleH
" los bene'icios que el patr(n #G% nos brinda.
Es necesario (ue tengamos en cuenta/ (ue -O =IE)P'E la estructura C organizacin
de directorios C archi0os puede predecirse. Por el contrario/ a medida (ue una
aplicacin a0anza/ =IE)P'E es recomendable re1actorizar el cdigo al mismo ritmo
(ue el sistema e0oluciona.
.or eso9 no se debe tener miedo de comenHar programando con grandes estructuras de
c(digo " hasta incluso9 por qu no9 VdesprolijasV.
Piensa en cuando 0as al supermercado. 'ealizas las compras de todo lo
(ue necesitas C las lle0as a tu casa en bolsas C generalmente/ con la
mercader4a desorganizada. Pero tienes todo lo (ue necesitas. Lna
0ez (ue lo tienes/ comienzas a organizarlo. Ouardar%s los alimentos
(ue re(uieran re1rigeracin/ en la heladeraT los congelados en el
1reezerT los art4culos de tocador en tu 9+T etc.
<o se debe tener miedo de agilizar la ar(uitectura de so1tKare " pensarla
adaptati0amente. N aqu09 es donde debemos considerar9 la metodolog0a que
utiliHaremos para gestionar nuestro pro"ecto.
?na de las prcticas tcnicas propuesta por E7treme Programming9 nos induce a realiHar
una re'actoriHaci(n constante del c(digo9 algo que9 desde mi punto de vista9 nos dar
mejores resultados a la hora de pensar una arquitectura adecuada.
@a siguiente estructura de directorios que propondr para adaptar nuestro ejemplo9
puede servir de punto de partida para la arquitectura de una aplicaci(n compleja de gran
robusteH.
%omenHaremos entonces9 por crear la siguiente estructura de directorios:
"#
coreF
el prop(sito de este directorio9 ser almacenar todas aquellas clases9 ,elpers9 utils9
decorators9 etc9 que puedan ser reutiliHados en otros m(dulos de la aplicaci(n )aqu0 solo
crearemos el de usuarios*9 es decir9 todo aquello que pueda ser considerado Ln7cleoM del
sistema.
siteEmediaF
ser el directorio e8clusivo para nuestros diseEadores. !n l9 organiHadmente9 nuestros
diseEadores podrn trabajar libremente9 creando los archivos estticos que la aplicaci(n
requiera.
usuariosF
ste9 ser el directorio de nuestro m(dulo de usuarios. !n l9 almacenaremos los archivos
correspondientes al modelo9 la l(gica de la vista " el controlador9 e8clusivos del m(dulo de
usuarios.
>ajo el supuesto de que los modelos $>Abstract#odel " ?suario se conservan "9
simplemente a modo de ejercicio Gen (uB directorio crees (ue se deber4a almacenar
cada uno de estos dos modelosH
Arc3ivos del Modelo
@os archivos de nuestro VmodeloV9 sern ahora nuestros viejos db1abstract1model'php "
usuarios1model'php a los cuales9 haremos algunas modi'icaciones.
Arc3ivo ;TcoreTdb_abstract_mode";php
#odi'icaciones incorporadas
/. Agregaremos la propiedad $mensa,e9 a 'in de que el objeto9 pueda comunicarse a
travs de mensajes con el resto de la aplicaci(n.
1. !l mtodo e?ecute_sin."e_Duer:() incorporar una validaci(n que solo
permitir proceder con sus 'unciones9 si recibe sus parmetros a travs variables
$_P345.
%(digo 'uente del archivo
<=php
abstract class 'C*bstract(ode" {
private static $db_host = '"oca"host';
private static $db_user = 'usuario';
private static $db_pass = 'contrase!a';
protected $db_name = 'm:db';
protected $Duer:;
protected $ro8s = arra:();
private $conn;
public $mensa,e = '+echo';
# mtodos abstractos para )*M de clases que hereden
abstract protected function .et();
abstract protected function set();
abstract protected function edit();
abstract protected function de"ete();

# los siguientes mtodos pueden de%inirse con e+actitud y
# no son abstractos
""
# "onectar a la base de datos
private function open_connection() {
$this->conn = new m:sD"i(self11$db_host$ self11$db_user$
self11$db_pass$ $this->db_name);
}
# !esconectar la base de datos
private function c"ose_connection() {
$this->conn->c"ose();
}
# Ejecutar un query simple del tipo ,-E./, !E0E/E, 1P!)/E
protected function e?ecute_sin."e_Duer:() {
i>($_P345) {
$this->conn->Duer:($this->Duer:);
} e"se {
$this->mensa,e = '(etodo no permitido';
}
}
# /raer resultados de una consulta en un )rray
protected function .et_resu"ts_>rom_Duer:() {
$resu"t = $this->conn->Duer:($this->Duer:);
8hi"e ($this->ro8sEF = $resu"t->>etch_assoc());
$resu"t->c"ose();
arra:_pop($this->ro8s);
}
}
=>
Arc3ivo ;TusuariosTmode";php
#odi'icaciones incorporadas
/. !l nombre del archivo cambia a model.php.
1. ,e agrega una emisi(n de mensaje por cada acci(n conclu"ente de cada uno de los
mtodos
B. ,in in'luencia prctica9 el mtodo constructor aparece debajo de los mtodos
propios de la clase )una simple cuesti(n organiHativa*
%(digo 'uente del archivo
<=php
# ,mportar modelo de abstracci4n de base de datos
reDuire_once(';;TcoreTdb_abstract_mode";php');
class Usuario extends 'C*bstract(ode" {
############################### P.5P,E!)!E- ################################
public $nombre;
public $ape""ido;
public $emai";
private $c"a/e;
protected $id;
"6

################################# M6/5!5- ##################################
# /raer datos de un usuario
public function .et($user_emai"='') {
i>($user_emai" G= '') {
$this->Duer: = H
46I6)5 id$ nombre$ ape""ido$ emai"$ c"a/e
-J3( usuarios
H;
$this->.et_resu"ts_>rom_Duer:();
}
i>(count($this->ro8s) == #) {
>oreach ($this->ro8sE@F as $propiedad=>$/a"or) {
$this->$propiedad = $/a"or;
}
$this->mensa,e = 'Usuario encontrado';
} e"se {
$this->mensa,e = 'Usuario no encontrado';
}
}
# "rear un nue$o usuario
public function set($user_data=arra:()) {
i>(arra:_9e:_e?ists('emai"'$ $user_data)) {
$this->.et($user_dataE'emai"'F);
i>($user_dataE'emai"'F G= $this->emai") {
>oreach ($user_data as $campo=>$/a"or) {
$$campo = $/a"or;
}
$this->Duer: = H
2&46J5 2&53 usuarios
(nombre$ ape""ido$ emai"$ c"a/e)
L*IU64
('$nombre'$ '$ape""ido'$ '$emai"'$ '$c"a/e')
H;
$this->mensa,e = 'Usuario a.re.ado e?itosamente';
} e"se {
$this->mensa,e = '6" usuario :a e?iste';
}
} e"se {
$this->mensa,e = '&o se ha a.re.ado a" usuario';
}
}
# Modi%icar un usuario
public function edit($user_data=arra:()) {
>oreach ($user_data as $campo=>$/a"or) {
$$campo = $/a"or;
}
$this->Duer: = H
UP'*56 usuarios
465 nombre='$nombre'$
ape""ido='$ape""ido'
K+6J6 emai" = '$emai"'
H;
$this->mensa,e = 'Usuario modi>icado';
}
";
# Eliminar un usuario
public function de"ete($user_emai"='') {
$this->Duer: = H
'6I656 -J3( usuarios
H;
$this->mensa,e = 'Usuario e"iminado';
}
# Mtodo constructor
$this->db_name = 'boo9_e?amp"e';
}
# Mtodo destructor del objeto
unset($this);
}
}
=>
Arc3ivos de la =ista
!n esta etapa9 crearemos los archivos correspondientes a la I?6 " su l(gica.
@os primeros9 sern los archivos que crearn nuestros diseEadores )3 archivos 2D#@ " /
archivo %,,9 que se e8pondrn a modo prctico9 sin nimo de servir de ejemplo como
inter'aces gr'icas*.
@a l(gica de la vista9 estar en nuestras manos.
+omencemos.
Arc3ivos de la A5*
Recordemos que se trataba de un A># de ?suarios9 donde ten0amos la posibilidad de:
#ostrar los datos de un usuario
Agregar un nuevo usuario
#odi'icar un usuario e8istente
!liminar un usuario de la base de datos
Dodos estos archivos9 se almacenarn en nuestro directorio esttico site_media.
%rearemos una plantilla 2D#@ general9 cuatro plantillas de 'ormularios " un archivo %,,.
@os 3 primeros se almacenarn en ;Tsite_mediaThtm"T con el pre'ijo usuario_ que
identi'icar el m(dulo )tambin podr0an almacenarse en un subdirectorio llamado
usuario. !so lo dejo a vuestra libre elecci(n*. !l archivo %,,9 l(gicamente se almacenar
en ;Tsite_mediaTcssT.
"<
Archivo ;Tsite_mediaThtm"Tusuario_temp"ate;htm"
)plantilla 2D#@ general*
<html "an.=HesH>
<head>
<"in9 re"=Hst:"esheetH t:pe=Hte?tTcssH
hre>=HTm/cTsite_mediaTcssTbase_temp"ate;cssH>
<tit"e>*C( de Usuarios1 {subtitu"o}<Ttit"e>
<Thead>
<bod&>
<div id=HcabeceraH>
<h(>*dministrador de usuarios<Th(>
<h+>{subtitu"o}<Th+>
<Tdiv>
<div id=HmenuH>
<a hre>=HTm/cT{L26K_465_U46J}H tit"e=H&ue/o usuarioH>*.re.ar usuario<Ta>
<a hre>=HTm/cT{L26K_N65_U46J}H tit"e=HCuscar usuarioH>CuscarTeditar
usuario<Ta>
<a hre>=HTm/cT{L26K_'6I656_U46J}H tit"e=HCorrar usuarioH>Corrar
usuario<Ta>
<Tdiv>
<div id=Hmensa,eH>
{mensa,e}
<Tdiv>
<div id=H>ormu"arioH>
{>ormu"ario}
<Tdiv>
<Tbod&>
<Thtml>
.or 'avor9 obsrvese que en este archivo9 se debern reemplaHar dinmicamente: el
subt0tulo del m(dulo )mtodo*9 las ?R@ de los enlaces de las vistas9 el mensaje emitido
por el sistema " el 'ormulario correspondiente al mtodo/vista solicitado por el usuario.
Archivo ;Tsite_mediaThtm"Tusuario_a.re.ar;htm"
)'ormulario para agregar un nuevo usuario*
<form id=Ha"ta_usuarioH action=H{465}H method=HP345H>
<div c"ass=Hitem_reDueridH>6-mai"<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hte?tH name=Hemai"H
id=Hemai"H><Tdiv>
<div c"ass=Hitem_reDueridH>)"a/e<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hpass8ordH name=Hc"a/eH
id=Hc"a/eH><Tdiv>
<div c"ass=Hitem_reDueridH>&ombre<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hte?tH name=HnombreH
id=HnombreH><Tdiv>
<div c"ass=Hitem_reDueridH>*pe""ido<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hte?tH name=Hape""idoH
id=Hape""idoH><Tdiv>
<div c"ass=H>orm_buttonH><input t:pe=HsubmitH name=Hen/iarH
id=Hen/iarH /a"ue=H*.re.arH><Tdiv>
<Tform>
<(tese que este archivo no posee datos dinmicos que deban ser reemplaHados.
"@
Archivo ;Tsite_mediaThtm"Tusuario_borrar;htm"
)'ormulario para eliminar un usuario identi'icado por su eFmail*
<form id=Ha"ta_usuarioH action=H{'6I656}H method=HP345H>
id=Hemai"H><Tdiv>
id=Hen/iarH /a"ue=H6"iminarH><Tdiv>
<Tform>
<(tese que al igual que el archivo anterior9 ste9 tampoco contiene datos dinmicos que
deban ser reemplaHados.
Archivo ;Tsite_mediaThtm"Tusuario_buscar;htm"
)archivo que permite buscar un usuario por su eFmail para luego mostrarlo en el
'ormulario de edici(n9 "a sea para editarlo o solo para ver sus datos*
<form id=Ha"ta_usuarioH action=H{N65}H method=HN65H>
id=Hemai"H><Tdiv>
<div c"ass=H>orm_buttonH><input t:pe=HsubmitH
id=Hen/iarH /a"ue=HCuscarH><Tdiv>
<Tform>
<(tese que al igual que los dos archivos anteriores9 ste9 tampoco contiene datos
dinmicos que deban ser reemplaHados.
Archivo ;Tsite_mediaThtm"Tusuario_modi>icar;htm"
)archivo para visualiHar los datos de un usuario " modi'icarlos*
<form id=Ha"ta_usuarioH action=H{6'25}H method=HP345H>
id=Hemai"H /a"ue=H{emai"}H readon":><Tdiv>
<div c"ass=Hitem_reDueridH>&ombre<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hte?tH name=HnombreH
id=HnombreH /a"ue=H{nombre}H><Tdiv>
<div c"ass=Hitem_reDueridH>*pe""ido<Tdiv>
<div c"ass=H>orm_reDueridH><input t:pe=Hte?tH name=Hape""idoH
id=Hape""idoH /a"ue=H{ape""ido}H><Tdiv>
id=Hen/iarH /a"ue=HNuardarH><Tdiv>
<Tform>
.or 'avor9 n(tese que en este archivo debern reemplaHarse dinmicamente los datos
del usuario en los campos de 'ormulario correspondientes. Obsrvese que el campo
LemailM es de solo lectura.
Archivo ;Tsite_mediaTcssTbase_temp"ate;css
)hoja de estilos en cascada*
bod: {
mar#in1 @p? @p? @p? @p?;
bac%#round,color1 Y>>>>>>;
color1 YOOOOOO;
font,famil&1 sans-seri>;
font,si-e1 #2p?;
6,
}
Ycabecera {
paddin#1 Op? Op? Up? Op?;
bac%#round,color1 YOOPP--;
color1 Y>>>>>>;
}
Ycabecera h#$ h2 {
mar#in1 @p? @p? @p? @p?;
}
Ymenu {
bac%#round,color1 Y@@@@@@;
color1 Y>>>>>>;
paddin#1 Qp? @p? Qp? @p?;
}
Ymenu a {
width1 #@@p?;
paddin#1 Qp? Up? Qp? Up?;
color1 Y>Q>Q>Q;
text,decoration1 none;
font,si-e1 #Rp?;
font,wei#ht1 bo"d;
}
Ymenu a1ho/er {
color1 Y>>>>>>;
}
Ymensa,e {
mar#in1 2@p?;
border1 #p? so"id YPP@@RR;
bac%#round,color1 Y>Q>Q>Q;
paddin#1 Up?;
color1 YPP@@RR;
font,si-e1 #p?;
font,wei#ht1 bo"d;
text,ali#n1 ,usti>:;
}
Y>ormu"ario {
mar#in1 @p? 2@p? #@p? 2@p?;
border1 #p? so"id Yc@c@c@;
bac%#round,color1 Y>P>P>P;
paddin#1 Up?;
text,ali#n1 left;
}
;item_reDuerid {
width1 #@p?;
hei#ht1 22p?;
paddin#,ri#ht1 Qp?;
font,wei#ht1 bo"d;
float1 left;
clear1 left;
text,ali#n1 ri#ht;
}
6
;>orm_reDuerid {
hei#ht1 22p?;
float1 left;
clear1 ri#ht;
}
input {
border1 #p? so"id Yc@c@c@;
}
;>orm_button {
paddin#,top1 #p?;
mar#in,left1 #Qp?;
clear1 both;
}
Yen/iar {
paddin#1 p? #@p? p? #@p?;
border1 2p? so"id Y>>>>>>;
color1 Y>>>>>>;
font,famil&1 sans-seri>;
font,si-e1 #Qp?;
font,wei#ht1 bo"d;
cursor1 pointer;
}
Yen/iar1ho/er {
}
Arc3ivo ;TusuariosT/ie8;php
@(gica de la vista
<=php
$diccionario = arra:(
'subtit"e'=>arra:(L26K_465_U46J=>')rear un nue/o usuario'$
L26K_N65_U46J=>'Cuscar usuario'$
L26K_'6I656_U46J=>'6"iminar un usuario'$
L26K_6'25_U46J=>'(odi>icar usuario'
)$
'"in9s_menu'=>arra:(
'L26K_465_U46J'=>(3'UI3;L26K_465_U46J;'T'$
'L26K_N65_U46J'=>(3'UI3;L26K_N65_U46J;'T'$
'L26K_6'25_U46J'=>(3'UI3;L26K_6'25_U46J;'T'$
'L26K_'6I656_U46J'=>(3'UI3;L26K_'6I656_U46J;'T'
)$
'>orm_actions'=>arra:(
'465'=>'Tm/cT';(3'UI3;465_U46J;'T'$
'N65'=>'Tm/cT';(3'UI3;N65_U46J;'T'$
''6I656'=>'Tm/cT';(3'UI3;'6I656_U46J;'T'$
'6'25'=>'Tm/cT';(3'UI3;6'25_U46J;'T'
)
);
function .et_temp"ate($>orm='.et') {
$>i"e = ';;Tsite_mediaThtm"Tusuario_';$>orm;';htm"';
$temp"ate = >i"e_.et_contents($>i"e);
return $temp"ate;
}
6&
function render_dinamic_data($htm"$ $data) {
>oreach ($data as $c"a/e=>$/a"or) {
$htm" = str_rep"ace('{';$c"a/e;'}'$ $/a"or$ $htm");
}
return $htm";
}
function retornar_/ista($/ista$ $data=arra:()) {
."oba" $diccionario;
$htm" = .et_temp"ate('temp"ate');
$htm" = str_rep"ace('{subtitu"o}'$ $diccionarioE'subtit"e'FE$/istaF$
$htm");
$htm" = str_rep"ace('{>ormu"ario}'$ .et_temp"ate($/ista)$ $htm");
$htm" = render_dinamic_data($htm"$ $diccionarioE'>orm_actions'F);
$htm" = render_dinamic_data($htm"$ $diccionarioE'"in9s_menu'F);
$htm" = render_dinamic_data($htm"$ $data);
// render 7mensaje8
i>(arra:_9e:_e?ists('nombre'$ $data)XX
arra:_9e:_e?ists('ape""ido'$ $data)XX
$/ista==L26K_6'25_U46J) {
$mensa,e = '6ditar usuario ';$dataE'nombre'F;' ';$dataE'ape""ido'F;
} e"se {
i>(arra:_9e:_e?ists('mensa,e'$ $data)) {
$mensa,e = $dataE'mensa,e'F;
} e"se {
$mensa,e = ''atos de" usuario1';
}
}
$htm" = str_rep"ace('{mensa,e}'$ $mensa,e$ $htm");
print $htm";
}
=>
.or 'avor9 n(tese que este archivo9 utiliHa constantes. @as mismas9 " a 'in de otorgar
ma"or legibilidad " organiHaci(n al c(digo9 sern de'inidas en un archivo independiente
almacenado en ;TusuariosT9 llamado constants.php que ser e8puesto ms
adelante.
El controlador
Arc3ivo ;TusuariosTcontro""er;php
<=php
reDuire_once('constants;php');
reDuire_once('mode";php');
reDuire_once('/ie8;php');
function hand"er() {
$e/ent = L26K_N65_U46J;
$uri = $_46JL6JE'J6ZU645_UJ2'F;
$peticiones = arra:(465_U46J$ N65_U46J$ '6I656_U46J$ 6'25_U46J$
L26K_465_U46J$ L26K_N65_U46J$ L26K_'6I656_U46J$
L26K_6'25_U46J);
>oreach ($peticiones as $peticion) {
$uri_peticion = (3'UI3;$peticion;'T';
i>( strpos($uri$ $uri_peticion) == true ) {
6$
$e/ent = $peticion;
}
}
$user_data = he"per_user_data();
$usuario = set_ob,();
s8itch ($e/ent) {
case 465_U46J1
$usuario->set($user_data);
$data = arra:('mensa,e'=>$usuario->mensa,e);
retornar_/ista(L26K_465_U46J$ $data);
brea9;
case N65_U46J1
$usuario->.et($user_data);
$data = arra:(
'nombre'=>$usuario->nombre$
'ape""ido'=>$usuario->ape""ido$
'emai"'=>$usuario->emai"
);
retornar_/ista(L26K_6'25_U46J$ $data);
brea9;
case '6I656_U46J1
$usuario->de"ete($user_dataE'emai"'F);
retornar_/ista(L26K_'6I656_U46J$ $data);
brea9;
case 6'25_U46J1
$usuario->edit($user_data);
retornar_/ista(L26K_N65_U46J$ $data);
brea9;
default1
retornar_/ista($e/ent);
}
}
function set_ob,() {
$ob, = new Usuario();
return $ob,;
}
function he"per_user_data() {
$user_data = arra:();
i>($_P345) {
i>(arra:_9e:_e?ists('nombre'$ $_P345)) {
$user_dataE'nombre'F = $_P345E'nombre'F;
}
i>(arra:_9e:_e?ists('ape""ido'$ $_P345)) {
$user_dataE'ape""ido'F = $_P345E'ape""ido'F;
}
i>(arra:_9e:_e?ists('emai"'$ $_P345)) {
$user_dataE'emai"'F = $_P345E'emai"'F;
}
i>(arra:_9e:_e?ists('c"a/e'$ $_P345)) {
$user_dataE'c"a/e'F = $_P345E'c"a/e'F;
}
} e"se i>($_N65) {
i>(arra:_9e:_e?ists('emai"'$ $_N65)) {
$user_data = $_N65E'emai"'F;
}
6#
}
return $user_data;
}
hand"er();
=>
.or 'avor9 obsrvese que el controlador importa el archivo constants.php " utiliHa
constantes que sern de'inidas en dicho archivo )veremos ste ms adelante*.
.or otro lado9 el ,andler del controlador9 maneja las peticiones del usuario sobre la base
de la ?R6 detectada. !ste ejemplo9 maneja L?R@ amigablesM )friendly url*9 que sern
tratadas ms adelante9 con'igurando las mismas en el archivo .htaccess de la
aplicaci(n.
Arc3ivos de coniguraci$n co!ple!entarios
Arc3ivo ;TusuariosTconstants;php
!ste archivo contiene todas las constantes del m(dulo " no se le deber0a agregar ning7n
dato que no 'uese una constante.
<=php
const (3'UI3 = 'usuariosT';
# controladores
const 465_U46J = 'set';
const N65_U46J = '.et';
const '6I656_U46J = 'de"ete';
const 6'25_U46J = 'edit';
# $istas
const L26K_465_U46J = 'a.re.ar';
const L26K_N65_U46J = 'buscar';
const L26K_'6I656_U46J = 'borrar';
const L26K_6'25_U46J = 'modi>icar';
=>
Arc3ivo ;htaccess
Agregar al archivo ;htaccess de la aplicaci(n9 las siguientes l0neas:
Je8rite6n.ine on
Je8riteJu"e [usuariosT usuariosTcontro""er;php
<(tese que dependiendo del directorio ra0H de la aplicaci(n9 probablemente se deba
modi'icar la l0nea Je8riteJu"e [usuariosT usuariosTcontro""er;php
6"
#ota $inal
2emos llegado al 'inal de este libro. !spero que todo lo aqu0 e8puesto9 les ha"a sido de
utilidad " los invito a hacerme llegar sus dudas9 sugerencias " comentarios atravs de mi
eFmail o visitando la p%gina del libro:
http://eugeniabahit.blogspot.com/1:///:&/pooF"FmvcFenFphp.html
>Oracias por el tiempo (ue han dedicado?
>U7itos en tu carrera?
66

Modelo Vista Control Ad or

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Modelo Vista Control Ad or

Uploaded by

Copyright:

Available Formats

POO y MVC en PHP

El paradigma de la Programacin Orientada a Objetos en

" .oros8el9eb.com " en

POO y MVC en PHP + E"!enia Ba,it

You might also like