Java EE

PROGRAMACION ORIENTADA A OBJETOS
mroescobar@yahoo.com.mx Prof. Ing. Octavio César Escobar Jaramillo
4 JavaEE
INDICE
4.1. La plataforma JavaEE y su importancia en el desarrollo de aplicaciones multicapa ..................... 2

En Términos Microsoft ..................................................................................... 2
4.1.1 Componentes JavaEE ........................................................................................................................ 2
4.1.2 Herramientas de desarrollo para JavaEE ........................................................................................... 3
4.2. Concepto HTML y XML ...................................................................................................................... 4
4.2.1 HTML................................................................................................................................................ 4
4.2.1.1. Estructura de un documento..................................................................... 4
4.2.1.2. Cabecera de un documento HTML. ............................................................ 4
4.2.1.3. Cuerpo del documento HTML. ................................................................... 5
Etiquetas principales para la estructuración del texto. ........................................ 6
4.2.2 XML ................................................................................................................................................ 14
Estructura.................................................................................................................................................. 16
DTD Definición de tipos de documento. .................................................................................................. 18
4.3. Concepto JavaScript.................................................................................................................. 21
4.3.1. JavaScript y HTML. ....................................................................................................................... 22
4.3.2. Ejemplo de una página con código en JavaScript incluído............................................................. 22
4.3.3. Ejemplo de una calculadora hecha con JavaScript. ........................................................................ 23
4.4. Concepto JavaServerPages (JSP) y Servlets.................................................................... 25
4.4.1. Servlets. .......................................................................................................................................... 25
4.4.2. Java Server Pages (JSP).................................................................................................................. 28
6.1.2 Como funciona JSP ......................................................................................................................... 31
4.5. Enterprise JavaBeans (EJB).................................................................................................... 34
4.5.1 Cuando usar Enterprise Beans ......................................................................................................... 35
4.5.2. Tipos de Enterprise Beans .............................................................................................................. 36
Bean de Sesión.................................................................................................. 36
Bean de Entidad................................................................................................ 36
Bean de Mensaje ............................................................................................... 36
Capítulo 4 JavaEE 1 JavaEE

4.1. La plataforma JavaEE y su importancia en el desarrollo de

aplicaciones multicapa
JavaEE (Java Enterprise Edition) es un grupo de especificaciones diseñadas por Sun que
permiten la creación de aplicaciones empresariales, esto es: acceso a base de datos
(JDBC), utilización de directorios distribuidos (JNDI), acceso a métodos remotos
(RMI/CORBA), funciones de correo electrónico (JavaMail), aplicaciones Web(JSP y
Servlets)...etc. Aquí es importante notar que JavaEE es solo una especificación, esto
permite que diversos productos sean diseñados alrededor de estas especificaciones
algunos son TomCat y Weblogic.
Aunque varios productos Java están diseñados alrededor de estas especificaciones, no

todos cumplen con el estándar completo, esto es, Tomcat solo emplea|cumple las
especificaciones de JSP y Servlets, sin embargo, existen productos como Websphere,
Weblogic, EPlanet y algunos otros "Java Application Servers" que son considerados "Fully
JavaEE Compliant" , en otras palabras, cumplen con todas las especificaciones definidas
por Sun.
Sun ofrece una implementación de todas estas especificaciones llamada JavaEE SDK, a
pesar que el JavaEE SDK es una implementación, esta es solo una muestra ofrecida por
Sun para utilizar las funcionalidades de las especificaciones JavaEE, aunque funcionaría
en un Sistema de Producción su licencia lo prohibe.
En Términos Microsoft
JavaEE pudiera ser considerado el rival de .NET ofrecido por Microsoft el problema es que
esta forzado a utilizar una sola implementación, a diferencia de implementaciones JavaEE
donde puede elegir entre diversos productos de distintas empresas. (.NET es lo que
anteriormente se conocía como DNA)
4.1.1 Componentes JavaEE

La especificación más reciente de Sun es JavaEE 5 , la cual esta conformada por
componentes como: JDBC, JNDI, RMI/IIOP, JavaMail, JSP, Servlet, JTA, EJB, JAF, JMS
y Connectors, los detalles se pueden encontrar en la dirección
http://java.sun.com/javaee.
El desarrollo de una aplicación empresarial estará basado en los componentes ofrecidos

en la especificación JavaEE y los que teníamos anteriormente en la especificación JavaSE
(Java Standard Edition). Es importante mencionar que la especificación JavaEE tiene sus
bases en JavaSE, todos los mecanismos y API especificados en JavaEE se basan en
JavaSE.
El siguiente esquema muestra algunos de los componentes principales que deben
utilizarse en el desarrollo de una aplicación multicapa.

Máquina Cliente Máquina Servidor J2EE Máquina Servidor

Base de Datos
Capa Cliente Capa Web Capa Negocio Capa B.D.

-- HTML, XML -- JSP -- Java Beans -- PL / SQL
-- JavaScript -- Servlets -- EJB
-- Applets
(Cliente ligero)
Es importante hacer mención que los componentes del diagrama anterior son de
múltiples especificaciones y plataformas (no únicamente de JavaSE o JavaEE) pero sin
embargo, son necesarios para el desarrollo total de la aplicación.
4.1.2 Herramientas de desarrollo para JavaEE

Ya habíamos mencionado la existencia de los IDE's ("Integrated Development
Environment"), estas herramientas permiten el desarrollo de los componentes con soporte
de procesos que hacen mas simple y óptima la generación de código. Muchas de ellas
cuentan inclusive con ‘Wizards’ para desarrollo acelerado y de forma gráfica de código.
El siguiente diagrama muestra las herramientas y productos que se requerirán para el

desarrollo total de las soluciones (soporte y producción de todos los componentes
mencionados anteriormente).
Máquinas de desarrollo Servidor de Servidor de B.D.

-- J Builder 5 Aplicaciones -- Oracle 8i
-- Dreamweaver -- Bea Weblogic 6.1
-- Microsoft Visual
SourceSafe
-- Oracle Client 8i
-- RUP
-- SQL Navigator
-- Power Designer

4.2. Concepto HTML y XML
4.2.1 HTML
La red mundial WWW es una red de recursos de información. Se basa en 3 mecanismos

para lograr que estos recursos estén disponibles a la mayor audiencia posible.
1. Un esquema uniforme de nombrado para localizar recursos en el Web (Ejemplo

URIs (Universal Resource Identifier))
2. Protocolos para accesar los recursos nombrados en el Web (Ejemplo HTTP).
3. Hipertexto, para la fácil navegación entre los recursos (Ejemplo HTML).
Para publicar información de manera global se requirió de un lenguaje universal de

entendimiento, un tipo de lengua materna para publicación que cualquier computadora
entendiera. El lenguaje utilizado para publicación por el WWW es HTML (HyperText
Markup Language).
El lenguaje HTML se basa en el uso de etiquetas también llamadas marcas, directivas o

comandos (tags). Estas etiquetas son fragmentos de texto delimitados por los símbolos
menor que < y mayor que >. Básicamente, estas etiquetas indican al navegador, la forma
de representar los elementos (texto, gráficos, etc...) que contiene el documento.
4.2.1.1. Estructura de un documento.

El lenguaje HTML se basa en la sintaxis SGML (Standard Generalized Markup
Languages). Esto implica que cualquier cosa que hagamos en HTML estará encerrada
entre dos etiquetas de esta manera:
<ETIQUETA parámetros> ... </ETIQUETA>
Hay ocasiones en que no es necesario cerrar la etiqueta. Un documento HTML esta

definido por una etiqueta de inicio <HTML> y una de terminación </HTML>. Otras dos
partes fundamentales de todo documento HTML son el encabezado, comprendido entre
las etiquetas <HEAD> y </HEAD> y el cuerpo entre <BODY> y </BODY>.
4.2.1.2. Cabecera de un documento HTML.

La cabecera de un documento viene delimitada por las etiquetas <HEAD> y </HEAD>
respectivamente y contiene fundamentalmente información sobre el documento. Todas
ellas son opcionales, aunque el uso de la etiqueta <TITLE> es más que recomendado.
La etiqueta <TITLE> es la encargada de especificar el título del documento. El titulo del

documento se suele mostrar generalmente en la parte superior del navegador. También es
utilizado como identificador en las listas de favoritos o bookmarks.
Otra etiqueta relacionada con la cabecera de un documento es <META>, usada

principalmente para sustituir el documento actual por otro en determinado número de
segundos o bien para incluir elementos informativos como el nombre del autor, la fecha
de expiración del documento o incluso el programa con el que hemos diseñado la página
(obviamente, en el supuesto de que se haya utilizado un software específico como ejemplo

el Dreamweaver o FrontPage). En todos los casos, la información se escribe usando pares

nombre/valor. Los siguientes ejemplos muestran la estructura para manejo de esta
etiqueta. Para dichos ejemplos se esta empleando atributos de tipo HTTP-EQUIV y NAME.
En ambos casos el valor se especifica en el campo CONTENT :
<META HTTP-EQUIV=”Refresh” CONTENT=”15; URL=http://www.unitec.mx/ >

<META http-EQUIV=”Expires” CONTENT=”Caduca en enero de 2003 00:00 GMT”>
<META NAME=”Autor” CONTENT=”Universidad Tecnológica de México”>
<META http-EQUIV = “authoring_tool” CONTENT = “Home Site 2.5”>
La etiqueta para incluir comentarios dentro del código es . Su uso es
ampliamente recomendado.
4.2.1.3. Cuerpo del documento HTML.

El cuerpo de un documento HTML contiene el texto de la página que se va a presentar.
Las etiquetas de inicio y fin son <BODY> y </BODY> respectivamente, y entre ellas. Se
debe situar todo el código fuente restante del documento.
La etiqueta <BODY> presenta una serie de atributos que permiten establecer una serie de
características generales para todo el documento, como puede ser el color del texto, de los
enlaces o del fondo del documento.
Los colores se pueden indicar de dos maneras diferentes: en formato hexadecimal o

referenciados por su nombre preestablecido.
Si queremos indicar colores en formato hexadecimal, se deberá indicar la proporción de

rojo, verde y azul correspondiente para formar el color deseado. Así pues, el valor RGB del
color vendrá determinado por RR, GG y BB para los niveles de Rojo, Verde y Azul, con
valores entre 0 y FF (0 a 255). Visto esto, el número “#000000” corresponde al color
negro, “#FF0000” al rojo, “#00FF00” al verde, “#0000FF” al azul, “#FFFFFF” al blanco y
así sucesivamente.
Sin embargo, es mucho más cómodo indicar el nombre del color en inglés, como black,
teal, blue, navy, lime, white, purple, yellow, olive, reg, marron, gray, fucsia, green, silver y
aqua.
Black Silver Gray White Maroon Red Purple Fuchsia

Green Lime Olive Yellow Navy Blue Teal Aqua
Una opción muy usada en los documentos HTML es una imagen como fondo del
documento. Esta imagen se mostrará debajo del texto y de las imágenes de contenido en
la página. Si no es lo suficientemente grande como para rellenar todo el fondo del
documento será reproducida tantas veces como sea necesario hasta completarlo.
El atributo que se encarga de determinar la imagen de fondo es BACKGROUND=”nombre

del archivo gráfico”.
Ejemplo del armado de cuerpo de un documento HTML:

<HTML>
<HEAD>
<TITLE>Ejemplo 1 de documento HTML</TITLE>
</HEAD>

<BODY BGCOLOR=Gray TEXT =Black LINK =Blue VLINK=Fucsia ALINK =Red>
</BODY>
</HTML>
Etiquetas principales para la estructuración del texto.

HTML no reconoce más de un espacio en blanco separando cualquier elemento o texto, es
decir, los saltos de línea, tabulaciones y demás separadores son convertidos a un único
espacio en blanco. Así pues existen una serie de etiquetas que se encargan de gestionar el
aspecto general del texto del documento HTML. Los siguientes cuadros resumen las
etiquetas principales utilizadas por HTML
Etiqueta Utilidad Resultado

Sirve para delimitar un párrafo.
<P> Inserta una línea en blanco antes del Soy un párrafo
texto.
<CENTER> ... Permite centrar todo el texto del Yo soy normal
</CENTER> párrafo. Yo estoy centrado
Representa el texto encerrado en
ella con un tipo de letra de paso fijo.
<PRE WIDTH=x> ... Muy útil a la hora de representar Estoy en paso fijo
</PRE> código fuente. El parámetro WIDTH
especifica el número máximo de
caracteres en una línea.
Yo estoy a la izquierda
Permite justificar el texto del párrafo Yo al centro
<DIV ALIGN=x> ... a la izquierda (ALIGN=LEFT), derecha Y yo a la derecha (recuerda a
</DIV> (RIGHT), al centro (CENTER) o a ambos la política esto, oye)
márgenes (JUSTIFY) Yo estoy justificado, porque
estoy en todos los lados.
Para escribir direcciones (de esas Daniel Rodríguez Herrera
<ADDRESS> ...
</ADDRESS> donde vive la gente, no C/Ecuador 9, 1ºB
electrónicas). 28220 Majadahonda
Me gustaría
Para citar un texto ajeno. Se suele
reencarnarme
implementar dejando márgenes
<BLOCKQUOTE> ... en las yemas de
tanto a izquierda como a derecha,
</BLOCKQUOTE> los dedos de
razón por la que se usa
Warren Beatty
habitualmente.
(Woody Allen)

Otra etiqueta muy asociada a lo anterior es <BR>. Esta etiqueta sólo tiene marca inicial y
se usa para cambiar de línea. Las cabeceras se emplean para dividir los documentos en
secciones, o más concretamente, para marcar los títulos de estas secciones. La etiqueta
que define la cabecera es <Hn> y </Hn>, donde n varía de 1 a 6.
Etiqueta Resultado
<H1> ... </H1>

Cabecera de nivel 1
<H2> ... </H2> Cabecera de nivel 2
Para poder separar partes del documento, la etiqueta <HR> dibuja una barra horizontal
que divide la pantalla con un grosor y una longitud determinada a través de sus
atributos. La siguiente lista de etiquetas mostrada se utiliza para dar formato a textos:

Soy un texto negro como
<B> ... </B> Pone el texto en negrita.
el tizón
<I> ... </I> Representa el texto en cursiva. Estoy ladeado
Como soy muy importante
<U> ... </U> Para subrayar algo.
estoy subrayado
A mí, en cambio, nadie me
<S> ... </S> Para tachar.
quiere
Permite representar el texto en un tipo
<TT> ... </TT> No soy variable
de letra de paso fijo.
<SUP> ... </SUP> Letra superíndice. E=mc2
<SUB> ... </SUB> Letra subíndice. ai,j=bi,j+1
<BIG> ... </BIG> Incrementa el tamaño del tipo de letra. Soy GRANDE
<SMALL> ...
</SMALL> Disminuye el tamaño del tipo de letra. Creí ver un lindo gatito
<BLINK> ... Hace parpadear el texto. Resulta algo

¿Molesto?
</BLINK> irritante.
Para dar formato a frases las etiquetas principales son:


<CITE> ... </CITE> Para citar un texto ajeno. Esta frase no es mía
<CODE> ... Para representar una etiqueta HTML
int x=0;
</CODE> o código de un programa.
<STRONG> ...
</STRONG> La cosa es importante. Hay cosas importantes.
Hay que poner énfasis en

<EM> ... </EM> Para dar énfasis.
algunas cosas.
El usuario debe teclear
<KBD> ... </KBD> Texto tecleado por el usuario.
Multivac es el mejor.
La variable x, definida
<VAR> ... </VAR> Representar variables de un código.
anteriormente...
<SAMP> ... Para representar una serie de
Estoy en un literal
</SAMP> caracteres literalmente.
<ABBR> ...
</ABBR> Abreviaturas. La WWW usa el protocolo http
La etiqueta <FONT> permite controlar casi totalmente el estilo de un bloque de texto.

Podremos establecer el tamaño de la fuente mediante el atributo SIZE, la fuente de texto a
usar mediante FACE y el color de la misma con el atributo COLOR. Debe cerrarse
mediante </FONT>.
Ejemplo manejo de <FONT>:
<HTML>
<HEAD>
<TITLE>Listado ejemplo de uso de FONT</TITLE>
</HEAD>
<BODY>
<FONT SIZE=6 FACE=Cosmic COLOR=Blue>Este texto está en azul con una fuente Cosmic
</FONT>
<BR>
<FONT SIZE=2 FACE=Arial COLOR=Black>Este otro en negro con la fuente Arial</FONT>
<BR>
<FONT SIZE=5 FACE=Dauphin COLOR=Red>Para terminar <FONT COLOR=blue>un <FONT
COLOR=Red>ejemplo<FONT COLOR=Navy> más<FONT COLOR=Black>. Final. </FONT>
</BODY>
</HTML>
Enlaces.
Otra función importante en el lenguaje HTML es el hipertexto. El hipertexto consiste en
poder moverse a través de un documento o varios seleccionando zonas de texto o
imágenes programadas para tal fin.

Cualquier elemento de un documento HTML puede ser definido como enlace, y una
imagen, un párrafo de texto o un bloque de texto pueden ser definidos como enlaces a
otros puntos del documento o de la red.
La estructura general de un enlace está formada por la etiqueta <A> seguida de

determinados atributos. Para comprender rápidamente la filosofía de trabajo de los
enlaces, veremos algunos ejemplos para ver su estructura y método de uso.
Como norma general un enlace se distingue del texto normal porque éste aparece
resaltado en otro color (generalmente azul) y subrayado. Si se trata de una imagen con
borde, éste aparecerá de color azul. Concretando un enlace será toda zona de la página
Web sobre la que al pasar el cursor este cambia de aspecto, y aparecerá en la parte
inferior del navegador el lugar al que se accederá.
Enlace a un punto de la misma página.

Cuando se trabaja con documentos muy extensos o índices suelen ponerse enlaces desde
el principio del documento al final del mismo y viceversa, así se agiliza la tarea del
usuario examinando el documento. Tomando esta situación como punto de partida, el
primer paso consiste en marcar las distintas zonas del documento a las que se desea
poder acceder de manera inmediata; en este caso el inicio y final del documento.
Así pues, en el principio del documento añadiremos la siguiente línea de código:
<A NAME=”iniciodocumento”>
Hemos marcado como inicio un punto en el comienzo del documento. Ahora nos situamos
al final del mismo y añadimos otra línea de código.
<A NAME=”finaldocumento”>
Una vez marcadas las distintas zonas del documento vamos a situar en el mismo los
enlaces que nos permitirán ir de arriba debajo de la página con un clic y viceversa. En el
inicio y final del documento añadiremos las siguientes líneas respectivamente:

<A HREF=”#finaldocumento”>Pulsa aquí para ir al final de esta página </A>

<A HREF=”#iniciodocumento”>Pulsa aquí para ir al principio de esta página </A>
Ejemplo de página con ligas:
<HTML>
<HEAD>
<TITLE>Ejemplo Documento con enlaces</TITLE>
</HEAD>

<BODY BGCOLOR=Gray TEXT =Black LINK=Blue VLINK=Fucsia ALINK =Red>
<A NAME="iniciodocumento">

<A HREF="#finaldocumento">Pulsa aquí para ir al final de esta página </A>

<H1><CENTER>World Wide Web</CENTER></H1>
<HR>
<P>
<STRONG>La red mundial WWW (World Wide Web) es una red de recursos de
información.</STRONG><BR>
La red se basa en tres mecanismos para lograr que estos recursos estén disponibles
a la mayor audiencia posible.
</P>
<BR>
<PRE width=30>
1. Un esquema uniforme de nombrado para localizar recursos en el Web
(Ejemplo URIs (Universal Resource Identifier))<BR>
2. Protocolos para accesar los recursos nombrados en el Web
(Ejemplo HTTP).<BR>
3. Hipertexto, para la fácil navegación entre los recursos
(Ejemplo HTML).<BR>
</PRE>
<BR>
<P>
Para publicar información de manera global se requirió de un lenguaje universal de
entendimiento, un tipo de lengua materna para publicación que cualquier computadora
entendiera. El lenguaje utilizado para publicación por el WWW es HTML (HyperText Markup
Language).
El lenguaje HTML se basa en el uso de etiquetas también llamadas marcas, directivas o
comandos (tags). Estas etiquetas son fragmentos de texto delimitados por los símbolos
menor que < y mayor que >. Básicamente, estas etiquetas indican al navegador, la forma de
representar los elementos (texto, gráficos, etc...) que contiene el documento.
</P>
<A NAME="finaldocumento">
<A HREF="#iniciodocumento">Pulsa aquí para ir al principio de esta página </A>
</BODY>
</HTML>
Enlaces a otras páginas.

Cuando se dispone de varias páginas, es normal que desde una de ellas se pueda acceder
a otra y, desde esta otra a una tercera, etc. Pues bien, el procedimiento es similar al
anterior, sólo que esta vez, deberemos especificar el nombre del archivo que contiene la
página a la que se quiere acceder.
Supongamos que tenemos dos páginas llamadas principal.html y secundaria.html. Para

crear un enlace de la primera a la segunda, deberemos escribir:
<A REF=”secundaria.html”> Pulsa aquí para acceder a la otra página </A>
Visto esto, si el enlace se quisiera conectar a un punto concreto de la página marcado

como opciones, la estructura del código sería la siguiente:
<A REF=”secundaria.html#opciones”> Pulsa aquí para ver las opciones en la otra página </A>
El siguiente ejemplo ilustra distintos modelos de enlaces:
<HTML>
<HEAD>

<TITLE>Ejemplo Modelos de enlaces</TITLE>

</HEAD>
<BODY>

<A HREF="http://www.java.sun.com">Todo sobre Java</A>
<BR>

<A HREF="mailto:oescobar@hotmail.com">Dudas JavaEE (oescobar@hotmail.com)</A>
<BR>

<A HREF="http://www.oracle.com"><img src="Oracle.jpg"</A>
<BR>

<A HREF="Scanner.jpg">Pulsar para ver modelo de Scanner</A>
<BR>
</BODY>
</HTML>
Imágenes.
Para incluir imágenes en documentos HTML se emplea la etiqueta <IMG> junto con el
tributo imprescindible: SRC. Un atributo muy útil es ALT. Su cometido es introducir una
descripción de la imagen con la finalidad de que los usuarios que acceden a la página con
un navegador en modo texto puedan hacerse una idea de las imágenes que contiene. Es
importante conocer los distintos formatos gráficos que podemos utilizar. Si se especifica
un formato no reconocido por HTML, el navegador simplemente lo ignora y no se visualiza
la imagen en el documento. Los formatos permitidos son: GIF, JPEG, XBM o PNG.
El atributo ALIGN permite alinear la imagen respecto al texto en función de los siguientes
valores principales:
Valor de ALIGN Utilidad
TOP
Coloca el punto más alto de la imagen coincidiendo con más alto de la
línea de texto actual.
MIDDLE Alinea el punto medio (en altura) de la imagen con la base del texto.
BOTTOM(Por
Alinea el punto más bajo de la imagen con la base del texto.
defecto)
LEFT Coloca la imagen a la izquierda del texto.
RIGHT Coloca la imagen a la derecha del texto.
Sonidos.
La capacidad de reproducir sonido en una página Web viene determinada en gran medida
por el navegador que estemos utilizando. Una página puede tener sonidos incorporados,
ya sea como música de fondo que se ejecuta automáticamente al cargar la página o bien
para que sea activada por el usuario.
La etiqueta encargada de reproducir un archivo de audio es <BGSOUND> asociada al

atributo SRC. Los archivos pudrán ser de formato *.wav, *.au, *.mid.

Un atributo fundamental es LOOP. Será usado para especificar el número de veces que se
debe ejecutar el archivo de sonido. LOOP puede tener un valor numérico que indicará el
número de veces que se reproducirá el archivo o valor infinite, que reproducirá el archivo
indefinidamente.
El siguiente ejemplo muestra el uso de sonido en una página:
<HTML>
<HEAD>
<TITLE>Ejemplo Manejo de Sonido</TITLE>
</HEAD>
<BODY TEXT=Blue BGPROPERTIES="fixed"

BACKGROUND="D:\CursojavaEE\EjerciciosHTML\Imagenes\Logo_unitec_light.jpg">
<H1> <CENTER>Ejemplo Manejo de Sonido</CENTER> </H1>
<HR>
<BGSOUND SRC="Sonidos\inicio.wav" LOOP=5>
<CENTER><IMG SRC="Imagenes\guerrero.jpg" ></CENTER>
</BODY>
</HTML>
Netscape tiene otra etiqueta para gestionar el sonido (entre otras cosas): <EMBED>
asociada al atributo SRC. A diferencia del navegador de Explorer, Netscape presenta en
pantalla una ventana de control de audio con las funciones de avance, retroceso,
ejecución y Stop.
Tablas.
El tag que define la tabla es <TABLE> </TABLE>, toda la tabla debe estar entre estas dos
etiquetas, y las opciones que se apliquen aquí tendrán efecto sobre toda la tabla.
Con <TR> </TR> se define cada una de las líneas de la tabla, los atributos que se
empleen en esta etiqueta tendrá efecto en toda la línea. En resumen, tendremos tantos
<TR>...</TR> como filas tenga la tabla y, como la tabla de arriba tiene dos filas, entonces
tiene dos tags <TR>...</TR>. También podemos utilizar las etiquetas <TH> y </TH> para
definir el inicio y final de una celda de cabecera. El contenido de ésta aparecerá en negrita
y centrado.
Dentro de cada fila indicamos una celda concreta con las etiquetas <TD> </TD>, entre
las cuales pondremos lo que queremos que este en esa celda (puede ser texto, imágenes o
cualquier otra cosa).
La etiqueta <CAPTION> permite asignar un título a la tabla. Esta etiqueta tiene de

parámetro el ALIGN que puede tomar valores de top y bottom.
Ejemplo:
<HTML>
<HEAD>
<TITLE>Ejemplo de dimensionado de celdas</TITLE>
</HEAD>

<BODY BGPROPERTIES="fixed" BACKGROUND="\Imagenes\Logo_unitec_light.jpg">

<H1> <CENTER>Ejemplo Manejo de tablas en HTML</CENTER> </H1>
<HR>
<TABLE BORDER=5 BGCOLOR=YELLOW CELLSPACING=10 CELLPADDING=5>
<CAPTION>Ejemplo de alineaciones y dimensionados</CAPTION>
<TR>
<TD COLSPAN=2 ALIGN=Right>ESTO OCUPA DOS CELDAS</TD>
<TD>CELDA</TD>
<TD>CELDA</TD>
</TR>
<TR>
<TD ROWSPAN=2 VALIGN=bottom>ESTO OCUPA DOS RENGLONES</TD>
<TD>CELDA</TD>
<TD>CELDA</TD>
</TR>
<TR>
<TD BGCOLOR=GREEN>CELDA</TD>
<TD>CELDA</TD>
<TD>CELDA</TD>
</TR>
</TABLE>
</BODY>
</HTML>
Frames.
Los frames es la herramienta que el HTML pone a nuestra disposición para presentar
varias páginas en una sola. Lo primero que necesitamos es una página "madre" que
dividiremos en viñetas (los frames propiamente dichos), y una serie de páginas "hijas",
que serán las que ocupen esas viñetas.
Para crear los frames usamos la sentencia <FRAMESET>...</FRAMESET>, un aspecto

importante a considerar es que el FRAMESET debe ser declarado en la cabecera de la
página (El BODY no tiene efecto).
Formularios.
Los formularios son el sistema del que nos provee el HTML para enviar información desde
una página web a algún programa u otro recurso en un ordenador remoto. Esto quiere
decir que un formulario no sirve de mucho si no tenemos un lugar al que enviarlo.
El funcionamiento de los formularios es muy simple: La persona que visita la página

rellena una "matriz" (el formulario propiamente dicho) con los datos que se quieran enviar
y, al picar en un botón, estos son enviados al lugar que corresponda (generalmente un
programa CGI o un servlet alojado en nuestro servidor) en la forma NOMBRE-DEL-
CONTROL=VALOR. Los programas alojados en el servidor se ejecutan en la máquina
donde está alojada la página (o en otra máquina de Internet), y envían una respuesta al
navegador.
La etiqueta principal que tenemos que tener en cuenta es el que crea un formulario. Esta
deberá englobar en su interior a todos los elementos que formen parte de este:
<FORM>...</FORM>

Dentro debemos colocar algunos elementos, llamados controles, como cuadros de texto,
botones, ect. Para crear cada uno de estos elementos tenemos la directiva <INPUT>, que
tiene un atributo obligatorio: TYPE, que es el que determina el tipo concreto de control de
que se trata:
<INPUT TYPE="tipo de control">
Donde "tipo de control" puede ser uno de los siguientes:
"SUBMIT" crea el clásico botón "Enviar", y es el que, al ser pulsado, envía los datos del
formulario a la dirección especificada en ACTION.
"RESET" inserta un botón "Borrar" que, al ser pulsado, elimina los datos de todos los
controles del formulario que lo contiene.
"BUTTON" crea un botón.
"TEXT" crea un cuadro para insertar una línea de texto.
"PASSWORD" hace lo mismo que "TEXT", pero los caracteres que se escriban no se verán
en pantalla, sino que serán sustituidos por asteriscos.
"CHECKBOX" crea una caja de verificación.
"RADIO" crea un "Radio Button", algo parecido a lo anterior, pero con la sutil diferencia
de que suelen ser redondos, estar agrupados, y que, dentro de un grupo solo puede
aparecer uno marcado cada vez.
"IMAGE" funciona exactamente igual que "SUBMIT", pero aquí puedes especificar una
imagen para que aparezca en lugar del aburrido botón tradicional.
"HIDDEN" no muestra nada, absolutamente nada. Si se pone dentro del formulario, este
se verá exactamente igual. ¿Y para que sirve entonces? Pues para enviar al programa en
el servidor, siempre que se use ese formulario, información que pueda ser necesaria, pero
que no necesite cambiarse ni verse.
"FILE" sirve para crear un cuadro de diálogo mediante el que enviar un archivo desde tu
disco duro. No está soportado en todos los navegadores.
4.2.2 XML
Antes de nada conviene repasar su historia y precedentes. La versión 1.0 del lenguaje
XML es una recomendación del W3C desde Febrero de 1998, pero se ha trabajado en ella
desde un par de años antes. Está basado en el anterior estándar SGML (Standard
Generalized Markup Language, ISO 8879), que data de 1986, pero que empezó a gestarse
desde principios de los años 70, y a su vez basado en el GML creado por IBM en 1969.
Esto significa que aunque XML pueda parecer moderno, sus conceptos están más que
asentados y aceptados de forma amplia. Está además asociado a la recomendación del
W3C DOM (Document Object Model), aprobado también en 1998. Éste no es más que un
modelo de objetos (en forma de API) que permite acceder a las diferentes partes que
pueden componer un documento XML o HTML.
SGML proporciona un modo consistente y preciso de aplicar etiquetas para describir las
partes que componen un documento, permitiendo además el intercambio de documentos
entre diferentes plataformas. Sin embargo, el problema que se atribuye a SGML es su
excesiva dificultad; baste con pensar que la recomendación ocupa unas 400 páginas.

Así que, manteniendo su misma filosofía, de él se derivó XML como subconjunto

simplificado, eliminando las partes más engorrosas y menos útiles. Como su padre XML
es un metalenguaje: es un lenguaje para definir lenguajes. Los elementos que lo
componen pueden dar información sobre lo que contienen, no necesariamente sobre su
estructura física o presentación, como ocurre en HTML.
Desde su creación, XML ha despertado encontradas pasiones, y como para cualquier

tema en Internet, hay gente que desde el principio se ha dejado iluminar por sus
expectativas, mientras que otras muchas lo han denostado o simplemente ignorado.
Durante el año 1998 XML ha tenido un crecimiento exponencial, y ello se refiere sobre
todo a sus apariciones en los medios de comunicación de todo tipo, menciones en páginas
web, soporte software, tutoriales, etc.
Una pregunta que ha acudido a muchos de nosotros es: ¿será XML el sustituto de HTML,
que tan bien conocemos, dominamos, amamos y odiamos? No. Esa es la respuesta,
básicamente XML no ha nacido sólo para su aplicación en Internet, sino que se propone
como lenguaje de bajo nivel (a nivel de aplicación, no de programación) para intercambio
de información estructurada entre diferentes plataformas. Se puede usar en bases de
datos, editores de texto, hojas de cálculo, y casi cualquier cosa que podamos pensar. Sin
ir más lejos, algunos lenguajes, definidos en XML, recorren áreas como la química y la
física, las matemáticas, el dibujo, tratamiento del habla, y otras muchas.
Pues bien, no lo sustituirá, pero, aplicado en Internet, sí va a mejorar algo de lo que

HTML empezaba a adolecer desde hace un tiempo: establece un estándar fijo al que
atenerse, y separa el contenido de su presentación. Esto significa que a partir de ahora, o
mejor desde el momento que se aplique definitivamente, para ver un documento web no
estaremos sujetos a la parte del estándar de hojas de estilo (CSS) que soporte el Navigator
de Netscape o el IExplorer de Microsoft, ni al lenguaje de script del servidor y al modelo de
objetos definido por MS, Nestcape, etc. Además tampoco estaremos atados a la
plataforma: podremos ver la misma información desde nuestro PC o desde un Hand-
HeldPC, un navegador textual, una lavadora, un microondas o un reloj con acceso a
Internet, con presentaciones adecuadas a cada entorno.
Se puede suponer de este modo que XML constituye la capa más baja dentro del nivel de
aplicación, sobre el que se puede montar cualquier estructura de tratamiento de
documentos, hasta llegar a la presentación. Y así podemos ver la compartición de
documentos entre dos aplicaciones como intercambio de datos a ese nivel:

Estructura.
Lo primero que debemos saber es que hay dos tipos de documentos XML: válidos y bien
formados. Éste es uno de los aspectos más importantes de este lenguaje, así que hace
falta entender bien la diferencia:
• Bien formados: son todos los que cumplen las especificaciones del lenguaje respecto
a las reglas sintácticas que después se van a explicar, sin estar sujetos a unos
elementos fijados en un DTD (luego veremos lo que es un DTD). De hecho lo s
documentos XML deben tener una estructura jerárquica muy estricta, de la que se
hablará más tarde, y los documentos bien formados deben cumplirla.
• Válidos: Además de estar bien formados, siguen una estructura y una semántica
determinada por un DTD: sus elementos y sobre todo la estructura jerárquica que
define el DTD, además de los atributos, deben ajustarse a lo que el DTD dicte.
DTD es una definición de los elementos que puede haber en el documento XML, y su
relación entre ellos, sus atributos, posibles valores, etc. De hecho DTD está por Document
Type Definition, o Definición de Tipo de Documento. Es una especie de definición de la
gramática del documento, en definitiva. Más adelante hablaré de cómo se incluye un DTD
en un documento XML, pero lo importante ahora es entender que cuando se procesa
cualquier información formateada mediante XML, lo primero es comprobar si está bien
formada, y luego, si incluye o referencia a un DTD, comprobar que sigue sus reglas
gramaticales. Hay pues diferencia entre los parsers que procesan documentos XML sin
comprobar que siguen las reglas marcadas por un DTD (sólo comprueban que está bien
formado), que se llaman parsers no validadores, y los que sí lo hacen, que son parsers
validadores (comprueba que además de bien formado se atiene a su DTD y es válido).
Veamos un ejemplo simple de un documento XML:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<ficha>
<nombre>Angel</nombre>
<apellido>Barbero</apellido>
<direccion>c/Ulises, 36</direccion>
</ficha>

Lo primero que tenemos que observar es la primera línea. Con ella deben empezar todos
los documentos XML, ya que es la que indica que lo que la sigue es XML. Aunque es
opcional, es más que recomendable incluirla siempre. Puede tener varios atributos (los
campos que van dentro de la declaración), algunos obligatorios y otros no:
• version: indica la versión de XML usada en el documento. La actual es la versión 1.0,

con lo que no debe haber mucho problema. Es obligatorio ponerlo, a no ser que sea
un documento externo a otro que ya lo incluía (ya veremos qué documentos externos
puede haber).
• encoding: la forma en que se ha codificado el documento. Se puede poner cualquiera,
y depende del parser el entender o no la codificación. Por defecto es UTF-8, aunque
podrían ponerse otras, como UTF-16, US-ASCII, ISO-8859-1, etc. No es obligatorio
salvo que sea un documento externo a otro principal.
• standalone: indica si el documento va acompañado de un DTD ("no"), o no lo necesita
("yes"); en principio no hay porqué ponerlo, porque luego se indica el DTD si se
necesita.
En cuanto a la sintaxis del documento, y antes de entrar en el estudio de las etiquetas,

hay que resaltar algunos detalles importantes y a los que nos debemos acostumbrar:
Los documentos XML son sensibles a mayúsculas, esto es, en ellos se diferencia las
mayúsculas de las minúsculas. Por ello <FICHA> sería una etiqueta diferente a <ficha>.
Además todos los espacios y retornos de carro se tienen en cuenta (dentro de las
etiquetas, en los elementos).
Hay algunos caracteres especiales reservados, que forman parte de la sintáxis de XML: <,
>, &, " y '. En su lugar cuando queramos representarlos deberemos usar las entidades
<, >, &, " y ' respectivamente.
Los valores de los atributos de todas las etiquetas deben ir siempre entrecomillados. Son
válidas las dobles comillas (") y la comilla simple (').
Pasando al contenido en sí, vemos etiquetas que nos recuerdan a HTML, y que contienen
los datos. Es importante diferenciar entre elementos y etiquetas: los elementos son las
entidades en sí, lo que tiene contenido, mientras que las etiquetas sólo describen a los
elementos. Un documento XML está compuesto por elementos, y en su sintaxis éstos se
nombran mediante etiquetas. Hay dos tipos de elementos: los vacíos y los no vacíos. Hay
varias consideraciones importantes a tener en cuenta al respecto:
Toda etiqueta no vacía debe tener una etiqueta de cerrado: <etiqueta> debe estar seguida
de </etiqueta>. Esto se hace para evitar la aberración (en el buen sentido de la palabra) a
la que habían llegado todos los navegadores HTML de permitir que las etiquetas no se
cerraran, lo que deja los elementos sujetos a posibles errores de interpretación.
Todos los elementos deben estar perfectamente anidados: no es válido poner:
<ficha><nombre>Angel</ficha></nombre>
Y sí lo es sin embargo:

<ficha><nombre>Angel</nombre> </ficha>.
Los elementos vacíos son aquellos que no tienen contenido dentro del documento. Un
ejemplo en HTML son las imágenes. La sintaxis correcta para estos elementos implica que
la etiqueta tenga siempre esta forma: <etiqueta/>.
DTD Definición de tipos de documento.

Como antes se comentó, los documentos XML pueden ser válidos o bien formados (o no
serlo, claro, pero entonces no serían documentos XML :-). En cuanto a los válidos, ya
sabemos que su gramática está definida en los DTD.
Hay varios modos de referenciar un DTD en un documento XML:
Incluir dentro del documento una referencia al documento DTD en forma de URI
(Universal Resource Identifier, o identificador universal de recursos) y mediante la
siguiente sintáxis:
<!DOCTYPE ficha SYSTEM "http://www.dat.etsit.upm.es/~abarbero/DTD/ficha.dtd">
En este caso la palabra SYSTEM indica que el DTD se obtendrá a partir de un elemento
externo al documento e indicado por el URI que lo sigue, por supuesto entrecomillado.
O bien incluir dentro del propio documento el DTD de este modo:
<?xml version="1.0"?>
<!DOCTYPE ficha [
<!ELEMENT ficha (nombre+, apellido+, direccion+, foto?)>
<!ELEMENT nombre (#PCDATA)>
<!ATTLIST nombre sexo (masculino|femenino) #IMPLIED>
<!ELEMENT apellido (#PCDATA)>
<!ELEMENT direccion (#PCDATA)>
<!ELEMENT foto EMPTY>
]>
<ficha>
<nombre>Angel</nombre>
<apellido>Barbero</apellido>
<direccion>c/Ulises, 36</direccion>
</ficha>
La forma de incluir el DTD directamente como en este ejemplo pasa por añadir a la
declaración <!DOCTYPE y después del nombre del nombre del tipo de documento, en vez
de la URI del DTD, el propio DTD entre los símbolos '[' y ']'. Todo lo que hay entre ellos
será considerado parte del DTD.
En cuanto a la definición de los elementos, es bastante intuitiva: después de la cláusula

<!ELEMENT se incluye el nombre del elemento (el que luego se indicara en la etiqueta), y
después diferentes cosas en función del elemento:

entre paréntesis, si el elemento es no vacío, se indica el contenido que puede tener el

elemento: la lista de elementos hijos o que descienden de él si los tiene, separados por
comas; o el tipo de contenido, normalmente #PCDATA, que indica datos de tipo texto, que
son los más habituales. si es un elemento vacío, se indica con la palabra EMPTY.
Ejemplos de cada caso se pueden ver en el DTD de mostrado.
A la hora de indicar los elementos descendientes (los que están entre paréntesis) vemos
que van seguidos de unos caracteres especiales: '+', '*', '?' y '|'. Sirven para indicar qué
tipo de uso se permite hacer de esos elementos dentro del documento:
+ : uso obligatorio y múltiple; permite uno o más elementos de ese tipo dentro del
elemento padre, pero como mínimo uno.
* : opcional y múltiple; puede no haber ninguna ocurrencia, una o varias.
? : opcional pero singular; puede no haber ninguno o como mucho uno.
| : equivale a un OR, es decir, da la opción de usar un elemento de entre los que forman
la expresión, y solo uno.
De este modo, si por ejemplo encontramos en un DTD la siguiente declaración:
<!ELEMENT ficha (nombre+, apellido+, direccion*, foto?, telefono*|fax*)>
Sabremos del elemento ficha que puede contener los siguientes elementos: un nombre y
un apellido como mínimo, pero puede tener más de uno de cada; opcionalmente puede
incluirse una o varias direcciones, pero no es obligatorio; opcionalmente también se
puede incluir una única foto; y por fin, pueden incluirse, aunque no es obligatorio en
ninguno de los dos casos, uno o más teléfonos o uno o más números de fax.
Como ya se comentó un documento XML presenta una jerarquía muy determinada,

definida en el DTD si es un documento válido, pero siempre inherente al documento en
cualquier caso (siempre se puede inferir esa estructura a partir del documento sin
necesidad de tener un DTD en el que basarse), con lo que se puede representar como un
árbol de elementos. Existe un elemento raíz, que siempre debe ser único (sea nuestro
documento válido o sólo bien formado) y que se llamará como el nombre que se ponga en
la definición del <!DOCTYPE si está asociado a un DTD o cualquiera que se desee en caso
contrario. Y de él descienden las ramas de sus respectivos elementos descendientes o
hijos. De este modo la representación en forma de árbol del documento XML del ejemplo
sería:

Vemos que es un documento muy sencillo, con una profundidad de 2 niveles nada más:
el elemento raíz ficha, y sus hijos nombre, apellido, direccion, foto. Es obvio que cuanta
más profundidad, mayor tiempo se tarda en procesar el árbol, pero la dificultad siempre
será la misma gracias a que se usan como en todas las estructuras de árbol algoritmos
recursivos para tratar los elementos.
El DTD, por ser precisamente la definición de esa jerarquía, describe precisamente la

forma de ese árbol. La diferencia (y la clave) está en que el DTD define la forma del árbol
de elementos, y un documento XML válido puede basarse en ella para estructurarse,
aunque no tienen que tener en él todos los elementos, si el DTD no te obliga a ello. Un
documento XML bien formado sólo tendrá que tener una estructura jerarquizada, pero sin
tener que ajustarse a ningún DTD concreto.
Para la definición de los atributos, se usa la declaración <!ATTLIST, seguida de:
• El nombre de elemento del que estamos declarando los atributos;

• El nombre del atributo;
• Los posibles valores del atributo, entre paréntesis y separados por el carácter |, que
al igual que para los elementos, significa que el atributo puede tener uno y sólo uno
de los valores incluidos entre paréntesis. O bien, si no hay valores de finidos, se
escribe CDATA para indicar que puede ser cualquier valor (alfanumérico, vamos).
También podemos indicar con la declaración ID que el valor alfanumérico que se le de
será único en el documento, y se podrá referenciar ese elemento a través de es e
atributo y valor;
• De forma opcional y entrecomillado, un valor por defecto del atributo si no se incluye
otro en la declaración;
• Por último, si es obligatorio cada vez que se usa el elemento en cuestión declarar este
atributo, es necesario declararlo con la clausula #REQUIRED; si no lo es, se debe
poner #IMPLIED, o bien #FIXED si el valor de dicho atributo se debe mantener fijo a
lo largo de todo el documento para todos los elementos del mismo tipo (notar que no
es lo mismo esto a lo que significaba ID).
Es importante destacar un aspecto de cara a la optimización del diseño de nuestros

DTDs: muchas veces tendremos que decidir entre especificar atributos de nuestros
elementos como elementos descendientes o como atributos en sí mismos. Esto es,
podríamos suponer una pieza de maquinaria con unas características determinadas, y de
la que podemos hablar de dos formas diferentes:
<pieza>MiPieza
<color>Rojo</color>
</pieza>
o bien considerar la opción:
<pieza color="Rojo">Mipieza</pieza>
¿Qué diferencia habría entre ambos? Queda a discreción del diseñador el decidir entra
ambas, pero hay que tener en cuenta que si se usa la primera forma, el procesador tiene
que bajar al siguiente nivel del árbol de elementos para saber el color de MiPieza,

mientras que en el segundo caso lo puedes obtener referenciando directamente el atributo

"color" del elemento en el que estás. Esto no quiere decir nada de todos modos, porque
hay quien prefiere hacerlo del primer modo por estar más acorde con la filosofía de XML
de que las etiquetas referencien siempre su contenido, sin necesidad de acudir a los
atributos, que era lo que hasta ahora se hacía en HTML.
4.3. Concepto JavaScript

JavaScript es un lenguaje de programación creado por Netscape con el objetivo de
integrarse en HTML y facilitar la creación de páginas interactivas sin necesidad de utilizar
scripts de CGI o Java.
JavaScript es un lenguaje de script, interpretedo, basado a objetos. Aunque tiene menos

capacidad que un lenguaje totalmente orientado a objetos como C++ y Java.
JavaScript no es una versión limitada de otro lenguaje, y no es una simplificación de

cualquier otro. Es por lo tanto, limitado. No se pueden escribir aplicaciones autónomas,
por ejemplo, y tiene una capacidad muy limitada para leer y escribir ficheros. Es mas, los
script (o guiones) de JavaScript no se pueden ejecutar sin la presencia de un interprete,
bien sea en un servidor Web o en un navegador (o browser).
JavaScript es un lenguaje sin tipo de datos. Es decir, no se requiere declarar el tipo de

datos de las variables explícitamente. Es mas, en muchos casos JavaScript realiza la
conversión automaticamente cuando sea necesario. Por ejemplo, al añadir un numero a
un campo o item que es una cadena de caracteres (o string), el numero se convierte a
texto.
No confundir Java con JavaScript. Java es un lenguaje completo que permite crear
aplicaciones independientes, mientras que JavaScript es un lenguaje que funciona como
extensión de HTML. Es un lenguaje de programación orientado a objetos, diseñado para
el desarrollo de aplicaciones cliente-servidor a través de Internet.
El código de programa JavaScript, llamado script, se introduce directamente en el

documento HTML y no necesita ser compilado, es el propio navegador el que se encarga
de traducir dicho código.
Gracias a JavaScript se puede desarrollar programas que se ejecuten directamente en el

navegador (cliente) de manera que éste pueda efectuar determinadas operaciones o tomar
decisiones sin necesidad de acceder al servidor. Por ejemplo, al desarrollar un programa
que verifique una clave de acceso para poder acceder a una determinada web, JavaScript
debe comprobar la información dada por el usuario, verificar que sea correcta y actuar en
consecuencia.
Como muchos otros lenguajes de programación, JavaScript se escribe en formato texto, y

se organiza en sentencias, bloques que consisten en un juego de sentencias, y
comentarios. Dentro de una sentencia se pueden utilizar variables, datos como cadenas
de caracteres, números, y expresiones.

4.3.1. JavaScript y HTML.

Sabemos que un programa en JavaScript no debe ser compilado, ya que el navegador se
encarga de leerlo cuando se carga la página, pero esto no quiere decir que todos los
códigos JavaScript se ejecuten nada más por cargarse el documento HTML, algunas
funciones permanecen en estado latente hasta que el usuario realiza una acción
determinada, como podría ser dar clic a un enlace.
Para diferenciar dentro de un documento lo que es JavaScript del resto HTML dispone de
una etiqueta que define el inicio y el final del código JavaScript. Para definir el inicio de
un programa o código se debe utilizar la etiqueta <SCRIPT LANGUAGE=”JavaScript”> y
determinar el final con </SCRIPT>. El atributo LANGUAGE indica al navegador el
lenguaje script utilizado.
4.3.2. Ejemplo de una página con código en JavaScript incluído.

El siguiente ejemplo muestra una página HTML con bloques de código en JavaScript.
Para distinguir los bloques en JavaScript utilizar las etiquetas <SCRIPT> descritas en la
sección anterior.
<HTML>
<HEAD>
<TITLE> Ejemplo de creación de Objetos </TITLE>
</HEAD>
<BODY>
<SCRIPT LANGUAGE="JavaScript">
function Computador(marca,cpu,memoria) {
this.marca = marca;
this.cpu = cpu;
this.memoria = memoria;
}
miComputador = new computador("HP","Pentium150","64Mb")

miComputador_Dos = new Computador("Philips","Pentium200","64Mb")
miComputador_Tres = new Computador("Acer","Pentium133","16Mb")
var mensaje;
mensaje = "micomputador\marca:" + miComputador.marca + "\n" +

"cpu:" + miComputador.cpu + "\n" + "memoria:" +
miComputador.memoria + "\n";
alert(mensaje);
mensaje = "micomputador_Dos\marca:" + miComputador_Dos.marca + "\n" +

"cpu:" + miComputador_Dos.cpu + "\n" + "memoria:" +
miComputador_Dos.memoria + "\n";
alert(mensaje);
mensaje = "micomputador_Tres\marca:" + miComputador_Tres.marca + "\n" +

"cpu:" + miComputador_Tres.cpu + "\n" + "memoria:" +
miComputador_Tres.memoria + "\n";
alert(mensaje);

</SCRIPT>
</BODY>
</HTML>
4.3.3. Ejemplo de una calculadora hecha con JavaScript.
El siguiente ejemplo muestra un calculadora hecha con JavaScript.
<HTML>
<HEAD>
<TITLE>Calculadora</TITLE>
<SCRIPT>

</SCRIPT>
</HEAD>
<BODY>
<FORM>
<TABLE BORDER=1>
<TR><TD COLSPAN=4><INPUT TYPE=text NAME=display VALUE=""
onFocus="this.blur();"></TD></TR>
<TR>

<TD><INPUT TYPE=button NAME="7" VALUE=" 7 " onClick="IntroduceNumero(this);"></TD>

<TD><INPUT TYPE=button NAME="+" VALUE=" + " onClick="Calcula(this);"></TD></TR><TR>
<TD><INPUT TYPE=button NAME="-" VALUE=" - " onClick="Calcula(this);"></TD>
</TR>
<TR>
<TD><INPUT TYPE=button NAME="*" VALUE=" * " onClick="Calcula(this);"></TD></TR><TR>
<TD><INPUT TYPE=button NAME="C" VALUE=" C " onClick="Limpiar(this.form);"></TD>
<TD><INPUT TYPE=button NAME="CE" VALUE="CE"
onClick="BorraNumero(this.form);"></TD>
<TD><INPUT TYPE=button NAME="/" VALUE=" / " onClick="Calcula(this);"></TD>
</TR>
</TABLE>
</FORM>
</BODY>
</HTML>
Obsérvese cómo se referencia un formulario a partir de un elemento del mismo: var

Formu = Digito.form permite obtener el formulario que contiene el boton Digito.

4.4. Concepto JavaServerPages (JSP) y Servlets
4.4.1. Servlets.
En su concepción más tradicional, los servidores HTTP se limitaban a enviar una página
HTML cuando el usuario la requería directamente o hacía clic sobre un enlace. La
interactividad de este proceso era mínima, ya que el usuario podía pedir ficheros, pero no
enviar sus datos personales de modo que fueran almacenados en el servidor u obtuviera
una respuesta personalizada.
Desde esa primera concepción del servidor HTTP como mero servidor de ficheros HTML el
concepto ha ido evolucionando en dos direcciones complementarias:
1. Añadir más inteligencia en el servidor, y
2. Añadir más inteligencia en el cliente.
Las formas más extendidas de añadir inteligencia a los clientes (a las páginas HTML) han
sido Javascript y las applets de Java.
Los caminos seguidos para añadir más inteligencia en el servidor HTTP tienen gran
relevancia. La primera y más empleada tecnología ha sido la de los programas CGI
(Common Gateway Interface), unida a los formularios HTML.
Los formularios HTML permiten de alguna manera invertir el sentido del flujo de la
información. Con algunos campos con cajas de texto, botones de opción y de selección, el
usuario puede definir sus preferencias o enviar sus datos al servidor. Cuando en un
formulario HTML se pulsa en el botón Enviar (o nombre equivalente, como Submit) los
datos tecleados por el cliente se envían al servidor para su procesamiento.
¿Cómo recibe el servidor los datos de un formulario y qué hace con ellos? Éste es el
problema que tradicionalmente han resuelto los programas CGI. Cada formulario lleva
incluido un campo llamado Action con el que se asocia el nombre de programa en el
servidor. El servidor arranca dicho programa y le pasa los datos que han llegado con el
formulario. Existen dos formas principales de pasar los datos del formulario al programa
CGI:
1. Por medio de una variable de entorno del sistema operativo del servidor, de tipo
String (método GET)
2. Por medio de un flujo de caracteres que llega a través de la entrada estándar

(stdin o System.in), que de ordinario está asociada al teclado (método POST).
En ambos casos, la información introducida por el usuario en el formulario llega en la

forma de una única cadena de caracteres en la que el nombre de cada campo del
formulario se asocia con el valor asignado por el usuario, y en la que los blancos y ciertos
caracteres especiales se han sustituido por secuencias de caracteres de acuerdo con una
determinada codificación. Lo primero que tiene que hacer el programa CGI es decodificar

esta información y separar los valores de los distintos campos. Después ya puede realizar
su tarea específica: escribir en un fichero o en una base de datos, realizar una búsqueda
de la información solicitada, realizar comprobaciones, etc. De ordinario, el programa CGI
termina enviando al cliente (el navegador desde el que se envió el formulario) una página
HTML en la que le informa de las tareas realizadas, le avisa de si se ha producido alguna
dificultad, le reclama algún dato pendiente o mal tecleado, etc. La forma de enviar esta
página HTML al cliente es a través de la salida estándar (stduot o System.out), que de
ordinario suele estar asociada a la pantalla. La página HTML tiene que ser construida
elemento a elemento, de acuerdo con las reglas de este lenguaje. No basta enviar el
contenido: hay que enviar también todas y cada una de las tags.
Es importante resaltar que estos procesos tienen lugar en el servidor. Esto a su vez puede
resultar un problema, ya que al tener múltiples clientes conectados al servidor, el
programa CGI puede estar siendo llamado simultáneamente por varios clientes, con el
riesgo de que el servidor se llegue a saturar. Téngase en cuenta que cada vez que se
recibe un requerimiento se arranca una nueva copia del programa CGI.
El objetivo de este capítulo es el estudio de la alternativa que Java ofrece a los programas
CGI: los servlets, que son a los servidores lo que los applets a los browsers. Se podría
definir un servlet como un programa escrito en Java que se ejecuta en el marco de un
servicio de red, (un servidor HTTP, por ejemplo), y que recibe y responde a las peticiones
de uno o más clientes.
Un servlet de forma intuitiva se puede definir como un programa independiente de

plataforma que aporta la misma funcionalidad a la programación en el lado del servidor
que tradicionalmente han realizado la interfaz CGI. Así como los applets son clases de
Java que se ejecutan en el cliente, los Servlets son clases de Java que se ejecutan en el
servidor.
Son clases de Java que extienden de la clase Servlet y pueden ser llamadas en una
petición http. Cuando una clase Servlet es invocada, el JSP Engine (un módulo del
servidor web) la ejecuta y devuelve al cliente una salida HTML.
Con respecto a esta tecnología aporta numerosas ventajas que citaremos a continuación:

• Independencia de la plataforma. (La tan anhelada premisa del “write once run
everywhere” aun no totalmente conseguida).Esto proporciona un menor esfuerzo
de codificación con respecto a soluciones dependientes del servidor web y de la
plataforma como ISAPI o NSAPI.
• Ejecución en paralelo de múltiples peticiones por una sola instancia del servlet.
Tradicionalmente en los programas CGI se ejecuta un proceso distinto para cada
petición lo que conlleva una gradual degradación del rendimiento y una necesidad
de recursos muy elevada. En un servlet todas las peticiones se atienden en el
mismo proceso por distintos hilos y una vez que se ha cargado el servlet este
permanece en memoria hasta que se reinicie el servidor o hasta que se le diga lo
contrario con lo cual las subsiguientes peticiones son mas rápidas al encontrarse
el programa ya cargado en memoria.
• Un servlet puede ejecutarse(incido en esto puede no es necesario) en una sandbox

o recinto de seguridad parecido al modelo que se se sigue con los applets. Debido
a esto pueden colocarse servlets en servidores dedicados a hosting sin que la
empresa tema por la integridad del servidor y la seguridad de las aplicaciones.
• Los servlets pueden llamar a otros servlets, e incluso a métodos concretos de otros
servlets. De esta forma se puede distribuir de forma más eficiente el trabajo a
realizar. Por ejemplo, se podría tener un servlet encargado de la interacción con
los clientes y que llamara a otro servlet para que a su vez se encargara de la
comunicación con una base de datos. De igual forma, los servlets permiten
redireccionar peticiones de servicios a otros servlets (en la misma máquina o en
una máquina remota).
• 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.
• Permiten además la utilización de cookies y sesiones, de forma que se puede

guardar información específica acerca de un usuario determinado, personalizando
de esta forma la interacción cliente-servidor. Una clara aplicación es mantener la
sesión con un cliente.
• Los servlets pueden actuar como enlace entre el cliente y una o varias bases de
datos en arquitecturas cliente-servidor de 3 capas (si la base de datos está en un
servidor distinto).
• Asimismo, 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 el servlet sí
puede hacerlo de su parte.
• Al igual que los programas CGI, los servlets permiten la generación dinámica de
código HTML dentro de una propia página HTML. Así, pueden emplearse servlets
para la creación de contadores, banners, etc.

Históricamente el rechazo al uso de los servlets se ha debido a la injustificada leyenda de

la falta de velocidad de ejecución del lenguaje Java. Sin embargo si observamos las
lenguajes de script que tradicionalmente se han usado para escribir aplicaciones CGI´s
(Perl,PHP..) nos encontramos con que también son interpretados lo que unido a la
necesidad de lanzar un proceso por petición provocan un rendimiento considerablemente
menor.Esto no pasa si el lenguaje de implementación del CGI es uno compilado como
puede ser C pero la obligatoriedad de cumplir la ecuación 1 peticion = 1 proceso sitúan el
rendimiento en niveles parecidos con un menor consumo de recursos del servlet.
Ejemplo de un servlet básico:
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class ServletBasico extends HttpServlet{
public void init(ServletConfig config) throws SerlvetException {
// Siempre se pasa el objet ServletConfig a la superclase
super.init(config);
}
// Proceso HTTP Get de la petición
public void doGet(HttpSerlvetRequest peticion,HttpserlvetResponse respuesta) throws
SerlvetException, IOException {
respuesta.setContentType("text/html");
PrintWriter out = respuesta.getWriter();
out.println("<html>");
out.println("<head><title>Servlet Basico</title></head>");
out.println("<body>");
// Imprime en pantalla el método enviado por la petición
out.println("El método de la petición es" + peticion.getMethod()+"\n");
out.println("</body></html>");
out.close();
}
// Proceso HTTP Post de la petición
public void doPost(HttpSerlvetRequest peticion,HttpServletResponse respuesta) throws
ServletException,IOException {
respuesta.setContentType("text/html");
PrintWriter out = respuesta.getWriter();
out.println("<html>");
out.println("<head><title>Servlet Basico</title></head>");
out.println("<body>");
// Imprime en pantalla el método enviado por la petición
out.println("El método de la petición es" + peticion.getMethod()+"\n");
out.println("</body></html>");
out.close();
}
4.4.2. Java Server Pages (JSP).

Java Server Pages (JSP) es una tecnología que nos permite mezclar HTML estático con
HTML generado dinámicamente (plantilla para una página web que emplea código Java
para generar un código HTML dinámicamente). Simplemente escribimos el HTML regular
de la forma normal, usando cualquier herramienta de construcción de paginas Web que
usemos normalmente. Encerramos el código de las partes dinámicas en unas etiquetas
especiales, la mayoría de las cuales empiezan con “<%” y terminan con “%>”. Muchas
páginas Web que están construidas con programas CGI son casi estáticas, con la parte
dinámica limitada a muy pocas localizaciones. Pero muchas variaciones CGI, incluyendo
los servlets, hacen que generemos la página completa mediante nuestro programa,
incluso aunque la mayoría de ella sea siempre lo mismo. JSP nos permite crear dos
partes de forma separada. Aquí tenemos un ejemplo:
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN”>

<HTML>
<HEAD><TITLE>Welcome to Our Store</TITLE></HEAD>
<BODY>
<H1>Welcome to Our Store</H1>
<SMALL>Welcome,

<% out.println(Utils.getUserNameFromCookie(request)); %>
To access your account settings, click
<A HREF=”Account-Settings.html”>here.</A></SMALL>
<P>
Regular HTML for all the rest oif the on-line store’s Web page.
</BODY>
</HTML>
Las páginas JSP se ejecutan en un componente del servidor conocido como contenedor
JSP, que las traduce a servlets Java equivalentes. Normalmente daremos al archivo una
extensión .jsp, y normalmente lo instalaremos en el mismo sitio que una página Web
normal. Aunque lo que escribamos frecuentemente se parezca a un HTML normal en vez
de un servelt, detrás de la escena, la página JSP se convierte en un servlet normal, donde
el HTML estático simplemente se imprime en el stream de salida estándard asociado con
el método service del servlet. Esto normalmente sólo se hace la primera vez que se solicita
la página, y los desarrolladores pueden solicitar la página ellos mismos cuando la
instalan si quieren estar seguros de que el primer usuario real no tenga un retardo
momentáneo cuando la página JSP sea traducida a un servlet y el servlet sea compilado y
cargado. Muchos servidores Web nos permiten definir alias para que una URL que parece
apuntar a un fichero HTML realmente apunte a un servelt o a una página JSP. El
siguiente esquema nos muestra el diagrama de ubicación de los JSP en un ambiente
basado en servidor de aplicaciones JavaEE.

Navegador Web Servidor Web

GET/requestURI
<HTML>...<HTML>
Motor de Servlets
Servlets Páginas JSP
Servicios J2EE
B.D. Otros servicios
Además de el HTML normal, hay tres tipos de construcciones JSP que se incluirán en una
página: elementos de script, directivas y acciones. Los elementos de script nos permiten
especificar código Java que se convertirá en parte del servlet resultante, las directivas nos
permiten controlar la estructura general del servlet, y las acciones nos permiten
especificar componentes que deberían ser usuados, y de otro modo controlar el
comportamiento del motor JSP.
¿Cuáles son las Ventajas de JSP?

• Contra Active Server Pages (ASP). ASP es una tecnología similar de Microsoft. Las
ventajas de JSP estan duplicadas. Primero, la parte dinámica está escrita en Java,
no en Visual Basic, otro lenguaje específico de MS, por eso es mucho más
poderosa y fácil de usar. Segundo, es portable a otros sistemas operativos y
servidores Web.
• Contra los Servlets. JSP no nos da nada que no pudierámos en principio hacer
con un servlet. Pero es mucho más conveniente escribir (y modificar) HTML
normal que tener que hacer un billón de sentencias println que generen HTML.
Además, separando el formato del contenido podemos poner diferentes personas
en diferentes tareas: nuestros expertos en diseño de páginas Web pueden
construir el HTML, dejando espacio para que nuestros programadores de servlets
inserten el contenido dinámico.
• Contra Server-Side Includes (SSI). SSI es una tecnología ámpliamente soportada
que incluye piezas definidas externamente dentro de una página Web estática. JSP
es mejor porque nos permite usar servlets en vez de un programa separado para
generar las partes dinámicas. Además, SSI, realmente está diseñado para
inclusiones sencillas, no para programas “reales” que usen formularios de datos,
hagan conexiones a bases de datos, etc.

• Contra JavaScript. JavaScript puede general HTML dinámicamente en el cliente.

Este una capacidad útil, pero sólo maneja situaciones donde la información
dinámica está basada en el entorno del cliente. Con la excepción de las cookies, el
HTTP y el envió de formularios no están disponibles con JavaScript. Y, como se
ejecuta en el cliente, JavaScript no puede acceder a los recursos en el lado del
servidor, como bases de datos, catálogos, información de precios, etc.
• No necesita una configuración especial por parte del cliente.
• Tienen pleno acceso a la tecnología Java –capacidad de reconocimiento del trabajo
en red, subprocesos y conectividad a base de datos- sin las limitaciones de los
applets del cliente.
Como las páginas JSP son similares al HTML, tienen mayor compatibilidad con las
herramientas de desarrollo Web (Dreamweaver por ejemplo).
6.1.2 Como funciona JSP

La página JSP pasa por tres etapas en la evolución de su código:
• Código fuente JSP. Este código es el que realmente escribe el desarrollador. Se
encuentra en un archivo de texto con extensión .jsp y consiste en una mezcla de
código de plantilla HTML, instrucciones en lenguaje Java, directivas JSP y
acciones que describen como generar una página Web para dar servicio a una
petición concreta.
• Código fuente Java. El contenedor JSP traduce el código fuente JSP al código
fuente de un servlet Java equivalente. Este código fuente se guarda en un área de
trabajo y suele ser útil en el proceso de depuración de errores.
• Clase Java compilada. Como cualquier otra clase Java, el código del servlet
generado se compila en código de bytes en un archivo .class, preparado para ser
cargado y ejecutado.
El contenedor de JSP administra cada una de estas etapas de la página JSP

automáticamente, basándose en la situación temporal de cada archivo. Como respuesta a
la petición HTTP, el contenedor comprueba si el archivo fuente .jsp ha sufrido
modificaciones desde que el código fuente .java se compiló por última vez.
El siguiente diagrama muestra el proceso empleado por el contenedor de JSP. Cuando
se realiza la petición de una página JSP, el contenedor determina primero el nombre de la
clase correspondiente al archivo .jsp (lo que significa que código fuente JSP ha cambiado
desde que fue compilado por ultima vez), entonces el contenedor crea el código fuente
Java para un servlet equivalente y lo compila. Si no hay un ejemplar o instancia del
servlet en funcionamiento, el contenedor carga la clase servlet y crea un ejemplar.
Finalmente, el contenedor lanza un subproceso para que se gestione la petición http
actual del ejemplar cargado.

El contenido de una página o archivo JSP se hace muy familiar y legible para una
persona con conocimientos de HTML y Java. Sólo necesitaría aprender algunas directivas
o tags propias del lenguaje JSP y conocer el API de algunos objetos para estar preparado
para desarrollar casi cualquier proyecto. Un ejemplo simple de una página JSP se
presenta en el siguiente ejemplo en la columna derecha está el código del archivo .jsp. En
la izquierda está el resultado que aparece en el browser del cliente.
<%@ page info="un primer ejemplo de JSP" %>

<html>
<head><title>Hello, World</title></head>
<body bgcolor="#ffffff">
<%!
Hello World String message = “Hello World”;
%>
<table>
<tr>
<td width=250 align=”center”>
<h1><%= message %></h1>
</td>
</tr>
</table>
</body>
</html>
A continuación se presentan los elementos del lenguaje junto a una breve descripción de
su uso.

Comentario  es enviado al cliente en la
salida HTML. Se ve en el
código de la página pero no
aparece visible.
Comentario <%-- comment [<%= expresión %>] Genera un comentario que
escondido --%> sólo es visible en el código de
la página JSP.
No es enviado al cliente.
Este tipo de comentarios se
utilizan para documentar el
código o dejar instrucciones
a otros desarrolladores.
Declaración <%! declaración %> Genera un comentario que
de variables es enviado al cliente en la
globales salida HTML. Se ve en el
código de la página pero no
aparece
visible.
Expresión <%= expresión %> Retorna el valor de una
expresión válida. Se utiliza
para imprimir el valor
de variables en la salida de
la página.
Código <% fragmento de código %> Contiene una pieza de
código en lenguaje Java. Se
utiliza para hacer cualquier
tarea necesaria como
conectarse a una base de
datos o evaluar condiciones.
Ejemplo:
<%@ page info="segundo ejemplo de JSP" %>

<html>
<head><title>Ejemplo - tags</title></head>
<body bgcolor="#ffffff">
<%-- Declaración de variables %>
black <%! Vector colors = new Vector(); %>
blue <%
green colors.addElement(“black”);
colors.addElement(“blue”);
colors.addElement(“green”);
%>
<%-- Contenido de la página %>
<table>
<% for (int i=0; i<colors.size(); i++) { %>
<tr>

<td width=250 align=”center”>


<font color=”<%= colors.elementAt(i); %
>”>
<%= colors.elementAt(i); %>
</font>
</td>
</tr>
<% } %>
</table>
</body>
</html>
Directivas JSP:
Directiva <%@ include file=”path relativo” %> Incluye el contenido (texto)

include de un archivo al JSP actual.
Hace el equivalente de un
cut and paste de el archivo
incluido. La inclusión se
realiza al momento de la
generación del Servlet. Es
muy utilizado para lograr
modularidad.
<jsp:forward> <jsp:forward page={path relativo | <% Redirecciona una petición
= expresión %>} /> http a otro archivo. La
salida que llegará al cliente
es la salida del archivo al
que se redirigió la petición y
no la salida del que hizo la
redirección.
<jsp:include> <jsp:include page={path relativo | <% Incluye datos desde un
= expresión %>} /> archivo sin ser ejecutados o
compilados. Se hace al
momento de la petición.
4.5. Enterprise JavaBeans (EJB)

Escritos en lenguaje de programación JAVA un enterprise bean es un componente
(montado en un servidor de aplicaciones) que encapsula la lógica de negocio en una
aplicación. La lógica de negocio es el código que soporta el propósito de una aplicación.
En una aplicación de control de inventarios por ejemplo, los enterprise beans pueden
implementar la lógica del negocio en métodos llamados checaNivelDeInventario y
OrdenaProducto. Por el llamado de estos métodos los clientes remotos pueden acceder los
servicios de inventario ofrecidos por la aplicación.
EJB nos dan la posibilidad de crear la lógica de negocio como componentes reusables, y
poderlos usar en cualquier tipo de servidor que soporte la especificación EJB. El

programar EJBs en lugar de aplicaciones enteras en JAVA permite ahorrarse las

preocupaciones de seguridad, pool de conexiones, gestión transaccional, control de
estado, persistencia o multithreading. Al desarrollar EJB el esfuerzo, y una vez superada
la curva de aprendizaje inicial, el esfuerzo se centra en programar la lógica de negocio.
Un EJB corre dentro de un container o contenedor en un servidor de aplicaciones (al

igual que los servlets y JSP). El contenedor lo facilita el fabricante del servidor de
aplicaciones y es el interface entre el EJB desarrollado y el servidor escogido. Los
contenedores proporcionan independencia al EJB del servidor en el que corre.
Por varias razones , los Enterprise beans simplifican el desarrollo de grandes aplicaciones
distribuidas.
1. El contenedor de EJB ofrece servicios a nivel de sistema a los enterprise beans.

El desarrollador de beans se puede concentrar en solucionar los problemas del
negocio.
El contenedor de EJB (no el desarrollador) es responsable de servicios a nivel
de sistema como el manejo transaccional y control de seguridad.
2. Los beans (no los clientes) contienen la aplicación de la lógica del negocio.
El desarrollador de las pantallas del cliente puede enfocarse únicamente a la
presentación, no debe preocuparse de codificar rutinas para integrar reglas de
negocio o acceso a la base de datos. Como consecuencia los clientes son mas
delgados y beneficia a aquellos limitados en recursos de computo.
3. Los EJB son portables. El integrador de aplicaciones puede construir nuevas

con los beans ya existentes. (Estas aplicaciones solo pueden correr con apoyo
de un servidor JavaEE ).
4.5.1 Cuando usar Enterprise Beans

Se debe considerar el uso de EJB si la aplicación tiene los sisguientes requerimientos:
• La aplicación es escalable. Para atender un número creciente de usuarios se

debe distribuir los componentes de la aplicación en varias máquinas. No solo
pueden correr en diferentes máquinas, su ubicación es transparente para los
clientes.
• Las transacciones son requeridas para la integridad de datos. Los Enterprise

Beans soportan transacciones el mecanismo que maneja el acceso concurrente a
objetos compartidos.
• La aplicación tiene gran variedad de clientes. Con solo algunas líneas de código
los clientes remotos pueden localizar los Enterpise Beans. Estos clientes pueden
ser delgados, variantes y numerosos.

4.5.2. Tipos de Enterprise Beans

Los tipos de Beans manejados son los siguientes:
Tipo de Enterprise Bean Propósito

Session (Sesión) Realiza una tarea del cliente
Entity (Entidad) Representa una entidad del negocio en un
almacenamiento persistente
Message-Driven (Mensaje) Actúa como un listener de JAVA el Message
Service API procesa mensajes asíncronos.
Bean de Sesión
Un bean de sesión representa un cliente simple dentro del servidor JavaEE. Para acceder
una aplicación que es implementada en el servidor, el cliente invoca los métodos del bean
de sesión. El bean de sesión ejecuta el trabajo para su cliente. Liberando al cliente de
complejidades al ejecutar tareas del negocio dentro del servidor.
Como su nombre lo intuye, un bean de session es similar a una sesión interactiva. Un

bean de sesión no es compartido debe tener un solo cliente, de la misma forma que una
sesión interactiva puede tener un solo usuario. Al igual que una sesión interactiva el bean
de sesión no es persistente (Esto es, sus datos no son salvados en la base de datos)
cuando el cliente termina, el bean de sesión aparenta su terminación y no esta asociado
más con el cliente.
Bean de Entidad
Un bean de entidad representa un objeto del negocio en un mecanismo persistente de
almacenamiento. Algunos ejemplos de objetos de negocio son clientes, ordenes y
productos. En el JavaEE SDK, el mecanismo de almacenamiento persistente es una base
de
datos relacional. Típicamente, cada bean de entidad tiene una tabla asociada en una base
de datos relacional, y cada instancia del bean corresponde a un registro de la tabla.
Debido a que el estado de un bean de entidad es salvado en un medio de

almacenamiento., este es persistente. Persistencia significa que el estado del bean de
entidad existe durante todo el tiempo de vida de la aplicación o del proceso de servidor
JavaEE. Los datos en una base de datos son persistentes porque ellos existen a pesar de
que se de shutdown al servidor o aplicaciones de bases de datos.
Bean de Mensaje
Un bean de mensaje (message-driven bean) es un tipo de enterprise bean que permite a
las aplicaciones JavaEE procesar mensajes de manera asíncrona. Los mensajes deben ser
enviados por cualquier componente JavaEE (una aplicación del cliente, otro enterprise
bean o un componente Web) o por una aplicación JMS o un sistema que no utilice
tecnología JavaEE.

Java EE

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java EE

Uploaded by

Copyright:

Available Formats

PROGRAMACION ORIENTADA A OBJETOS

mroescobar@yahoo.com.mx Prof. Ing. Octavio César Escobar Jaramillo

4.1. La plataforma JavaEE y su importancia en el desarrollo de aplicaciones multicapa ..................... 2

Capítulo 4 JavaEE 1 JavaEE

4.1. La plataforma JavaEE y su importancia en el desarrollo de

Aunque varios productos Java están diseñados alrededor de estas especificaciones, no

4.1.1 Componentes JavaEE

El desarrollo de una aplicación empresarial estará basado en los componentes ofrecidos

Capítulo 4 JavaEE 2 JavaEE

Máquina Cliente Máquina Servidor J2EE Máquina Servidor

Capa Cliente Capa Web Capa Negocio Capa B.D.

4.1.2 Herramientas de desarrollo para JavaEE

El siguiente diagrama muestra las herramientas y productos que se requerirán para el

Máquinas de desarrollo Servidor de Servidor de B.D.

Capítulo 4 JavaEE 3 JavaEE

4.2. Concepto HTML y XML

La red mundial WWW es una red de recursos de información. Se basa en 3 mecanismos

1. Un esquema uniforme de nombrado para localizar recursos en el Web (Ejemplo

Para publicar información de manera global se requirió de un lenguaje universal de

El lenguaje HTML se basa en el uso de etiquetas también llamadas marcas, directivas o

4.2.1.1. Estructura de un documento.

<ETIQUETA parámetros> ... </ETIQUETA>

Hay ocasiones en que no es necesario cerrar la etiqueta. Un documento HTML esta

4.2.1.2. Cabecera de un documento HTML.

La etiqueta <TITLE> es la encargada de especificar el título del documento. El titulo del

Otra etiqueta relacionada con la cabecera de un documento es <META>, usada

Capítulo 4 JavaEE 4 JavaEE

el Dreamweaver o FrontPage). En todos los casos, la información se escribe usando pares

<META HTTP-EQUIV=”Refresh” CONTENT=”15; URL=http://www.unitec.mx/ >

4.2.1.3. Cuerpo del documento HTML.

Los colores se pueden indicar de dos maneras diferentes: en formato hexadecimal o

Si queremos indicar colores en formato hexadecimal, se deberá indicar la proporción de

Black Silver Gray White Maroon Red Purple Fuchsia

El atributo que se encarga de determinar la imagen de fondo es BACKGROUND=”nombre

Ejemplo del armado de cuerpo de un documento HTML:

Capítulo 4 JavaEE 5 JavaEE

Etiquetas principales para la estructuración del texto.

Etiqueta Utilidad Resultado

Capítulo 4 JavaEE 6 JavaEE

<H1> ... </H1>

Etiqueta Utilidad Resultado

<BLINK> ... Hace parpadear el texto. Resulta algo

Para dar formato a frases las etiquetas principales son:

Capítulo 4 JavaEE 7 JavaEE

Etiqueta Utilidad Resultado

Hay que poner énfasis en

La etiqueta <FONT> permite controlar casi totalmente el estilo de un bloque de texto.

Ejemplo manejo de <FONT>:

Capítulo 4 JavaEE 8 JavaEE

La estructura general de un enlace está formada por la etiqueta <A> seguida de

Enlace a un punto de la misma página.

Así pues, en el principio del documento añadiremos la siguiente línea de código:

Ejemplo de página con ligas:

Capítulo 4 JavaEE 9 JavaEE

<A HREF="#finaldocumento">Pulsa aquí para ir al final de esta página </A>

Enlaces a otras páginas.

Supongamos que tenemos dos páginas llamadas principal.html y secundaria.html. Para

<A REF=”secundaria.html”> Pulsa aquí para acceder a la otra página </A>

Visto esto, si el enlace se quisiera conectar a un punto concreto de la página marcado

El siguiente ejemplo ilustra distintos modelos de enlaces:

Capítulo 4 JavaEE 10 JavaEE

<TITLE>Ejemplo Modelos de enlaces</TITLE>

Valor de ALIGN Utilidad

<!ELEMENT ficha (nombre+, apellido+, direccion, foto?, telefono|fax*)>