Dinamicas

Programación orientada a objetos
mayo, 2005

ESTUDIO DE TECNOLOGÍAS PARA LA
CREACIÓN DE PÁGINAS WEB DINÁMICAS

David del Pozo González
Alberto Pastor Nieto

Departamento de Informática y Automática
Universidad de Salamanca

Información de los autores:
David del Pozo González
Alumno de tercer curso de Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias - Universidad de Salamanca
david_del_pozo@hotmail.com
Alberto Pastor Nieto
Alumno de tercer curso de Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias - Universidad de Salamanca
alberto.es@gmail.com

Este documento puede ser libremente distribuido.
© 2005 Departamento de Informática y Automática - Universidad de Salamanca.

Resumen
Este documento recoge las características más representativas de las principales tecnologías
para la creación de páginas Web dinámicas, haciendo especial hincapié en las más utilizadas:
PHP, ASP.NET y JSP.
Se trata de dar una visión global de cada una de ellas, desde la perspectiva de la orientación
a objetos, estudiando los diferentes lenguajes utilizados en dichas tecnologías, la evolución que
han seguido, su funcionamiento y características principales.

Abstract
This document picks up the most representative characteristics of the main technologies for the
creation of dynamic Web pages, making special emphasis in the most classics: PHP, ASP.NET
and JSP.
Giving a global vision of each one, from the perspective of the object orientation, studying
the different languages used in these technologies, the evolution they have followed, their
operation and main characteristics.

Programación Orientada a Objetos

i

Tabla de Contenidos
ESTUDIO DE TECNOLOGÍAS PARA LA CREACIÓN DE PÁGINAS WEB
DINÁMICAS ................................................................................................................................ 1
1.

Introducción ................................................................................................................. 1

2.

CGI (Common Gateway Interface).............................................................................. 2

3.

Coldfusion.................................................................................................................... 3

4.

PHP (Hypertext Preprocessor) .................................................................................... 4
4.1.
4.2.

Funcionamiento................................................................................................... 4

4.3.
5.

Introducción ........................................................................................................ 4
Evolución y características del lenguaje ............................................................. 5

JSP y Servlets .............................................................................................................. 9
5.1.

Servlets................................................................................................................ 9

5.2.

JSP (Java Sever Pages)..................................................................................... 12

5.2.1
5.2.2

Como trabaja JSP.......................................................................................... 13

5.2.3
6.

Introducción.................................................................................................. 12
JAVA ............................................................................................................ 15

ASP.NET ................................................................................................................... 17
6.1.

Introducción ...................................................................................................... 17

6.2.

Arquitectura de .NET Framework..................................................................... 17

6.3.

Funcionamiento páginas ASP en el servidor..................................................... 18

6.3.1

Interacción cliente servidor........................................................................... 18

6.3.2

Procesamiento del lado del servidor ............................................................. 19

6.4.

Lenguajes soportados por ASP.NET................................................................. 20

6.5.

C# ...................................................................................................................... 22

7.

Conclusiones.............................................................................................................. 24

8.

Bibliografía ................................................................................................................ 25
8.1.
8.2.

PHP ................................................................................................................... 25

8.3.

Tecnología Java................................................................................................. 25

8.4.

CGIs .................................................................................................................. 25

8.5.

Coldfusion......................................................................................................... 26

8.6.

ii

ASP.NET........................................................................................................... 25

Información general .......................................................................................... 26


1.

Introducción

La evolución de Internet ha sido muy rápida, así como la de sus tecnologías asociadas. Al
principio HTML ofrecía todo lo que se necesitaba, mostrar el contenido de páginas cuya
información no solía cambiar o cambiaba muy poco. Pero rápidamente cambiaron las
necesidades precisando algo más potente que nos ofreciera la posibilidad de crear páginas que
se relacionaran con el usuario y cuyo contenido cambiara según la necesidad en un momento
determinado. Todo esto con HTML era irrealizable, por ello fueron apareciendo lenguajes y
herramientas que nos permiten crear páginas dinámicas, más fáciles de mantener y que se
adecuan a las necesidades de cada usuario.
Este tipo de lenguajes para la realización de páginas dinámicas ha ido también
evolucionando con el paso de los años, siendo éstos cada vez más flexibles y adaptándose a las
corrientes de programación de cada momento. La gran mayoría de estos lenguajes han ido
evolucionando hacia el paradigma de la orientación a objetos.
Las aplicaciones que generan las páginas dinámicas se encuentran situadas en los
servidores Web. Se encargan de procesar las peticiones que realiza un usuario desde su
navegador y en tiempo real procesan la página de acuerdo con la información que ha solicitado
ese determinado cliente. Se genera una página en HTML que será visualizada en el navegador
de este tal y como llega. Todo este proceso recae del lado del servidor, siendo esto una gran
ventaja, ya que el cliente no debe preocuparse de nada.
En este trabajo se tratará de dar una visión global de las diversas tecnologías que existen
para crear este tipo de páginas y los lenguajes que éstas utilizan para crear las aplicaciones que
las generan. Dando una visión de cómo es la evolución de la gran parte de éstos hacia la
orientación a objetos y de sus principales características. Este estudio se centra sobre todo en las
tecnologías JSP, PHP y ASP.NET, por ser las de uso más extendido en la actualidad, no
olvidando otras también importantes pero tratados de forma más general.

-1-

Estudio de tecnologías para la creación de páginas Web dinámicas

2.

CGI (Common Gateway Interface)

Cuando Internet inició su funcionamiento como se conoce hoy día, empezando a tomar
popularidad sobre 1993, solo se podía apreciar texto, imágenes y enlaces. La introducción de
plugins en los navegadores permitió mayor interactividad entre el usuario y el cliente, aunque
éstos tenían bastantes limitaciones por la velocidad y la necesidad de tener que descargar e
instalar cada plugin que se necesitara, por lo que éstos se desarrollaron sobre todo en áreas de
vídeo, audio y realidad virtual.
CGI supuso un gran cambio en la forma de tratar la información de la Web siendo una de
las primeras soluciones que se plantearon para poder crear páginas con contenido dinámico, que
se relacionan con el usuario. CGI es un estándar para establecer la comunicación entre un
servidor Web y un programa, para que éste pueda interactuar con recursos en Internet. Un CGI
entendiéndolo como la aplicación es un programa que se ejecuta en tiempo real en un servidor
Web en respuesta a una solicitud de un cliente desde su navegador. Cuando esto sucede el
servidor ejecuta un proceso hijo que recibirá los datos del usuario, pone a disposición del mismo
algunos datos en forma de variables de entorno y captura la salida del programa para enviarlo
como respuesta al navegador del usuario. Los programas CGIs se pueden programar en
cualquier lenguaje, pero a la hora de la práctica hay que tener en cuenta si el sistema operativo
del servidor lo soporta, los más utilizados son C y Perl.

Figura 1. Esquema de funcionamiento de CGI


2

Del Pozo y Pastor

3.

Coldfusion

ColdFusion proporciona un lenguaje de script (CFML: Cold Fusion Markup Language) que usa
etiquetas (tags) similares a las de HTML. Dreamweaver (su ultima versión es MX 2004) es la
herramienta que nos proporciona Macromedia para trabajar con CFML, ya que ha sido mejorada
especialmente para que generar código de Coldfusion a través de su entorno visual resulte fácil
y rápido. Asimismo es posible usar cualquier otro editor de texto.
El servidor de Coldfusion se instala en la misma máquina del servidor Web (ver figura) y
cada vez que se pide una pagina cuya extensión termina en '.cfm' (extensión de Coldfusion), el
servidor Web envía esta pagina al servidor Coldfusion, el cual procesa este archivo (por
ejemplo, accede a la base de datos o conecta con otra aplicación), antes de enviarlo de vuelta el
servidor Web y finalmente a la persona que la pidió desde su navegador. El navegador recibe
esta pagina como un archivo de texto o un archivo HTML.

Figura 2. Esquema de funcionamiento de Coldfusion
Ejemplo de CFML de ColdFusion:
<CFFUNCTION NAME="getTomorrow">
<CFRETURN dayofweekAsString(dayofweek(dateadd("d", 1, now())))>
</CFFUNCTION>
<CFOUTPUT>Tomorrow is #getTomorrow()#.</CFOUTPUT>
ColdFusion es una herramienta que corre en la mayoría de los servidores Web de
Windows, Linux y Solaris. Puede trabajar con variedad de gestores de bases de datos como:
Microsoft Access, Oracle, Sybase, Microsoft SQL Server y muchas otras. Además se integra
con los principales estándares de Internet y modelos de componentes, entre ellos: XML,
servicios Web, Java, .NET/COM y CORBA.

3

¡Error! No se encuentra el origen de la referencia.Programación Orientada


4.

PHP (Hypertext Preprocessor)

4.1. Introducción
PHP (Hypertext Preprocessor) es uno de los lenguajes de lado servidor más extendidos en
Internet, es un lenguaje de script que se pude usar inmerso en HTML o de forma independiente
(aunque el primer uso es mucho más común). Nacido en 1994, se trata de un lenguaje de
creación relativamente reciente que ha tenido una gran aceptación en la comunidad de
webmasters debido sobre todo a la potencia y simplicidad que lo caracterizan.
Es un producto Open Source (código abierto). Proporciona grandes facilidades para manejo
de patrones y acceso a bases de datos. Puede interactuar con muchos motores de bases de datos
tales como MySQL, MS SQL, Oracle, Informix, PostgreSQL y ODBC.
PHP corre en numerosas plataformas utilizando el mismo código fuente, pudiendo ser
compilado y ejecutado en diferentes versiones de Unix, Windows y Macs, así como con un
amplio número de servidores Web como Apache, Microsoft IIS y Netscape Enterprise Server.
Posee una excelente biblioteca de funciones que permite realizar cualquier labor (acceso a
base de datos, encriptación, envío de correo, gestión de un e-commerce, XML, creación de PDF,
etc.). Además existen en Internet multitud de programas gratuitos creados en PHP para realizar
una buena cantidad de tareas habituales tales como servidores de banners, servidores de
sistemas de afiliación, servidores orientados al control de bases de datos, sistemas de agenda,
sistemas de chat o comercios electrónicos. Por ejemplo: phpMyAdmin (gestor bases de datos
MySQL), phpAdsNew (servidor de banners) o PHP-Nuke (sistema completo para
administración de un portal Web).

4.2. Funcionamiento

Figura 3. Esquema de funcionamiento de PHP


4

Del Pozo y Pastor

PHP no se compila para conseguir código máquina, sino que, en vez de eso, existe un intérprete
que lee el código y se encarga de ejecutar las instrucciones que contiene este código. Esto ayuda
a que el desarrollo con PHP sea rápido y dinámico, puesto que no hay que compilar el código
cada vez que se haga un cambio. Actualmente, la última versión de PHP (PHP5) utiliza un
intérprete denominado Zend 2. En la figura anterior se puede ver de forma gráfica el interprete
Zend (antecesor de éste), que funciona de la misma forma, para observar cómo se integra con
todo el sistema.

4.3. Evolución y características del lenguaje
Con las primeras 2 versiones de PHP, PHP 3 y PHP 4, se había conseguido una plataforma
potente y estable para la programación de páginas del lado del servidor. Sin embargo, todavía
existían puntos negros en el desarrollo PHP que se han tratado de solucionar con la versión 5,
aspectos que se echaron en falta en la versión 4 casi desde el día de su lanzamiento, como la
programación orientada a objetos (POO) que, a pesar de que estaba soportada a partir de PHP3,
sólo implementaba una parte muy pequeña de las características de este tipo de programación.
Con PHP4, se reescribió el motor de PHP para hacerlo mucho más rápido y estable, pero la
POO, que había introducido la anterior versión del lenguaje, no se llegó a modificar
prácticamente. Aun así, durante la vigencia de PHP 4, la programación orientada a objetos fue
utilizada habitualmente, a menudo en aplicaciones de gran tamaño. Entornos donde se puso de
manifiesto la falta de potencia de la POO en PHP 4 y la necesidad de mejorarla en una nueva
versión.
Una debilidad existente era que todos los métodos y atributos sólo tenían visibilidad
pública, pero el mayor problema se basaba en que, cada vez que se asignaba una variable que
contenía un objeto a otra variable, o se pasaba un objeto como parámetro en una función, se
realizaba una copia (un clon) de ese objeto y quedaba a disposición del programa en la nueva
variable o parámetro. Aunque también se permitía el paso por referencia, esto no dejaba de ser
un problema, puesto que obligaba a utilizar ese mecanismo en múltiples lugares, era tedioso de
usar. Además era fácil de olvidar en algún punto del archivo, con lo que el programa fallaba.
Para solventar este problema, en PHP5 los objetos son referenciados a través de los
manejadores de objetos (Object handles), que son una especie de punteros que apuntan hacia los
espacios en memoria donde residen los objetos. Como consecuencia de esta característica,
cuando se realiza una asignación de un objeto, en realidad se duplica el manejador y no el objeto
en sí. Asimismo cuando son los objetos son pasados como parámetros a las funciones, éstas
trabajan con un duplicado del manejador
Gráficamente el proceso es el siguiente:

Figura 4. Funcionamiento de los manejadores de objetos

5



Ejemplo de una clase en PHP:
class Vehiculo
{
//// atributos públicos
public $velocidadMaxima;
public $potencia;
public $color;
public $peso;
//// constructor
function __construct($potencia,$peso)
{
$this->potencia = $potencia;
$this->peso = $peso;
return true;
}
//// metodo relacionPesoPotencia()
function relacionPesoPotencia()
{
if ($this->potencia>0)
{
return ($this->peso/$this->potencia);
}
return -1;
}
} //// termina def. clase Vehiculo

//// creamos un vehiculo (10 CV, 100 Kg)
$obj_vehiculo = new Vehiculo(10,100);
echo $obj_vehiculo->relacionPesoPotencia()."<br>";
//// muestra 10
//// PHP5:
//// asignación de objetos = asignación de manejadores
(handlers)
$obj_alias = $obj_vehiculo;
echo $obj_alias->relacionPesoPotencia()."<br>";
//// muestra 10
//// los dos manejadores referencian al mismo objeto
$obj_alias->peso = 60;
echo $obj_vehiculo->relacionPesoPotencia()."<br>";
//// muestra 6
echo $obj_alias->relacionPesoPotencia()."<br>";
//// muestra 6


6

Del Pozo y Pastor

El lenguaje PHP posee las características típicas de un lenguaje orientado a objetos aunque
presencia algunas carencias con respecto a Java o C#:
Abstracción: permite usar tanto variables y métodos de instancia como de clase (static).
Encapsulación: permite el acceso public, private y protected a atributos y métodos. La
propiedad por defecto es public.
Modularidad: se puede dividir la aplicación en varios archivos .php para hacer más
sencilla su depuración y entendimiento.
Herencia: permite solamente la herencia simple, evitando los problemas derivados de la
herencia múltiple. Proporciona interfaces para suplir esta carencia, las interfaces se
utilizan en la POO para definir un conjunto de métodos que implementa una clase. Una
clase puede implementar varias interfaces o conjuntos de métodos.
Comprobación débil de tipos.
Ligadura tardía.
Sobrecarga de métodos (overloading): no está soportada en PHP, debido a que es un
lenguaje débilmente tipado, no sabría a que función llamar en cada momento, por
consistencia la sobrecarga por cantidad de parámetros tampoco funciona.
Soporte para manejo de excepciones.
No soporta la persistencia de objetos. Provee unos métodos que puedes ser llamados por
el objeto para ser serializado, convirtiéndolo en un string para poder ser almacenado y
posteriormente recuperado.
Posee cantidad de entornos de desarrollo como puede ser: Zend Studio, PHP-Eclipse,
Eclipse-TRUStudio, PHPEdit, PhpED, PHP Expert, Edit+, UltraEdit y DevPHP 2.

7



Ejemplo de herencia e interfaces. La clase Piloto es derivada de Persona e implementa las
interfaces Ficha e Identificación.
interface Ficha
{
public function queEres();
}
interface Identificacion
{
public function quienEres();
}
//// clase Persona
class Persona
{
public $nombre;
}
//// un Piloto es una Persona
class Piloto extends Persona implements Ficha, Identificacion
{
public function queEres()
{
return "Soy un piloto de carreras";
}
public function quienEres()
{
return "Mi nombre es: ".$this->nombre;
}
}


8

Del Pozo y Pastor

5.

JSP y Servlets

5.1. Servlets
Fueron introducidos por Sun en 1996 como pequeñas aplicaciones Java para añadir
funcionalidad dinámica a los servidores Web. Los Servlets eran una alternativa para sustituir a
los CGIs, que al igual que éstos, reciben una petición del cliente y generan los contenidos
apropiados para su respuesta, aunque el esquema de funcionamiento es diferente:

Figura 5. Esquema de funcionamiento de servlets
Lo primero que hace es leer cualquier dato que recibe del usuario normalmente de la
página Web, aunque también lo puede recibir de un applet de Java. Obtiene información sobre
la petición concreta http, información obtenida de cookies, nombre de host, IP…
Genera los resultados, a partir de los datos de entrada, accediendo a una base de datos,
ejecutando una llamada RMI… A partir de estos resultados genera un documento con los
mismos, normalmente una página HTML. Establece cuales son los parámetros de respuesta y la
envía al cliente.
Todos los servlets asociados con un servidor se ejecutan dentro de un proceso simple. Cada
vez que llega una petición, la JVM (Máquina virtual Java) crea un hilo Java para manejar la
petición, reduciendo así la sobrecarga del sistema.
Una desventaja de esta aproximación es que el contenido (estático y dinámico) de la página
generada reside en el código fuente del servlet. Como consecuencia, cualquier cambio estático
en la página (cambio de una URL de un enlace o una imagen) requiere la intervención del
programador y la recompilación del servlet.
Respecto otro tipo de tecnologías, los Servlets tienen muchas más ventajas:

9



Independencia: al estar escritos en Java, pueden ser ejecutados en multitud tipo de
servidores, independientemente también de su sistema operativo.
Integración: los Servlets están desarrollados en Java y por ello tienen la ventaja de
poder utilizar otras tecnologías de Java como JDBC, para el acceso a bases de datos,
JNDI para acceso a directorios, RMI para acceso remoto de fuentes. Los Servlets están
completamente integrados en la tecnología Java interaccionando con otros componentes
Java como son las JavaBeans, otros Servlets…
Personalización de la relación con el usuario: permiten la utilización de cookies y
sesiones, de forma que se puede guardar información específica acerca de un usuario
determinado para personalizar la interacción cliente/servidor.
Eficiencia: los Servlets ejecutan los procesos por hilos separados. Esto es mucho más
eficiente que el modelo de GCI, donde un nuevo proceso es creado por cada petición.
Con GCI el uso de recursos de memoria es muy elevado comparándolo con los Servlets.
Escalabilidad: debido a que está escrito en Java, la escalabilidad es alta. Pudiendo crear
la aplicación en una plataforma para luego ser utilizada en cualquier otra que lo soporte.
Robustez y seguridad: debido a las características del lenguaje Java, que es bastante más
robusto que otros lenguajes de programación en lo que respecta a errores de
“manejadores”, esa característica de robustez y seguridad se puede extrapolar a los
Servlets. A esto hay q sumarle que la comunicación con el servidor no es vulnerable a
los típicos ataques. También pueden realizar tareas de proxy para un applet. Debido a
las restricciones de seguridad, un applet no puede acceder directamente por ejemplo a
un servidor de datos localizado en cualquier máquina remota, pero sí podría hacerlo a
través de un servlet.
Interacción cliente/servidor: los servlets pueden obtener fácilmente información acerca
del cliente (la permitida por el protocolo HTTP), tal como su dirección IP, el puerto que
se utiliza en la llamada, el método utilizado (GET, POST), etc.
No se exige una gran inversión: el incremento de coste no es muy alto si lo comparamos
con GCI a la hora de dar una funcionalidad a nuestro servidor. Su fácil reutilización
también es una característica a tener en cuenta en el plano económico.
Existen paquetes que hacen más fácil la implementación: el programador dispone de
una cantidad considerable de paquetes escritos en Java que hace más fácil el trabajo con
los servlets.


10

Del Pozo y Pastor

Un servlet, como ya se dijo con anterioridad es una clase Java con alguna restricción
derivada de su herencia de su superclase servlet, como se muestra en este ejemplo.

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse
res)throws ServletException, IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<HTML>");
out.println("<HEAD><TITLE>Hello World</TITLE></HEAD>");
out.println("<BODY>");
out.println("<BIG>Hello World</BIG>");
out.println("</BODY></HTML>");
}
}

11



5.2. JSP (Java Sever Pages)
5.2.1 Introducción
La utilización solamente de Java Servlets limita mucho las posibilidades a la hora a de realizar
una página dinámica conllevando nuevos problemas a la hora de modificar la apariencia al tener
que cambiar código y después recompilarla. Es una forma de trabajo poco eficiente.
Solucionaremos varios de estos problemas añadiendo JSP, ya que permite separar la lógica
de negocio de la presentación de la página.
Lo más típico a la hora de utilizar esta tecnología es utilizar el patrón Modelo-VistaControlador (MVC) [Buschmann et al., 1996]. La parte de procesamiento la puede llevar a cabo
un Servlet, la lógica de negocio Javabeans, separando estas partes de la presentación que es
realizada mediante una página JSP, que en realidad es una página HTML con partes de código
específico JSP.
Esto permite a la hora de trabajar una mayor eficiencia ya que a la vez que un programador
implementa la lógica de negocio y su procesamiento, un diseñador diseña la apariencia de la
página. Otra de las ventajas es que si se produce un cambio en una de las partes de la aplicación
el resto no tienen porqué ser modificadas, fomentando así la reutilización de los JavaBeans,
pudiendo ser utilizados por otras páginas JSP, Servlets u otras aplicaciones Java.

Arquitectura MVC
Modelo

Vista

Datos (Propiedades Beans)

Beans

JSPs
Evento (Forward)

Evento (Petición)

Controlador

Info.Interfaz
(HTML)
Datos
(<jsp.getproperty>)
Info.Eventos
(Parámetros)

Interfaz

Servlet
Evento (Petición)

Navegador

Figura 6. Modelo Vista Controlador con JSP
Los JavaBeans se idearon como un mecanismo para diseñar componentes, generalmente de
tipo gráfico, que pudiesen ser reutilizados por los entornos de desarrollo integrado (IDE). Para
ello el interfaz de un JavaBean debería ser capaz de mostrar su contenido en tiempo de
ejecución. Esta característica ha hecho que los JavaBeans se utilicen en otros entornos, como
puede ser el desarrollo de aplicaciones Web.
Un JavaBean no es más que una clase java que sigue ciertas convenciones establecidas,
como puede ser el nombrado de sus métodos. Por ejemplo si tenemos un atributo que sea
propiedad, los métodos de lectura y escritura serán: getPropiedad() y setPropiedad().


12

Del Pozo y Pastor

5.2.2 Como trabaja JSP
Para poder utilizar esta tecnología es necesario un servidor que soporte páginas HTML y un
contenedor JSP, donde se ejecutarán las etiquetas JSP, como Tomcat. El primer componente de
implementaciones basadas en servlets, es un servlet especial llamado “compilador de páginas”.
Este servlet junto a sus clases Java asociadas se conoce como contenedor JSP. El contenedor
está configurado para llamar al compilador de páginas para todas las peticiones que coincidan
con una página .jsp. Su misión es compilar la página .jsp en un servlet que será el encargado de
generar el contenido dinámico. Para compilar una página, el compilador de páginas busca las
etiquetas JSP generando código Java para cada una de ellas. Las etiquetas de HTML las
convierte a cadenas de Java. Las etiquetas que referencian a JavaBeans se traducen a sus
correspondientes objetos y métodos. Con el servlet construido, el compilador de páginas llama
al compilador Java para que compile el código fuente y añade el fichero de bytecode resultante
al directorio del contenedor JSP. El compilador de páginas invoca al servlet creado que genera
la respuesta al cliente. Mientras el código de la página JSP no cambie, todas las referencias a la
página ejecutarán este servlet.

Recibe
solicitud

¿Existe
Servlet
JSP?

No

Escanear
página JSP

Si

¿Está en
memoria?

Generar
código fuente
servlet JSP

No

Cargar
Servlet JSP

Compilar
selvlet JSP

Generar
respuesta

Si

Generar
respuesta

Figura 7. Esquema de funcionamiento de páginas JSP
Las características ofrecidas por JSP como alternativa a la generación de contenido
dinámico para la Web se pueden resumir en:
Respecto a su rendimiento nos proporciona varias ventajas. Utilización de hilos para
manejar las peticiones, manejo de múltiples peticiones en un momento dado, el contenedor

13



servlet puede ser ejecutado como parte del servidor Web y una gran facilidad para compartir
recursos entre peticiones.
La reutilización es una ventaja reseñable de este tipo de tecnología. Los JavaBeans pueden
ser utilizados en servlets, applets u otras aplicaciones Java.
Su mantenimiento resulta fácil.
Siguiendo el patrón MVC explicado anteriormente se pude dividir el trabajo, entre
desarrolladores y diseñadores.

Este es un sencillo ejemplo de una página JSP
<%!-- Breve ejemplo de página JSP --%>
<%@ page language='java' contentType='text/html;charset=iso8859-1'%>
<%@ page import='java.util.Date' %>
<html>
<head>
<title>Hola Mundo</title>
</head>
<body>
Hola, esto es una página JSP.
<p>La hora del servidor es <%= new Date() %></p>
</body>
</html>

Este código es traducido en un servlet que tras su ejecución genera esta página de HTML:
<html>
<head>
<title>Hola Mundo</title>
</head>
<body>
Hola, esto es una página JSP.
<p>La hora del servidor es Fri Apr 29 14:21:48 CET 2005</p>
</body>
</html>


14

Del Pozo y Pastor

5.2.3 JAVA
Esta tecnología distribuida es muy potente ya que se sustenta en el lenguaje de
programación Java, con las siguientes características que se verán a continuación.
Java es un lenguaje orientado a objetos puro que recibe muchas influencias de C++ e
intenta mejorarlo sin perder su simplicidad y su potencia.
En lo que destaca realmente Java y lo que lo hace verdaderamente potente es su
independencia de plataforma, pudiéndose sus aplicaciones ejecutar en cualquier sistema siempre
y cuando éste tenga instalada la máquina virtual de Java (JVM).

Figura 8. Esquema de compilación del código Java
Es un lenguaje estrictamente tipado lo que proporciona mayor seguridad y la ventaja de
poder detectar errores en tiempo de compilación.
Soporta hilos con las ventajas que ello trae en el uso de recursos de memoria.
Soporta el polimorfismo. Una clase derivada puede tener un método con el mismo nombre
que uno de su superclase, pudiendo llamar a éste (el de la clase derivada). Por defecto, en Java
todos los métodos son virtuales. Es decir, que el de la subclase “solapa” al de la superclase.
Todos los objetos son referencias, éstos son creados en el montículo o heap.
Incorpora un recolector de basura para liberar la memoria dinámica en desuso haciendo que
el programador se desentienda de esta tarea.
No hay ficheros de cabecera. Simplificando bastante el proceso de implementación.
Las variables se inicializan automáticamente con un valor por defecto al ser creadas, a no
ser que el programador le indique otro explícitamente.
La herencia simple de implementaciones. Una clase sólo puede heredar de una superclase,
evitando todos los problemas de ambigüedad que se pueden producir con la herencia múltiple.
La carencia de herencia múltiple se solventa con el uso de interfaces. Las interfaces son un
concepto que proporciona un mecanismo sencillo para describir de forma abstracta la
funcionalidad que debe implementar una clase de objetos. Una clase puede heredar de varias
interfaces.
Principio de encapsulación: todo el código tiene que pertenecer a una clase, no puede haber
variables ni funciones globales.

15



La abstracción es soportada por variables y métodos de instancia así como variables y
métodos de clase, pudiendo haber clases abstractas.
Los objetos no son persistentes, es decir, si por algún motivo el sistema donde son
ejecutados necesita ser reiniciado, los objetos que mantiene se perderán. Para lograr objetos
persistentes, esto es, que conserven sus características, el programador deberá guardarlos en
disco y recuperarlos cuando sea necesario.
Da soporte al manejo de excepciones, permitiendo ver qué excepción se ha producido e
intentar recuperarse de ella.
Java carece de punteros haciendo más sencilla la programación, ya que la mayor parte de
los fallos son debidos a su mala utilización.
En Java no hay sobrecarga de operadores, que es la capacidad para transformar los
operadores de un lenguaje como por ejemplo el +, -, etc. Algunos programadores ven la
carencia de esta característica como una ventaja argumentando que su utilización complica el
código.
En comparación con el lenguaje C++ que permite la instanciación de variables u objetos de
cualquier tipo en tiempo de compilación sobre memoria estática (ligadura estática), o en tiempo
de ejecución sobre memoria dinámica (ligadura dinámica), Java requiere que todas las variables
de tipos primitivos sean instanciadas en tiempo de compilación, y todos los objetos sean
instanciados en memoria dinámica en tiempo de ejecución (ligadura dinámica).


16

Del Pozo y Pastor

6.

ASP.NET

6.1. Introducción
Desde hace algún tiempo, Microsoft está llevando adelante una estrategia para construir una
nueva tecnología tendiente a crear aplicaciones Web distribuidas y que aprovechen al máximo
las posibilidades que ofrece Internet. Esta tecnología, que lleva el nombre de .NET, y que
incluye un nuevo lenguaje denominado C#, una nueva versión de Visual Basic, con el nombre
de Visual Basic.Net y otra serie de tecnologías, entre las que se encuentra: ASP.NET, que viene
a reemplazar a las Active Server Pages (ASP), logrando el desarrollo de aplicaciones Web más
dinámicas, con un código más claro y limpio, por tanto reusable y más simple, ya que el entorno
ASP.NET permite la creación automática de alguna de las tareas más comunes para un creador
Web, cómo los formularios o la validación de los datos.
Funciona sobre plataformas Windows (2000 y XP) y con el servidor Microsoft IIS
(Internet Information Server). Posee un potente entorno de desarrollo, Visual Studio .NET que
permite crear de forma rápida y cómoda aplicaciones Web.

6.2. Arquitectura de .NET Framework
.NET Framework
Windows Forms

ASP.NET
Web

Servicios
Marco de Servicios
Base

Datos

Depuración

...

Common Language Runtime
Servicios del Sistema

Figura 9. Arquitectura de .NET Framework
El Framework de .NET es una infraestructura sobre la que se reúne todo un conjunto de
lenguajes y servicios que simplifican enormemente el desarrollo de aplicaciones. Los
principales componentes de este entorno son: lenguajes de compilación, biblioteca de clases de
.Net y todos los servicios que ofrece y CLR (Common Language Runtime). Todos estos
conceptos se irán viendo más adelante.

17



6.3. Funcionamiento páginas ASP en el servidor
6.3.1 Interacción cliente servidor
Cuando una página Web Form (página con un formulario) de ASP.NET se baja en navegador
del usuario se añade código adicional a versiones anteriores de ASP. Este código extra habilita
una funcionalidad mayor al formulario, incluyendo la habilidad de mantener el estado de valor
de formulario. El servidor determina cuál es navegador del usuario y envía la página correcta
para éste.
Cuando se reciben las respuestas del formulario, los valores del formulario se mantienen
con una nueva característica de ASP.NET: “State Bags” y están comprimidas en un elemento
del formulario oculto conteniendo el estado de la página (Viewstate). Esto permite que los
elementos del formulario con los que el usuario ha interactuado mantengan los mismos valores
que cuando la página fue enviada.
Como se ilustra en la figura, el navegador puede pedir la información al usuario y enviarla
al servidor mediante dos métodos de HTTP: GET y POST.

Figura 10. Esquema de interacción entre el usuario y las páginas ASP


18

Del Pozo y Pastor

6.3.2 Procesamiento del lado del servidor
El proceso de compilar y entregar las páginas de ASP.NET sigue las siguientes fases:
1. IIS encuentra el archivo requerido por el URL en el disco duro.
2. Se comprueba la extensión del archivo pedido para ver si tiene que ser enviado al
usuario o ser procesado.
3. Si es la primera visita desde que el archivo se modificó, el código ASP es compilado
usando el compilador del CLR, en MSIL, y después en el código máquina específico
para la ejecución.
4. El código binario es una clase DLL de .NET y se guarda en una localización temporal.
5. La próxima vez que se pida la página, el servidor verificará si el código ha cambiado. Si
el código es el mismo, entonces se salta el paso de la compilación. En caso contrario, se
borra la clase y recompilaría.
6. El código compilado se ejecuta y se interpretan los parámetros recibidos en la petición.
7. Si el desarrollador ha usado Web forms, entonces el servidor puede descubrir que
navegador está usando el usuario y sirve páginas adaptadas a sus necesidades, por
ejemplo, devolviendo código específico para Netscape, o Wireless Markup Language
(WML) para móviles.
8. Cualquier resultado es devuelto al navegador del usuario.
9. Los elementos del formulario son convertidos al enviarse al cliente en código de
etiquetas y script, como puede ser el HTML, y JavaScript para los navegadores Web, y
WML y WMLScript para móviles.

Figura 11. Esquema de procesamiento de las páginas ASP

19



6.4. Lenguajes soportados por ASP.NET
Microsoft, ASP.NET y NET Framework proporcionan tres idiomas principales: JScript.NET,
VB.NET, y C #. Otros vendedores tienen disponibles o están desarrollando versiones adaptadas
a .NET de muchísimos otros lenguajes como APL, CAML, Cobol, Eiffel, Fortran, Haskell,
Java, Mercury, ML, Mondrian, Oberon, Oz, Pascal, Perl, Python, RPG, Scheme o Smalltalk.
JScript.NET y VB.NET sustituyen respectivamente a los lenguajes JScript y VBScript
(utilizados en versiones anteriores de ASP para crear las páginas). Han sido totalmente
actualizados y por primera vez son lenguajes plenamente orientados a objetos y tienen total
acceso a los servicios proporcionados por .NET.
C# es el nuevo lenguaje creado por Microsoft para su plataforma .NET. C# es un lenguaje
orientado a objetos que intenta combinar los mejores elementos de múltiples lenguajes de
amplia difusión como C++, Java, Visual Basic o Delphi. La idea principal detrás del lenguaje es
combinar la potencia de lenguajes como C++ con la sencillez de lenguajes como Visual Basic, y
que además la migración a este lenguaje por los programadores de C/C++/Java sea lo más
inmediata posible. Más adelante se profundizará sobre este lenguaje.
Todos los lenguajes de .NET tienen acceso a las mismas bibliotecas de clases, el mismo
tipo de sistemas e interoperabilidad plena con los componentes COM, y además, objetos
escritos bajo un lenguaje pueden usarse, heredarse, y ser extendidos sobre cualquiera de los
otros. Éste es un concepto muy poderoso e introduce la idea de la independencia del lenguaje.
Esto se logra a través de la tecnología CLR (Common Language Runtime).
El CLR toma el código de cualquier lenguaje del .NET y lo convierte en un lenguaje
intermedio (Microsoft Intermediate Language [MSIL]) y a su vez, este lenguaje intermedio se
compila al código máquina específico. Varios proyectos están en marcha para conseguir migrar
esta tecnología del .NET a plataformas distintas de Windows, como Mono y Portable.NET en la
comunidad del código abierto, además de desarrollos de Corel y Borland.
ASP.NET permite la modularización de nuestra aplicación separando la presentación o
interfaz de la parte lógica en diferentes archivos. Lo cual, supone más comodidad para el
programador a la hora de actualizar y depurar, al evitar el acoplamiento. Como se observa en la
figura, se pueden tener archivos .aspx (extensión de ASP.NET) implementando la interfaz y por
otro lado archivos .cs o .vb, que pertenecen a los lenguajes C# y VBScript.NET, implementando
la lógica. En los archivos .aspx se puede usar cualquiera de los lenguajes de ASP.NET como
lenguajes de script, mezclándolos con HTML, mientras que, en los ficheros donde va la parte
lógica iría cualquiera de estos lenguajes de forma independiente. Esto es vital para aplicaciones
con cierto grado de complejidad.

.cs
.aspx

o
.vb

Figura 12. Esquema de modularización de una aplicación ASP.NET


20

Del Pozo y Pastor

A continuación se expone un pequeño ejemplo de lo visto anteriormente. Se tienen dos
archivos thisfile.vb y thisfile.aspx.
Contenido de thisfile.vb:
Protected void SubmitBtn_Click(Object S, EventArgs E)
Message.Text=“Hi “ & Name.Text
End Sub

Contenido de thisfile.aspx:
<%@ Page Language=“VB“ Codebehind=“thisfile.vb“ ... %>
<body>
<form action=“thisfile.aspx“ method=post runat=server>
<h3> Name: <asp:textbox id=“Name“ runat=“server“ />
<asp:button type=submit text=“LookUp“ id=“LookUp“
OnClick=“SubmitBtn_Click“ runat=“server“ />
<br>
<asp:label id=“Message“ runat=“server“ />
</form>
</body>
</html>
Se tiene un formulario y cuando se introduce un nombre en el mismo, debajo se muestra
“Hi” y el nombre a modo de saludo. La implementación de la función a la que se llama cuando
se pulsa el botón está en el fichero .vb, mientras que la implementación del formulario se
encuentra en el archivo .aspx.

Figura 13. Ejemplo de funcionamiento de una página ASP

21



6.5. C#
Como lenguaje más representativo y máximo exponente de la plataforma .NET, se
profundizará en sus características principales:
Orientación a objetos: C# es un lenguaje de programación orientado a objetos puro, es
decir, no admite funciones ni variables globales, todo el código debe definirse dentro de
tipos de datos (clases, estructuras...). Esto reduce los conflictos de nombres y facilita la
legibilidad del código. Todos los tipos de datos que se definan deben derivar, aunque
sea de manera implícita, de una clase base común llamada System.Object. Esto facilita
la creación de colecciones genéricas ya que pueden almacenar objetos de cualquier tipo.
C# soporta las características principales del paradigma orientado a objetos:
o

o

o

Encapsulación: además de los modificadores public, private y protected se
añade uno nuevo: internal, que sirve para indicar que el elemento sólo podrá ser
accedido desde su propio ensamblado.
Herencia: a diferencia de C++ y al igual que Java, C# sólo admite herencia
simple de clases ya que la múltiple provoca más problemas que facilidades y en
la mayoría de los casos su utilidad puede ser simulada con facilidad mediante
herencia múltiple de interfaces.
Polimorfismo.

Seguridad de tipos: C# es un lenguaje fuertemente tipado, esto evita cometer errores que
son difíciles de detectar:
o
o

o
o

Sólo se permite realizar conversiones entre tipos compatibles.
No se pueden usar variables no inicializadas. El compilador da a los campos un
valor por defecto (los pone a cero) y controla que no se lean variables locales
sin que se le haya asignado previamente algún valor
En los accesos a elementos de tablas (arrays, matrices,…) se comprueba que
los índices no se salgan de rango.
Se puede controlar la producción de desbordamientos en operaciones
aritméticas, informándose de ello con una excepción cuando ocurra.

Sencillez: se eliminan elementos incluidos en otros lenguajes y que son innecesarios en
.NET, como por ejemplo:
o
o
o

No necesita ficheros adicionales al código fuente como son los ficheros de
cabecera o los ficheros IDL.
El tamaño de los tipos de datos básicos es fijo e independiente del compilador,
sistema operativo o máquina utilizada, lo que facilita la portabilidad.
No se incluyen elementos como las macros, herencia múltiple… de otros
lenguajes.

Gestión automática de memoria: C# dispone de recolector de basura, lo cual evita al
programador el tener que preocuparse de destruir objetos, liberar memoria. Sin
embargo, se puede llamar al recolector de basura explícitamente, ya que, la destrucción
de los objetos a través del recolector de basura es indeterminista y sólo se realiza
cuando ésta se activa.
Instrucciones seguras: se evitan errores comunes cometidos en otros lenguajes
imponiendo una serie de restricciones en algunas instrucciones. Por ejemplo, todos los
casos de un switch terminen con un break o un goto y las condiciones de bucles
deben ser expresiones condicionales y no aritméticas.


22

Del Pozo y Pastor

Orientación a componentes: se incluyen en la sintaxis elementos del diseño de
componentes. Con lo cual se pueden definir de forma sencilla propiedades (similares a
campos de acceso controlado), eventos (asociación controlada de funciones de respuesta
a notificaciones) o atributos (información sobre un tipo o sus miembros).
Extensibilidad de tipos básicos: a través de estructuras permite definir tipos de datos
para los que se apliquen las mismas optimizaciones que para los tipos de datos básicos.
Es decir, que se puedan almacenar directamente en pila (luego su creación, destrucción
y acceso serán más rápidos) y se asignen por valor y no por referencia.
Extensibilidad de operadores: al igual que C++ y a diferencia de Java, se puede
redefinir el significado por defecto de gran parte de los operadores. Se realiza de forma
inteligente, a partir de una definición de un operador, el compilador deduce como es la
forma sufija y postfija o a partir de definiciones simples de operadores halla la
compuesta.
Eficiencia: todo el código incluye numerosas restricciones por seguridad y no permite el
uso de punteros. No obstante, marcando regiones de código como inseguras, se pueden
usar punteros de forma similar a cómo se hace en C++, lo que puede resultar vital para
situaciones donde se necesite una eficiencia y velocidad de procesamiento muy grande.
Soporte de XML: el compilador de C# es capaz de generar la documentación en XML a
partir de los comentarios que el programador haya escrito en su código fuente. Esto es
de gran ayuda puesto que código y documentación estarán en el mismo documento.
Espacio de nombres: es un novedad de C# que ayuda a tener ordenados los tipos de
datos. Se podría comparar con los ficheros que se organizan por directorios. Una de las
ventajas más obvias es que se pueden declarar dos clases distintas con el mismo nombre
sin más que hacerlas pertenecer a espacios de nombres diferentes.

23



7.

Conclusiones

Hace algún tiempo JSP sacaba gran ventaja a sus rivales, ASP y PHP, ya que ninguno de éstos
estaba orientado a objetos. Poco a poco han ido evolucionando y adaptándose a este paradigma,
hasta la llegada de PHP5 y ASP.NET que ya admiten toda la potencia de la orientación a
objetos.
La riqueza del lenguaje de Java y C# por parte de ASP.NET es superior a la de PHP
aunque éste admite muchas posibilidades. Además ASP.NET permite programar en diferentes
lenguajes adecuándose a las necesidades del usuario.
Por el contrario, PHP es más sencillo de utilizar y su uso es muy extendido debido a que
existen multitud de aplicaciones que resuelven problemas concretos listas para usar, como
pueden ser weblogs, tiendas virtuales o periódicos. ASP.NET posee un entorno de desarrollo
muy potente como es Visual Studio .NET.
Respecto a la compatibilidad JSP y PHP corren sobre prácticamente todas las plataformas y
servidores, mientras que ASP.NET, salvo algunos casos puntuales, está preparado para
funcionar sobre Windows e IIS. Están en evolución proyectos para portarlo a otras plataformas.
Por tanto, se puede observar que estas tres tecnologías nos aportan grandes beneficios a la
hora de crear nuestras aplicaciones Web y son muy parecidas en cuanto a lo que pueden ofrecer,
con lo cual, es difícil decantarse por una de ellas. La decisión depende de los gustos del
desarrollador, forma de trabajar, tipo de proyecto, plataforma utilizada, etc.


24

Del Pozo y Pastor

8.

Bibliografía

8.1. ASP.NET
Mridula Parihar et al. “ASP.NET Bible”. Hungry Minds, 2002
Mesbah Ahmed, Chris Garrett, Jeremy Faircloth, Chris Payne “ASP.NET Web
Developer’s Guide”. Syngress Publishing, 2002
Clikear.com: http://www.clikear.com/
ASP.NET Web: The Official Microsoft ASP.NET Site: www.asp.net
MSDN Home Page: http://www.msdn.com

8.2. PHP
Tim Converse, Joyce Park, Clark Morgan “PHP5 and MySQL Bible” Wiley Publishing,
2004
Stig Sæther Bakken, Alexander Aulbach, Egon Schmid, Jim Winstead, Lars Torben
Wilson, Rasmus Lerdorf, Andrei Zmievski, y Jouni Ahto. “Manual de PHP”, Editado por
Rafael Martínez, 2002
PHP Group: http://www.php.net/
Zend Technologies: http://www.zend.com
Epsilon Eridani: http://www.epsilon-eridani.com

8.3. Tecnología Java
Lou Marco, “EJB & JSP: Java On The Edge” Unlimited Edition
Hans Bergsten, “JavaServer Pages™, 2nd Edition”, O'Reilly, 2002
Universidad del País Vasco:
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/virtual.htm
Sun Developer Network: http://java.sun.com
http://www.sun.com/java
http://wlc-sai.sun.com
Curso de Java de Ecom: http://gsii.usal.es/~ecom/java
Curso de Java de Mailxmail: http://www.mailxmail.com/curso/informatica/java
Programación.net: http://www.programacion.net/java/articulo/joa_patrones1

8.4. CGIs
Maestros del Web: http://www.maestrosdelweb.com/editorial/cgiintro/
Curso de Java de Ecom: http://gsii.usal.es/~ecom/java

25



CGI Master: http://www.ok.cl/cgi/
NCSA HTTPd: http://hoohoo.ncsa.uiuc.edu/cgi/intro.html

8.5. Coldfusion
Página oficial de Coldfusion: http://www.macromedia.com/es/software/coldfusion/

8.6. Información general
Programación en castellano: http://www.programacion.net/
Ciberaula: http://www.ciberaula.com/
Desarrollo Web: http://www.desarrolloweb.com/
Tejedores del Web: http://www.tejedoresdelweb.com


26

Dinamicas

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (17)

Similar a Dinamicas

Similar a Dinamicas (20)

Dinamicas