Autor: Alvaro del Castillo

Se otorga permiso para copiar, distribuir y/o modificar este documento bajo los términos de la Licencia de Documentación Libre GNU, Versión 1.1 o cualquier otra versión posterior publicada por la Free Software Foundation. Puede consultar una copia de la licencia original en: http://www.gnu.org/copyleft/fdl.html.

Sobre PHP

Introducción a PHP

En mi experiencia como desarrollador de aplicaciones web, PHP ha significado junto al servidor de web Apache, las dos herramientas claves para la creación de aplicaciones. PHP es un lenguaje sencillo, de sintaxis cómoda y similar a la de otros lenguajes como C o C++, es rápido a pesar de ser interpretado, multiplataforma y dispone de una gran cantidad de librerías que facilitan muchísimo el desarrollo de las aplicaciones.

El código generado es mantenible, se lee muy bien y podemos programar utilizando objetos. PHP es un lenguaje ideal tanto para el que comienza a desarrollar aplicaciones web como para el desarrollador experimentado, y está alcanzando unos niveles de uso (más de 1 millón de webs lo utilizan ya) que convierten su conocimiento en algo indispensable para los profesionales del desarrollo en Internet.

Y, además, PHP es un lenguaje basado en herramientas con licencia de software libre, es decir, no hay que pagar ni licencias, ni estamos limitados en su distribución y, podemos ampliarlo con nuevas funcionalidades si así lo quisiéramos. Respecto a su licencia, en la versión PHP 3.0 era GPL, pasando a ser modificada en su versión 4.0, por la incorporación de Zend, un nuevo interprete de PHP mucho más rápido que el anterior de PHP. Este interprete Zend tiene asociado un optimizador opcional, el cual ya está más dentro del mundo comercial que del software libre, tema que ha levantado algunas suspicacias dentro de la comunidad de desarrolladores de software libre.

En esta serie de presentación de PHP mostraremos este lenguaje, como se instala y configura, como se desarrolla con él, las librerías fundamentales y como no, su excelente forma de trabajar con casi todas las bases de datos, y en especial, con MySQL, con la que forma un equipo estrella dentro del mundo de desarrollo software.

No olvidaremos por otro lado a PostgreSQL, la base de datos que es realmente software libre, y que avanza con piso firme para convertirse en la base de datos de referencia dentro de cualquier proyecto libre, sobre todo tras la publicación de la versión 7.0.

En los artículos de la serie vamos a describir PHP en su última versión, PHP4, que por fin en Mayo del 2000 ha sido publicada. Posiblemente para cuando el lector comience a desarrollar con PHP, esta versión 4 será la estándar. En ella hay muchos cambios y mejoras que detallaremos a lo largo de los artículos de la serie.

La serie está orientada al uso conjunto de Apache y PHP, aunque PHP se puede compilar como un ejecutable que puede ser utilizado como cgi-bin. De esta forma, cualquier servidor de web que soporte cgi podría ejecutar las páginas PHP. La ventaja que tiene Apache frente a estos es que podemos compilar el interprete PHP como un módulo de Apache, por lo que la velocidad de ejecución de estas páginas PHP es muy superior, así como el consumo de recursos al cargarse el interprete de PHP una sola vez en memoria.

¿Qué es PHP?

Con estas siglas nos referimos a un lenguaje de programación que está muy orientado al desarrollo de aplicaciones web. Cuando pedimos a nuestro servidor de web una página PHP, que no es más que un programa PHP que genera HTML, antes de enviar dicha página al cliente se la pasa al interprete de PHP. Este la interpreta y es el resultado de esta interpretación del programa PHP, contenido en la página PHP, lo que termina llegando al cliente.

Supongamos que el contenido de una página web que reside en el servidor, y cuyo nombre es "intro.php", tiene el siguiente contenido:

<? echo "<h1>Mensaje desde PHP</h1>";?>

Cuando un navegador le pida al servidor de web la página "intro.php", el servidor de web va a darse cuenta, por la extensión ".php", de que esta página ha de enviarse primero al interprete de PHP. Este recibe el contenido de la página y como resultado de esta ejecución (interpretación) genera una página HTML, que es la que envía al cliente a través de Apache. Como veremos en una página PHP se puede mezclar HTML y PHP, algo muy flexible pero que hay que manejar con cuidado ya que puede llevar a confusiones y, sobretodo, a que el equipo que diseñe las páginas web y el que programe la aplicación no puedan ser independientes.

Sin duda esta sección del manual debe de ser actualizada ya que se refiere aún a la última beta de PHP4, pero salvo este detalle, el procedimiento sigue siendo válido. También hay que estar atentos a la publicación de Apache 2.0 ya que quizás, implique unos cambios mayores dentro esta sección. Si algún lector quiere contribuir y actualizar la versión será gratamente bienvenida.

Uno de los mayores quebraderos de cabeza de PHP en sus comienzos era que obligaba a tener Apache en código fuente y compilarlo. Por fin la instalación de PHP se puede hacer de forma sencilla y sin tener que modificar en casi nada a nuestro servidor de web. Tan sólo necesitamos tener una versión de Apache con soporte DSO para la carga dinámica de objetos. La versión con la que se está desarrollando este artículo es la 1.3.9 aunque toda la serie 1.3 tiene este soporte.

Si el lector tiene ya instalado PHP3 en su servidor de web Apache debe de tomar la precaución de desactivarlo. Se puede tener de forma simultánea ambas versiones funcionando, pero este proceso es algo complejo y no lo vamos a tratar de momento. Por ello el lector necesita un servidor de web Apache sin soporte para PHP. La mejor forma de comprobar este dato es editar el fichero de configuración de Apache "httpd.conf" (normalmente en el directorio "/etc/httpd") y revisar que no se hagan referencias en él a PHP. Si las encontrara debería de comentarlas y reiniciar el servidor de web.

Es necesario que los paquetes de desarrollo de Apache estén también instalados en el entorno del lector. Estos son básicamente los ficheros de cabecera de la librerías de Apache ("/usr/include/apache"), las librerías para extender Apache y algún ejecutable como "apxs" que es una utilidad que permite añadir módulos de carga dinámica a Apache. El resultado de nuestra compilación de PHP va a ser uno de estos módulos.

Ha llegado el momento de obtener la última versión de PHP de la red. Esta la puede conseguir el lector de http://www.php.net. Una vez que tengamos las fuentes de PHP4beta3 vamos a pasar a instalarla. Los pasos a dar son:

• tar xvfz php-4.0b3.tar.gz
• cd php-4.0b3
• configure –with-apxs=/usr/sbin/apxs
• make
• make install (como superusuario)

Si todo ha ido bien ya tenemos todo preparado para poder reiniciar el servidor de web Apache con el módulo de PHP4 entre sus funcionalidades. De la compilación cabe destacar el gran tiempo que transcurre en la compilación de uno de los nuevos componentes de PHP4, Zend, el motor principal para la interpretación del lenguaje PHP.

Si el lector ha estado atento en la fase de "make install" habrá podido observar como se utiliza la herramienta "apxs" para añadir "libphp4.so" a los módulos de carga dinámica de Apache. La instrucción en concreto es:

/usr/sbin/apxs -i -a -n php4 libs/libphp4.so

Esta herramienta copia este fichero al directorio donde residen los demás módulos de carga dinámica, "/usr/lib/apache" normalmente, y modifica el fichero de configuración "httpd.conf" para que se cargue este nuevo módulo al arrancar.

En Mandrake 6.1, y probablemente en RedHat 6.0 y superior, este proceso no incluye de forma correcta la referencia al módulo dentro de "httpd.conf" lo que nos obliga a editar este fichero y modificar la línea con el contenido:

LoadModule php4_module   lib/apache/libphp4.so

por la línea

LoadModule php4_module   modules/libphp4.so

Ahora ya sólo nos queda decirle a Apache que todos los ficheros que acaben con la extensión ".php" sean enviados al interprete de PHP, algo que logramos añadiendo a "httpd.conf" la línea:

AddType application/x-httpd-php .php4

En anteriores versiones de Apache existían tres ficheros de configuración y esta última línea había que insertarla en el fichero "srm.conf".

Reiniciamos nuestro servidor Apache, "/etc/rc.d/init.d/httpd restart" en sistemas Red Hat y si todo ha ido bien tendremos ya todo preparado para empezar a desarrollar con PHP. Si existe algún problema el servidor de web no se arrancará. Para detectar que puede estar ocurriendo se pueden analizar los ficheros de registro de Apache del directorio "/var/log/httpd" e intentar localizar allí el error. A veces también es útil iniciar a mano el demonio de Apache sin la ayuda de ""/etc/rc.d/init.d/httpd", ejecutando de forma directa "/usr/sbin/httpd".

Algo que nos puede confirmar de forma definitiva que todo ha ido bien es una línea de registro dentro de "/var/log/httpd/error_log" con un contenido similar a:

 Apache/1.3.9 (Unix)
(NetRevolution Advanced Server/Linux-Mandrake)
PHP/4.0b3 configured -- resuming normal operations

Si has logrado llegar ya hasta aquí, prepárate porque ahora viene lo divertido: la programación de páginas PHP.

Lo primero que vamos a hacer es crear una página PHP que nos informe de las características del interprete de PHP que tenemos instalado en nuestro servidor de web. Para ello debemos de crear una página PHP con el contenido siguiente:

<? phpInfo(); ?>

Este debe de ser el contenido de un fichero de nombre "info.php" y que debe de estar en algún lugar accesible por el servidor de web. Quizás lo mejor sea que lo guardes dentro de tú directorio personal web: "/home/tu_login/public_html". Por ejemplo yo lo tengo dentro del directorio "/home/acs/public_html/info.php". Una vez que lo tengas guardado vamos a intentar abrir esta página. Para ello apunta tú navegador a la página: "http://localhost/~tu_login/info.php". En mi caso dicha página es: "http://localhost/~acs/info.php".

Al pedirle esta página al servidor de web, este al ver su extensión llama al interprete de PHP y le dice que "ejecute" la página y le entregue los resultados. El interprete abre la página y ejecuta la llamada a la función "phpInfo()" que, como resultado, nos entrega toda la información sobre el interprete de PHP en formato HTML. ¿Verdad que es sencillo?.

Vamos con una página algo más complicada. Y vamos con la orientación a objetos. PHP tiene soporte para la programación orientada a objetos, es decir, puedes crear clases para la construcción de objetos, con sus constructores etc. El soporte de objetos que tenemos en PHP no es tan potente como el de C++, pero cada vez es más completo y en esta versión nueva de PHP4 este soporte ha sido mejorado.

Si no sabes programar utilizando objetos en este curso algo vas a aprender pero te recomiendo que sin más dilación consigas algún buen libro o tutorial por Internet. Los objetos cada vez tienen más fuerza a la hora de desarrollar software. De cualquier forma en este curso vamos a utilizar la programación con objetos en un nivel muy básico.

En nuestro siguiente ejemplo vamos a crear un objeto que nos va a permitir acceder a diversas bases de datos. Claro está que lo vamos a dejar sin implementar aún en gran parte, pero todo llegará. Aquí va el código de la página:

<?php  class connection { var $dbug=1, $con, $type;
function getType() {global $type;return $this->type;}
// Constructor del objeto de conexión a la base de datos
function connection($typedb="MySQL",$database_name="template1")
{ $this->connection_open ($typedb,$database_name);}
// Apertura de la conexión con la base de datos
function connection_open ($typedb,$database_name) {
$this->$type=$typedb;
if ($type=="PostgreSQL") $this->$con=new postgresql_connection;
elseif ($type=="MySQL") $this->$con=new mysql_connection;
else {error_message("Open:Unkown database type");exit;}
$this->$con->connection_open($database_name); }  }
class mysql_connection { function mysql_connection() {
echo "<h1>La clase mysql_connection aún no
está implementada.<h1>";}
function connection_open($database_name) {
echo "<h1>Método connection_open sin implementar.<h1>";} }
$bd = new connection("MySQL","template1");  ?>

Si el lector está acostumbrado a la programación con objetos este código le resultará muy familiar. Tenemos una clase principal "connection" que se encarga de gestionar las conexiones con la base de datos. Cuando desde nuestro programa queramos acceder a una base de datos, nos creamos un objeto connection pasándole como parámetros al constructor de connection, método que se llama de forma automática al crear el objeto, el tipo de base de datos al que queremos acceder y el nombre de la base de datos concreta con la que queremos trabajar.

Este objeto delega en los objetos específicos de cada base de datos, el del gestor de base de datos MySQL es "mysql_connection", la apertura de una conexión, las peticiones SQL etc. Esta técnica de utilizar objetos que delegan el trabajo final en otros es muy utilizada en lenguajes que carecen de herencia, mecanismo por el que una clase hereda toda la información de estado y métodos de la clase de a que hereda. PHP3 en sus primeras versiones no tenía soporte para herencia por lo que me vi obligado a utilizar esta técnica. En la actualidad PHP ya soporta herencia, aunque no múltiple. Y no, todas las reglas de encapsulación pública y privada no están implementadas. Y hay que tener cuidado con algo que nos puede dar muchos quebraderos de cabeza: al crear un objeto de una clase B que hereda de una clase A, se llama de forma automática al constructor de la clase B pero no al de su padre, la clase A.

Sobre la sintaxis de PHP, es muy similar a la de C o C++. Quizás lo más destacado ocurre a nivel semántico: el tipado es muy poco estricto, algo típico en los lenguajes "script", y cuando creamos una variable en ella podemos meter el tipo de datos que queramos. Esto es muy flexible y cómodo para el desarrollador, aunque los errores que se cometen pueden ser mucho más graves y difíciles de corregir. Las posibilidades del interprete para detectar incompatibilidades entre variables se reducen mucho y puede ocurrir cosas extrañas en determinadas circunstancias si no tenemos cuidado.

Sobre el código de este ejemplo en concreto, tenemos dos clases. La definición de una clase es hace con la palabra clave "class" seguida del nombre de la clase. Entre llaves desarrollamos toda la descripción de la clase, sus variables y métodos. Dentro de un método de la clase (function) se pueden acceder otras partes de la clase por medio del puntero "$this". Por ejemplo, para acceder desde el método "connection_open" a la variable de la clase "$type" lo hacemos con "$this->$type".

Si guardamos esta clase en un fichero, por ejemplo "ejemploDB.php", cuando accedamos a este fichero a través del servidor de web, este llamará de nuevo al interprete de PHP al ver que la extensión del fichero es "php". El interprete de PHP analizará el código y ejecutará la instrucción ":

$bd = new connection("MySQL","template1");

Con ello se crearía un nuevo objeto de la clase "connection". Al crearse se llama de forma automática al constructor "function connection" que a su vez llama al método "connection_open". Este método crea un nuevo objeto de la clase "mysql_connection" ($con) el cual llama de forma automática a su constructor "function mysql_connection" el cual envía la cadena HTML "<h1>La clase mysql_connection aún no está implementada.<h1>". Desde el método "connection_open" de "connection" se llama a "connection_open" del objeto "$con", que es de la clase mysql_connection, lo que provoca que se imprima otra cadena HTML: "<h1>Método connection_open sin implementar.<h1>.". Tras esta última invocación el programa finaliza y se envía el resultado al servidor de web, el cual reenvía estos datos al cliente. En la figura 2 podemos ver el resultado de dicha ejecución.

PHP en cada nueva versión soporta nuevas funcionalidades por lo que el mejor método para ver que nuevas librerías incluye es cuando compilamos. Si dentro del directorio con las fuentes de PHP ejecutamos el comando "configure –help" nos dará información de todas las posibles opciones que tiene PHP al ser compilado y, entre esta información, la de todos los módulos que podemos añadir a PHP si disponemos de las librerías adecuadas. Dentro del manual de PHP disponemos también de una referencia a todas las funciones disponibles. Ojo que muchas veces es necesario compilar PHP de forma especial para incluir soporte para una determinada funcionalidad. Por ejemplo, si queremos acceder desde PHP al gestor de base de datos MySQL, es necesario que a la hora de compilar PHP incluyamos ests soporte. Para ello es necesario tener las librerías de MySQL instaladas en el sistema, normalmente en el paquete "dev" de MySQL, y ejecutar "./configure –with-mysql" antes de compilar PHP. De esta forma PHP incluirá en el módulo generado dicho soporte. En la información que obtenemos con la llamada a la función "phpInfo()" se incluye informació n sobre los módulos incluidos. En la figura 3 se puede observar la información referente al módulo MySQL y al GD, que se utiliza para la creación de gráficos "al vuelo".

De esta información es importante a versión de API del cliente. Si esta no es compatible con la del servidor que queramos acceder, no podremos acceder a este servidor. En este caso tenemos la versión 3.22 que utiliza el protocolo 10 para comunicarse con el servidor MySQL. Si tuvieramos una versión 3.20 del cliente (la versión de MySQL que se liberó con licencia GPL) no podríamos acceder a los servidores 3.22 ya que el cliente utilizaría el protocolo de comunicaciones versión 9, incompatible con la versión 10.

Siempre que se habla de PHP lo primero que se hace es presentar el gran número de gestores de bases de datos a los que puede acceder.

• Adabas D
• dbm
• dBase
• filePro
• Hyperwave
• Informix
• InterBase
• LDAP
• Microsoft SQL server
• mSQL
• MySQL
• ODBC
• Oracle
• PostgreSQL
• Solid
• Sybase

Pero si este aspecto resulta impresionante no menos el soporte para:

• Acceso a servidores IMAP
• Envío de correo con SMTP
• Acceso a servidores de FTP
• Acceso a SNMP para gestión de redes y equipos
• Generación dinámica de gráficos y documentos PDF
• Análisis de documentos XML
• Corrector de ortografíai
• Genración de datos en WDDX (Intercambio Web de Datos Distribuidos)

Y todo esto ha sido posible gracias a que PHP ha sido diseñado de forma muy modular y ha sido sencillo según han sido surgiendo librerías, utilizarlas desde PHP. Toda esta funcionalidad está basada en librerías que en su mayor parte no han sido desarrolladas por el equipo de PHP. La gente de PHP lo que ha implementado han sido os cabos necesarios para poder acceder a las librerías.

A lo largo del curso iremos presentando el uso de algunas de estas librerías, aunque nada detiene al lector de comenzar este aprendizaje. En el manual de PHP dispone de documentación abundante sobre todas estas funciones, su uso y los posibles resultados. Esta entrega la vamos a finalizar con una descripción de las nuevas características de PHP4, versión que utilizaremos a lo largo de todo el curso.

Además del aumento en rendimiento en lo referente al soporte de objetos en PHP, la sobrecarga de objetos se ha mejorado. De esta forma se ha añadido la posibilidad de métodos polimórficos, métodos que según desde que referencia a un objeto se llamen se comportan de una forma o de otra. Esta característica es muy importante para incluir soporte para acceder a las arquitecturas CORBA y COM.

Otra nueva característica de PHP4 es que se puede compilar para soportar hebras, algo que no era posible en PHP3. La principal ventaja que podemos obtener de esta funcionalidad es el uso de librerías que utilicen hebras. Y en la mayoría de las implementaciones de CORBA esto es así. Quizás pase ya poco tiempo antes de poder acceder al mundo CORBA desde PHP.

Para el desarrollador con PHP4 se incluye un depurador lo que nos evitará muchos quebraderos de cabeza con PHP. Podremos seguir con mayor profundidad esos errores misteriosos que ocurren en estos lenguajes poco tipados. El nuevo interprete de PHP es capaz de liberar los recursos que reservemos de forma automática con lo que nos podremos olvidar de liberarlos. Sí, esto es algo similar al recolector de basura de Java. Habrá que hacer pruebas para ver que tal funciona porque en el caso de Java, muchas veces da más dolores de cabeza de los que te ahorra. En la referencia [2] se puede acceder a un informe realizado por Javier Carretero sobre PHP4, el más completo que he encontrado en Internet.

Conclusiones

Esperamos que con esta primera entrega del Tutorial de PHP el lector haya recibido la motivación suficiente como para empezar a utilizarlo. Si algo caracteriza a PHP es su sencillez: en pocos días se puede llegar a ser un desarrollador de PHP bastante profesional.

En las próximas entregas del curso se irán presentando las librerías principales de PHP, las virguerías que se pueden acceder con muy poco código y las noticias que aparezcan dentro del mundo de PHP.

Quizás podamos ver PHP como una extensión de HTML del lado del servidor. Recordemos que en principio el lenguaje PHP se mezcla con HTML en una página HTML con extensión “.php”. Es precisamente esta extensión la que alerta al servidor de web para que antes de entregar la página al cliente, se la pase al interprete de PHP para que ejecute las partes PHP y envíe al cliente el HTML y los resultados de las partes PHP. A lo largo de esta entrega nos vamos a centrar en describir PHPLIB, una librería que nos va a permitir de forma sencilla poder trabajar con diferentes bases de datos de forma transparente, poder gestionar sesiones de una forma sencilla y llevar un control de acceso muy flexible basado en bases de datos. PHPLIB también proporciona clases, está basada en objetos, para gestionar plantillas y crear HTML desde PHP. Como veremos uno de los problemas fundamentales con lenguajes como PHP, donde se mezcla el código PHP con el código HTML, es que no está bien delimitado el campo del diseñador HTML y del programador y que el código resultante puede ser complejo de entender y por o tanto, muy complicado de mantener. Las plantillas permiten que el código HTML esté totalmente fuera del código PHP con lo que el resultado final es mucho más flexible y mantenible.

PHPLIB es una librería GPL y se puede obtener en la referencia [1]. Su instalación es un tanto compleja ya que toda su funcionalidad principal utiliza base de datos. Por lo tanto lo primero es tener una base de datos funcionando en el sistema. Nos vamos a centrar en MySQL pero la instalación sería muy similar para PostgreSQL o MS Access.

Una vez que hayamos obtenido el “tar.gz” de la librería la descomprimimos en un directorio (tar xvfz phplib-7.2.tar.gz ) y pasamos a instalarla. La estructura de directorios resultante es:

CHANGES  COPYING  HELP    README  VERSION  pages  stuff
COMMIT  CREDITS  Makefile  TODO   doc     php  unsup

La documentación de la librería es de los más completa y se encuentra en el directorio “doc”. Las clases que componente la librería se encuentran en el directorio “php” y los “scripts” de creación de base de datos y tablas necesarios para el funcionamiento de la librería y el soporte de LDAP se encuentra en el directorio “stuff”. En el directorio “pages” tenemos unos sencillos ejemplos para comenzar a trabajar con la librería y en “unsup” tenemos utilidades de las que no se da soporte, es decir, que pueden ser útiles pero que no son parte de la distribución oficial. Sobre la licencia como ya dijimos es software GPL y por lo tanto dentro de “COPYING” tenemos la querida licencia GPL.

La guía de instalación rápida nos cuenta en 10 pasos como instalar la librería. Como ya dijimos lo primero es tener una base de datos funcionando en el sistema. Quizás puede parecer un requisito excesivo pero los servidores web sin base de datos serán una especie en extinción en el futuro cercano. Si tenemos MySQL instalado todo va a ser sencillo. Accedemos al directorio “stuff” y ejecutamos:

mysqladmin -u root create phplib  mysql -u root
< create_database.mysql

Con ello creamos una base de datos para PHPLIB y dentro de ella la poblamos con una serie de tablas. En estas tablas es donde PHPLIB guarda toda la información de sesiones y control de accesos. Una vez que ya tenemos la infraestructura de base de datos preparada hay que indicar a PHP que en todas las páginas incluya el núcleo de PHPLIB. Se puede evitar hacer esto pero es muy cómodo tener toda esta funcionalidad de forma automática en nuestras páginas PHP, y este núcleo es bastante reducido. Esto lo vamos a lograr accediendo al fichero de configuración de PHP, normalmente “/etc/php.ini”, e incluir en la línea que comienza con “auto_prepend_file” la localización del fichero “prepend.php3″ que se encuentra dentro del directorio “php” de PHPLIB. De esta forma el interprete de PHP incluye PHPLIB en todas las páginas PHP. Una vez hecho esto solo nos queda acceder al fichero “local.inc” y especificar los datos necesarios en la clase “DB_Example” para que PHPLIB puede acceder a la base de datos. El contenido de esta clase es:

class DB_Example extends DB_Sql {var $Host  = "localhost";
var $Database = "phplib"; var $User = "root";
var $Password = ""; }

Tenemos que especificar en que máquina está corriendo la base de datos, como se llama la base de datos en la que se van a almacenar los datos de PHPLIB, y un usuario y clave para acceder a esa base de datos. La clase DB_Sql es una abstracción del acceso a la base de datos, es decir, que a través de esta clase podemos acceder de forma idéntica a varios tipos de bases de datos diferentes. En concreto en la versión actual de PHPLIB nos encontramos implementaciones de DB_Sql para las siguientes bases de datos:

db_msql.inc: msql   db_mssql.inc: MS SQL Server
db_mysql.inc: MySQL
db_oci8.inc, db_oracle.inc: ORACLE   db_odbc.inc: ODBC
db_pgsql.inc: PostgreSQL   db_sybase.inc: Sybase

Si basamos nuestros desarrollos en PHPLIB y DB_Sql la migración de un sistema de bases de datos será trivial: sólo habrá que traspasar los datos y cambiar la clase con la que se accede a la base de datos. Todo nuestro código será idéntico.

Ya en este punto estamos en disposición de utilizar la librería PHPLIB. Para ello lo mejor es poner el directorio “pages” de la distribución en algún lugar desde el que el servidor de web pueda acceder a él y a través de un navegador acceder a la página “index.php3″.

Si prueba el lector a recargar la página verá que el contador que aparece va aumentando. Lo que está ocurriendo es que la primera vez que se accedió a esta página se creó una “cookie” para el control de la sesión. A partir de este momento está “cookie” con el identificador de sesión es enviado al servidor de web por el cliente cada vez accede a la página permitiendo el control del estado de la sesión. De hecho este control se realiza utilizando la base de datos “phplib” que creamos anteriormente. Si vemos las tablas que hay en la base de datos “phplib” encontramos:

active_sessions   active_sessions_split
auth_use   auth_user_md5   db_sequence

En la tabla “active_sessions” es donde se almacena la información de sesión y cada vez que se crea una nueva sesión, se crea un registro en esta tabla para su control. Supongamos que queremos controlar el acceso a un conjunto de páginas por nuestros clientes. Con PHPLIB es tan sencillo como incluir al comienzo de cada página con control de sesión la llamada:

page_open(array("sess" => "Sesión de control"));

De esta forma PHPLIB verifica si el usuario tiene ya creada la “cookie”. Si no la tiene se la crea y si la tiene nos permite acceder a todos los datos de la sesión. Gracias al control de sesiones podemos almacenar diferentes variables asociadas a esta sesión. Desde el momento que se abre una sesión, se abren todas las variables de dicha sesión. Para asociar una variable a una sesión utilizamos una llamada de PHPLIB:

$sess->register("s");

Al final de una página con control de sesión, tenemos que realizar una llamada a PHPLIB para cerrar la sesión. En esta llamada todas las variables asociadas a la sesión se guardan para que no se pierdan:

page_close();

Es por todos conocido lo poco que gustan las “cookies” a la gente por el ataque hacia su privacidad que supone. Con PHPLIB el control de sesiones se puede realizar también utilizando el método GET de envío de datos, es decir, adjuntando a la URL de acceso a la página el identificador de la sesión. Esto se controla si en la página con control de sesiones ponemos todos los enlaces a otras páginas de la siguiente forma:

$sess->purl("showoff.php3");

Ya hemos visto pues una de las principales ventajas de utilizar PHPLIB: el sencillo control de sesiones. con este control el implementar una bolsa de la compra donde se vayan almacenando todos los artículos de una compra es trivial. O el almacenamiento de una barra de navegación con todas las páginas por las que ha ido accediendo el usuario.

PHPLIB. Control de Identidad de Usuarios

Junto con el control de sesiones es el control de acceso a páginas una de las principales necesidades en las aplicaciones web. Y de nuevo con PHPLIB tenemos solucionado de forma sencilla este control. Es cierto que con Apache tenemos mecanismos para el control de acceso a páginas, pero es un control de acceso o no acceso. Normalmente necesitamos ir más allá. Necesitamos que según la persona que acceda dar acceso a unas partes u otras, poder crear grupos de usuarios con privilegios etc.

Además PHPLIB asocia este control de identidad de usuarios al control de sesiones, algo que nos permite asociar de forma automática una sesión a un usuario identificado. Cuando queremos que una página solo pueda ser accedida por un usuario identificado incluimos en la primera línea de esta página:

page_open(array("sess" => "Example_Session",
"auth" => "Example_Auth",

"perm" => "Example_Perm", "user" => "Example_User"));

Es en la tabla “auth_user” de la base de datos “phplib” donde se almacena toda la información sobre los usuarios. Y en esta tabla también se incluye un campo “perms” donde se pueden detallar los permisos que tiene un usuario.

Supongamos que hay una parte de administración a la que sólo pueden acceder los usuarios con permiso de administrador. Para ello en el campo “perms” del registro del usuario debe aparecer “admin”. Con PHPLIB lo único que hay que hacer para realizar este control es incluir la llamada:

$perm->check("admin");

Si el usuario no está aún autenticado se le presentará una página para que inserte un identificador y una clave de entrada.

En el ejemplo inicial de PHPLIB el identificador es “kris” y la clave es “test”. Una vez introducidos podemos volver a acceder a esta página y ya se nos volverá a pedir el identificador.

Ya se ha comentado que uno de los principales problemas a la hora de programar con PHP, o cualquier otro lenguajes que mezcle HTML y el código, es que el código final de las páginas tiene mezclado los datos a presentar y el código.

Este mezcla impide además un correcto trabajo entre los desarrolladores de código y los creadores de páginas HTML y diseñadores gráficos. Para resolver este problema lo mejor es intentar independizar totalmente el código PHP y el código HTML. Este objetivo es bastante lioso de lograr a menos que se ataque el problema de una forma general y se sea muy estricto a la hora de desarrollar las páginas.

Los beneficios logrados por esta separación son muy grandes incluyendo por ejemplo el cambio de temas según el tipo de usuario que acceda al servidor de web, facilitar la traducción de webs sin tocar para nada el código facilitando así la internacionalización del código etc.

Dentro de la librería PHPLIB nos encontramos con una clase que nos ayuda con este objetivo: la clase Template.

Para ver la potencia del uso de plantillas vamos a planter un ejemplo de unsa sencilla página que debe de controlar el acceso a un web y según el usuario que entre, se debe de presentar el web en un idioma u otro. La aplicación lo único que hace es mostrar una serie de datos númericos sobre cotización en bolsa en euros, por lo que esta información es idéntica para todos los idiomas.

Para ello podríamos utilizar os mecanismos de autenticación de la propia PHPLIB. Podríamos crear una nueva tabla en la base de datos asociando identificador de usuario e idioma y tendríamos que preparar los diferentes webs.

Supongamos que inicialmente tenemos dos idiomas: español e inglés. Podemos crear dos directorios, uno con las plantillas en español y el otro con las plantillas en inglés. El código podría empezar de la forma:

page_open(array("sess" => "Example_Session", "auth" =>
"Example_Auth", "perm" => "Example_Perm", "user" =>
"Example_User"));

// Template no es del núcleo de PHPLIB por lo que hay que
// incluir esta clase de forma explícita.  

include("template.inc");
$plantillas = "/home/acs/public_html/plantillas";
$plantillasEspañol = $plantillas."/español";
$plantillasIngles= $plantillas."/ingles";

// Ya sabemos que usuario es $auth[uname
// La función miraIdioma accedería a la base de datos
// para ver que idioma le corresponde a un usuario.
$idioma=miraIdioma ($auth[uname]);
if ($idioma=="español") $t=new Template($plantillasEspañol);
elseif ($idioma=="ingles") $t=new Template($plantillasIngles);
else {echo "Error en la selección de idioma.";exit;}

// Tenemos dos plantillas: una para la cabecera y otra
// para el cuerpo

$t->set_file(array( "cabecera" => "cabecera.ihtml",
"cuerpo"  => "cuerpo.ihtml"));

// Suponemos que existe una función que nos devuelve
// los valores a presentar.

$valores = obtenValores();  $fecha = date("d/m/a");

// Cada plantilla puede contener un número de variables cuyo
// valor se controla desde el código a través de Template

$t->set_var(array("Fecha"   => $fecha,
"Valores" => $valores));  $t->parse("OUT",
array("cabecera", "cuerpo"));   

/* imprimimos OUT */

$t->p("OUT");

Todas las plantillas asociadas a un objeto Template han de encontrarse en un directorio. En nuesto ejemplo según el idioma se cogen del directorio en inglés o del español. Una vez asignado el directorio a través de la función “set_file” asociamos plantillas a nombres. De esta forma en nuestro programa utilizaremos los nombres aquí indicados para referirnos a la plantilla a utilizar. En este sencillo ejemplo sólo hay dos plantillas “cabecera.ihtml” y “cuerpo.ihtml”.

Aparte de definir las plantillas con las que vamos a trabajar hay que definir las variables que hay que sustituir en dichas plantillas. Cualquier ocurrencia de una variable dentro de una plantilla es sustituido por el valor que le asociamos a través de “set_var”. En nuestro caso la varible “{Fecha}” se sutituye por “$fecha” y “{Valores}” por $valores.

Por ejemplo, el contenido de “cabecera.ihtml” podría ser:

<html><head><title>Valores de cotización<title>
<head><body>Fecha de los valores: {Fecha}

El valor de “{Fecha}” será sustituido de forma automática cuando ejecutemos la función de sustitución de valores “parse”. El resultado lo almacenamos en la variable “OUT” que imprimimos finalmente con la función “p()”.

Las plantillas que se incluyen en PHPLIB tienen una funcionalidad más amplia y sugerimos al lector una lectura de la documentación de PHPLIB para ver todas sus posibilidades.

Ya dijimos que gracias al control de sesiones sería trivial construir una cesta de la compra. Pues PHPLIB incluye una clase llamada "Cart" que es precisamente esto, una cesta de la compra.

El comercio electrónico siempre obliga a que a la hora de comprar el cliente vaya teniendo su carro de compra con los productos que ha ido adquiriendo. El mecanismo por el que se suele mantener este estado del cliente es mediante cookies, aunque ya vimos que PHPLIB podía evitar el uso de "cookies" utilizando el método GET.

La cesta de la compra en PHPLIB es un conjunto de artículos que se almacenan en la base de datos. PHPLIB nos proporciona una API sencillo para añadir, consultar o borrar la lista de artículos en la bolsa de la compra. Para crear nuestra cesta de la compra necesitaremos en general realizar una nueva clase de cesta de la compra basada en "Cart", principalmente para controlar la visualización de los productos, tal y como se muestra a continuación:

class Mi_Cesta extends Cart {
var $classname = "Mi_Cesta";
// Base de datos donde guardamos los artículos
var $database_class = "DB_Article";
var $database_table = "articles";
var $db;
var $sum = 0;  function show_cart_open() {
printf("<table class=cart_table>n");
$this->sum = 0; }
function show_cart_close() {
printf("</table>n");
printf("That's a total of %s.n", $this->sum);}
function show_item($art, $num) {
if (!is_object($this->db)) {
$class    = $this->database_class;
$this->db = new $class; }
$query = sprintf("select * from %s where artid = '%s'",
$this->database_table,   $art);
$this->db->query($query);
while($this->db->next_record()) {
printf(" <tr class=cart_row>n
<td class=cart_cell>%s</td>n",
$this->db->Record["name"]);
printf("  <td class=cart_cell>%s</td>n",
$this->db->Record["price"]);
printf("  <td class=cart_cell>%s</td>n",
$num); $rowsum = $num * $this->db->Record["price"];
$this->sum += $rowsum;
printf("  <td class=cart_cell>%s</td>n",
$rowsum); printf(" <tr>n");} }  }

Para utilizar la clase "Cart" vamos a necesitar crear una tabla más donde se encuentren la descripción de todos los artículos que vendamos en nuestra tienda. Esta tabla la podemos crear dentro de una base de datos propia para cada uno de nuestros clientes, base de datos que también deberá tener la información de "active_sessions" y "auth_user".

Un ejemplo sencillo podría ser:

# # Estructura de la tabla de 'articles' #
CREATE TABLE articles (  name text, price float(8,2),
artid int(11) DEFAULT '0' NOT NULL auto_increment,
PRIMARY KEY (artid)  );

En la documentación de PHPLIB se encuentran todos los detalles necesarios para un uso completo de esta clase. Su descripción completa desbordaría el espacio del que disponemos para este artículo.

PHPLIB incluye también un conjunto de clases para facilitar la creación de código HTML. Por un lado con Sql_Query podemos construir formularios HTML a partir de los cuales hacer peticiones SQL a una base de datos.

Con Table podemos construir tablas HTML de una forma sencilla, muy útil para presentar el contenido de matrices de datos y de resultados de consultas a una base de datos.

Menu es un widget que a partir de un árbol genera un menú jerárquico con enlaces que se puede utilizar como barra de navegación. De esta forma se puede facilitar mucho la creación de este tipo de barras de navegación, que siempre son muy engorrosas de mantener y que, en muchos casos, llevan a los diseñadores web al uso de marcos (frames) en sus páginas.

OOHForms es un widget para la construcción de formularios con la ventaja de que puede utilizar Javascript y SSI para comprobar que los valores de los campos del formulario son correctos. Antes de enviar el formulario se pueden chequear los valores que los campos del formulario, evitando así el envío de datos que desde su origen sus erróneos.

Por último existen dos últimos widget: "tpl_form" para la construcción de formularios utilizando OOHForms pero a un nivel de abstracción mayor (el objeto es una caja negra de la que podemos obtener datos, pero no sabemos como se obtienen) y Tree que permite representar en HTML estructuras de datos complejas en árbol como subdirectorios.

Resumen de PHPLIB

Os hemos presentado PHPLIB, una librería orientada a objetos que facilita en gran medida las necesidades más básicas a la hora de montar un sitio web basado en PHP: control de sesiones y de identidad. Junto a estas necesidades básicas PHPLIB nos ofrece también clases para programar nuestros sitios utilizando plantillas lo facilita el trabajo en paralelo de desarrolladores PHP y creadores de páginas HTML y diseñadores gráficos.

Hemos visto también como PHPLIB no se ha olvidado del comercio electrónico y entre sus objetos incluye una cesta de la compra integrada con el control de sesiones y de autenticación. Esto nos va a permitir montar tiendas virtuales en Internet utilizando PHP con un esfuerzo mínimo. Por último PHPLIB también contiene un conjunto de widgets que nos liberan de tareas tan arduas como chequear los valores de un formulario o la presentación en HTML de complejas estructuras en árbol.

Referencias

• [1] http://phplib.netuse.de: Librería PHPLIB