Share
Aunque generalmente es aconsejable utilizar algún tipo de marco o CMS, a veces un proyecto es lo suficientemente pequeño como para que esas opciones afecten el desarrollo. Sin embargo, incluso en proyectos más pequeños, no se debe ignorar la separación de los elementos de presentación de las consultas de back-end. Este tutorial lo guiará a través de la creación de un motor de consulta básico basado en clases para PHP y MySQL..
Lo primero que vamos a hacer es crear algunos archivos y directorios específicos. Así es como me gusta configurar mis proyectos. Por supuesto, puede sentirse libre de cambiar los nombres y la estructura a su gusto. Solo asegúrate de cambiar los requisitos más adelante también.
Necesitaremos un nuevo directorio para contener todo. En este caso, lo llamé. gesto de desaprobación. Dentro de eso, puse mis archivos de configuración en un directorio llamado conf. Entonces, haré un Cía directorio (abreviatura de incluir) y poner un directorio de "clase" dentro de ese.
Entonces dentro / conf, Nosotros lo harémos config.php. Dentro / inc / clase Nosotros lo harémos DAL.php. Finalmente, en el directorio raíz, haremos index.php.
DAL significa "Capa de acceso a datos" o "Enlace de acceso a datos".
En la arquitectura de varios niveles, se utiliza esencialmente para traducir los resultados de las consultas de la base de datos en objetos y viceversa..
Necesitamos hacer una base de datos y poblarla con algunos datos. Para los fines de este tutorial, solo será una base de datos de dos tablas con una única relación de uno a varios. Esto es solo para que podamos mostrar nuestro motor de consultas que abarca al menos una relación..
Entonces, en una base de datos llamada "tut", hagamos una tabla llamada hace y una mesa llamada modelos. los hace La tabla tendrá los campos "ID" y "Nombre" y la modelos la tabla tendrá los campos "id", "make" y "name".
Ahora solo podemos agregar algunas marcas (como Ford, Chevy, etc.) como datos en la tabla de marcas y algunos modelos de los que los fabricantes son responsables..
Este tutorial asume que tiene conocimientos de bases de datos y SQL, por lo que no voy a entrar en detalles sobre la configuración de la relación / clave externa.
Por lo general, no me gusta trabajar con constantes en bruto en PHP. Normalmente definiré un montón de cosas y luego haré algunas funciones para conectarlas a esas constantes. Para este ejemplo, mantengamos las cosas simples y usemos las constantes.
En nuestro /conf/config.php archivo, vamos a configurar nuestras variables de conexión de base de datos. Mientras estamos en ello, vamos a incluir una inclusión en nuestro script DAL.php.
Esta configuración asume que está ejecutando MySQL en su puerto predeterminado.
Ahora dentro /inc/class/DAL.php, Haremos una función que utilizaremos para conectarnos a nuestra base de datos..
La conexión, así como todas las consultas futuras, vivirán dentro de una clase llamada DAL. Envolver toda la participación de la base de datos dentro de una sola clase nos permite manipular nuestras consultas más adelante sin necesidad de tocar los scripts de capa de presentación o negocios. Además, proporciona algún grado de espacio de nombre simulado.
En el caso de esta clase, agregaremos un constructor aunque no tenga que hacer nada..
Accentsconagua
No se pudo conectar al servidor MySQL "); mysql_select_db (DB_DB, $ conn) o die ("
No se pudo seleccionar la base de datos indicada "); return $ conn;?> Tenga en cuenta que el alcance de la dbconnect El método es privado. Esto se debe a que no deberíamos necesitar conectarnos a la base de datos desde fuera de nuestro DAL. En su lugar, tendremos métodos de consulta pública que llamarán a dbconnect desde dentro del DAL. Un poco confuso? No te preocupes sigue leyendo.
Para abstraer nuestras consultas para que podamos reutilizar fragmentos de código cortos, necesitaremos dos cosas. Primero, necesitaremos algún tipo de clase de "resultado de consulta genérico". Segundo, necesitaremos un método de consulta genérico dentro de nuestro DAL.
El propósito de todo esto es poder convertir consultas SQL en objetos y minimizar el uso de lo feo. while ($ row = mysql_fetch_array ($ resultado)) lazo. Es mucho más fácil trabajar con los objetos y nos permite usar propiedades en lugar de claves de matriz.
En resumen, queremos crear una clase que cree nombres de propiedades sobre la marcha y almacene datos asociados con esas propiedades.
Pondremos esta clase dentro de nuestra /inc/class/DAL.php guión. Dado que es una clase nueva, estará fuera de la clase DAL.
clase DALQueryResult private $ _results = array (); función pública __construct () función pública __set ($ var, $ val) $ this -> _ resultados [$ var] = $ val; función pública __get ($ var) if (isset ($ this -> _ results [$ var])) return $ this -> _ results [$ var]; else return null;
Ahora dentro de nuestro DAL clase, tenemos que hacer un método de consulta genérico que se convertirá SELECCIONAR consultas en DALQueryResult objetos.
Básicamente, queremos convertir cada nombre de campo devuelto en una propiedad del DALQueryResult objeto.
consulta de función privada ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); if ($ res) if (strpos ($ sql, 'SELECT') === false) return true; else else if (strpos ($ sql, 'SELECT') === false) return false; else return null; $ resultados = matriz (); while ($ row = mysql_fetch_array ($ res)) $ result = new DALQueryResult (); foreach ($ fila como $ k => $ v) $ resultado -> $ k = $ v; $ resultados [] = $ resultado; devolver $ resultados;
Aquí hay una función privada que acepta una consulta SQL. Se conecta a la base de datos y ejecuta la consulta. Luego, verifica si hay algún resultado. Si no hay resultados, devuelve null en un SELECCIONAR consulta, falso en otras consultas. Si la consulta fue exitosa y la consulta no fue SELECCIONAR consulta, se devolverá verdadero. Si fuera un SELECCIONAR, luego convierte los resultados en una matriz de objetos DALQueryResult. Esto imita los resultados que normalmente se obtendrían de un mysql_query.
Ahora estamos listos para escribir una consulta SQL. Las consultas DAL deben ser muy específicas tanto en nombre como en propósito. Hagamos uno que encuentre todos los modelos de una marca dada..
Este será nuestro primer método público..
función pública get_models_by_make_name ($ nombre) $ sql = "SELECCIONE models.id como id, models.name como nombre, makes.name como make DE los modelos INNER JOIN hace ON models.make = makes.id DONDE makes.name = '$ nombre'"; devuelve $ this-> query ($ sql);
Aquí solo estamos escribiendo la consulta y devolviendo el resultado en forma de objetos DALQueryResult. Nuestro genérico consulta El método se encarga de las iteraciones y toma de decisiones..
En este punto, nuestro DAL.php el script está terminado. Debería verse como la siguiente.
_results [$ var] = $ val; función pública __get ($ var) if (isset ($ this -> _ results [$ var])) return $ this -> _ results [$ var]; else return null; clase DAL función pública __construct () función pública get_models_by_make_name ($ nombre) $ sql = "SELECCIONE models.id como id, models.name como nombre, makes.name como make FROM models INNER JOIN crea modelos ON .make = makes.id WHERE makes.name = '$ name' "; devuelve $ this-> query ($ sql); función privada dbconnect () $ conn = mysql_connect (DB_HOST, DB_USER, DB_PASSWORD) o die ("
No se pudo conectar al servidor MySQL "); mysql_select_db (DB_DB, $ conn) o die ("
No se pudo seleccionar la base de datos indicada "); return $ conn; consulta de función privada ($ sql) $ this-> dbconnect (); $ res = mysql_query ($ sql); if ($ res) if (strpos ($ sql, 'SELECT') === false) return true; else else if (strpos ($ sql, 'SELECT') === false) return false; else return null; $ results = array (); while ($ row = mysql_fetch_array ($ res)) $ result = new DALQueryResult (); foreach ($ row as $ k => $ v) $ result -> $ k = $ v; $ results [] = $ resultado; devolver $ resultados;?> Ahora, finalmente vamos a nuestra /index.php Guarde y visualice nuestros resultados utilizando el DAL. Todo lo que necesitamos hacer es incluir nuestra /conf/config.php Archivo, ejemplificar el DAL, y hacer algo con los datos. Aquí un ejemplo.
get_models_by_make_name ($ make); eco "Modelos por $ make
"; // verifique si hubo resultados si ($ resultados) echo"
Lo sentimos, no tenemos información sobre ese fabricante..
";?>Como puede ver, ahora tenemos resultados a los que podemos llamar nombres de campo como propiedades de un objeto PHP.
A menudo, será útil convertir el genérico DALQueryResult en un objeto más específico. En este caso, puede escribir objetos de negocio que acepten un DALQueryResult como parámetro constructor. Entonces, solo usas eso para construir el nuevo objeto.
Aquí un ejemplo
_id = $ result-> id; $ this -> _ make = $ result-> make; $ this -> _ name = $ result-> name; función pública __get ($ var) switch ($ var) case 'id': devolver $ this -> _ id; descanso; caso 'make': devolver $ this -> _ make; descanso; caso 'nombre': devolver $ this -> _ nombre; descanso; por defecto: devolver nulo; descanso; función pública __toString () return $ this -> _ name; ?>
Luego, simplemente escriba una consulta para devolver una matriz de estos objetos en lugar de una matriz de genéricos DALQueryResult objetos.
Recuerde, siempre nombre sus consultas muy específicamente.
función pública get_models_by_make_name_as_CarModel ($ name) // Reutilizar la consulta existente $ resultados = $ this-> get_models_by_make_name ($ sql); // verifique los resultados si (! $ resultados) return $ resultados; else // array para contener objetos de CarModel $ object_results = array (); // recorra y convierta a objetos CarModel para cada ($ resultados como $ resultado) object_results [] = nuevo CarModelo ($ resultado); // devuelve la matriz de objetos CarModel devuelve object_results;
La construcción de objetos específicos puede ser muy útil cuando se necesitan cálculos para extraer datos significativos de los campos.
Espero que todos hayan disfrutado el tutorial! Buena suerte.
