Saludos para todas.
Espero de corazón que estén descansando mucho en estos días que se acercan las navidades.
Bueno siguiendo con mi intensión de escribir un poco sobre el lenguaje de programación PHP y con la intención de desmentir a esos personajes que se atribuyen el trabajo de otro como propio y gozan de un reinado hecho de puro lobby, lamería, palancas y pura suerte, aquí les coloco una clase en que he hecho PHP hace como tres años, basándome en mi otra clase de ConexionBaseDatos.java, la cual por cierto, ha tenido mucha acogida por los estudiantes de una universidad donde trabajo. He caso es que he diseñando esta clase inicialmente con el fin de facilitarles el trabajo de conexión a los SMBD (Sistemas manejadores de Base de Datos) desde el lenguaje de programación Java, pues he notado que el concepto de arquitectura JDBC (Java Data Base Connection) no es tan simple de entender y mucho menos de explicar, mas aun cuando no se tienen los la fundamentación y las buenas prácticas de programación necesarias para enseñar y aprender estos temas, lo importantes es que comprendamos que nuestro conocimiento sobre las cosas va evolucionado a medida que aumentemos nuestro interés por la lectura, investigación documental, la práctica y el análisis comparativo que realicemos sobre las cosas que conocemos y queremos aprender, esto aplica muchísimo y es supremamente fundamental más en nuestra carrera.
Buscando ganar para PHP el mismo objetivo he alcanzado con éxito al diseñar una clase ConexionBaseDatos para Java, hace tres años hice lo mismo con PHP, como verán no es nada del otro mundo, nada que una persona que estudie el desarrollo de software no pueda realizar, solo hay que organizar las ideas y los conocimientos ya adquiridos y comenzar a utilizarlos para nuestro beneficio.
Partes de la clase ManejadorBaseDatos.php
Cuerpo de la clase
1
2
3
4
5
6
7
8
9
10
11
12
| class ManejadorBasedatos { // inicio de la clase
// Propiedades o variableesGoblaes de objetos y de clase
// Patrón de Diseño Singleton
// Métodos o Funciones Constructores
// Método o Función Conectar
// Método o Función Desconectar
// Método o Función Modificar
// Método o Función Consultar
// Método o Función hayFilas
// Métodos o Funciones get y set
} // fin de la clase
?> // fin del script PHP |
A continuación Mostrare y explicara cada parte
Propiedades de la clase
1
2
3
4
5
| class ManejadorBasedatos{
private static $unico_objeto; // variable para el patrón de diseño singleton
private $conn; // variable para que referencia a la conexión con el SMBD
private $rst; // variable que referencia hacia al último resultado de una consulta ejecutada sobre el SMBD
?> |
Constructor de la clase
1
| private function __construct(){ } |
Como pueden notar el constructor es privado y no es público, como la mayoría de constructores que ustedes están a acostumbrados a utilizar.
¿Cómo puedo crear un objeto fuera de esta clase si el constructor privado? ¿Será que el profe John Arrieta se está volviendo medio loco?, …
Bueno el no es que el profe este muy cuerdo que digamos, pero esto de hacer un constructor privado sí que lo me eta preocupando.
Señores no estoy loco, locos los que dicen ser ingenieros de software, disque enseñan programación orientada a objetos y un poco de cosas más, sin tener meritos académicos, ni experiencia y sobre todo lo que da más risa es ver como se creen más que cualquiera de nosotros, camina, miran y se expresan con una grandeza única, yo diría que una grandeza invisible, porque todos sabemos muy bien que de grande no tienen ni su estatura, jajaja.
Caramba, que me pasa, mil disculpas, mil disculpas a todos los que me están leyendo, les confieso que tengo estados en que me pongo a pensar cosas y las escribo sin darme cuenta, será que no me tome la pastilla esta mañana, nuevamente mil disculpas, ahora soy yo quien se está preocupando, jajaja mentiras, estoy mamando gallo.
La idea intencional de hacer el constructor privado es justamente para eso que ustedes están pensando, no que yo estoy loco, no, eso no, es para evitar que se puedan crear objetos de esta clase en cualquier lugar fuera de su propia clase, si hago privado al constructor, absolutamente nadie puede hacer por ejemplo esto:
Supongamos que estamos haciendo una agenda electrónica Web y utilizamos PHP como lenguaje de programación, entonces tendremos un directorio raíz llamado agenda, dentro de este directorio tenemos tres directorios mas, uno llamado modelo, donde se encuentra una clase llamada Persona, la cual tiene toda la logia de persistencia para poder almacenar, eliminar, modificar, consultar, realizar listas y operaciones estadísticas sobre las personas que se encuentran en nuestra agenda electrónica, otro directorio llamado web, donde se encuentran las paginas que el usuario utilizara para insertar, modificar, eliminar, consultar y ver reportes sobre las personas, un último directorio llamado control, donde se encuentra dos clase una llamada ControlPersonas la cual se dedica a servir de intermediario entre las operaciones que solicita el usuario desde las páginas Web y las funciones de persistencia y lógica de personas, lógica escrita en la clase Persona de la carpeta modelo y un archivo más llamado ManejadorBaseDatos que tendrá la clase que estoy explicando en este articulo.
Si quisiéramos insertar una nueva persona dentro de la agenda, podríamos hacer esto desde la case ControlPersonas
Guardado en un directorio llamado cotrol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| include_once("../modelo/Persona.php");
class ControlPersona {
public function registrarPersona(){
//recuperar los datos que vienen de la pagina web/registrar_persona.php
$cedula = $_REQUEST["cedula"];
$nombre = $_REQUEST["nombre"];
$apellidos = $_REQUEST["apellidos"];
$telefono = $_REQUEST["telefono"];
$direccion = $_REQUEST["direccion"];
Persona $objPersona = new Persona();
$objPersona->setCedula($cedula);
$objPersona->setNombre($nombre);
$objPersona->setApellido($apellido);
$objPersona->setTelefono($telefono);
$objPersona->setDireccion($direccion);
try{
$objetoPersona->registrar();
}
catch( Exception $error){
header("Location: ../web/mesaje.php?msg=".$error->getMessage()."&volver=registrar_persona.html");
exit();
}
}
}
?> |
Ahora veamos lo que no podríamos hacer en dentro de la clase Persona, porque el ZENDCompilarPHP o interprete de PHP nos emitiría un error,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| // Guardado en el directorio modelo
class Persona {
// propiedades
private $cedula;
private $nombre;
private $apellido;
private $telefono;
private $direccion;
public function __construct( ){
}
// set y get
// ....
public function registrar( ){
$sql_insert = "INSERT INTO Personas
VALUES ('$this->cedula', '$this->nombre', '$this->apellido', '$this->telefono', '$this->dierccion')";
/**
LA SIGUEINTE INSTRUCCION MOSTRAR EL SIGUIENTE ERROR
Fatal error: Call to private ManejadorBasedatos::__construct() from context 'Persona' in C:\xampp\htdocs\agenda\modelo\Persona.php ...
porque el constructor de nuestra clase ManejadorBasedatos lo he hecho privado
*/
$basedatos = new ManejadorBaseDatos(); // no se puede porque es privado
//... siguientes instrucciones...
}
}
?> |
Comprendido lo anterior automáticamente nos nace una pregunta.
¿Entonces Cómo podemos crear un objeto de la clase ManejadorBaseDatos para ser utilizado en otras clases?
Esta respuesta podría hacer de muchas manera, una de ellas podría ser:
- Declarando una variable static de la clase ManejadorBaseDatos dentro de ella misma
- Haciendo un método estatic que llamase a al constructor privado de la clase par que su valor sea asignado a la validable estática
- Retornado el valor de la variable stacti que es a su vez es un objeto de la clase ManejadorBaseDatos
1
2
3
4
5
| class ManejadorBaseDatos { // inicio de la clase
// Propiedades o variableesGoblaes de objetos y de clase
private static $objeto;
private function __construct(){
} |
1
2
3
4
5
6
7
8
| public static function getObjeto()
{
self::$objeto = new self;
return self::$objeto;
}
}
?> |
Así quedaría entonces el código de la función registrar de la clase Persona
1
2
3
4
5
6
7
| public function registrar( ){
$sql_insert = "INSERT INTO Personas
VALUES ('$this->cedula', '$this->nombre', '$this->apellido', '$this->telefono', '$this->dierccion')";
$basedatos = ManejadorBasedatos.getObjeto();
//... siguientes instrucciones...
}
} |
No hay que discutir el hecho de que esta solución no tendría ningún sentido, ya que no aporta nada nuevo, teniendo en cuenta que me evitaría todo esto simplemente haciendo el constructor público y listo, no seria para nada diferente.
El patrón de Diseño Singlton
Pero imaginemos que queremos evitar que en el programa se creer más de una un objeto (en Orientación a objetos, Instancia es lo mismo que Objeto, son palabras sinónimas) al mismo tiempo, es decir que no existan dos objetos del tipo ManejadorBasedatos de forma concurrente en la memoria asignada, algo muy útil en este caso, ya que al crear más de un objeto ManejadorPersonas al mismo tiempo, estamos realizando al mismo tiempo múltiples conexiones al SMBD, por operación realizada por el usuario de nuestra agenda, como consecuencia:
- Podríamos agotar la memoria que el SO le asigna a nuestro programa, por ende
- En programa quedaría suspendió o lo que se conoce como bloqueado
- El sistema operativo podría bloquearse si el programa exige más uso de memoria y el sistema operativo llegase a entregársela.
- El SMBD podría quedar en suspenso si el numero conexiones sobrepasa el valor soportado o simplemente por seguridad rechaza las mas conexiones, dejando a nuestro programa fuera.
Para poder lograr esto, podemos verificar si la variable static objeto ya tiene un valor asignado previamente, si esto es falso, es porque nuestro programa no había llamado antes a la función getObjeto, entonces llamamos al constructor y la instancia que este crea se la asignamos a la variable static objeto retornando su valor. Si por el contrario, la variable static objeto ya tiene un valor asignado, es porque la nuestro programa ya había creado llamado a la función getObjeto, creándose un nueva instancia de la clase ManejadorBasedatos, entonces devolvemos el valor que esta variable ya tenía, de esta manera nunca se podría crear más de una instancia del la clase ManejadorBasedatos, porque al momento de crear se verifica si ya se había creado uno antes, si es asi se devuelve el objeto ya creado, si no es asa se crea uno nuevo.
Esta técnica que permite crear una sola instancia de objetos de una clase especifica se le conoce como Singleton, el cual es un patrón de diseño de software y hace parte de los patrones de diseño de creación, técnicas que fueron diseñadas, probadas y puestas en práctica por muchas personas, aun no se sabe quién es el verdadero idealista de estas técnicas, puesto que son soluciones comunes a las que muchas programados han llegado durante el desarrollo de sus proyectos, lo importante tener presente que fueron recopiladas y bien documentadas por un grupo de investigadores e ingenieros de software, conocidos como la pandilla de los cuatro, conformada por Erich Gamma, Richard Helm, Ralph Johnson y John Vlissides, los cuales escribieron un primer libro en 1995 que lleva como título “Patrones de diseño: Elementos de software orientado a objetos reutilizables” donde muestran muy detalladamente 23 patrones y sus posibles aplicaciones, si su deseo es convertirse en verdadero ingenieros de software y quieren que con el tiempo se les reconozca este merito y sean llamado como tal, les aseguro y recomiendo que leyéndose y poniendo en práctica este libro, ya están muy cerca de lograr su sueño, no como ciertos personajes que yo conozco, los cuales se vanaglorian autodenominándose disque ingenieros de software, les juro que si algún día llegasen a conocerlos, les va a dar es pura risa de lo payasos que son, payasos con suerte porque eso es lo que les sobra, suerte.
Así quedaría implementado el patrón de diseño Singleton en nuestra clase ManejadorBaseDatos.php.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| class ManejadorBaseDatos { // inicio de la clase
// Propiedades o variables Globales de objetos y de clase
private static $objeto;
private function __construct(){
}
public static function getObjeto()
{
if ( !self::$objeto instanceof self)
{
self::$objeto = new self; }
return self::$objeto;
}
}
?> |
1
2
3
4
| $basedatos = ManejadorBaseDatos::getObjeto( );
$basedatos->conectar();
// ....
$basedatos->conectar(); |
Como se puede apreciar, existen la posibilidad de crear más de una conexión al SBMD al mismo tiempo, aunque sea utilizando un único objeto ManejadorBaseDatos.
Para solucionarlo podemos hace lo siguiente:
Solución No.1
Dentro de la función conectar podemos verificar si hay o no hay conexión al SMBD, te tal forma que al ser llamada esta función realicemos las conexión so esta no existe o por el contra la evitamos si esta ya existe
1
2
3
4
5
6
7
8
| public function conectar( ){
if( $this->conn != NULL){
return;
}
else{
// realizar la conexion
}
} |
Solución No.2
- Hacemos la función conectar privada, de esa forma no se podrá utilizar fueran de la clase ManejadorBaseDatos.
- En la función getObjeto podemos verificar si no hay conexión, si es verdadero llamamos a la función conectar utilizando la variable static objeto y finalizamos retornado dicha variable con la conexión abierta;
- Si la conexión existe, entonces utilizamos la función mysql_ping( $conn ) para verificar si la aun la comunicación es posible con el SMBD, esta función recibe como argumento o parámetro variable $conn que tiene información sobre la ultima conexión realizada.
- Esta función devuelve verdadero si la conexión es buena y false si no lo es, en este último caso lanzamos una excepción o un error en tiempo de ejecución con nuestra propia información del error.
- Ppor último si todo va bien retornamos la variable objeto con la conexión abierta.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| public static function getUnicoObjeto()
{
if ( !self::$unico_objeto instanceof self)
{
self::$unico_objeto = new self;
}
if( $this->conn == NULL ){
self::$unico_objeto->conectar();
}
else if ( ! mysql_ping $this->con ) ) {
throw new Exception("Se ha perdido la conexion con al SMBD
Veritique que el Servidor este Iniciado
Mensaje: " . mysql_errno());
exit;
}
return self::$unico_objeto;
} |
A continuación les mostrare y explicare el resto de funciones conectar y el resto de funciones que conforman a la clase ManejadorBaseDatos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <?php
private function conectar() {
$this->conn = @mysql_connect("localhost","root","");
if( !$this->conn ){ // isset($this->conn) $this->conn == null
throw new Exception ("Error conectando a la base de datos ".mysql_errno());
}
$res = @mysql_select_db( "agendaphp",$this->conn ); // use agendaphp
if(!$res){
throw new Exception("Error seleccionando la base de datos
Codigo: ".mysql_errno()."
Mensaje: ".mysql_error());
}
}
?> |
La función de PHP mysql_connect( $pc_del_SMBD, $usuario_de_SMDB, $Pass) realiza la operación de conexión al SMBD que es este caso es MySQL Server, recibiendo como parámetros el nombre de red (conocido como dominio de red) o en su defecto la dirección IP del computador donde se encuentra corriendo y atendiendo peticiones el SMBD, luego sigue el nombre de un usuario registrado y con permisos de conexión al SMBD y por último la contraseña de de conexión de dicho usuario, esta función retorna un error si no se puede conectar por algún motivo y si todo va bien retorna información sobre la conexión yo la almaceno en la variable global $conn, la arroba en PHP absorbe los mensajes de error que ven directo a mostrar de forma desagradable en la página web del usuario, evitando que estos puedan ser visualizados.
}
1
2
3
4
| if( $this->conn == NULL){
throw new Exception ("Error conectando a la base de datos
Numero de Error: ".mysql_errno()." Mensaje: ". mysql_error());
} |
Lanza una excepción si $conn mysql_connect no se puedo conectar al SMDB
1
2
3
4
5
6
7
| $res = @mysql_select_db( "agendaphp",$this->conn ); // use agendaphp
if(!$res){
throw new Exception("Error seleccionando la base de datos
Error Numero. ",mysql_errno()."
Mensaje: ".mysql_error());
} |
Aquí se selecciona la base de datos sobre la cual deseamos trabajar una vez realizada de forma satisfactoria la conexión y lanzamos lanza una excepción si llegase a ocurrió un error al seleccionar la BD.
Función desconectar
1
2
3
4
5
6
7
8
9
10
| public function desconectar(){
if( isset( $this->rst ) ){
mysql_free_result( $this->rst );
}
if( isset( $this->conn ) ){
mysql_close( $this->conn );
unset( $this->conn ); // $this->conn = null;
unset( $this->rst ); // $this->rst = null;
}
} |
Primero liberamos e la memoria algún residuo de resultado si este existiera la conexión si esta existe nos luego desconectamos y hacemos cada variable NULL
1
2
3
4
5
6
7
8
9
10
11
12
13
| //Realiza una consulta con la conexion iniciada
public function consultar( $sql ){
if( !isset( $this->conn )){
$this->conectar();
}
$this->rst = @mysql_query( $sql, $this->conn);
if( !$this->rst ){
throw new Exception("ERROR: Al ejecutar la consulta...
Codigo: ".mysql_errno()." Explicacion: ".mysql_error());
}
return $this->rst;
} |
La instrucción $this->rst = @mysql_query( $sql, $this->conn); ejecuta instrucciones SQL sobre la BD seleccionada en la conexión al SMBD, y almacena el resultado en una variable global, retornando dicho resultado si no llegase a ocurrir ningún error durante la ejecución de la sentencia SQL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| public function modificar($sql){
$rst = mysql_query($sql,$this->conn);
if(!$rst){
if(mysql_errno() == 1062){
throw new Exception("La información a grabar ya existe
Error: ".mysql_errno($this->conn).
" Explicacion: ".mysql_error($this->conn));
}
throw new Exception("ERROR: al Ejecutar la Operacion...
Codigo: ".mysql_errno($this->conn).
" Explicacion: ".mysql_error($this->conn));
}
return $rst;
} |
Igual a la función consultar consular, poro en este caso se ejecutan una instrucción SQL del tipo UPDATE o INSERT o DELETE y si llegase a ocurrir un error y el error emitido por el SMBD es tiene el código 1062 se notifica al usuario una violación de restricción e clave primaria o clave única, es decir que se está insertando o modificando un valor duplicado en una columna con restricción de clave primaria o con restricción de único valo
1
2
3
4
5
6
7
8
9
10
| //retorna true si el resultado de la última consulta realizada tiene al menos una fila sin recorrer
public function hayFilas(){
if( !isset($this->rst) || empty($this->rst)|| mysql_num_rows($this->rst) == 0){
return false;
}
else{
return true;
}
} |
Retorna verdadero o falso si la variable global donde se almacena el resultado tiene al menos una fila sin recorrer.
Mi clase ManejadorBaseDatos completa
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
| class ManejadorBasedatos{
//objeto conexion
private static $objeto;
private $conn;
//objeto resulset
private $rst;
private function __construct(){
}
public static function getObjeto()
{
if ( !self::$objeto instanceof self)
{
self::$objeto = new self;
}
if( $conn == NULL){
self::$objeto->conectar();
}
else if (!mysql_ping($conn)) {
throw new Exception("Se ha perdido la conexion con al SMBD
Veritique que el Servidor este Iniciado
Mensaje: " . mysql_errno());
exit;
}
return self::$objeto;
}
//Inicia una conexion con el motor de base de datos
private function conectar() {
$this->conn = @mysql_connect("localhost","root","");
if( !$this->conn ){ // isset($this->conn) $this->conn == null
throw new Exception ("Error conectando a la base de datos eee.",mysql_errno());
}
$res = @mysql_select_db( "agenda",$this->conn ); // use agendaphp
if(!$res){
throw new Exception("Error seleccionando la base de datos.",mysql_errno()."
".mysql_error());
}
}
//cierra la conexion con el motor de base de datos
public function desconectar(){
if( isset( $this->rst ) ){
mysql_free_result( $this->rst );
}
if( isset( $this->conn ) ){
mysql_close( $this->conn );
unset( $this->conn ); // $this->conn = null;
unset( $this->rst ); // $this->rst = null;
}
}
//Realiza una consulta con la conexion iniciada
public function consultar( $sql ){
if( !isset( $this->conn )){
$this->conectar();
}
$this->rst = @mysql_query( $sql, $this->conn);
if( !$this->rst ){
throw new Exception("ERROR: Al ejecutar la consulta...
Codigo: ".mysql_errno()." Explicacion: ".mysql_error());
}
return $this->rst;
}
//Ejecuta un codigo SQL que realiza una modificacion sobre alguno
//de los registros de la Base de datos (insercion, modificacion, eliminacion)
public function modificar($sql){
$rst = mysql_query($sql,$this->conn);
if(!$rst){
if(mysql_errno() == 1062){
throw new Exception("La información a grabar ya existe
Codigo: ".mysql_errno($this->conn)."
Explicacion: ".mysql_error($this->conn));
}
throw new Exception("ERROR: al Ejecutar la Operacion...
Codigo: ".mysql_errno($this->conn)." Explicacion: ".mysql_error($this->conn));
}
return $rst;
}
//Obtiene el resulset
public function getResultado(){
return $this->rst;
}
//Devuelve un booleano que indica si los datos obtenidos como resultado de una consulta (resulset)
//contiene filas
public function hayFilas(){
if( !isset($this->rst) || empty($this->rst)|| mysql_num_rows($this->rst) == 0){
return false;
}
else{
return true;
}
}
}
?> |
Un ejemplo competo de su uso.
El código de la pagina Web agenda/index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Agenda PHP</title>
</head>
<body>
<div align="center"> ::: Agenda Electronica con PHP :::
<hr width="40%"/>
<p><a href="/agenda/web/registrar_persona.html">::: Resitrar una Nueva Persona :::</a></p>
</div>
</body>
</html> |
El código de la pagina Web agenda/web/registrar_persona.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| <html>
<head>
<meta http-equiv="Content-Language" content="es-co">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Registrar Nuevas Personas en Mi</title>
</head>
<body>
<p align="center"><font size="5">Registrar Nuevas Personas en Mi AgandaPHP</font></p>
<hr width="40%"/>
<form method="get" action="../control/ManejadorPersona.php">
<div align="center">
<table border="0" width="29%">
<tr>
<td width="88">Cedula:</td>
<td><input type="text" name="cedula" size="20"></td>
</tr>
<tr>
<td width="88">Nombres:</td>
<td><input type="text" name="nombre" size="20"></td>
</tr>
<tr>
<td width="88">Apellidos:</td>
<td><input type="text" name="apellido" size="20"></td>
</tr>
<tr>
<td height="26" width="88">Teléfono:</td>
<td height="26"><input type="text" name="telefono" size="20"></td>
</tr>
<tr>
<td height="26" width="88">Dirección:</td>
<td height="26"><input type="text" name="direccion" size="20"></td>
</tr>
<tr>
<td height="26" colspan="2">
<p align="center">
<input type="submit" value="Insertar" name="accion">
<input type="reset" value="Restablecer" >
</td>
</tr>
</table>
</div>
</form>
</body>
</html> |
Al pulsar en registrar estos datos son enviados al ManejadorPersona.php, el cual recupera la acción, luego llama a la función registrarPersona y esta a su vez recupera el resto de datos envidos por el formulario, por ultimo crea un objeto Persona seteandole (uso de los métodos set) los datos recuperados y llama a la función registrar de la clase Persona.
El método registrar de la clase persona arma una expresión SQL del tipo INSERT, cuyos datos son los datos seteados al objeto Persona, luego llama al Singleton de la clase ManejardorBaseDatos y obtiene un objeto de dicha clase, ejecuta la función modificar de ManejardorBaseDatos pasándole como parámetro la instrucción SQL.
El singleton de la clase ManejadorBaseDatos verifica si se creó o no un objeto anteriormente, devolviendo un nuevo objeto o el que ya se ha creado según sea el caso, se ejecuta la operación de inserción y se retorna el control al objeto Persona, está a su vez lo retorna al ManejadorPersonas y este redirección a la pagina mensaje enviándole una notificación de satisfacción.
Si el usuario intenta registrar otra persona con la misma cedula, el SMBD emite un error el cual es capturado por el método modificar del objeto ManejadorBaseDatos y lo lanza hacia el objeto Persona, quien lo captura y le adiciona más información, luego lo relanza al objeto ManejadorBaseDatos, este lo captura y redirección el control a la página mensaje.php, enviándole la información de error suministrada por el ManejadorBaseDatos y el objeto Persona, a demás le envía la ruta del enlace que va hacia atrás.
El código de la pagina Web agenda/web/mensaje.php
1
2
3
4
5
6
7
8
9
10
11
12
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title> ::: Operacion Realizada ::: </title>
</head>
<body>
<div align="center"><%= $_REQUEST['msg'] %></div>
<div align="center"><a href="<%= $_REQUEST['volver'] %>">Volver</a></div> <!--<?php // echo $_REQUEST['enlace']; ?> -->
</body>
</html> |
El código la clase agenda/control/ManejadorPersona.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| session_start();
include_once("../modelo/Persona.php");
class ManejadorPersona{
// propiedades del objeto = variables globales de la clase
private $persona;
public function getPersona( ){
return $this->persona;
}
public function setPersona($persona){
$this->persona = $persona;
}
public function registrarPersona(){
//recuperar los datos que vienen de la pagina web/registrar_persona.php
$cedula = $_REQUEST["cedula"];
$nombre = $_REQUEST["nombre"];
$apellido = $_REQUEST["apellido"];
$telefono = $_REQUEST["telefono"];
$direccion = $_REQUEST["direccion"];
$objPersona = new Persona();
$objPersona->setCedula($cedula);
$objPersona->setNombre($nombre);
$objPersona->setApellido($apellido);
$objPersona->setTelefono($telefono);
$objPersona->setDireccion($direccion);
try{
$objPersona->registrar();
header("Location: ../web/mensaje.php?msg= Registro Satisfactorio de CC. ".$objPersona->getCedula( )." ".$objPersona->getNombre()." ".$objPersona->getApellido()."&volver=registrar_persona.html");
exit();
}
catch( Exception $error){
header("Location: ../web/mensaje.php?msg=".$error->getMessage()."&volver=registrar_persona.html");
exit();
}
}
public function ejecutarAccion(){
$accion = @$_REQUEST['accion'];
switch ($accion){
case "Insertar":
$this->registrarPersona();
break;
}
}
}
$control = new ManejadorPersona();
$control->ejecutarAccion();
?> |
El código de la clase agenda/modelo/Persona.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| include_once("../control/ManejadorBaseDatos.php");
class Persona{
// variables globales
private $cedula;
private $nombre;
private $apellido;
private $telefono;
private $direccion;
public function setCedula( $cedula){
$this->cedula = $cedula;
}
public function getCedula( ){
return $this->cedula;
}
public function setNombre($nombre){
$this->nombre = $nombre;
}
public function getNombre( ){
return $this->nombre;
}
public function setApellido($apellido){
$this->apellido = $apellido;
}
public function getApellido( ){
return $this->apellido;
}
public function setTelefono($telefono){
$this->telefono = $telefono;
}
public function getTelefono( ){
return $this->telefono;
}
public function setDireccion($direccion){
$this->direccion = $direccion;
}
public function getDireccion( ){
return $this->direccion;
}
public function registrar(){
// generar las enetancia SQL de tipo insert
$sql = "INSERT INTO Personas
VALUES('$this->cedula',
'$this->nombre',
'$this->apellido',
'$this->telefono',
'$this->direccion')";
// llamada a singleton de la clase MajenadorBaseDatos
try{
$basedatos = ManejadorBaseDatos::getObjeto();
$basedatos->modificar( $sql);
//$basedatos->desconectar();
}
catch(Exception $error){
throw new Exception("Error al regitrar las persona $this->cedula
". $error->getMessage());
}
}
}
?> |
No me queda mas que invitarlos a seguir leyendo, practicando y aprendiendo, es lo único que no diferencias de los mediocres y de los charlatanes, si alguno quiere continuar con el trabajito de la agendaphp, lo animo a que se lean este otro de mis artículos Mi implementación Personal de MVC con PHP5 y descargue el el proyecto ejemplo que he colocado en un enlace al final, esta bastante completo, tiene upload, reportes xls, pdf y .doc, ademas que he colocado unos JavaScript siempre útiles para las validaciones y un calendario muy simpetico.
Descargar el código fuente de este articulo
Por otro lado este lo descrito aquí este articulo lo he hecho con intención de explicar como se hacen las cosas a palito como digo Yo, hoy día muy rara vez utilizo esta clase para realizar mis programas en PHP, actualmente utilizo una librería muy potente llamada PDO (PHP Data Object), diagamos que hace casi lo mismo que yo quise hacer con mi clase ManejadorBaseDatos, pero obviamente esta librería es mil veces mas funcional, estándar y practica que mis pobre clase, PDO estos son algunos de los SMBD que soporta PDO
- PDO_PGSQL (PostgreSQL)
- PDO_MYSQL (MySQL v3.x a v5.x)
- PDO_OCI (Oracle)
- PDO_DBLIB (FreeTDS – Microsoft SQL Server – Sybase )
- PDO_IBM (DB2)
- PDO_INFORMIX (Informix Dynamic Server)
- PDO_ODBC (ODBC v3 – IBM DB2 – unixODBC y win32 ODBC)
- PDO_SQLITE (SQLite )
- PDO_FIREBIRD (Firebird/Interbase)
- PDO_4D (4D)
Pero esta no es la única librería que se utiliza para gestionar de forma fácil las conexiones a base de datos con PHP, existen otras muy populares como:
Y para finalizar loes muestro los FrameWork RDO (Relational Data Object) para PHP
Los RDO son framework o marcos de trabajo que aparecieron hace 4 años aproximadamente, su objetivo principal es hacer una equivalencia entre el modelo de datos o capa de persistencia de una aplicación con su capa de objetos tipo entidad, algo conocido como modelo conceptual en Ingeniería del Software, esto permite por ejemplo generar la base de datos y obtener los las clases equivalente a las tablas de la base de datos o viceversa, las clase son generadas con toda la funcionalidad necesaria para realizar las operaciones básicas de persistencia de sus objetos, tales como insertar, eliminar, modificar y consultar.
Uno de los pioneros en RDO fue Microsoft con su ADO.NET, pero rápidamente fue desplazado por una gran innivacion de Java llamada Hibernate, el cual ha sobrepasado las fronteras de Java y hoy existe para casi todos los lenguajes de programación.
Existen varias alternativas para trabajar con RDO en PHP:
La mayoría de los Framework mas famosos para PHP utilizan uno de estos proyectos para generar el código CRUD, la BD y las vistas.
Que Dios todo poderoso los siga bendiciendo, los proteja de todo mal y les de larga vida para que puedan ayudar hacer buenas cosas en esta vida tan llena de injusticia.
Feliz navidad y prospero Año nuevo Para todos
171 Visitas hoy
