5. HERRAMIENTAS PARA EL DESARROLLO DE APLICACIONES WEB

Transcripción

1 5.1. SERVLETS 5. HERRAMIENTAS PARA EL DESARROLLO DE APLICACIONES WEB Los servlets son la respuesta de la tecnología JAVA a la programación de CGIs. Aunque ambas tecnologías proporcionan la misma funcionalidad básica: ofrecer un mecanismo para ejecutar programas en equipos servidores, en función de las peticiones que los clientes realicen haciendo uso de los navegadores Web ; al utilizar servlets con cada petición se inicia un hilo en vez de un proceso como lo hace CGI, lo cual reduce el uso de memoria del servidor y el tiempo de respuesta de éste al cliente VENTAJAS DE LOS SERVLETS SOBRE LOS CGIs Si comparamos los servlets con la tecnología CGI, llegaremos a la conclusión de que son bastante más simples y potentes que los segundos. Sus principales características son: Al estar escritos en JAVA, son independientes de la plataforma Consumen menos recursos de máquina, ya que sólo son cargados la primera vez que se solicitan sus servicios. Son más rápidos que los programas CGI Son seguros y portables ya que se ejecutan bajo la misma máquina virtual de JAVA No requieren soporte para JAVA del lado del cliente, pues operan en el dominio del servidor y envían los resultados en HTML. Los servlets son entonces programas que se ejecutan en un servidor Web, que fungen como una capa intermedia entre una petición proveniente de un navegador Web u otro cliente http, y las bases de datos o aplicaciones del servidor http. Explorador Petición HTTP Respuesta HTTP Servlet La figura anterior indica que un servlet acepta peticiones de un cliente, procesa la información relativa a la petición realizada por el cliente y le devuelve a éste los resultados que podrán ser mostrados mediante páginas HTML CICLO DE VIDA DE UN SERVLET 1. El cliente realiza una petición http haciendo uso de un navegador Web (ueden existir parámetros asociados). 54

2 2. La petición y sus datos asociados los recoge el servidor Web a través de la red. 3. El servidor Web detecta que hay que ejecutar un servlet y delega a esta acción a un contenedor de servlets, que puede ser el mismo servidor Web, para que sea ejecutado. 4. Una vez ejecutado el servlet se traspasan los resultados (mediante páginas Web) al servidor Web 5. El servidor Web envía las páginas Web de resultados mediante la red. 6. La página Web de respuesta le llega al cliente, que la visualizará haciendo uso del navegador Web. Por lo tanto, los servlets nos permiten crear páginas Web dinámicas, en el sentido de que la respuesta que ofrecen puede variar en función de los datos que proporcione el cliente y la situación de contexto existente. De hecho existen varias razones por las que las páginas Web requieren ser dinámicas (generadas al momento), como las siguientes: La página Web está basada en los datos enviados por el usuario. Por ejemplo, páginas para confirmación de pedidos en Internet La página Web se deriva de datos que cambian constantemente. Por ejemplo páginas de informes de clima o encabezados noticiosos. La página Web utiliza información de bases de datos corporativas u otros orígenes de datos que se encuentran del lado del servidor. Por ejemplo un sitio de comercio electrónico que liste precio y disponibilidad del punto de venta ESTRUCTURA DE LOS SERVLETS JAVA proporciona el soporte necesario para escribir servlets a través de los paquetes javax.servlet y javax.servlet.http. El primero de ellos contiene las interfaces y clases más genéricas que soportan el funcionamiento de los servlets. Al programar servlets, lo más habitual es hacer uso del segundo paquete, que resulta más especializado, útil y fácil de utilizar, pues responde a peticiones realizadas desde un cliente HTML. Object_Servlet javax.servlet.genericservlet javax.servlet.http.httpservlet MiServlet Por tanto, un servlet no es más que un objeto de alguna de las clases de la API Java Servlet (ver figura de arriba) que implemente la interfaz Servlet, como son GenericServlet y 55

3 HttpServlet. Como esta última clase es la idónea para servicios específicos http, entonces el tipo de servlet más básico puede ser de la forma siguiente: Un objeto de una clase derivada de HttpServlet que encapsula los métodos init() para iniciar el servlet, si procede, dopost y/o DoGet para responder a las peticiones de los clientes y destroy() para realizar operaciones de limpieza cuando se descarga el servlet. import java.io.*; import javax.servlet.* ; import javax.servlet.http.* ; public class MiServlet extends HttpServlet public void init(servletconfig config) throws ServletException super.init(config); //... // Método dopost para responder a una petición POST public void dopost(httpservletrequest request, HttpServletResponse response) Throws ServletException, IOException //... // Método doget para responder a una petición GET public void doget(httpservletrequest request, HttpServletResponse response) Throws ServletException, IOException //... public void destroy() // Liberar recursos EJECUCIÓN DE UN SERVLET Todo Servlet debe implementar la interfaz Sevlet ya que ésta es quien declara los métodos que definen el ciclo de vida del mismo: init, service y destroy. El método init es invocado por el contenedor Web para iniciar la ejecución del servlet. Éste método se ejecuta una sola vez y tiene como misión inicializar las variables y los recursos necesarios para la ejecución del servlet. Si la ejecución de este método no se realiza con éxito, lanzará la excepción ServletException. El método service se llama cada vez que el servidor recibe una petición para el servlet. Este método puede recibir varias llamadas simultáneas. Para cada una de ellas se crea un nuevo 56

4 hilo y examina el tipo de petición http (get, post, put, delete, trace, options o head), con el fin de llamar al método adecuado para atenderla, por ejemplo doget, dopost, doput, etc. El tipo de petición por omisión es GET. El método service tiene dos parámetros de tipos HttpServletRequest y HttpServletResponse, respectivamente, que son pasados al método invocado. Si la ejecución no se desarrolla con éxito, se lanzará una excepción del tipo ServletException o IOException. El objeto de la clase HttpServletRequest encapsula los datos enviados por el cliente al servidor. El objeto de la clase HttpServletResponse encapsula los datos que el servidor enviará al cliente. Este objeto proporciona dos formas para retornar los datos: una mediante un objeto PrintWriter devuelto por su método getwriter y otra, mediante un objeto ServletOutputStream devuelto por su método getoutputstream. La primera forma devuelve texto (cadenas de caracteres) y la segunda forma devuelve datos binarios (cadenas de bytes). El método destroy es el último método invocado justo antes de destruir el servlet. Normalmente se utiliza para liberar los recursos de máquina adquiridos, por ejemplo, borrar archivos temporales UN PRIMER SERVLET SENCILLO Este primer servlet que se muestra a continuación, implementa el caso más sencillo posible; la aplicación HolaMundo que mostrará el texto Hola Mundo en el navegador del cliente. En este caso, independientemente del tipo de petición http GET o POST que se realice, el servlet responderá en ambos casos enviando la misma página Web: import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class HolaMundo extends HttpServlet // Manipular las posibles peticiones enviadas por el cliente: // utilizando el atributo method=get o method=post. protected void procesarpeticion(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException response.setcontenttype("text/html"); PrintWriter out = response.getwriter(); out.println("<html>"); out.println("<head>"); out.println("<title>servlet HolaMundo</title>"); out.println("</head>"); out.println("<body>"); out.println("<font size=7>"); out.println(" Hola mundo!!!"); 57

5 out.println("</font>"); out.println("</body>"); out.println("</html>"); out.close(); // Manipular la petición enviada por el cliente // utilizando el atributo method=get. protected void doget(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException procesarpeticion(request, response); // Manipular la petición enviada por el cliente // utilizando el atributo method=post. protected void dopost(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException procesarpeticion(request, response); En las primeras líneas del código anterior se colocan las sentencias import de los paquetes ya citados. El paquete java.io se requiere para las operaciones de entrada y salida de datos y resultados a través de los objetos request y response. La manera más sencilla de definir un servlet es heredar de la clase HttpServlet. Así, cuando este servlet recibe una petición del cliente, el servidor lo carga para su ejecución, instante en el que se ejecuta el método init() que lo inicia (en este caso el que se invoca es el que se da por omisión en la superclase de HolaMundo). Cuando init finaliza, el servlet esta en condiciones de atender a las peticiones de los clientes; en el ejemplo, para cada una de las peticiones GET o POST se ejecuta el método procesarpeticion que es invocado por doget o DoPost. El servlet permanecerá cargado hasta que el servidor decida destruirlo ejecutando el método destroy si es que se implementó. Analizando el método procesarpeticion se observa que el método almacena en el objeto out de la clase PrintWriter los datos que el servlet HolaMundo enviará al cliente que realizó la petición. Este objeto forma parte del objeto response y es obtenido a través de su método getwriter. Los datos se almacenan en out utilizando su método println. Los datos almacenados, como se puede ver, se corresponden con una página HTML, que será enviada al explorador del cliente. Además de estos datos explícitos también se envía otra información de protocolo http como son las cabeceras de respuesta generadas por el servidor. Estas cabeceras de respuesta incluyen la línea: Content-type: text/html. Esta línea identifica el tipo de documento a enviar o a recibir; en este caso se trata de un documento HTML. Cuando el navegador del cliente reciba esta información, sabrá como interpretar el tipo de documento que tiene que visualizar. Para establecer este valor procesarpeticion, utiliza el método setcontenttype del objeto response. 58

6 PUESTA EN FUNCIONAMIENTO DEL SERVLET HolaMundo Una vez escrito el servlet, los pasos necesarios para ver el resultado que produce son: Compilarlo Instalarlo en un servidor Invocarlo para su ejecución desde un navegador Web Como puede leerse, no resulta tan sencillo desarrollar y ejecutar por vez primera un servlet a diferencia de una aplicación JAVA normal que esté basada en el SDK estándar. Estos pasos requieren proceder entonces de alguna de las dos formas siguientes: 1. Suponiendo que se tiene instalado el J2SE SDK, en particular la versión 1.5.0, habrá que instalar el servidor Web de aplicaciones Tomcat 5. El servidor Tomcat soporta un contenedor Web que permite ejecutar servlets y páginas JSP (de las que se hablarán en la sección siguiente). En el apéndice B del presente documento se muestra la manera de No obstante existen muchos tipos de servidores aparte del Tomcat que permiten el uso de los servlets, algunos de estos son: a. JavaServer Web Development Kit (JSWDK) hoy llamado JWSDP (Java Web Services Developer Pack o Paquete de desarrollo de servicios Web de Java) b. Allaire JRun (motor para JSP y Servlet que puede ser integrado en servidores de Netscape Enterprise o Microsoft Personal Web Server) c. ServletExec de Nwe Atlanta (Motor para JSP y Servlet que puede ser integrado en los servidores Web más populares para Solaris, Windows, MacOs, HP-UX y Linux. d. LiteWebServer (LWS) de Gefion Software (Es un pequeño servidor Web gratuito derivado de Tomcat) e. Java Web Server de Sun (Servidor totalmente gratuito escrito en JAVA 2. Suponiendo que no se tiene instalado ningún software para desarrollar aplicaciones JAVA, habrá que instalar el Java 2 Enterprise Edition Software Development Kit o J2EE SDK. Este paquete proporciona la base para desarrollar y distribuir aplicaciones multicapa distribuidas e incluye entre otras herramientas, el J2SE y un servidor de aplicaciones (J2EE Application Server). En el apéndice A, se muestra la manera en que se puede instalar y la forma en la que se puede lanzar el servidor de aplicaciones. La versión que se esta suponiendo se trabajará es la J2EE 1.4 SDK que incluye el J2SE 1.4.2_02 y ejemplos, además del J2EE 1.4 Application Server. Para ejecutar un servlet como el del HolaMundo del ejemplo anterior, teniendo ya instalados los paquetes J2SE y Tomcat 5, siga los pasos siguientes: 1. añada a la variable de entorno path de su sistema operativo la ruta de la carpeta bin del J2SE que tiene instalado 2. Copie el archivo servlet-api.jar que se encuentra en common\lib\ del tomcat que tiene instalado a \jre\lib\ext del J2SE 3. Cambie al directorio de la aplicación, es decir, donde se encuentra el servlet 59

7 4. Compile el servlet, en el ejemplo: javac HolaMundo.java 5. Añada el archivo.class (HolaMundo.class) que resulta de la compilación a la carpeta \webapps\root\web-inf\classes del Tomcat 6. Edite el archivo \conf\web.xml del Tomcat para definir el servlet invoquer que permite ejecutar servlets anónimos. 7. Arranque el servidor Tomcat (este punto debe realizarse después del paso 5 para que el servidor reconozca la aplicación que se acaba de instalar). Si el servidor ya estaba arrancado cuando se realizó el punto 4, detengalo y vuelvalo a arrancar o abra el explorador y escriba el URL: y recargue la aplicación. 8. Una vez arrancado el servidor, verifique que funciona correctamente escribiendo en el navegador: o es el puerto utilizado para acceder al servidor 9. Ejecute el servlet escribiendo en el navegador el URL: que en el caso del ejemplo, sería En conclusión, para ejecutar un servlet, habrá que copiar el archivo.class que lo define en la carpeta ROOT\WEB-INF\classes de la carpeta webapps del servidor a la que tienen acceso los clientes Web y ejecutar: de forma que el servlet HolaMundo se mostraría en su ejecución como en la figura siguiente: Ahora bien, lo más interesante es invocar a los servlets desde páginas Web. Se puede solicitar la ejecución de un servlet de igual manera que pedimos un recurso cualquiera; basta con definir el URL del servlet en el punto deseado en la página Web. El siguiente ejemplo muestra un servlet que además de generar la página HTML donde se manda a escribir Hola Mundo, devuelve la fecha y hora del servidor. Con esto se trata de dar a entender que, por una parte un servlet no tiene porque generar sólo páginas HTML, sino que además un servlet es capaz de generar contenido dinámico incluyendo cualquier proceso escrito que pueda ejecutar JAVA (leer o escribir archivos, ejecutar programas, cargas bibliotecas, etc.) 60

8 import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import java.util.*; public class Saludo extends HttpServlet // Manipular la petición enviada por el cliente // utilizando el atributo method=get. protected void doget(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException response.setcontenttype("text/html"); PrintWriter out = response.getwriter(); out.println("<html>"); out.println("<head>"); out.println("<title>servlet Saludo</title>"); out.println("</head>"); out.println("<body>"); out.println("<center>"); for (int tamaño = 1; tamaño <= 7; ++tamaño) out.println("<font size="+tamaño+" color=blue>"); out.println(" Hola mundo!!!"); out.println("<br>"); out.println("<br>"); Calendar fechahora = new GregorianCalendar(); Random rnd = new Random(); int tamaño = rnd.nextint(7)+1; out.println("<font size="+tamaño+">"); out.println("<font color=green>"); out.println("son las " + fechahora.get(calendar.hour_of_day) + ":" + fechahora.get(calendar.minute) + ":" + fechahora.get(calendar.second) ); out.println("<br>"); out.println("<font color=gray>"); out.println("del día " + fechahora.get(calendar.day_of_month) + "/" + (fechahora.get(calendar.month)+1) + "/" + fechahora.get(calendar.year) ); out.println("</font>"); out.println("</center>"); out.println("</body>"); out.println("</html>"); out.close(); Para ejecutar este servlet llamado Saludo, podemos crear una carpeta dentro de webapps, por ejemplo: saludo\web-inf\classes y copiar dentro de classes Saludo.class 61

9 Para ejecutar el servlet Saludo tendríamos entonces que escribir: Pero si queremos invocar a este servlet desde una página HTML, se deberá utilizar este mismo URL o bien el URL relativo a la carpeta del servidor donde copiemos el archivo html, que será copiado en la carpeta Saludo: El código HTML almacenado en saludo.html deberá incluir una de las dos líneas siguientes: <a href= > ejecutar Saludo </a> <a href= servlet/saludo > ejecutar Saludo </a> La segunda opción es la más interesante porque no depende de la dirección del servidor. Para ejecutar entonces el servlet a través de saludo.html basta con escribir el URL siguiente: EMPAQUETADO DE SERVLETS Puede darse el caso en que diversos programadores, en un entorno de producción dado, podrían estar desarrollando servlets para el mismo servidor. El colocar todos estos servlets en el directorio principal de estos programas podría dar como resultado un directorio difícil de administrar, además de que se corre el riesgo de duplicar los nombres de los servlets si 62

10 dos desarrolladores distintos eligen el mismo nombre para el programa que desarrollan. Los paquetes son la solución lógica a este problema. El uso de paquetes tiene como resultado cambios en la forma en que se generan los servlets, la forma en que se compilan y en la que se invocan. Para colocar los servlets en paquetes se requieren de dos pasos: 1. Mover los archivos (.class) a un subdirectorio que coincida con el nombre del paquete pretendido. 2. Insertar una instrucción de paquete en el archivo de clase. Para ello, la primera línea en el código fuente (.java) del servlet deberá ser: package nompaquete; Por ejemplo, el fragmento siguiente de código Java presenta una variación del Servlet HolaMundo que se encuentra en el paquete misservlets: package misservlets ; import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class HolaMundo extends HttpServlet // Manipular las posibles peticiones enviadas por el cliente: // utilizando el atributo method=get o method=post. protected void procesarpeticion(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException response.setcontenttype("text/html"); PrintWriter out = response.getwriter(); out.println("<html>"); El archivo.class se encontrará dentro de una carpeta llamada misservlets que será el paquete creado o utilizado por la aplicación en este caso del HolaMundo, dependiendo si exitía o no antes de compilar la aplicación. A continuación deberemos copiar dentro de la carpeta \webapps\root\web-inf\classes del Tomcat la carpeta misservlets junto con el HolaMundo.class que estará dentro de ella y ejecutar el servlet en el explorador escribiendo: 63

11 PROCESAMIENTO DE FORMULARIOS Hasta este punto, los servlets que hemos estudiado sólo envían información al navegador del cliente. No obstante, estos clientes Web pueden Mostar formularios que permitan solicitar datos a los usuarios, que serán enviados al servidor para, por ejemplo, ser almacenados en una base de datos para posteriores peticiones o para otros procesos o bien para dar al usuario una respuesta ajustada a dicha petición. En el siguiente URL se invoca la ejecución de un servlet llamado Parametros, aportando la lista de pares: (Nombre, Mario)-(Edad, 22), en formato GET. Hay que observar la manera de colocar los datos tras el símbolo? y de separarlos con el símbolo &. El código del servlet es el siguiente: import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class Parametros extends HttpServlet public void doget(httpservletrequest request, HttpServletResponse response) throws IOException, ServletException response.setcontenttype("text/html"); PrintWriter out = response.getwriter(); out.println("<html>"); out.println("<body>"); String NombreRecibido = request.getparameter("nombre"); String EdadRecibida = request.getparameter("edad"); out.println("<h1> Hola " + NombreRecibido + "</h1>"); out.println("<h1> Tienes " + EdadRecibida +" años </h1>"); out.println("</body>"); out.println("</html>"); El objeto httpservletrequest en el código anterior request, contiene una serie de métodos de utilidad para recibir información proveniente del usuario, en concreto el método getparameter permite obtener el valor asociado a un nombre en la lista de pares (nombre, valor) que puede proporcionar un URL. Además de poder introducir el URL anterior en el navegador proporcionando directamente los datos enviados al servlet en dicha URL: 64

12 También podemos generar el URL mediante una página Web que podrá utilizar el usuario: <html> <body> <h1> Cuestionario </h1> <form action=" method="get"> Nombre: <input type="text" name=nombre> <br> Edad: <input type="text" name=edad> <br><br> <input type="submit" value="enviar datos"> <br> </form> </body> </html> Los formularios en HTML permiten enviar datos al servidor Web. En la línea 5 de la página Web mostrada se encuentra la etiqueta form, que en el ejemplo contiene el atributo action que indica la acción que debe realizarse en el servidor, en este caso ejecutar el servlet Parametros; y el atributo method que indica la manera en la que se envían los datos (en este caso la petición GET). 65

13 Petición HTTP GET: Cuando el tipo de petición HTTP es GET, los datos del formulario son enviados al servidor a continuación del URL especificado por el atributo action de form. El tamaño de la cadena enviada está limitado y al estar en ASCII es totalmente legible, por tanto no es un modo seguro. Es por ello que, cuando se requiere del envío de datos seguros y además el número de datos del formulario que son enviados al servidor son muchos; resulta ser mejor el uso del método POST. Veamos otro ejemplo: import java.io.*; import javax.servlet.*; import javax.servlet.http.*; import java.util.*; public class MostrarParametros extends HttpServlet public void doget(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException response.setcontenttype("text/html"); PrintWriter out= response.getwriter(); String titulo="lectura de todos los parámetros de Petición"; out.println("<!doctype html public \"-//W3C//DTD HTML 4.0 "+ "Transitional//EN\">"); out.println("<html>"); out.println("<head><title>"+titulo+"</title></head>"); out.println("<body bgcolor=\"#fdf5e6\">\n"+ "<h1 align=center>"+titulo+"</h1>\n"+ "<table border=1 align=center>\n"+ "<tr bgcolor=\"#ffad00\">\n"+ "<th>nombre del parámetro<th>valor(es) del parámetro"); Enumeration nombresparam=request.getparameternames(); while(nombresparam.hasmoreelements()) String nombreparam= (String)nombresParam.nextElement(); out.print("<tr><td>"+nombreparam+"\n<td>"); String[]valoresParam= request.getparametervalues(nombreparam); if (valoresparam.length==1) String valorparam=valoresparam[0]; if (valorparam.length()==0) out.println("<i> Sin valor </i>"); else out.println(valorparam); else out.println("<ul>"); for (int i=0; i<valoresparam.length;i++) out.println("<li>"+valoresparam[i]); out.println("</ul>"); 66

14 out.println("</table>\n</body></html>"); public void dopost(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException doget(request,response); El servlet escrito utiliza un método dopost que sólo ejecuta a Donet. Esto es porque se quiere que el servlet pueda manejar tanto las peticiones GET como las POST. Por otro lado el formulario es el siguiente: <!doctype html public "-//W3C//DTD HTML 4.0 Transitional//EN"> <html> <head> <title> Un Formulario de ejemplo que utiliza POST </title> </head> <body bgcolor="#fdf5e6"> <h1 align="center"> Un formulario de Ejemplo que utiliza POST </h1> <form action=" servlet/mostrarparametros" method="post"> Número de elemento: <input type="text" name="elemnum"> <br> Cantidad: <input type="text" name="cantidad"> <br> Precio Unitario: <input type="text" name="precio" value="$"> <br><hr> Nombre de Pila: <input type="text" name="nombrepila"> <br> Apellido(s): <input type="text" name="apellido"> <br> Iniciales: <input type="text" name="iniciales"> <br> Domicilio de envio: <textarea name="domicilio" rows=3 cols=40></textarea> <br> Tarjeta de crédito: <br> <input type="radio" name="tipotarjeta" value="visa">visa <br> <input type="radio" name="tipotarjeta" value="master Card"> Master Card <br> <input type="radio" name="tipotarjeta" value="amex">american Expresss <br> <input type="radio" name="tipotarjeta" value="discover">discover <br> <input type="radio" name="tipotarjeta" value="java Smart Card">Tarjeta Inteligente de Java <br> 67

15 Número de la tarjeta de crédito: <input type="password" name="numtarjeta"><br> Repita el número de la tarjeta de crédito: <input type="password" name="numtarjeta"><br><br> <center> <input type="submit" value="enviar pedido"> </center> </form> </body> </html> El formulario HTML del listado anterior utiliza POST, como debería ser en todos los campos que tienen contraseña. 68

16 Si intenta ejecutar el servlet MostrarParametros directamente en el explorador con el URL: se obtendrá la página Web sin resultados. Petición HTTP POST: Cuando el tipo de petición HTTP es POST, los datos son enviados al servidor en el cuerpo de la petición. Es el método más usual de enviar los datos de un formulario. Con este tipo de petición la información del formulario se envía después del URL indicado por action en el cuerpo de la petición y el tamaño de la información enviada no esta limitado. Según lo expuesto, escoger el método para enviar la información no es difícil. Si los datos son pocos y no importa su confidencialidad o manipulación, utilizamos GET. Si son largos, privados o importantes, utilizamos POST ACCESO A BASES DE DATOS CON SERVLETS Una aplicación Java que realiza accesos a bases de datos funciona según una arquitectura que permite escribir los programas abstrayéndose de los detalles de los niveles inferiores (discos, controladores, sistema operativo, etc), como lo muestra la figura siguiente: APLICACION JVM SISTEMA OPERATIVO CONTROLADOR Oracle Access MySql JDBC (Java DataBase Connectivity Conexión con Bases de Datos desde Java) es una API de Java que permite ejecutar instrucciones SQL para manipular y gestionar bases de datos relacionales. Para que una aplicación Java pueda hacer operaciones sobre una base de datos, previamente tiene que establecer una conexión con la misma. Esta conexión se realiza a través de un controlador (driver) según la figura de arriba. La API-JDBC se proporciona en dos paquetes: java.sql y javax.sql. El primer paquete, contiene las 69

17 interfaces y clases Java fundamentales de JDBC, en tanto que el segundo paquete es una extensión del primero e incluye las clases que interactúan con JNDI y otras que gestionan conjuntos de conexiones con una misma base de datos. Para más detalles del uso de JDBC, véase el apéndice A de estas notas. El primer paso para crear una conexión entre una aplicación Java y una base de datos es registrar el controlador JDBC adecuado para esa base, con el fin de que la JVM pueda utilizarlo. Existen distintos tipos de controladores JDBC, por ejemplo: com.mysql.jdbc.driver que es el controlador utilizado cuando el motor de base de datos que se utiliza es MySql. En el supuesto caso de que la base de datos sólo permitiera el acceso a través de controladores ODBC, como lo hace ACCESS, siempre podemos usar el controlador puente JDBC-ODBC incluido como parte del JDK: sun.jdbc.odbc.jdbcodbcdriver. Este tipo de controladores, es decir, los basados en ODBC (Open DataBase Connectivity) son bastante utilizados en entornos Windows, pues este S.O. incluye ODBC. El apéndice A describe al final como administrar los orígenes de datos ODBC en Windows. Así pues, la mayor ventaja de los servlets con respecto a la conexión con bases de datos vía JDBC es que su ciclo de vida les permite mantener conexiones abiertas con las mismas a lo largo de toda una sesión. Esto permite recortar tiempo con respecto a otras tecnologías como la CGI. Además, JDBC es una tecnología independiente de las bases de datos. Como ejemplo vamos a implementar una simple aplicación Web basada en servlets que muestre una especie de directorio de personas. La aplicación podrá consultar, insertar, modificar, borrar o listar la información de cada una de las personas almacenadas en la base de datos a la que se hace acceso (que estará en formato access). La estructura de la Base de Datos es una tabla con los siguientes campos: 70

18 DNI Nombre Apellido Edad A Pedro Rubio P Luis Tejedor MRL Mario Rossainz 35 La estructura de la aplicación se muestra en la figura siguiente: SvAccesoBD.html SvAccesoBD ObBorrado ObListado ObConsulta ObInsercion ObModificacion ObPosicionamiento ObRegistro <html> <body> <table border=1><tr><td> <form action=" method="get"> DNI: <input type="text" name="dni"> <br> Nombre: <input type="text" name="nombre"> <br> Apellido: <input type="text" name="apellido"> <br> Edad: <input type="text" name="edad"> <br><br> <input type="submit" value="consultar" name="botonconsultar"> <input type="submit" value="insertar" name="botoninsertar"> <input type="submit" value="modificar" name="botonmodificar"> <input type="submit" value="borrar" name="botonborrar"> <input type="submit" value="listar" name="botonlistar"> <br> <center> <input type="submit" value=" < " name="botonprimero"> <input type="submit" value=" -- " name="botonmenoscinco"> <input type="submit" value=" - " name="botonanterior"> <input type="submit" value=" + " name="botonsiguiente"> <input type="submit" value=" ++ " name="botonmascinco"> <input type="submit" value=" > " name="botonultimo"> </center> </td> <td> 71

19 <textarea name="areadelistado" rows="10" cols="35"></textarea> </td> </tr> </form> </table> </body> </html> SvAccesoBD.html import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class SvAccesoBD extends HttpServlet private int PosicionBuscada = 1; private String AreaDeListado=""; PrintWriter out; public void doget(httpservletrequest request, HttpServletResponse response) throws IOException, ServletException String DNI = request.getparameter("dni"); String Nombre = request.getparameter("nombre"); String Apellido = request.getparameter("apellido"); String Edad = request.getparameter("edad"); String BotonConsultar = request.getparameter("botonconsultar"); String BotonInsertar = request.getparameter("botoninsertar"); String BotonModificar = request.getparameter("botonmodificar"); String BotonBorrar = request.getparameter("botonborrar"); String BotonListar = request.getparameter("botonlistar"); String BotonPrimero = request.getparameter("botonprimero"); String BotonMenosCinco = request.getparameter("botonmenoscinco"); String BotonAnterior = request.getparameter("botonanterior"); String BotonSiguiente = request.getparameter("botonsiguiente"); String BotonMasCinco = request.getparameter("botonmascinco"); String BotonUltimo = request.getparameter("botonultimo"); AreaDeListado = request.getparameter("areadelistado"); response.setcontenttype("text/html"); out = response.getwriter(); out.println("<html>"); out.println("<body>"); if (BotonConsultar!=null) ConsultarDatos(DNI); if (BotonInsertar!=null) InsertarDatos(DNI,Nombre,Apellido,Edad); if (BotonModificar!=null) ModificarDatos(DNI,Nombre,Apellido,Edad); if (BotonBorrar!=null) BorrarDatos(DNI); if (BotonListar!=null) ListarDatos(DNI); if (BotonPrimero!=null) Controles("1"); if (BotonMenosCinco!=null) Controles("2"); if (BotonAnterior!=null) Controles("3"); if (BotonSiguiente!=null) Controles("4"); if (BotonMasCinco!=null) Controles("5"); if (BotonUltimo!=null) Controles("0"); out.println("</body>"); out.println("</html>"); 72

20 private void ConsultarDatos(String DNI) ObConsulta InstanciaConsulta = new ObConsulta(DNI); PosicionBuscada = InstanciaConsulta.PosicionEncontrada(); if (PosicionBuscada!=0) ObRegistro InstanciaFila = InstanciaConsulta.DameDatos(); GenerarRespuesta(InstanciaFila.DameDNI(),InstanciaFila.DameNombre(), InstanciaFila.DameApellido(), String.valueOf(InstanciaFila.DameEdad())); else GenerarRespuesta(DNI,"----","-----","---"); PosicionBuscada = 1; public void ListarDatos(String DNI) ObListado InstanciaListado = new ObListado(); AreaDeListado = InstanciaListado.DameResultado(); ConsultarDatos(DNI); PosicionBuscada = 1; public void BorrarDatos(String DNI) ObConsulta InstanciaConsulta = new ObConsulta(DNI); PosicionBuscada = InstanciaConsulta.PosicionEncontrada(); if (PosicionBuscada!=0) ObBorrado InstanciaBorrado = new ObBorrado(PosicionBuscada); GenerarRespuesta("","","",""); else GenerarRespuesta("----","----","----","----"); PosicionBuscada = 1; public void ModificarDatos(String DNI, String Nombre, String Apellido, String Edad) ObConsulta InstanciaConsulta = new ObConsulta(DNI); PosicionBuscada = InstanciaConsulta.PosicionEncontrada(); if (PosicionBuscada!=0) ObRegistro InstanciaFila = new ObRegistro(DNI, Nombre, Apellido, Integer.parseInt(Edad)); ObModificacion InstanciaModificacion = new ObModificacion(PosicionBuscada, InstanciaFila); GenerarRespuesta(DNI,Nombre,Apellido,Edad); else GenerarRespuesta("----","----","----","----"); PosicionBuscada = 1; public void InsertarDatos(String DNI, String Nombre, String Apellido, String Edad) ObRegistro InstanciaFila = new ObRegistro(DNI, Nombre, Apellido, Integer.parseInt(Edad)); ObInserccion InstanciaInserccion = new ObInserccion(InstanciaFila); GenerarRespuesta("","","",""); PosicionBuscada=1; public void Controles(String Identificador) ObPosicionamiento InstanciaPosicionamiento = 73

21 new ObPosicionamiento(Identificador,PosicionBuscada); ObRegistro InstanciaFila = InstanciaPosicionamiento.DameDatos(); GenerarRespuesta(InstanciaFila.DameDNI(),InstanciaFila.DameNombre(), InstanciaFila.DameApellido(), String.valueOf(InstanciaFila.DameEdad())); PosicionBuscada = InstanciaPosicionamiento.Posicion(); private void GenerarRespuesta(String DNI, String Nombre, String Apellido, String Edad) out.println("<table border=1>"); out.println("<tr>"); out.println("<td>"); out.println("<form action=' method='get'>"); out.println(" DNI: <input type='text' name='dni' value="+dni+"><br>"); out.println(" Nombre: <input type='text' name='nombre' value="+nombre+"><br>"); out.println(" Apellido: <input type='text' name='apellido' value="+apellido+"><br>"); out.println(" Edad: <input type='text' name='edad' value="+edad+"><br><br>"); out.println(" <input type='submit' value='consultar' name='botonconsultar'>"); out.println(" <input type='submit' value='insertar' name='botoninsertar'>"); out.println(" <input type='submit' value='modificar' name='botonmodificar'>"); out.println(" <input type='submit' value='borrar' name='botonborrar'>"); out.println(" <input type='submit' value='listar' name='botonlistar'> <br>"); out.println(" <center>"); out.println(" <input type='submit' value=' < ' name='botonprimero'>"); out.println(" <input type='submit' value=' -- ' name='botonmenoscinco'>"); out.println(" <input type='submit' value=' - ' name='botonanterior'>"); out.println(" <input type='submit' value=' + ' name='botonsiguiente'>"); out.println(" <input type='submit' value=' ++ ' name='botonmascinco'>"); out.println(" <input type='submit' value=' > ' name='botonultimo'>"); out.println(" </center>"); out.println(" </td>"); out.println(" <td>"); out.println(" <textarea name='areadelistado' rows='10' cols='35'>"+areadelistado+"</textarea>"); out.println(" </td>"); out.println(" </tr>"); out.println(" </form>"); out.println(" </table>"); SvAccesoBD.java 74

22 import java.sql.*; public class ObBorrado ObBorrado(int PosicionBuscada) try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); Personas.absolute(PosicionBuscada); Personas.deleteRow(); Personas.close(); Conexion.close(); SentenciaSQL.close(); catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); catch (SQLException e) System.out.println(e); ObBorrado.java import java.sql.*; import java.awt.textarea; public class ObListado private String Resultado=""; ObListado() String DNI, Nombre, Apellido, Linea; int Edad, Posicion; try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement(); ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); while (Personas.next()) DNI = Personas.getString("DNI"); Nombre = Personas.getString("Nombre"); Apellido = Personas.getString("Apellido"); Edad = Personas.getInt("Edad"); Posicion = Personas.getRow(); Linea = DNI+", "+Nombre+" "+Apellido+", "+String.valueOf(Edad); Resultado=Resultado+String.valueOf(Posicion)+": "+Linea+"\n"; Personas.close(); Conexion.close(); SentenciaSQL.close(); 75

23 catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); catch (SQLException e) System.out.println(e); public String DameResultado() return Resultado; ObListado.java public class ObRegistro private String DNI, Nombre, Apellido; private int Edad; ObRegistro (String DNI, String Nombre, String Apellido, int Edad) this.dni = DNI; this.nombre = Nombre; this.apellido = Apellido; this.edad = Edad; String DameDNI() return DNI; String DameNombre() return Nombre; String DameApellido() return Apellido; int DameEdad() return Edad; ObRegistro.java import java.sql.*; public class ObConsulta private int Posicion = 0; private ObRegistro DatosPersona; ObConsulta(String DNIPedido) try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement(); ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); 76

24 while (Personas.next()) String DNI = Personas.getString("DNI"); if (DNI.equalsIgnoreCase(DNIPedido)) Posicion = Personas.getRow(); String Nombre = Personas.getString("Nombre"); String Apellido = Personas.getString("Apellido"); int Edad = Personas.getInt("Edad"); DatosPersona = new ObRegistro(DNI,Nombre,Apellido,Edad); break; Personas.close(); Conexion.close(); SentenciaSQL.close(); catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); catch (SQLException e) System.out.println(e); public int PosicionEncontrada() return Posicion; public ObRegistro DameDatos() return DatosPersona; ObConsulta.java import java.sql.*; public class ObInserccion ObInserccion(ObRegistro Datos) try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); Personas.moveToInsertRow(); Personas.updateString("DNI", Datos.DameDNI()); Personas.updateString("Nombre",Datos.DameNombre()); Personas.updateString("Apellido", Datos.DameApellido()); Personas.updateInt("Edad",Datos.DameEdad()); Personas.insertRow(); Personas.close(); Conexion.close(); SentenciaSQL.close(); catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); 77

25 catch (SQLException e) System.out.println(e); ObInsercion.java import java.sql.*; public class ObModificacion ObModificacion(int PosicionBuscada, ObRegistro Datos) try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); Personas.absolute(PosicionBuscada); Personas.updateString("DNI",Datos.DameDNI()); Personas.updateString("Nombre",Datos.DameNombre()); Personas.updateString("Apellido",Datos.DameApellido()); Personas.updateInt("Edad",Datos.DameEdad()); Personas.updateRow(); Personas.close(); Conexion.close(); SentenciaSQL.close(); catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); catch (SQLException e) System.out.println(e); ObModificacion.java import java.sql.*; public class ObPosicionamiento private ObRegistro DatosPersona; private int Posicion; ObPosicionamiento(String Accion, int Posicion) int IDAccion,Edad; String DNI,Nombre,Apellido; boolean PosicionCorrecta=false; try Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String BaseDeDatos = "jdbc:odbc:nombrelogico"; Connection Conexion = DriverManager.getConnection(BaseDeDatos); Statement SentenciaSQL = Conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); 78

26 ResultSet Personas = SentenciaSQL.executeQuery("SELECT * FROM DatosPersonales"); Personas.absolute(Posicion); IDAccion = Integer.parseInt(Accion); switch (IDAccion) case 0: PosicionCorrecta = Personas.last(); break; case 1: PosicionCorrecta = Personas.first(); break; case 2: PosicionCorrecta = Personas.relative(-5); break; case 3: PosicionCorrecta = Personas.previous(); break; case 4: PosicionCorrecta = Personas.next(); break; case 5: PosicionCorrecta = Personas.relative(+5); break; if (PosicionCorrecta) this.posicion = Personas.getRow(); DNI = Personas.getString("DNI"); Nombre = Personas.getString("Nombre"); Apellido = Personas.getString("Apellido"); Edad = Personas.getInt("Edad"); else this.posicion = Posicion; DNI = "----"; Nombre = "----"; Apellido = "----"; Edad = 0; DatosPersona = new ObRegistro(DNI,Nombre,Apellido,Edad); Personas.close(); Conexion.close(); SentenciaSQL.close(); System.out.println(String.valueOf(Posicion)+":"+String.valueOf(this.Posicion)); catch (ClassNotFoundException e) System.out.println("Clase no encontrada"); catch (SQLException e) System.out.println(e); public int Posicion() return Posicion; public ObRegistro DameDatos() return DatosPersona; ObPosicionamiento.java En este ejemplo se emplean servlets y páginas Web. Los clientes habitualmente trabajan en una computadora remota y los programas se ejecutan en un servidor. El mecanismo de 79

27 comunicaciones que soporta el protocolo http nos permite consultar, en el servidor, los datos que ha seleccionado o escrito el usuario; de esta manera, se puede observar una disociación entre la interfaz gráfica de usuario (que se ejecuta en los equipos de los clientes) y el programa que recoge los datos y ejecuta las acciones pertinentes (que se ejecuta en el servidor). Como puede observarse el código SvAccessoBD es un servlet que lleva a cabo las siguientes operaciones: 1. Recoge los valores provenientes del usuario 2. Determina la naturaleza de la acción a realizar 3. Realiza su cometido con la base de datos 4. Genera la respuesta que recibirá el usuario 5.2. JSP JSP significa Java Server Pages, que traducido quiere decir Páginas de Servidor Java y es por tanto una tecnología orientada a crear páginas Web con programación en JAVA., es decir, permite mezclar HTML estándar y estático con un contenido dinámico; etiquetas especiales (órdenes) y trozos de código JAVA (scriptlets o secuencias de órdenes) o contenido dinámico generado por servlets. Éste contenido dinámico se encuentra encerrado en etiquetas especiales, muchas de las cuales inician con <% y finalizan con %>. El motor de las páginas JSP esta basado en los servlets de JAVA. En la tecnología JSP se crean páginas parecidas a las páginas que se crean en ASP (Active Server Page de Microsoft) o PHP (Personal Home Page), que son dos tecnologías de páginas ejecutadas en el servidor. Sin embargo JSP no se ciñe a un sistema operativo o servidor Web en particular además de que proporciona acceso a la tecnología de Servlets y a JAVA en la parte dinámica. El proceso para generar páginas JSP accesibles en Web es mucho más simple que en los servlets. Dando por hecho que se tiene un servidor Web que permite usar JSP, el código se almacenará en archivos con extensión.jsp que incluyen, dentro de la estructuras de etiquetas HTML, las sentencias JAVA a ejecutar y tan sólo se colocarán en cualquier lugar en donde se pusiera una página Web normal; sin compilación, sin paquetes y sin configuración, aunque el servidor tendrá que ser configurado para acceder a los archivos de clases Servlets y de JSPs. Aunque lo que se escriba con frecuencia lucirá como un archivo HTML estándar, detrás de ello, la página JSP se convierte automáticamente en un servlet normal donde el HTML estático tan sólo es enviado al flujo de salida asociado con el método service del servlet. Esta traducción se realiza la primera vez que se solicita la página. De acuerdo como este configurado el servidor, es posible ver el código fuente de los servlets generados a partir de sus páginas JSP. 80

28 Por ejemplo, supongamos que se ha escrito el siguiente código en el archivo Saludo.jsp contenttype="text/html"%> <html> <head><title>ejemplo JSP</title></head> <body bgcolor="ffffcc"> <center> <h2>hola mundo</h2> <%java.util.date hoy = new java.util.date();%> La fecha de hoy es: <%=hoy%> </center> </body> </html> Este ejemplo muestra HTML tradicional y un fragmento de un scriptlet de JAVA. La etiqueta <% identifica el comienzo del scriptlet y %> el final. Una expresión de la forma: =variable, es sustituida por el valor de esa variable. Para ejecutar esta página o cualquier otra página JSP desde un navegador, hay que instalarla en el servidor de aplicaciones de la misma manera en como se hizo con los servlets. Suponiendo entonces que se tiene instalado el Tomcat 5, siga los siguientes pasos: 1. Añadir en el servidor la carpeta digamos JSP2, dentro de la carpeta webapps del Tomcat y construir sobre ella la jerarquía de clases ya conocida de los servlets: webapps JSP2 WEB-INF classes WEB-INF lib WEB-INF tags 2. Editar en la carpeta WEB-INF el descriptor de despliegue web.xml que se indica a continuación. Este archivo XML indica dónde se localiza el esquema XML para la especificación Servlet 2.4 que a suvez utiliza el esquema XML para la especificación Java Server Page 2.0 que son las especificaciones que soporta en servidor Tomcat. <?xml version="1.0" encoding="iso "?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation= " web-app_2_4.xsd" version="2.4"> </web-app> 3. Crear en JSP2 la carpeta saludo que contendrá la aplicación y copiar en ella la página Saludo.jsp. 81

29 4. Arrancar el servidor. Si el servidor ya estaba arrancado, detenerlo y volverlo a arrancar o bien, abrir el explorador, escribir el URL e instalar la aplicación. 5. Una vez arrancado el servidor, verificar si está funcionando correctamente, escribiendo el URL siguiente en el explorador: El explorador debe mostrar la página del Tomcat. 6. Ejecutar la página JSP iniciando el explorador y escribiendo el URL siguiente: donde la sintaxis genérica es: Cuando esta página (Saludo.jsp) es invocada por primera vez, el motor JSP lleva a cabo una fase de traducción de la misma en un servlet y el motor Servlet es el que ejecutará éste último para generar el HTML dinámico que será enviado al explorador cliente, según puede deducirse de la figura siguiente. La próxima vez que la página sea solicitada, el motor JSP ejecutará el servlet que fue caragado la primera vez, a no ser que la página haya cambiado, en cuyo caso será compilada automáticamente en un nuevo servlet y ejecutada. 82

30 Servidor Explorador Web Motor Servlet Motor JSP Máquina Cliente Contenedor Web Regresando al ejemplo, el archivo.java generado por el Tomcat a partir del archivo Saludo.jsp se localiza en la carpeta work\catalina\localhost\... de la instalación de Tomcat ELEMENTOS PARA SECUENCIAS DE COMANDOS Los elementos para secuencias de comandos permiten insertar código en el servlet que será generado a partir de la página JSP. Existen tres formas: 1. Expresiones del tipo <%= expresión %>, que se evalúan e insertan en el resultado del servlet. 2. Los scriptlets del tipo <% codigo %>, que se insertan en el método _jspservice del servlet (ejecutado por service) 3. Las declaraciones del tipo <%! Codigo %>, que se insertan en el cuerpo de la clase del servlet, fuera de cualquier método existente. NOTA: Los comentarios en JSP se escriben: <%-- Comentario JSP --%>, en tanto que los comentarios en HTML son de la forma: <!--Comentario HTML -->. La diferencia semántica radica en que los comentarios HTML cuando se insertan en la respuesta enviada por el servidor al cliente, no se muestran cuando se visualiza el documento HTML, pero si 83

31 los podemos ver cuando se visualiza el código fuente; en tanto que los comentarios JSP aunque se inserten en la respuesta enviada por el servidor al cliente no son enviados al explorador, de forma que tampoco se muestran ni se ven cuando se visualiza el código fuente HTML desde el explorador EXPRESIONES Se utiliza una expresión JSP para insertar valores directamente en el resultado. La sintaxis es : <%= expresión %>. Por ejemplo: <%= request.getparameter( parnombre) %>, has visitado esta página <%= application.getattribute( atrcuenta ) %> <%= s %> La fecha y hora actual es <%= new java.util.date() %> La expresión se evalúa, se convierte a cadena y se inserta en la página. Esta evaluación se realiza durante la ejecución VARIABLES PREDEFINIDAS Para simplificar estas expresiones, se pueden utilizar cierta cantidad de variables predefinidas. Estos objetos implícitos como también se les llama están disponibles para su uso durante la implementación de una página Web: pagecontext: Es un objeto de la clase PageContext que proporciona acceso a objetos relacionados con los servlets. request: Es un objeto de la clase HttpServletRequest, que se puede obtener a través del método getrequest, que encapsula los datos enviados por el cliente al servidor. response: Es un objeto de la clase HttpServletResponse, que puede obtenerse a través del método getresponse, que encapsula los datos que el servidor enviará al cliente. application: Es un objeto de la clase ServletContext, que se obtiene a través del método getservletcontext, que define un conjunto de métodos que todo servlet utiliza para comunicar con el contenedor de servlets. config: Es un objeto de la clase ServletConfig, que se obtiene a través del método getservletconfig, y que se utiliza por el contenedor de servlets para pasar información al servlet durante la iniciación. session: Es un objeto de la clase HttpSession, que se obtiene a través del método getsession, que proporciona una forma de identificar a un usuario que visita las páginas de un sitio Web. out: Es un objeto de la clase JspWriter, que se obtiene a través del método getout, que se utiliza para almacenar la respuesta que será enviada al cliente que hizo la petición de la página. page: Es un objeto genérico de la clase Object, que se obtiene a través del método getpage y que representa al servlet obtenido a partir de la página JSP. 84

32 exception: Es un objeto de la clase Exception, que se obtiene a través del método getexception, que contendrá información a cerca de cualquier excepción que se lance desde la página JSP. Un ejemplo del uso de uno de estos objetos implícitos sería el siguiente: El nombre de tu host es: <%= request.getremotehost() %> El listado siguiente da un ejemplo de una página JSP que utiliza algunas variables predefinidas como uso de expresiones JSP: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional //EN"> <html> <head> <title> Expresiones JSP </title> </head> <body> <h2> Expresiones JSP </h2> <UL> <li> Fecha y hora en curso: <%= new java.util.date() %> </li> <li> Nombre de su host: <%= request.getremotehost() %> </li> <li> Identificador de su sesión: <%= session.getid() %> </li> <li> El parámetro <code> paramprueba </code> del formulario: <%= request.getparameter("paramprueba") %> </li> </UL> </body> <html> Cuya salida es la siguiente: 85

33 LOS SCRIPTLETS JSP Si se desea hacer algo más complejo que una simple expresión, los scriptlets permiten insertar código JAVA en el método _jspservice del servlet (que es ejecutado por service). La sintaxis utilizada por los scriptlets es: <% código java %>. Los escriptlets tienen acceso a las mismas variables definidas de forma automática como expresiones. A manera de ejemplo, si se desea que el resultado aparezca en la página generada, debería de utilizarse la variable out como en la siguiente instrucción: <% String datosconsultados= request.getquerystring(); out.println( Datos GET adjuntos: +datosconsultados); %> En este ejemplo, podría haberse obtenido el mismo resultado utilizando la siguiente expresión JSP: Datos GET adjuntos: <%=request.getquerystring() %> En general, los scriptlets pueden ejecutar varias tareas que no podrían realizarse con las expresiones. Tales tareas incluyen: La determinación de encabezados de respuesta Actualización de Bases de Datos Ejecución de bucles, condiciones y otras estructuras complejas <% for (int i=1; i<=6; i++) %> <h <%=i %>> Hola Mundo </h<%=i %>> <% %> Como un ejemplo concreto se muestra la siguiente página JSP llamada Cuenta.jsp en donde se observa cómo se hace un seguimiento del número de veces que un cliente accede a esta página a través de distintas sesiones. Para ello supondremos que dicha cuenta es el valor del atributo atrcuenta del objeto implícito application ya citado. La primera vez que el cliente accede a la página el valor de atrcuenta será null, debido a que aún no ha sido fijado este atributo; en este caso, se fijará con el valor 1. En los siguientes accesos, se leerá el valor del atributo atrcuenta, se incrementará en una unidad y se volverá a fijar. Finalmente se envía la respuesta al cliente para que se muestre al usuario el valor del contador. <%@page contenttype="text/html"%> <html> <head><title>página JSP cuenta</title></head> <body> <!--Incrementar el contador para esta página. El valor es guardado en el objeto implícito application con el nombre "atrcuenta". --> 86

34 <% Integer cuenta = (Integer)application.getAttribute("atrCuenta"); String s = " vez."; if (cuenta == null) cuenta = new Integer(1); else cuenta = new Integer(cuenta.intValue() + 1); s = " veces."; application.setattribute("atrcuenta", cuenta); %> <h1>demostración de seguimiento a nivel de aplicación</h1> <!-- Visualizar la cuenta para esta página --> Has visitado esta página <%= cuenta %> <%= s %> </body> </html> Este ejemplo muestra HTML tradicional, un fragmento de código JAVA o scriptlet, expresiones y comentarios Aquí otro ejemplo de la ejecución de un código demasiado complejo para una expresión JSP. Este listado presenta una página JSP que utiliza el parámetro de petición colorfondo para establecer el color de fondo de la página. <%@page contenttype="text/html"%> <html> <head> <title> Prueba de Color </title> </head> <% String colorfondo=request.getparameter("colorfondo"); boolean tienecolorexplicito; if (colorfondo!=null) tienecolorexplicito=true; else tienecolorexplicito=false; colorfondo="white"; %> 87

35 <body bgcolor="<%= colorfondo %>"> <h2 align="center"> Prueba de color </h2> <% if (tienecolorexplicito) out.println("ha indicado un color de fondo explícito "+ colorfondo +"."); else out.println("usaré el color de fondo predeterminado WHITE "+ "Indique el atributo de petición <i>colorfondo</i>"+ " para intentar un color estándar, un "+ "valor RRGGBB o para ver si el navegador Web "+ "permite el uso de nombres de color X11."); %> </body> </html> Cuyas posibles salidas son: 88

36 DECLARACIONES JSP Una declaración JSP permite definir métodos o campos que serán insertados en el cuerpo principal de la clase del servlet (fuera del método _jspservice). Una declaración tiene la sintaxis: <%! Código Java %>. Por ejemplo: <%! int i=0; %> <%! Public void jspinit() // código de iniciación %> Una declaración no genera ningún resultado y se usan junto con las expresiones JSP o los scriptlets. A continuación se muestra una página JSP que despliega la cantidad de veces que se ha solicitado esta página desde que se arrancó el servidor, haciendo uso de las declaraciones JSP. <%@page contenttype="text/html"%> <html> <head><title>declaraciones JSP</title></head> <body> <h1>declaraciones JSP</h1> <%-- Esto es un comentario en JSP --%> <%! private int recuentoaccesos=0; %> <h2> Accesos a la página desde el reinicio del servidor: <%= ++recuentoaccesos %> </h2> </body> </html> La salida es la siguiente: 89

37 EL LENGUAJE DE EXPRESION EN JSP 2.0 Anteriormente se ha visto la necesidad de utilizar fragmentos de código java en el desarrollo de páginas JSP, pero con la aparición de la especificación JSP 2.0 ya no hay necesidad de utilizar fragmentos de código Java para nada, gracias al nuevo lenguaje de expresión EL (Expresión Language), a la biblioteca de etiquetas estandar JSTL (JSP Standar Tag Library) y a las nuevas formas para desarrollar etiquetas personalizadas. El lenguaje de expresión JSP es más un lenguaje de acceso a datos que un lenguaje de programación. Ya se ha visto que para pasar información de un cliente a una página JSP, se utilizan parámetros en la petición y atributos en la página. El lenguaje de expresión lo hace posible sin tener que utilizar scriptlets o expresiones (<%= expresión %>). Por ejemplo, las líneas JSP 1.2 siguientes, escritas utilizando código Java: <%= request.getparameter( parnombre ) %>, has visitado esta página <%= application.getattribute( atrcuenta ) %> veces bajo la especificación JSP 2.0 se pueden escribir de una forma más sencilla, como sigue (ahora no se trata de código JAVA): $param.parnombre, has visitado esta página $atrcuenta veces La sintaxis de JSP es sensible a mayúsculas y minúsculas pero un par de comillas simples es equivalente a un par de comillas dobles VARIABLES PREDEFINIDAS (Objetos Implícitos) El lenguaje de expresión JSP 2.0 soporta los objetos implícitos siguientes: pagecontext. Objeto de javax.servlet.jsp.pagecontext que proporciona acceso a los datos de una petición. param. Colección (objeto de tipo java.util.map) de todos los valores de los parámetros enviados en una petición; un String por parámetro. paramvalues. Colección de todos los valores de los parámetros enviados en una petición; una matriz de tipo String por parámetro. header. Colección de todos los valores de las cabeceras enviadas en una petición; un String por cabecera. headervalues. Colección de todos los valores de las cabeceras enviadas en una petición; una matriz de tipo String por cabecera. cookie. Colección de todos los valores de las cookies; un objeto javax.servlet.http.cookie por cookie. initparam. Colección de todos los valores de los parámetros de iniciación de la aplicación; un String por parámetro. También hay objetos que permiten acceder a variables definidas en diferentes ámbitos lo que posibilita compartir información: 90

38 pagescope. Colección de los nombres de las variables definidas en el ámbito de página. requestscope. Colección de los nombres de las variables definidas en el ámbito de petición. sessionscope. Colección de los nombres de las variables definidas en el ámbito de sesión applicationscope. Colección de los nombres de las variables definidas en el ámbito de aplicación DIRECTRICES Las directrices page, incluye y taglib son mensajes para el motor JSP y son siempre incluidas entre los símbolos <%@ y %> LA DIRECTRIZ PAGE Define atributos que se aplican a toda la página JSP donde es incluida: <%@ page lista_de_atributos %> Donde la lista_de_atributos puede contener algunos de los siguientes (aquellos que están escritos en negrita son los tomados por omisión): language= scriptinglanguage extends= classname import= importlist session= true false buffer= none sizekb autoflush= true false isthreadsafe= true false info= info_text errorpage= error_url iserrorpage= true false contenttype= ctinfo pageencoding= peinfo iselignored= true false Típicamente se localiza al principio de la página JSP y puede haber cualquier número de ellas. El lenguaje por omisión es Java. Ejemplos: <%@ page contenttype= text/html language= java %> <%@ page import= java.util.*, java.lang.* %> <%@ page buffer= 5kb autoflush= false %> 91

39 LA DIRECTRIZ INCLUDE La directriz include incluye un archivo (.html,.jsp,.xml o de texto) en una página JSP. Esto permite dividir el contenido de la página en trozos más manejables: <%@ incluye file= URL_relativo %> El ejemplo siguiente muestra dos archivos; el primero incluye al segundo para mostrar la fecha y hora actuales: <!-- fichero: mostrarfechahora.jsp --> <html> <head><title>incluir un fichero</title></head> <body bgcolor="white"> <font color="blue"> La fecha y hora actuales son: <%@ include file="fechahora.jsp" %> </font> </body> </html> <!-- fichero: fechahora.jsp --> <%@ page import="java.util.*" %> <%= (new java.util.date()).tolocalestring() %> LA DIRECTRIZ TAGLIB La directriz taglib indica la biblioteca de acciones personalizadas que podremos utilizar en la codificación de la página JSP. Para distinguir esas acciones entre otras existentes, se utiliza un prefijo (prefix). Su sintaxis es: <%@ taglib (uri= URI_biblioteca tagdir= Dir_biblioteca_tag ) prefix= prefijo %> Cuando se trata de una biblioteca definida mediante una clase Java y un descriptor (archivo.tld), ésta se identifica mediante un URI (Uniform Resource Identifier- URL relativos). Por ejemplo: <%@ taglib uri= prefix= fun %>... <p><fun:accion01 /> La última línea del ejemplo tiene dos etiquetas: una etiqueta p HTML y otra accion01 perteneciente a la biblioteca mibiblioteca. En cambio, si la biblioteca se define mediante un archivo.tag, entonces se identifica mediante su ruta relativa en el sistema de archivos: 92

40 taglib tagdir= /WEB-INF/tags prefix= fun %>... <p><fun:accion01 /> La directriz taglib debe colocarse antes de utilizar en la página JSP las acciones personalizadas definidas por la misma. Se puede utilizar más de una directriz pero el prefijo utilizado debe ser único para cada una de ellas ACTIVACION DEL LENGUAJE DE EXPRESION (LE) La especificación JSP 2.0 define un lenguaje de expresión como alternativa a elementos de programación escritos con código Java y especificaciones anteriores a la JSP 2.0. Para que este lenguaje pueda ser interpretado tienen que cumplirse 2 requisitos: 1. Que la propiedad iselignored de la directriz page valga false: <%@ page iselignored= false %> 2. Que el descriptor de despliegue web.xml en la carpeta WEB-INF indique dónde se localiza el esquema XML para la especificación Servlet 2.4 que a su vez utiliza el esquema XML para la especificación Java Server Page 2.0: <?xml version="1.0" encoding="iso "?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" web-app_2_4.xsd" version="2.4"> </web-app> Utilizando el lenguaje de expresión, se podría modificar la página Cuenta.jsp de la sección de este documento, como se muestra a continuación. Esta nueva página: 1. Especifica que utilizará la biblioteca core de etiquetas estandar (de la que se hablará más adelante). 2. La primera vez que sea accedida definirá la variable atrcuenta en el ámbito de la aplicación con un valor inicial nulo y la incrementará en una unidad; cuando sea accedida sucesivas veces, simplemente incrementará esta variable en una unidad. 3. Finalmente, mostrará una página con un contenido análogo al siguiente. Esta formado por una cabecera y una segunda línea compuesta por el valor del parámetro parnombre enviado con la petición, un texto fijo, el valor de la variable atrcuenta y otro texto fijo dependiente del valor de esta variable. 93

41 El código completo es el siguiente: <%-- página JSP Cuenta.jsp --%> contenttype="text/html"%> taglib uri=" prefix="c" %> <html> <head><title>página JSP cuenta</title></head> <body> <!--Incrementar el contador para esta página. El valor es guardado en la variable "atrcuenta" definida en el ámbito de aplicación. --> <c:set var="atrcuenta" scope="application" value="$atrcuenta + 1"/> <h1>demostración de seguimiento a nivel de aplicación</h1> <!-- Visualizar la cuenta para esta página --> $param.parnombre, has visitado esta página $atrcuenta $(atrcuenta > 1)? " veces." : " vez." </body> </html> VARIABLES Y EXPRESIONES Para acceder a una simple variable, se puede escribir algo como lo siguiente: $nombre y para acceder a una propiedad de un objeto, podemos escribir algo como: $param.parnombre $applicationscope.atrcuenta $pagecontext.request.requesturi La primera línea del ejemplo anterior obtiene el valor de la propiedad parnombre del objeto param, la segunda el valor del atributo atrcuenta del objeto applicationscope y la tercera el URL relativo de la página JSP solicitada. El lenguaje de expresión es más tolerante con respecto a las variables con valor null y ejecuta muchas más conversiones de forma automática sobre el tipo de los datos, cuando la expresión a evaluar así lo requiere. Por ejemplo, la etiqueta condicional siguiente incluye una expresión que compara el valor del atributo atrcuenta con ámbito de aplicación, con 94

42 10 (convirtiendo implícitamente el valor del atributo al tipo de la constante para poder realizar la comparación. El resultado será un valor de tipo boolean. <c:if test= $applicationscope.atrcuenta > 10 >... </c:if> o bien <c:if test= $atrcuenta > 10 >... </c:if> Para que una literal pueda incluir un caracter significativo para el lenguaje, dicho caracter debe ser especificado como una secuencia de escape (\caracter). Por ejemplo, la siguiente expresión da lugar al literal vez o veces entre comillas dobles: $(atrcuenta > 1) \ veces\ : \ vez\ Cualquier objeto o atributo de un objeto definido en algunos de los ámbitos de una página puede ser utilizado como una variable. Por ejemplo: $atrcuenta+1 es una expresión que realiza la suma de la variable atrcuenta con 1. Cuando se trate de una propiedad de un objeto, para acceder a ella se utilizará el operador punto, o bien la notación empleada para acceder a un elemento de una matriz. Por ejemplo: $param.parnombre $param[ parnombre ] Una expresión LE puede aparecer en cualquier lugar donde pueda aparecer un texto fijo. Por tanto, para informar al contenedor JSP que se trata de una expresión y no de un texto fijo, se utilizan los delimitadores $ al principio y al final OPERADORES OPERADOR DESCRIPCIÓN. Acceso a la propiedad de un objeto o a un elemento de un Map [] Acceso al elemento de una matriz o de un objeto List () Paréntesis para alterar la prioridad en la evaluación de una expresión? : If ternario condicion? expresion1 : expresión 2 + Suma - Resta * Producto / ó div División % ó mod Módulo o resto de una división == ó eq Igualdad!= ó ne Diferente < ó lt Menor que 95

43 > ó gt Mayor que <= ó le Menor o igual que >= ó ge Mayor o igual que && ó and Operación Lógica AND ó or Operación Lógica OR! ó not Operación Lógica NOT empty Verifica si el valor de una variable es null, si un String esta vacío, o si una matriz, Map o Collection no tienen elementos func(args) Llamada a una función, donde func es el nombre de la función y arg representa cero o más argumentos separados por comas. El ejemplo siguiente muestra una página JSP compuesta por elementos HTML, expresiones LE y objetos implícitos: <html> <head><title>jsp 2.0</title></head> <body> <h3>lenguaje de expresión (LE)</h3> <p>la siguiente tabla ilustra algunas expresiones LE: <br><br><table border="1"> <tr> <th><b>expresión</b></th> <th><b>valor</b></th> </tr> <tr> <td>\$3 + 6</td> <td>$3 + 6</td> </td> <tr> <td>\$(7 > 4)? 7 : 4</td> <td>$(7 > 4)? 7 : 4</td> </tr> <tr> <td>\$header["host"]</td> <td>$header["host"]</td> </tr> </table> </body> </html> 96

44 BIBLIOTECA ESTANDAR DE ETIQUETAS La biblioteca estándar de etiquetas JSP (JSTL Java Server Page Estándar Tag Library) incluye una cantidad amplia de etiquetas para diferentes áreas de trabajo: Área básica: (su prefijo es c core) y contiene: o Soporte de variables (remove y set) o Control del flujo (choose... when... otherwise, foreach, fortokens, if) o Manejo de URL (import... param, redirect...param y url...param) o Operaciones varias (match y out) o El identificador de esta biblioteca (URI) es: Área XML (su prefijo es x) y contiene: o Sentencias básicas (out, parse y set) o Control del flujo (choose when otherwise, foreach e if) o Transformación de Documentos (transform param) o El identificador de esta biblioteca (URI) es: Área Internacionalización: (su prefijo es fmt). Contiene: o Localidad (setlocale y requestencoding) o Mensajes (bundle, message...param y setbundle) o Formateo de Fechas y números (formatnumber, formatéate, parsedate, parsenumber, settimezone, timezone) o El identificador de esta biblioteca (URI) es: 97