rea: TECNOLOGÍA M2

Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)

Co
nc
Índice ep
tos
av
an
Introducción ......................................................................................................................................................... 1 za
do
1. Java Enterprise Edition (EE) .............................................................................................................................. 2
s
1.1. Servelt Java ................................................................................................................................................................. 4 de
2.1. Páginas de Servidor Java (JSP) .................................................................................................................................. 10 Jav
a
2.2. JavaBeans ................................................................................................................................................................. 15
3. Struts............................................................................................................................................................... 18
3.1. struts.xml .................................................................................................................................................................. 19
3.2. action ........................................................................................................................................................................ 20
3.3. result ......................................................................................................................................................................... 23
4. Enterprise Java Beans (EJB) ............................................................................................................................ 24
Cierre .................................................................................................................................................................. 25
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)

Co
nc
Mapa de Contenido ep
tos
av
an
za
do
Conceptos avanzados de Java s
de
Jav
a

Java Enterprise Edition Struts Enterprise Java Beans

Servlet strut.xml

JSP action

JavaBeans result
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 1

Co
RESULTADO DE nc
Crea un programa computacional aplicando conceptos avanzados de Java,
APRENDIZAJE para resolver un problema dado.
ep
tos
DEL MÓDULO av
an
za
Introducción do
s
de
La tecnología Java Enterprise Edition (EE) permite una inserción laboral en un nivel más alto que el Jav
proporcionado solo por el conocimiento y manejo de Java. Java EE es la plataforma por excelencia de las a
aplicaciones de negocios al más alto nivel empresarial, pues organizaciones multinacionales de seguros,
bancos internacionales y aplicaciones gubernamentales hacen uso de ella. No es casualidad, Java EE es una
tecnología madura, confiable y robusta, que proporciona todos los elementos para programar aplicaciones
distribuidas, seguras y confiables que entregan servicios 24x7.

El componente central de esta tecnología es el Servlet, una clase

Java orientada a la Web. Sus métodos, desarrollados durante
años, usan la experiencia de miles de programadores a través
del mundo, permitiendo manejar de forma eficiente y segura
todos los tipos de peticiones (request) que realizan las
aplicaciones Web. Complementando al Servlet, encontramos las
páginas de servidor Java (JSP) que proporcionan las
características ideales para desplegar vistas atractivas a los
usuarios; formularios de ingreso de datos, imágenes y videos,
están soportadas por la tecnología JSP.

Sin embargo, verá que los conocimientos de programación y fundamentos de Java le abrirán la puerta a la
programación orientada a la Web. Porque, si bien, las aplicaciones desarrolladas con Java EE funcionan en un
entorno Web, la lógica de negocio aún debe implementarse con Java. De aquí, la necesidad de manejar
correctamente los fundamentos de programación con Java; los tipos de datos para el paso correcto de
parámetros, métodos privados y públicos para efectuar procesamiento y retorno de resultados, declaración
de atributos y modificadores de acceso, así como, el uso correcto de operadores lógicos y aritméticos, son
fundamentales para el desarrollo de clases y métodos que realicen una implementación correcta de la lógica
de negocio en todos sus niveles.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 2

Co
1. Java Enterprise Edition (EE) nc
ep
Al comienzo de la era Web, los sistemas empresariales se diseñaban utilizando el modelo cliente-servidor. En tos
este modelo los sistemas cliente solicitaban procesamiento de los sistemas servidor. Sin embargo, los av
sistemas empresariales estaban migrando hacia un nuevo ambiente; el ambiente Web (propiciado por el an
za
rápido crecimiento de Internet). Un nuevo modelo conocido como servicios web comenzaba a imponerse en
do
las empresas y a reemplazar al modelo cliente-servidor. Puedes ver lo anterior explicado en la siguiente s
imagen. de
Jav
a

En el modelo de servicios web, los programadores ensamblan sistemas (o aplicaciones) a partir de un

conjunto de componentes de procesamiento conocidos como servicios web. Cada servicio web es
independiente de los demás servicios web y de las aplicaciones. Las aplicaciones cliente se comunican con
una aplicación servidora, la cual a su vez interactúa con los servicios web necesarios que también se
encuentran en el servidor.

Debido a la rápida expansión de Internet, era necesario proporcionar una forma en que las aplicaciones web
pudieran interactuar con servicios como, por ejemplo, bases de datos, y generar páginas web en forma
dinámica. La tecnología de la interfaz común de pasarela (Common Gateway Interface o CGI) fue una
solución que adoptaron muchas empresas. La tecnología CGI consistía en un programa que el navegador
podía llamar cada vez que se seleccionaba un enlace o se enviará un formulario web.

Además de llamar al programa CGI, el navegador podía enviar datos al programa, ya sea introducidos por el
usuario en un formulario web o codificados directamente en algún enlace. El programa CGI utilizaba dichos
datos para interaccionar con otros servicios, por ejemplo, extraer datos desde una base de datos. Luego los
datos se incorporaban a una página web generada dinámicamente por el programa CGI y se enviaba al
navegador del usuario para su despliegue. Un servidor podía mantener varios de estos programas CGI en
memoria para atender distintas áreas del negocio de una empresa.
 Esquema de ejecución CGI Co
nc
ep
tos
av
an
za
do
s
de
Jav
a

1. Formulario 4. Respuesta del programa 1

2. Datos del formulario se envían al programa 1 5. Página generada por programa 1

3. Invoca ejecución con datos del formulario

La tecnología CGI resolvió el problema de conectar a los clientes con la infraestructura computacional de la
empresa. Sin embargo, surgieron problemas relacionados con la ejecución de múltiples programas en el
servidor porque cada programa implicaba la asignación de memoria y CPU, lo que consumía muchos recursos
del servidor (que eran muy caros aquellos días) y hacía muy difícil la escalabilidad del servicio. Lo anterior
dificultaba el crecimiento para poder hacer frente al aumento de la demanda de usuarios que requerían de
los servicios que proporcionaban los programas CGI.

La solución vino de la mano de Java con el servlet. Este componente es escalable y necesita muchos menos
recursos que el programa CGI, a la vez, que permite conectar con la infraestructura de la empresa. Un servlet
consiste en una clase Java con sus propios atributos y métodos, los cuales pueden llamar un navegador en
forma similar a como lo hace con un programa CGI. La tecnología servlet evita las ineficiencias del programa
CGI, ya que solo se requiere la carga de un servlet en la JVM (con el consiguiente ahorro de memoria) sin
importar el número de peticiones que deban ser respondidas. Con cada nueva petición se inicia un nuevo hilo
(Thread) en vez de un nuevo programa, reduciendo también el tiempo de respuesta. Además, un servlet
tiene persistencia, lo cual indica que el servlet sigue “vivo” después que terminan las peticiones. Si es
necesario para la aplicación, los datos que utiliza el servlet se pueden mantener en memoria entre una
llamada al servlet y otra.

Aunque los servlets mejoraban la situación respecto de los programas CGI, tenían un serio problema: los
servlets exigen a los programadores web que manejen el lenguaje Java. Si bien los programadores de esa
época conocían bien HTML y JavaScript, se le hacía difícil manejar un lenguaje complejo como Java. Java se
utiliza durante todo el desarrollo del servlet, mientras que HTML solo se usaba para generar la salida que iba
dirigida al navegador. La solución a este problema vino de la mano de una nueva tecnología; Java Server
Pages (JSP). Las páginas JSP se pueden escribir con pocos conocimientos de Java, debido a que la mayor parte
del código de una JSP consiste en HTML con fragmentos de Java embebidos. La figura siguiente muestra el
modelo servlet/JSP resultante.
 Co
nc
ep
tos
av
an
za
do
s
de
Jav
a

1.1. Servelt Java

Las aplicaciones Java EE utilizan un cliente liviano, como un navegador, el cual ofrece poca o ninguna
capacidad de proceso. Es un programa que se encuentra en el servidor el que se encarga del procesamiento
(por ellos se dice que es lógica del lado servidor). Un servlet es un programa escrito en Java que se encuentra
en el servidor y que responde a las peticiones (request) que efectúan los clientes a través del protocolo HTTP
(HyperText Transfer Protocol). Las peticiones pueden efectuarse de diferentes maneras, ya sea, pasando los
datos del cliente de forma explícita o implícita. En general, cuando se pasan los datos de una petición en
forma explícita se usa el método get del protocolo HTTP. Una petición que usa get pasa los datos como parte
de una dirección URL (Localizador Uniforme de Recursos).

EJEMPLO

La siguiente URL muestra la forma en que se pasan parámetros (variables que contienen datos) mediante get. Los
datos en get se pasan como parte de la cadena de dirección URL, como resaltamos a continuación.

https://www.google.cl/search?q=metodo+get&oq=metodo+get&aqs=chrome..69i57j0l5.1251j0j7&sourceid=chrome&ie=UTF-8

Una segunda alternativa de paso de parámetros es mediante post. Una petición que usa post envía los datos de la
petición como parte del formulario web enviado al servidor y no serán visibles en la dirección URL. Si accedemos a
la gestión de banca personal en BancoEstado con nuestro usuario y contraseña, se mostrará la dirección URL como:

https://bancapersonas.bancoestado.cl/eBankingBech/home/home.htm

Debido a que las peticiones get hacen que los parámetros de entrada se anexen a la URL solicitada, estos quedan
visibles como pares variable=valor. Por esta razón, no es aconsejable utilizar get para enviar datos delicados como
contraseñas u otros, que involucren información privada.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 5

CoE
nc s
epp
tos
e
av
anc
za í
dof
s i
dec
Java
a m
e
n
t
e
,

u
n

s
e
r
v
l
e
t

e
s

u
n
a

c
l
a
s
e

J
a
v
a

q
u
e recibe peticiones que envía un cliente, y que envía de vuelta una respuesta al cliente.
La clase Java debe extender a HttpServlet (herencia) y sobrescribir los métodos doGet(…)
y doPost(…) de dicha clase. El método doGet se utiliza para atender aquellas peticiones que
se envían desde un formulario web que utiliza el atributo method igual a get, es decir,
method=get, o bien, al introducir una URL directamente en la barra de direcciones del
navegador. El método doPost se utiliza para atender peticiones que se envían desde un
formulario web con method=post. Los métodos doGet y doPost reciben dos parámetros. El
primero es un objeto HttpServletRequest, el cual contiene los datos provenientes del cliente,
mientras que el segundo, es un objeto HttpServletResponse que se utiliza para
enviar datos de
respuesta al cliente.

EJEMPLO

El siguiente código muestra una clase servlet llamada ServletEjemplo.

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ServletEjemplo extends HttpServlet

{
public ServletEjemplo()
{
//códigos del constructor
}

//método doGet
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
{
//códigos del método doGet
}

//método doPost
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
{
//códigos del método doPost
}
}
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 6

CoEsta
nc clase
eppres
tosenta
av tres
annuev
za as
docara
s cterí
destica
Javs
a que
será
n
detal
ladas
a
conti
nuac
ión.

He
a
at
sy
m
s

L
a

c
l
a
s
e

S
e
r
v
l
e
t
E
j
e
m
p
lo hereda de HttpServlet y se declara mediante el código extends HttpServlet a
continuación del nombre de la clase, e indica que los atributos y métodos de HttpServlet
pasan a ser parte
de ServletEjemplo, extendiendo las funciones necesarias para iniciar la transmisión de datos.

Importación de librerías

La instrucción import (declarada varias veces en la parte superior del código)

indica que deben incorporarse algunas librerías al código del ServletEjemplo.
La razón de incorporar otras clases al código obedece a la lógica de ampliar las capacidades
de la programación con clases construidas, que son útiles en ciertos tipos de problemas y
facilitan el desarrollo de código complejo. Estas clases, son incorporadas a nuestro código al
momento de la ejecución por parte del interprete Java que opera en la JVM. Veamos la
siguiente figura.

Cada librería pertenece a un package (paquete) que corresponde a un archivo .jar (Java
archive) o .zip alojado en alguna carpeta de instalación de Java o un servidor Web. Por
ejemplo, la clase HttpServlet se encuentra en la instalación del servidor Tomcat, carpeta
lib, en el archivo servlet-api.jar. Dentro de este archivo, la encontramos en la ruta
javax/servlet/http/. Si abrimos el archivo .jar con WinRAR o WinZip, veremos algo similar a
lo mostrado en la siguiente figura.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 7

Co
nc M
ep de
tos er
av
an
za J
do a
s v
de a
Jav
a c
o
n
s
i
d
e
r
a

e
l

m
a
n
e
j
o

d
e

e
r
r
o
r
e
s

m
e
d
i
a
 nte Exception (excepciones). Cada tipo de Exception, como ServletException o IOException
por ejemplo, está asociada a un tipo distinto de error. De esta manera, ServletException
está asociado a errores que ocurren cuando uno de los métodos, doGet o doPost,
encuentra problemas para ejecutarse. IOException está asociado a errores de entrada y/o
salida (input/output, IO) que pueden ocurrir durante la ejecución del método. La palabra
throws señala que el método puede “lanzar” estos dos tipos de excepciones. Cuando algo
va mal en la ejecución de doGet o doPost el método lanzará ServletException, o cuando
ocurra un error de entrada/salida, el método lanzará
I
O
E
x
c
e
p
t
i
o
n
.

Generalmente se hará uso de un método, doGet o doPost, para el procesamiento de las peticiones, ya
que
estas vendrán de un formulario web que pasará datos por get o post y no por ambos al mismo tiempo.

EJEMPLO

La siguiente página HTML de ejemplo indica que el servlet ServletEjemplo manejará las
peticiones pasadas por post.

<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Incio de sesión</title>
</head>
<body>
<form action="servletejemplo"
method="post"> Datos de
usuario
<table>
<tr><td>Usuario:</td><td><input type="text" name="usuario"
value=""></td></tr>
<tr><td>Contraseña:</td><td><input type="password"
name="conrasenia" value=""></td></tr>
<tr><td><input type="submit" name="aceptar"
value="Aceptar"></td></tr>
</table>
</form>
</body>
</html>

La vista de esta página en un navegador se muestra en la siguiente figura.

 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 8

CoE
nc s
ept
tos
e
av
an
za c
doó
s d
dei
Javg
a o

e
s

c
o
m
ú
n

l
a
s

p
á
g
i
n
a
s

H
T
M
L

y
,

p
a
r
a
este ejemplo, corresponde a la página index.html que contiene un formulario web declarado
por el tag <form …> … </form>, resaltado en el ejemplo. Todo lo abarcado por el tag form se
considera parte del formulario. Este tag declara un atributo action=”servletejemplo” que
indica que las peticiones serán procesadas por el elemento denominado “servletejemplo”, y
otro atributo method=”post” que declara que los datos de este formulario serán pasados por
post.

Para que la aplicación reconozca que las peticiones deben ser procesadas de acuerdo con el
valor del atributo action (en este caso servletejemplo), este debe ser configurado en el archivo
web.xml de la aplicación web. Este archivo se denomina descriptor de despliegue.

EJEMPLO

Para nuestro ejemplo, el descriptor de despliegue debe similar a lo siguiente:

<?xml version="1.0" encoding="UTF-8"?>

<web-app
xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/j
avaee http://xmlns.jcp.org/xml/ns/javaee/web-
app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>Modulo2</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<servlet>
<servlet-name>servletejemplo</servlet-name>
<servlet-class>servlets.ServletEjemplo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servletejemplo</servlet-name>
<url-pattern>/servletejemplo</url-pattern>
</servlet-mapping>
</web-app>

El código presentado se encuentra en formato XML y que es similar a un archivo HTML,

puesto que declara tags para almacenar información de configuración de la aplicación. En
particular nos interesa el tag <servlet>
… </servlet> que declara otros dos tags: <servlet-name>servletejemplo</servlet-name> que
indica el nombre del servlet, y <servlet-class>servlets.ServletEjemplo</servlet-class> que
indica la clase Java del servlet. Estos dos tags trabajan juntos para asociar una clase Java
con un nombre que puede ser agregado al atributo action del form.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 9

Un desarrollo orientado a la Web recibe normalmente el Co

nombre de Proyecto Web Dinámico, ya que el contenido de nc
ep EJE
respuesta que se envía al navegador del cliente se genera M
tos
dinámicamente. Dinámicamente quiere decir que, dependiendo PL
av
de los datos que ha suministrado el cliente, se pueden mostrar an O
distintas páginas Web. Estos datos pueden ser un usuario y za
contraseña, y la aplicación debería mostrar, después de las do El
validaciones necesarias, una página “home” de usuario, por s sig
ejemplo. La figura de la derecha muestra la estructura de un de uie
proyecto web llamado “AplicacionWeb” desarrollado en Jav nte
NetBeans que incluye el servlet, la página HTML y el archivo a có
dig
XML indicados en los ejemplos anteriores.
o
mu
est
Para que la aplicación realice alguna tarea, el servlet debe procesar los datos provenientes de la página ra
HTML. Siguiendo con el ejemplo anterior, tomaremos los datos provenientes de index.html en el método la
doPost del servlet, y llamaremos a un método booleano que valide (no detallado), contra una base de datos, im
el usuario y la contraseña pasados. De ser correctos los datos, el método derivará al cliente a su home ple
(home.html). En caso contrario, derivará al cliente nuevamente a la página index.html. me
nta
ció
n
me
nci
on
ad
a
ant
eri
or
me
nte
:

//
do
pr
vo
do
tp
Re
re
Ht
et
e
re
th
Se
IO
{
Re
r
nu
 String usuario = request.getParameter("usuario");
String contrasenia = request.getParameter("contrasenia");

if(esUsuarioValido(usuario,contrasenia))
despachador = request.getRequestDispatcher("home.html");
else
despachador = request.getRequestDispatcher("index.html");

despachador.forward(request, response);
}
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 10

Si miramos dentro del método doPost vemos que se declara un objeto de la clase RequestDispatcher llamado Co
“despachador” (inicializado en nulo) que usaremos para “redireccionar” el flujo de la aplicación hacía la nc
página correcta; home.html en caso de ser válidos los datos de usuario o, index.html en caso de no serlos. ep
tos
Luego, recuperamos los parámetros “usuario” y “contrasenia” provenientes de index.html (ver código
av
página) usando el método getParameter(…) del objeto request. Los valores de estos parámetros se guardan an
en dos variables de tipo String, las que finalmente son pasadas al método esUsuarioValido(…). Este método, za
devolverá true o false dependiendo si los datos son correctos o no, respectivamente. Si el valor devuelto es do
true, el objeto despachador se configura para enviar al cliente hacía home.html o, en caso contrario, para s
enviar al cliente hacía index.html. Finalmente se invoca al método forward(…) del objeto despachador para de
realizar la acción configurada. Jav
a

2.1. Páginas de Servidor Java (JSP)

Una JSP es una plantilla para una página Web que emplea código Java para generar dinámicamente un
documento HTML. Las páginas JSP se ejecutan en un componente del servidor conocido como contenedor de
JSP, que las traduce a servlets Java equivalentes. Como internamente son servlets, las páginas JSP tienen
todas las ventajas de los servlets; mayor rendimiento y flexibilidad que los programas CGI. Incorporan
soporte para sesiones HTTP, tienen pleno acceso a la tecnología Java y tienen mayor compatibilidad con las
herramientas de desarrollo Web, entre otras características.
La página JSP pasa por tres etapas antes de ejecutarse, que son las siguientes: Co
nc
ep
tos
1. Código escrito por el programador. Se encuentra en un archivo de texto con av
Código fuente JSP an
extensión .jsp que mezcla código HTML con código Java, e incluye directivas
JSP y acciones que describen como generar una página Web para dar za
do
servicio a una petición concreta.
s
de
Jav
2. a
Código fuente Java El contenedor de JSP traduce el código fuente JSP a código fuente de un
servlet Java equivalente. Este código fuente se guarda en un área de trabajo
y es útil en el proceso de depuración de errores.

3.
Clase Java compilada
Como cualquier otra clase Java, el código del servlet se compila a bytecode
en un archivo .class, preparado para ser cargado y ejecutado.

El contenedor de JSP administra cada una de estas etapas automáticamente, basándose en la situación
temporal del archivo, si ha cambiado. Como respuesta a la petición HTTP, el contenedor comprueba si el
archivo fuente .jsp ha cambiado desde la última vez que el código .java asociado fue compilado.

Como ejemplo, supongamos que la página “home” del ejemplo anterior se programa como una página JSP, y
que el método doPost del servlet se modifica para enviar al cliente a dicha página JSP. Además, se pasa el
usuario a la JSP mediante el método setAttribute(…) del objeto request. Este método recibe dos parámetros:
el primero es una “etiqueta” que identifica al atributo, y el otro, es el valor del atributo. En nuestro caso, el
usuario que suministro el cliente.
 Co
EJEMPLO nc
ep
Si tenemos el siguiente código del método doPost, correspondiente al ejemplo anterior: tos
av
an
//método doPost
protected void doPost(HttpServletRequest request, HttpServletResponse response) za
throws ServletException, IOException do
{ s
RequestDispatcher despachador = null;
de
String usuario = request.getParameter("usuario"); Jav
String contrasenia = request.getParameter("contrasenia"); a
if(esUsuarioValido(usuario,contrasenia))
despachador = request.getRequestDispatcher("home.html");
else
despachador = request.getRequestDispatcher("index.html");

despachador.forward(request, response);
}

El código de la JSP queda de la siguiente forma:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>
<%@ page import="java.util.*" %>
<%@ page import="java.text.SimpleDateFormat" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Bienvenido</title>
</head>
<body>
<%
//código Java
String usuario = (String)request.getAttribute("usuario");

Date fecha = new Date();

SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
String fechaActual = formato.format(fecha);
%>
<table border="" align="right">
<tr><td>Usuario: </td><td><%=usuario %></td></tr>
<tr><td>Fecha: </td><td><%=fechaActual %></td></tr>
</table>
</body>
</html>
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 13

CoPode
ncmos
epver la
tosexiste
avncia
ande
zados
donueva
s s
decaract
Javerístic
a as en
los
códig
os
prese
ntado
sy
que
detall
arem
os a
conti
nuaci
ón.

D
v

L
a
s

p
á
g
i
n
a
s

J
S
P

n
o sólo contienen código que gestiona peticiones y genera respuestas, también contiene
instrucciones para el compilador. Estas instrucciones se llaman directivas. En las primeras
líneas de este
código, podemos ver la directiva page. La directiva page tiene la siguiente sintaxis:

<%@ page atributo1=”valor1” atributo2=”valor2” … %>

Esta directiva proporciona un medio para establecer los atributos que determinan la
interpretación y ejecución de la página. Vemos que el atributo language tiene asociado el
valor “java”, que indica el lenguaje que llevará la página junto con “text/html” y
pageEncoding, que indica la codificación de la página, en este caso “ISO-8859-1” que
corresponde al alfabeto latino. Por último, se declara el atributo import, que le indica al
compilador que debe incorporar las clases contenidas en el package “java.util.*”, donde el
* (asterisco) indica todas las clases contenidas en dicho package, y la clase
SimpleDateFormat contenida en el package “java.text”.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 14

Co
nc<
ep
%
tos
av
an>
za
do
s S
de
Javc
a
r

P
o
d
e
m
o
s

v
e
r

q
u
e

e
l

c
ó
d
i
g
o
 Java se encuentra incorporado entre los símbolos <% … %>. Este “fragmento” de código
Java se llama scriptlet e indica que se puede escribir cualquier cosa que un compilador
Java pueda entender dentro de los símbolos <% %>.
Dentro del scriptlet, en primer lugar se captura el dato “usuario” pasado desde el
servlet, mediante el método getAttribute(…) y se asigna su valor a la variable “usuario”
de tipo String. Luego, se declara un objeto de la clase Date llamado “fecha”, con el objeto
de mostrar la fecha en que ingreso el cliente a su home. A continuación, se formatea la
fecha mediante un objeto de la clase SimpleDateFormat llamado “formato” con la
configuración “dd/MM/yyyy” (día/mes/año), y se aplica el formato a la fecha con el método
format de la clase SimpleDateFormat. El resultado, se asigna a la variable “fechaActual” de
tipo String.
Por último, las variables usuario y fechaActual se muestran dentro de una tabla HTML
como lo indica el código siguiente:

<table border="1.0" align="right">

<tr><td>Usuario: </td><td><%=usuario %></td></tr>
<tr><td>Fecha: </td><td><%=fechaActual %></td></tr>
</table>

Note que se ha usado la sintaxis <%= … %> para mostrar el contenido de las variables. Estos
fragmentos de código Java se denominan expresiones, y permiten mostrar directamente el
contenido de variables Java en
páginas JSP.

EJEMPLO

En la siguiente figura se muestra el resultado de ingresar en index.html con usuario “claudio” y contraseña
“123456”, validados los datos en el método doPost y redireccionado a home.jsp.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 15

Co
nc2.2.
epJav
tos
avaBe
anans
za
doUn
s bean
dees
Javuna
a clase
Java
que
cumpl
e dos
requis
itos:

Tiene
un
con
ucto
sin
pará
etro

S
ó
l
o

s
e

n
e
c
e
s
i
t
a

u
n
a
 JVM para que los beans funcionen. Esto permite que los beans se utilicen en cualquier
entorno Java: servlets, páginas JSP o aplicaciones Java.

Los bean tienen propiedades, que corresponden a los atributos para los cuales el bean
proporciona métodos get y set. Todo acceso a las propiedades del bean debe realizarse por
medio de estos métodos, ya que los atributos tienen modificador de acceso private.

Nuestro interés es aplicar los JavaBeans a las páginas JSP, de manera que pueda
implementarse lógica de mediante estos “componentes”. La especificación JSP
proporciona soporte especial para los beans y permiten ser codificados con scripts
(secuencia de comandos) a un nivel más alto que la programación
mediante Java o HTML. Este soporte consta de tres
acciones estándar:

<jsp:useBe <jsp:setPrope <jsp:getProperty>

an> rty>

•Para declarar, •Para establecer •Para recuperar valores

instanciar e inicializar las propiedades de las propiedades del
beans. del bean. bean.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 16

Co
ncE
epJ
tosE
avM
anP
zaL
doO
s
deP
Java
ar
a

e
j
e
m
p
l
i
f
i
c
a
r

l
a

u
t
i
l
i
z
a
c
i
ó
n

d
e

u
n

b
e
a
n
, la clase BeanHora mostrada a continuación, implementa la lógica para obtener la hora actual,
de forma que podamos agregarla al JSP home.jsp (ejemplo anterior). La idea es que el cliente
cuando accede a su home, junto con visualizar la fecha de acceso, se muestre la hora y minutos de
acceso.

package beans;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class BeanHora

{
//propiedades
private Calendar fechaHoraActual;
private int formato; //12 o 24 horas
private int hora;
private int minutos;

//constructor sin argumentos

public BeanHora()
{
formato = 24; //valor por
defecto fechaHoraActual =
new GregorianCalendar();
}

//implementación de las propidades

public int getFormato()
{
return formato;
}

public void setFormato(int f)

{
formato = f;
}

public int getHora()

{
if(formato == 24)
hora = fechaHoraActual.get(Calendar.HOUR_OF_DAY);
else
hora = fechaHoraActual.get(Calendar.HOUR);

return hora;
}

public int getMinutos()

{
minutos = fechaHoraActual.get(Calendar.MINUTE);
return minutos;
}
}
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 17

CoE
ncs
ep
tos
c
av
ano
zan
dov
s e
den
Javi
ae
n
t
e

m
e
n
c
i
o
n
a
r

q
u
e

e
l

b
e
a
n

B
e
a
n
H
o
r
a

e
s
tá alojado en el package beans del proyecto de ejemplo. Esto se declara en la primera línea del
código anterior. Es una práctica común en el desarrollo de proyectos el separar las clases en
packages, ya que se necesita organizar un gran número de clases, y separar las clases en
packages (carpetas) permite organizar mejor las clases del proyecto.

Para implementar el bean, se han utilizado las clases Calendar y GregorianCalendar

pertenecientes a la librería java.util. El desarrollo del bean cumple las normas antes
establecidas; constructor sin parámetros y para cada propiedad (atributo) se proporciona
métodos get y/o set.

EJEMPLO

Retomando el ejemplo BeanHora en la página home.jsp, te presentamos el código que debemos agregar.

<h2>Bienvenido</h2><p>
<%=usuario %>
<jsp:useBean id="bhora" class="beans.BeanHora"/><p>
Son las <jsp:getProperty property="hora" name="bhora"/>:<jsp:getProperty
property="minutos" name="bhora"/>
hrs.

El resultado se muestra en la
siguiente figura.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 18

CoC
nco
epm
toso
av
anp
za u
don
s t
deo
Jav
a f
i
n
a
l

d
e

e
s
t
e

d
e
s
a
r
r
o
l
l
o
,

t
e

p
r
e
s
e
n
t
a
m
o
s
la estructura completa del proyecto web dinámico
AplicacionWeb desarrollado
con NetBeans. V

4. M
de n

3
.
S
t
r
u
t
s
Struts es un marco de trabajo o framework para el desarrollo de aplicaciones. Este framework
está basado en el patrón de sistema Modelo Vista – Controlador (MVC), y proporciona una API
(conjunto de librerías) para el desarrollo de acuerdo con MVC. Específicamente, Struts se
implementa mediante:

1. El controlador es un servlet de una clase proporcionada por Struts. Será necesario

Controlador configurar la aplicación web (a través del archivo web.xml) para que todas las peticiones
del usuario se redirijan a este servlet.

2.
El controlador despacha las peticiones del usuario a la clase adecuada para ejecutar una
Despacho
acción. En Struts, las clases que ejecuten las acciones deben heredar de la clase Action.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 19

CoLa
ncsiguie
epnte
tosfigura
avmues
antra el
za“flujo
do” de
s proce
deso de
JavStruts
a.

I
M
P
O
R
T
A
N
T
E

¿
C
ó
m
o

f
u
n
c
i
o
n
 a Struts? La siguiente figura muestra el flujo de una aplicación donde primero se ingresan los
datos de un producto: nombre, identificador y precio neto. Luego el controlador deriva la
“acción” hacia una clase Java, la que calcula el valor bruto del producto (neto + IVA) y envía el
resultado junto al nombre e identificador del producto a otra página JSP. Todas las acciones
están configuradas en el archivo struts.xml.

3.1.
strut
s.xm
l
El archivo struts.xml define las action (acciones) y result (respuestas) que ejecutará la
aplicación como resultado de las peticiones del usuario. Cada acción tiene esta
identificada por un atributo name que contiene un valor o nombre de la acción y un
atributo class que contiene el nombre de la clase que implementa la acción.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 20

Co
nc EJE
ep MP
tos LO
av
an E
za l
do
s s
de i
Jav g
a u
i
e
n
t
e

c
ó
d
i
g
o

n
o
s

m
u
e
s
t
r
a

e
l

c
o
n
t
e
n
i
d
o

d
e
 l archivo struts.xml que deberemos usar para el caso presentado. Destacamos la existencia del
código action y result.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts
Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="default" extends="struts-default">
<action name="producto" class="cl.ejemplo.Producto">
<result name="exito">/datos.jsp</result>
</action>
</package>
</struts>

3.2. action
El name del action debe declararse en el formulario de la página JSP que requiere una
respuesta a su petición.

EJEMPLO

Distinga cómo la JSP declara en el formulario el siguiente código:

<s:form action="producto" method="post">

Indicando que la petición debe ser procesada por la clase cl.ejemplo.Producto y que la
respuesta debe ser enviada a datos.jsp.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 21

Co
nc E
ep J
tos E
av M
an P
za L
do O
s
de E
Jav l
a
c
ó
d
i
g
o

c
o
m
p
l
e
t
o

d
e

i
n
d
e
x
.
j
s
p

s
e

m
u
e
s
t
r
a

c
o
 ntinuación:

<%@ page language="java" contentType="text/html;

charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Producto</title>
</head>
<s:form action="producto" method="post">
<table>
<tr><td><s:textfield label="Nombre" name="nombre"/></td></tr>
<tr><td><s:textfield label="ID" name="id"/></td></tr>
<tr><td><s:textfield label="Precio" name="precio"/></td></tr>
<tr><td><s:submit value="Guardar"/></td></tr>
</table>
</s:form>
</html>

Considere que el formulario (s:form), y los campos “nombre”, “id” y “precio” se declaran
mediante el tag s: definido e implementado por Struts, y debe declararse mediante en una
directiva JSP al comienzo de la página, como se muestra a continuación:

<%@ taglib uri="/struts-tags" prefix="s"%>

Los campos de la tabla HTML se “mapean” o copian directamente en los atributos de la clase
Producto. Esta es una característica muy importante de Struts que facilita enormemente la
programación de aplicaciones con este framework.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 22

Co
ncEJEM
epPLO
tos
avPara
anaclara
zar lo
doseñala
do,
s vea el
decódigo
Javque
a debe
prese
ntar la
clase
Produ
cto:

pa
e
cl
mp

im
co
en
ho
wo
Ac
Su
t;

pu
cl
Pr
to
ex
s
Ac
Su
t
{
pr
St
no
pr
id
pr
pr

pu
ge
{
re
}

pu
se
in
{
 nombre = n;
}

public int getId()

{
return id;
}

public void setId(int i)

{
id = i;
}

public int getPrecio()

{
return precioConIVA();
}

public void setPrecio(int p)

{
precio = p;
}

private int precioConIVA()

{
return (int)(precio*1.19);
}

public String execute()

{
return "exito";
}
}
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 23

Co
nc3
ep.
tos
av3
an.
za
do
s r
de
Jave
as

u
l
t
P
a
r
a

t
e
r
m
i
n
a
r

l
a

d
e
s
c
r
i
p
c
i
ó
n

d
e
l
 funcionamiento de Struts, debemos decir que la clase que responde a las peticiones e
implementa la lógica de negocio, debe heredar de ActionSupport e implementar el
método public String execute(). Este método debe devolver una cadena, cuyo valor deberá
coincidir con alguno de los declarados en el tag result del action que atenderá las peticiones.

EJEMPLO

Vea el siguiente código del struts.xml para aclarar lo anterior.

<action name="producto" class="cl.ejemplo.Producto">

<result name="exito">/datos.jsp</result>
</action>

El método retorna la cadena “éxito” y este valor está declarado en el atributo name del tag result.
Esta
asociación permite definir hacía dónde debe proseguir el flujo de la aplicación. En este caso, hacía datos.jsp.

EJEMPLO

Revisa el código de la
página datos.jsp:

<%@ page language="java" contentType="text/html;

charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Datos del producto</title>
</head>
<body>
<table border="1">
<tr><td>Nombre producto:</td><td><s:property value="nombre"/></td></tr>
<tr><td>Id producto:</td><td><s:property value="id"/></td></tr>
<tr><td>Precio producto:$</td><td><s:property value="precio"/></td></tr>
</table>
</body>
</html>
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 24

CoPor
ncúltim
epo, la
tossiguie
avnte
anfigura
zamues
dotra la
s estruc
detura
Javdel
a proye
cto
usado
como
ejem
plo
en
esta
secció
n.
4. Enterprise Java Beans (EJB)
Con la tecnología Enterprise JavaBeans (EJB) es
posible desarrollar componentes que agrupan IMPOR
funcionalidades que luego se pueden reutilizar y TANTE
ensamblar en distintas aplicaciones. Por ejemplo, se
El funcionamiento de los
podría desarrollar un EJB Cliente que represente un
componentes EJB se basa
cliente en una base de datos. Este se podría usar
fundamentalmente en el trabajo del
después en un programa de contabilidad o en una contenedor EJB. El contenedor EJB
aplicación de comercio electrónico o virtualmente es un programa Java que se ejecuta
en cualquier programa en el que se necesite en el servidor y que contiene todas
representar un cliente. De hecho, incluso sería las clases y objetos necesarios para
posible que el desarrollador del bean y el el correcto funcionamiento de los
ensamblador de la aplicación no fueran la misma EJB.
persona o que ni siquiera trabajen en la misma
empresa.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 25

CoE
ncn
ep
tos
l
av
ana
za
dos
s i
deg
Javu
ai
e
n
t
e

f
i
g
u
r
a

p
u
e
d
e
s

v
e
r

u
n
a

r
e
p
r
e
s
e
n
t
a
ción del funcionamiento básico de los EJB. En primer lugar, el cliente que realiza peticiones al
EJB y el servidor que lo contiene están ejecutándose en JVM distintas. Incluso pueden estar La
en distintos hosts. El cliente nunca se comunica directamente con el EJB, sino que el p
contenedor EJB proporciona un EJBObject que hace de interfaz. Cualquier petición del cliente JS
(una llamada a un método de negocio del EJB) se debe hacer a través del objeto EJB, el cual co
solicita al contenedor EJB una serie de servicios y se comunica con el EJB. Por último, el EJB a
realiza las peticiones correspondientes a la base de datos. có
H
Ja
p
lo
u
p
m
d
a
a
lo
re
m
ca
ve
e
C e
lo
i u
s.
e có
Ja
r p
a
r se
e
e a
JS
La programación orientada a la Web con Java se transforma en una potente opción para
u
crear programas potentes, robustos y económicos para las organizaciones.
sc
s
Los servlets constituyen el núcleo de esta programación. Permiten usar Java
fo
para recibir, procesar y responder peticiones que vienen desde páginas HTML
a
aprovechando todo el potencial que presentan las aplicaciones que operan
u
sobre Internet. Los servlets aprovechan la herencia de la POO para heredar de
e
HttpServlet y reutilizar atributos y métodos de dicha clase. También permiten
o
el manejo de errores mediante excepciones, de forma que el programador
pueda “atrapar” las distintas situaciones anómalas que puedan producirse.

A pesar de todas las ventajas señaladas con anterioridad, se debe conocer

bien el lenguaje Java para programar servlets, lo que resulta complicado para
muchos de quienes trabajan en el área web y que no manejan lenguajes de
programación. Para ello, las páginas JSP fueron otro gran avance en el
desarrollo de la tecnología orientada a Internet, y que facilitaron la
integración entre programación orientada a la web y HTML.
 Área: TECNOLOGÍA M2
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág.26

Co
nc E
ep a
tos
ca
av
an a
za e
do sti
s a
de su
Jav p
a n
n
u
a
g
n
fl
xi
lid
a
p
a
to
o
q
e
e
se
d
e
p
ñ
n
e
e
á
b
o
d
d
e
o
w
b
E
p
g
m
dor que no maneja Java en profundidad puede integrar fácilmente sus
características en la web, mientras que el programador avanzado puede
desarrollar código que soporte las peticiones complejas que utilizan las
aplicaciones Web de hoy, haciendo uso de directivas, scriptlets y otros
elementos que complementan la experiencia de Java.

La lógica de negocio en una JSP puede ampliarse al incorporar JavaBeans. Estos

componentes tienen un soporte especial en páginas JSP mediante la
incorporación de scripts. Estas secuencias de comandos permiten instanciar,
obtener y escribir propiedades de los JavaBeans utilizando instrucciones
sencillas, a la vez que se utiliza todo el potencial de clases Java.

Los JavaBeans son clases Java que implementan lógica de negocio y la exponen
mediante propiedades que son visibles desde una JSP, al tener modificadores
de acceso de tipo public.

El framework Struts implementa el patrón de sistema MVC. Este patrón

permite diseñar aplicaciones Web separando claramente la vista (páginas JSP)
del controlador (servlet Java) y del modelo (clases Java).

Las acciones que debe realizar el controlador están configuradas en el archivo

struts.xml mediante el tag action y la clase Java que implementa la lógica de
negocio mediante el tag class. La navegación se define mediante la cadena
que devuelve el método execute(), y que debe coincidir con alguna de las
configuradas en el tag result. Además, los campos de una JSP pueden
mapearse directamente a los atributos del modelo, sin necesidad de llamar
explícitamente a los métodos get o set. De aquí que el desarrollo
con Struts sea especialmente sencillo y potente.

Por último, los EJB son componentes distribuidos del lado servidor. Permiten
implementar la lógica de negocio que puede ser reutilizada por distintas
aplicaciones. Su funcionamiento es más complejo que los servlets o los
JavaBeans, puesto que la invocación que realiza un cliente no se efectúa
directamente sobre el EJB que posee la lógica de negocio, sino que hace uso de
objetos e interfaces intermediarias.