capítulo 1.2-JSP-Servlet(1)

1 de 85

Índice de contenido1. Introducción......................................................................................................................................................4

1.1 JSP...........................................................................................................................................................4 1.2 Servlet......................................................................................................................................................4 1.3 Servidores de aplicaciones.......................................................................................................................4

1.3.1 WebSphere......................................................................................................................................5 1.3.2 GlassFish.........................................................................................................................................5 1.3.3 Tomcat.............................................................................................................................................6 1.3.4 JBoss...............................................................................................................................................7

2. Modelos J2EE - JEE.........................................................................................................................................9 2.1 Modelo J2EE..........................................................................................................................................10 2.2 Modelo JEE............................................................................................................................................12

2.2.1 Comunicación en JEE...................................................................................................................13 2.2.2 Componentes Web........................................................................................................................14 2.2.3 Componentes de negocio...............................................................................................................14 2.2.4 EIS.................................................................................................................................................15 2.2.5 Contenedores JEE.........................................................................................................................15

2.3 Historia...................................................................................................................................................173. JSP..................................................................................................................................................................18

3.1 JSP.........................................................................................................................................................18 3.2 Scriptlets................................................................................................................................................19 3.3 Declaraciones.........................................................................................................................................20 3.4 Atributos................................................................................................................................................22

3.4.1 import............................................................................................................................................22 3.4.2 contentType...................................................................................................................................22 3.4.3 isThreadSafe .................................................................................................................................22 3.4.4 session...........................................................................................................................................23 3.4.5 buffer ............................................................................................................................................23 3.4.6 autoFlush ......................................................................................................................................23 3.4.7 errorPage ......................................................................................................................................23 3.4.8 isErrorPage ...................................................................................................................................23 3.4.9 Ejemplo.........................................................................................................................................23 3.4.10 include.........................................................................................................................................26 3.4.11 include y flush.............................................................................................................................27

3.5 request....................................................................................................................................................294. Servlet.............................................................................................................................................................31

4.1 Estructura básica....................................................................................................................................31 4.2 Hola Mundo...........................................................................................................................................32 4.3 Métodos.................................................................................................................................................36

4.3.1 String getParameter(String name).................................................................................................36 4.3.2 String[ ] getParameterValues(String name)..................................................................................40

5. Encapsulación (Java Bean).............................................................................................................................43 5.1 Métodos accesadores: get......................................................................................................................43 5.2 Métodos mutadores: set.........................................................................................................................43 5.3 Ejemplo..................................................................................................................................................44

6. JDBC..............................................................................................................................................................46 6.1 ¿Qué la API de JDBC 2.0 Incluye.........................................................................................................46 6.2 ¿Qué es la API de JDBC?......................................................................................................................47 6.3 ¿Qué hace la API de JDBC hacer?........................................................................................................48 6.4 Conexión de Información general..........................................................................................................48 6.5 Establecer una conexión.........................................................................................................................48 6.6 URL de Uso General..............................................................................................................................49 6.7 JDBC URL.............................................................................................................................................50 6.8 Liberación DBMS Recursos..................................................................................................................50 6.9 DriverManager Información general......................................................................................................51 6.10 Crear una conexión..............................................................................................................................51

2 de 85

6.11 Eliminar datos......................................................................................................................................58 6.12 Actualiza registro.................................................................................................................................62 6.13 Listar información................................................................................................................................71

7. Instalación de PostgreSQL.............................................................................................................................75

3 de 85

1. Introducción

1.1 JSPJavaServer Pages (JSP) es una tecnología Java que permite generar contenido dinámico para web, en forma de documentos HTML, XML o de otro tipo.

Esta tecnología es un desarrollo de la compañía Sun Microsystems. La Especificación JSP 1.2 fue la primera que se liberó y en la actualidad está disponible la Especificación JSP 2.1.

Las JSP's permiten la utilización de código Java mediante scripts. Además, es posible utilizar algunas acciones JSP predefinidas mediante etiquetas. Estas etiquetas pueden ser enriquecidas mediante la utilización de Bibliotecas de Etiquetas (TagLibs o Tag Libraries) externas e incluso personalizadas.

El sitio oficial es:

http://java.sun.com/products/jsp/

1.2 ServletUn servlet es un objeto que se ejecuta en un servidor o contenedor JEE, especialmente diseñado para ofrecer contenido dinámico desde un servidor web, generalmente HTML. Otras opciones que permiten generar contenido dinámico son con los lenguajes ASP, PHP, JSP (un caso especial de servlet) y Python. Forman parte de JEE (Java Enterprise Edition), que es una ampliación de JSE (Java Standard Edition).

El uso más común de los servlets es generar páginas web de forma dinámica a partir de los parámetros de la petición que envíe el navegador web.

GlassFish v3 implementa la especificación de Java Servlet 3.0 y GlassFish v2.1 implementa la especificación de Java Servlet 2.5


http://java.sun.com/products/servlet/reference/index.html

1.3 Servidores de aplicacionesEn informática, se denomina servidor de aplicaciones a un servidor en una red de computadores que ejecuta ciertas aplicaciones.

Usualmente se trata de un dispositivo de software que proporciona servicios de aplicación a las computadoras cliente. Un servidor de aplicaciones generalmente gestiona la mayor parte (o la totalidad) de las funciones de lógica de negocio y de acceso a los datos de la aplicación. Los

4 de 85

principales beneficios de la aplicación de la tecnología de servidores de aplicación son la centralización y la disminución de la complejidad en el desarrollo de aplicaciones. Si bien el término es aplicable a todas las plataformas de software, hoy en día el término servidor de aplicaciones se ha convertido en sinónimo de la plataforma Java EE (antes J2EE) de Sun Microsystems.

1.3.1 WebSphereWebSphere es una familia de productos de software propietario de IBM, aunque el término se refiere de manera popular a uno de sus productos específicos: WebSphere Application Server (WAS). WebSphere ayudó a definir la categoría de software middleware y está diseñado para configurar, operar e integrar aplicaciones de e-business a través de varias plataformas de red usando las tecnologías del Web.

La familia de productos WebSphere además incluye herramientas para diseñar procesos de negocio (WebSphere Business Modeler), para integrarlos en las aplicaciones existentes (WebSphere Designer) y para ejecutar y monitorizar dichos procesos (WebSphere Process Server, WebSphere Monitor).


http://www-01.ibm.com/software/websphere/

1.3.2 GlassFishGlassFish es un servidor de aplicaciones desarrollado por Sun Microsystems que implementa las tecnologías definidas en la plataforma Java EE y permite ejecutar aplicaciones que siguen esta especificación. La versión comercial es denominada Sun GlassFish Enterprise Server. Es gratuito y de código libre, se distribuye bajo un licenciamiento dual a través de la licencia CDDL y la GNU GPL.

GlassFish está basado en el código fuente donado por Sun y Oracle Corporation, éste

5 de 85

último proporcionó el módulo de persistencia TopLink. GlassFish tiene como base al servidor Sun Java System Application Server de Sun Microsystems, un derivado de Apache Tomcat, y que usa un componente adicional llamado Grizzly que usa Java NIO para escalabilidad y velocidad.


https://glassfish.dev.java.net/

1.3.3 Tomcat

Tomcat (también llamado Jakarta Tomcat o Apache Tomcat) funciona como un contenedor de servlets desarrollado bajo el proyecto Jakarta en la Apache Software Foundation. Tomcat implementa las especificaciones de los servlets y de JavaServer Pages (JSP) de Sun Microsystems.

Tomcat no es un servidor de aplicaciones, como JBoss o JOnAS. Incluye el compilador Jasper, que compila JSPs convirtiéndolas en servlets. El motor de servlets de Tomcat a menudo se presenta en combinación con el servidor web Apache.

Tomcat puede funcionar como servidor web por sí mismo. En sus inicios existió la percepción de que el uso de Tomcat de forma autónoma era sólo recomendable para entornos de desarrollo y entornos con requisitos mínimos de velocidad y gestión de transacciones. Hoy en día ya no existe esa percepción y Tomcat es usado como servidor web autónomo en entornos con alto nivel de tráfico y alta disponibilidad.

Tomcat 3.x (distribución inicial)

• Implementado a partir de las especificaciones Servlet 2.2 y JSP 1.1

• Recarga de servlets

• Funciones básicas HTTP

Tomcat 4.x


• Contenedor de servlets rediseñado como Catalina

• Motor JSP rediseñado con Jasper

6 de 85

• Conector Coyote

• Java Management Extensions (JMX), JSP Y administración basada en Struts

Tomcat 5.x


• Recolección de basura reducida

• Capa envolvente nativa para Windows y Unix para la integración de las plataformas

• Análisis rápido JSP

Tomcat 6.x

• Implementado de Servlet 2.5 y JSP 2.1

• Soporte para Unified Expression Language 2.1

• Diseñado para funcionar en Java SE 5.0 y posteriores

• Soporte para Comet a través de la interfaz CometProcessor


http://tomcat.apache.org/

1.3.4 JBoss

JBoss es un servidor de aplicaciones J2EE de código abierto implementado en Java puro. Al estar basado en Java, JBoss puede ser utilizado en cualquier sistema operativo que lo soporte. Los principales desarrolladores trabajan para una empresa de servicios, JBoss Inc., adquirida por Red Hat en Abril del 2006, fundada por Marc Fleury, el creador de la primera versión de JBoss. El proyecto está apoyado por una red mundial de colaboradores. Los ingresos de la empresa están basados en un modelo de negocio de servicios.


7 de 85

http://www.jboss.org/

8 de 85

2. Modelos J2EE - JEEJ2EE es una especificación que define una plataforma de desarrollo empresarial, a la que llamaremos la plataforma J2EE.

La plataforma J2EE está formada de varios componentes:

• Un conjunto de especificaciones.

• Un test de compatibilidad: El J2EE Compatibility Test Suite (CTS).

• La implementación de referencia de J2EE.

• Un conjunto de guías de desarrollo y de “buenas prácticas” aconsejadas denominadas J2EE BluePrints

En la especificación se encuentra bajo el JSR-151, se definen, de manera muy general, las pautas, reglas y servicios que han de seguir y ofrecer los diferentes servidores de aplicaciones que quieran implementar la plataforma J2EE. Para acceder http://jcp.org/en/jsr/detail?id=151

Los servicios que han de ofrecer los servidores de aplicaciones que implementen la plataforma J2EE están a su vez definidos por diferentes especificaciones. Estas especificaciones definen con mucho más detalle los diferentes componentes de los servidores de aplicaciones, como puedan ser un contenedor Web, un servidor de mensajería, el sistema de seguridad, otros.

De algún modo, se podría decir que la especificación J2EE engloba a un gran conjunto de especificaciones. Por poner un ejemplo. En la especificación de J2EE 1.4 se definen lo siguiente:

• JSR-109, (Servicios Web)

• JSR-67, (JAXM, Java API for XML Messaging)

• JSR-93, (JAXR, Java API for XML Registries)

• JSR-77, (Configuración y control)

• JSR-88, (API de despliegue)

• JSR-115, (Interfaz de servicios de autorización)

• JSR-56, (JNLP, Ejecución remota de aplicaciones)

• JSR-112, (JCA 2.0, Arquitectura de conectores)

• JSR-152, (JSP 1.3, Java Server Pages)

• JSR-152, (Servlets 2.4)

• JSR-153, (EJB 2.1, Enterprise Java Beans)

9 de 85

• JSR-9XX, (JAXP 1.2, Soporte de esquemas XML)

• JSR-9XX, (JMS 1.1, API de mensajería)

Como se puede ver, todas estas especificaciones tienen asociado un JSR, regido por un comité de empresas, asociaciones o individuos que se aseguran de crear dichas especificaciones y de que vayan evolucionando. La gran importancia de toda esta enorme lista de especificaciones radica en que cuando utilizamos un servidor de aplicaciones que implementa la plataforma J2EE, los desarrolladores, obtenemos de manera automática todos estos servicios. Es decir, se pone a nuestra disposición una gran caja de herramientas que podemos aprovechar para realizar aplicaciones de una manera mucho más eficaz.

Hay que tener presente que cada una de estas especificaciones puede utilizarse perfectamente por separado.

2.1 Modelo J2EELa plataforma de J2EE define un modelo de programación encaminado a la creación de aplicaciones basadas en n-capas. Típicamente una aplicación puede tener cinco capas diferentes:

Capa de cliente Representa la interfaz de usuario que maneja el cliente. Se forma a parir de HTML, JavaScript, CSS, Applet, DHTML, Active X

Capa de presentación Representa el conjunto de componentes que generan la información que se representará al cliente. Típicamente se creará a través de componentes basados en Servlets y JSP.

Capa de lógica de negocio

Contiene nuestros componentes de negocio reutilizables (por ejemplo, realizar un pedido, pagar una cuenta). Normalmente se forma a partir de componentes EJB.

Capa de integración: Aquí se encuentran componentes que nos permiten hacer más transparente el acceso a la capa de sistemas de información. Por ejemplo este es el lugar idóneo para implementar una lógica de objetos de acceso a datos, DAO (Data Access Objects).

Capa de sistemas de información:

Esta capa engloba a nuestros sistemas de información: bases de datos relacionales, bases de datos orientadas a objetos, sistemas legacy (sistemas no generados con J2EE, por ejemplo sistemas generados en Cobol o una ERP como SAP), otros.

10 de 85

11 de 85

2.2 Modelo JEEJava Platform, Enterprise Edition o Java EE (anteriormente conocido como Java 2 Platform, Enterprise Edition o J2EE hasta la versión 1.4) es una plataforma de programación—parte de la Plataforma Java—para desarrollar y ejecutar software de aplicaciones en Lenguaje de programación Java con arquitectura de N niveles distribuida, basándose ampliamente en componentes de software modulares ejecutándose sobre un servidor de aplicaciones. La plataforma Java EE está definida por una especificación. Similar a otras especificaciones del Java Community Process, Java EE es también considerada informalmente como un estándar debido a que los suministradores deben cumplir ciertos requisitos de conformidad para declarar que sus productos son conformes a Java EE; estandarizado por The Java Community Process / JCP.

Java EE incluye varias especificaciones de API, tales como JDBC, RMI, e-mail, JMS, Servicios Web, XML, etc y define cómo coordinarlos. Java EE también configura algunas especificaciones únicas para Java EE para componentes. Estas incluyen Enterprise JavaBeans, servlets, portlets (siguiendo la especificación de Portlets Java), JavaServer Pages y varias tecnologías de servicios web. Esto permite al desarrollador crear una Aplicación de Empresa portable entre plataformas y escalable, a la vez que integrable con tecnologías anteriores. Otros beneficios añadidos son, por ejemplo, que el servidor de aplicaciones puede manejar transacciones, la seguridad, escalabilidad, concurrencia y gestión de los componentes desplegados, significando que los desarrolladores pueden concentrarse más en la lógica de negocio de los componentes en lugar de en tareas de mantenimiento de bajo nivel.

Aplicaciones multicapa distribuidas

La plataforma Java EE utiliza un modelo de aplicación distribuida multicapa para aplicaciones empresariales. Lógica de la aplicación se divide en componentes según la función, y los componentes de distintas aplicaciones que componen una aplicación Java EE se instalan en máquinas diferentes dependiendo del nivel en el entorno de múltiples niveles Java EE al que pertenece el componente de aplicación.

Aunque una aplicación Java EE puede constar de los tres o cuatro niveles, las aplicaciones Java EE multicapa se consideran en general en tres niveles, ya que están distribuidas en tres localidades:

• Las máquinas clientes

• El servidor Java EE

• La base de datos o el legado de las máquinas en la parte final.

Aplicaciones en tres niveles que funcionan de esta manera ampliar el estándar de dos niveles y el modelo de cliente servidor mediante la colocación de un servidor de aplicaciones multiproceso entre la aplicación cliente y el almacenamiento de datos.

12 de 85

2.2.1 Comunicación en JEELa Figura siguiente muestra los diferentes elementos que pueden hacerse a nivel de cliente. El cliente se comunica con la capa de negocio se ejecuta en el servidor de Java EE, ya sea directamente o, como en el caso de un cliente que se ejecuta en un navegador, yendo a través de las páginas JSP o servlets que se ejecutan en la capa web

13 de 85

2.2.2 Componentes Web

Componentes Web Java EE son los servlets o páginas creadas con tecnología JSP (páginas JSP) y / o la tecnología JavaServer Faces:

• Servlets son las clases de lenguaje Java de programación dinámica que da respuestas de las solicitudes y proceso de construcción.

• Las páginas JSP son documentos basados en texto que se ejecutan como servlets pero permiten una aproximación más natural a la creación de contenido estático.

• La tecnología JavaServer Faces se basa en la tecnología de servlets y JSP y proporciona un marco de interfaz de usuario de componentes para aplicaciones web.

Páginas HTML estáticas y applets se combinan con componentes web durante el montaje de solicitud, pero no se consideran componentes web de la especificación Java EE. Clases de utilidad en el cliente puede combinarse con los componentes Web, pero no se consideran componentes Web.

Como se muestra en la Figura los niveles web y cliente, puede incluir un componente JavaBeans para gestionar la entrada del usuario y enviar la entrada a un Enterprise Bean en el nivel de negocio de JEE

2.2.3 Componentes de negocio

El código de negocio, que es la lógica que resuelve o satisface las necesidades de un dominio particular de negocios como la banca, venta al por menor, o la financiación, está a cargo de un Enterprise Bean que se ejecuta en la capa de negocio. Figura muestra cómo un Enterprise Bean

14 de 85

recibe los datos de los programas cliente, los procesos (si es necesario), y los envía al Legacy System o a la base de datos. Un bean de empresa también recupera datos desde el almacenamiento, procesos (si es necesario), y lo envía de nuevo al programa cliente.

2.2.4 EIS

La empresa de nivel de información del sistema se encarga EIS incluye:

• Software

• Sistemas de infraestructura de la empresa, tales como la planificación de recursos empresariales (ERP), procesamiento de transacciones mainframe, sistemas de base de datos y otros sistemas de información heredados. Por ejemplo, los componentes de aplicaciones Java EE necesidad de tener acceso a los sistemas de información de la empresa para la conectividad de base de datos.

2.2.5 Contenedores JEE

Los contenedores son la interfaz entre un componente y la plataforma de bajo nivel de funcionalidad específica que soporta el componente. Antes que una componente web, EJB o de cliente de la aplicación puede ser ejecutado, debe ser ensamblado en un módulo Java EE.

El proceso de ensamblado consiste en especificar la configuración de contenedores para cada componente en la aplicación Java EE y para la aplicación Java EE en sí. El contenedor debe personalizar la configuración de soporte subyacente proporcionada por el servidor de Java EE, incluidos los servicios tales como seguridad, gestión de transacciones, Java Naming and Directory

15 de 85

InterfaceTM (JNDI) las búsquedas, y la conectividad remota. Éstos son algunos de los aspectos más destacados:

• El modelo de seguridad de Java EE permite configurar un componente para que los recursos del sistema sean accesibles únicamente por usuarios autorizados.

• El modelo de transacciones Java EE permite especificar las relaciones entre los métodos que conforman una sola transacción, de modo que todos los métodos en una sola transacción se tratan como una sola unidad.

• Los servicios de búsqueda JNDI proporcionar una interfaz unificada para múltiples nombres y los servicios de directorio en la empresa de manera que los componentes de aplicación puede tener acceso a estos servicios.

• El modelo de Java EE de conectividad remota gestiona la comunicación de bajo nivel entre los clientes y los EJB. Después de un EJB se crea, un cliente llama a los métodos en él como si estuviera en la misma máquina virtual.

El contenedor también administra los servicios no configurable como los ciclos de vida del servlet, la puesta en común de recursos de conexión de bases de datos, la persistencia de datos y el acceso a la API de la plataforma Java EE.

El proceso de implementación instala los componentes de aplicaciones Java EE en los contenedores Java EE como se ilustra en la Figura.

16 de 85

2.3 HistoriaLa especificación original J2EE fue desarrollada por Sun Microsystems.

• Comenzando con J2EE 1.3, la especificación fue desarrollada bajo el Java Community Process. JSR 58 especifica J2EE 1.3 y JSR 151 especifica J2EE 1.4.

• El SDK de J2EE 1.3 fue liberado inicialmente como beta en abril de 2001. La beta del SDK de J2EE 1.4 fue liberada por Sun en diciembre de 2002.

• La especificación Java EE 5 fue desarrollada bajo el JSR 244 y la liberación final fue hecha el 11 de mayo de 2006.

17 de 85

3. JSPJSP implementa la parte dinámica de nuestras páginas Web del HTML estáticas. Simplemente escribimos el HTML regular de la forma normal y encerramos el código de las partes dinámicas en unas etiquetas especiales, la mayoría de las cuales empiezan con "<%" y terminan con "%>“. Por ejemplo:

La fecha y hora actual: <%= new java.util.Date() %>

• Los JSP son transformados, en el proceso de compilación, en un Servlet

3.1 JSPUna expresión JSP se usa para insertar valores Java

<%= expresión Java %>

Por ejemplo, aquí se muestra la fecha y hora y un número aleatorio.

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%= new java.util.Date() %><br /> <%= new java.util.Random().nextDouble() %> </body></html>

Resultado:

18 de 85

3.2 ScriptletsSi queremos hacer algo más complejo que insertar una simple expresión, los scriptlets JSP nos permiten insertar código java arbitrario dentro del servlet que será construido al generar el JSP.

<% Código Java %>

Ejemplo

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> Buenos <% java.util.Calendar currTime = new java.util.GregorianCalendar(); if (currTime.get(currTime.HOUR_OF_DAY) < 12) { %> Dias! <% } else if (currTime.get(currTime.HOUR_OF_DAY) < 18) { %> Tardes! <% } else { %> Noches! <% } %> </body></html>

19 de 85

Resultado:

3.3 DeclaracionesUna declaración JSP nos permite definir métodos o campos que serán insertados dentro del cuerpo principal de la clase servlet (fuera del método service que procesa la petición). Tienen la siguiente forma:

<%! Código Java%>

Sirve, por ejemplo, para controlar los acceso a una página mientras el servidor este operativo.

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%! private int recuentoAccesos = 0; %> Accesos a la página desde el reinicio del servidor: <%= ++recuentoAccesos %> </body></html>

20 de 85

Si se cierra la ventana en el próximo intento se tendrá:

Si se hace clic en actualizar se produce el mismo resultado.

También se puede definir un método

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%! public String miMetodo(String parametro) { return parametro; } %> El parámetro recibido es: <%= miMetodo("Hola Mundo") %> </body></html>

21 de 85

3.4 AtributosAlguno de los atributos manejados habitualmente por un JSP son:

3.4.1 importPermite especificar los paquetes que deberán ser importados por el servlet (al cual se traduce la página jsp). El servlet importa por defecto al menos:

• java.lang.*

• javax.servlet.*

• javax.servlet.jsp.*

• javax.servlet.http.*

<@page import =“paquete.clase1,..., paquete.claseN” %>

Por ejemplo:

<@page import =“java.util.*, coreservlets.*” %>

3.4.2 contentTypeIndica el tipo MIME del documento que será devuelto

<@page contentType=“Tipo-MIME” %>

<@page contentType=“Tipo-MIME; charset=Conjunto-De-Caracteres %>

Por ejemplo: La salida del out.println() o los elementos de expresión (<%= object%>) se convierten automáticamente a la codificación seleccionada. Además, la página en sí misma se interpreta como parte de este codificación.

<%@ page contentType="text/html; charset=UTF-8" %>

3.4.3 isThreadSafe El comportamiento normal de un servlet es que atiende a varias peticiones simultaneas concurrentemente. Si el servlet integra la interfaz SingleThreadModel, entonces se garantizará que no habrá accesos simultáneos a la misma instancia del Servlet; entonces, en este caso, se encolarán las peticiones.

<@page isThreadSafe = “true” %> <%! --Valor predeterminado--%><@page isThreadSafe = “false” %>

Este atributo se encuentra deprecado en la versión 2.4 de Servlet. Por ende, se recomienda el uso de bloques synchronized

22 de 85

3.4.4 sessionControla si la página participa en sesiones HTTP. Un valor false provoca un error al traducir la página JSP a servlet.

<@page session =“true” %> <%! --Valor predeterminado--%><@page session =“false” %>

3.4.5 buffer Establece el tamaño del buffer utilizado por la variable out, que es tipo JspWriter (una subclase de PrintWriter).

<@page buffer =“32kb” %>

3.4.6 autoFlush Controla si el buffer resultante deberá ser automáticamente descargado cuando esté lleno o si debe generar una excepción cuando se sobresature.

<@page autoFlush =“true” %> <%! --Valor predeterminado--%><@page autoFlush =“false” %>

3.4.7 errorPage Especifica que una página JSP que deberá procesar cualquier excepción arrojadas pero no capturadas en la página en curso

<%@ page errorPage = "error.html"%>

3.4.8 isErrorPage Indica si la página en curso puede ser utilizada como una página de error para otra página JSP.

<@page isErrorPage =“true” %><@page isErrorPage =“false” %> <%! --Valor predeterminado--%>

3.4.9 EjemploVamos a crear una página de error. Consideremos el siguiente código sin manejo de error:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%! private double divideXY(String x, String y){

23 de 85

double z =0.0; z = Double.parseDouble(x)/Double.parseDouble(y); return z; } %> <%= divideXY("5.2","0.0") %> </body></html>

El resultado es:

Ahora para el caso:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%! private double divideXY(String x, String y){ double z =0.0; z = Double.parseDouble(x)/Double.parseDouble(y); return z; } %> <%= divideXY("a","2.1") %> </body></html>

24 de 85

Entonces, dependiendo del error se generan mensajes muy distintos. Vamos a agregar una página de error:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%@page errorPage="Error.jsp" %> //Página de error <%! private double divideXY(String x, String y){ double z =0.0; z = Double.parseDouble(x)/Double.parseDouble(y); return z; } %> <%= divideXY("a","2.1") %> </body></html>

La página que maneja el error es:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%@page import="java.io.*" %> //Para crear un objeto de PrintWriter <%@page isErrorPage="true" %> //Para usar esta página como de error

25 de 85

<table border="1"> <tbody> <tr> <td>Error al calcular la división</td> </tr> </tbody> </table> index.jsp ha informado del siguiente error: <i><%= exception %></i> //Captura la excepción <br /><br /> Este problema sucedió en el siguiente lugar:<hr /> <% exception.printStackTrace(new PrintWriter(out)); %> //Muestra la traza del error </body></html>

3.4.10 include

Se usa para incluir un archivo en el documento JSP principal.

<%@include file=“URL relativo” %>

Vamos a incluir una página que hará las veces de pie de página

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <table border="1"> <tbody>

26 de 85

<tr> <td>Esta es la página principal</td> </tr> </tbody> </table> <%@include file="piePagina.jsp" %> //Página que será incluida </body></html>

La página con el código a adicionar es la siguiente. Notar que debe tener la estructura para ser incrustada dentro de otra página html.

<%@page import="java.util.Date" %>

<%! private int recuentoAccesos = 0; private Date fechaAcceso = new Date(); private String hostAcceso = "<I>No hay acceso anterior </I>";%>

<hr>Esta página © 2010<a href="http://www.mi-empresa.com/">www.mi-empresa.com</a>.Esta página a sido accedida <%= ++recuentoAccesos %> veces desde que se reinició el servidor.Fue accedida por última vez desde <%= hostAcceso %> a las <%= fechaAcceso %>.

<% hostAcceso = request.getRemoteHost(); %><% fechaAcceso = new Date(); %>

3.4.11 include y flush

Permite insertar ficheros (no JSP) en una página que está siendo generada. Sirve, como se verá en el ejemplo siguiente, para insertar un bloque de texto que requiere ser constantemente cambiado.

<jsp:include page="URL relativo" flush="true" />

27 de 85

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <jsp:include page="Texto1.html" flush="true" /> <hr /> <jsp:include page="Texto1.html" flush="true" /> </body></html>

El archivo Texto1.html

DT de Boca califica como "barbara" la gran actuacion de Gary Medel<br />El chileno, junto a sus dos companeros en el mediocampo, se llevoloas de parte de Abel Alves tras derrotar con claridad a Lanus<a href="http://www.terra.cl/deportes/index.cfm?accion=futbolnacional&id_reg=1354307">...</a>

El archivo Texto2.html

Alexis Sanchez se pondra la camiseta de River Plate<br />El vocero de Udinese, Guido Gomirato, informo que eldirector deportivo de la institución italiana le dijoque el delantero chileno se iria al club argentino a prestamo.<a href="http://www.emol.com/noticias/deportes/detalle/detallenoticias.asp?idnoticia=265530">...</a>

Resultado:

28 de 85

3.5 requestAtributos del objeto Request: El objeto request contiene gran cantidad de informaci?n sobre la petici?n que se ha hecho al servidor, como el m?todo usado (get/post), la IP del cliente, etc. Afortunadamente, el objeto request tiene un m?todo llamado getAttributeNames() que devuelve un objeto de la clase java.util.Enumeration con el nombre de todos los atributos del objeto. As?, para obtener toda la informaci?n de dicho objeto, podemos utilizar el siguiente c?digo:

<% java.util.Enumeration enum; String atributo;

enum = request.getAttributeNames(); // Leemos todos los atributos del request

while (enum.hasMoreElements()) {

atributo = (String) enum.nextElement();%>

<%=atributo%> = <%=request.getAttribute(atributo)%> <BR><% } // del while%>

Par?metros: Adem?s de los atributos anteriores, es muy interesante saber qu? par?metros ha recibido el JSP a trav?s del objeto request. La manera m?s sencilla de mostrarlos todos es muy similar a la anterior:

<% java.util.Enumeration enum; String parametro;

enum = request.getParameterNames(); // Leemos todos los par?metros recibidos


parametro = (String) enum.nextElement();%>

<%=parametro%> = <%=request.getParameter(parametro)%> <BR><% }

Objetos de sesión: Objetos de sesión: Por último, aunque no menos importante, suele ser interesante conocer el contenido de la sesión. Para ello, utilizamos un código muy similar a los

29 de 85

anteriores, aunque con alguna pequeña diferencia:

<% java.util.Enumeration enum; String elemento;

session = request.getSession(true); // Creamos la sesión, si no existe%>

Sesión activa desde: <%=new java.util.Date(session.getCreationTime())%%> <BR> Ultimo acceso: <%=new java.util.Date(session.getLastAccessedTime())%> <BR>Contenido: <BR><BR>

<% enum = session.getAttributeNames(); // Leemos todos los objetos de sesion


elemento = (String) enum.nextElement();%>

<%=elemento%> = <%=session.getAttribute(elemento)%> <BR><% } // del while%>

30 de 85

4. ServletSon programas que se ejecutan en un servidor Web compatible con la tecnología servlets como Tomcat.

• Los servlets actúan como una capa intermedia entre la petición de un clientes de un navegador Web y una base de datos.

• Generan páginas web de forma dinámica a partir de los parámetros de la petición que envíe el navegador web.

Un servlets podría ser responsable de tomar los datos de un formulario HTML de entrada y aplicar la lógica del negocio utilizada para actualizar la base de datos.

Implementación completa para la versión J2EE se encuentra en:

http://java.sun.com/j2ee/1.4/docs/api/javax/servlet/http/package-summary.html

4.1 Estructura básicaCuando un servlet acepta una llamada de un cliente, recibe dos objetos:

• Un ServletRequest, que encapsula la comunicación desde el cliente al servidor. Contiene los métodos que permiten encontrar información entrante como datos de un formulario, cabeceras de petición HTTP y el nombre de un Host de un cliente

• Un ServletResponse, que encapsula la comunicación de vuelta desde el servlet hacia el cliente. Contiene los métodos que permiten especificar líneas de respuesta HTTP (200, 404, etc.), cabeceras de respuesta (Content-Type, Set-Cookie, etc.), y, todavía más importante, nos permiten obtener un PrintWriter usado para enviar el contenido del documento al cliente

31 de 85

Servidor

Estación de trabajo

ServletRequest

ServletResponse

4.2 Hola MundoCrear un servlet en Netbeans:

Paso 1: Crear un proyecto Web

Paso 2: Elija un nombre para el proyecto y una carpeta de almacenamiento

32 de 85

Paso 3: Selecciones el servidor de aplicaciones o Web y una versión de java:

Paso 4: Selecciones un FrameWork:

33 de 85

Paso 5: selecciones la siguiente opción

Paso 6: Ponga nombre al servlet y al package que lo contiene y hacer clic en “Finish”:

34 de 85

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

public class Prueba extends HttpServlet { //Se debe heredar desde la clases HttpServlet

protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //Se debe implementar este método response.setContentType("text/html;charset=UTF-8"); //Procesa datos en html, codificación UTF-8 PrintWriter out = response.getWriter(); //Objeto para mostrar datos try { //Se forma el html out.println("<html>"); out.println("<head>"); out.println("<title>Servlet Prueba</title>"); out.println("</head>"); out.println("<body>"); out.println("<h1>Hola Mundo</h1>"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } }

@Override //Maneja un envío de datos get protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }

@Override //Maneja un envío de datos post protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }

@Override public String getServletInfo() { return "Short description"; }}

35 de 85

Se debe configurar el Netbeans para que la aplicación corra desde este Servlet, desde las “Properties” del proyecto

La ejecución genera:

4.3 MétodosA continuación se describen algunos de los métodos usados con mayor frecuencia en un Servlet y que tiene relación con el objetivo de este capítulo

4.3.1 String getParameter(String name)Método que recupera un parámetro de la request. Devuelve un String con el valor del parámetro o null en caso de que no exista el parámetro que se intenta recuperar.

Vamos a considerar un formulario de ingreso de user y password y vamos a recuperar sus parámetros. Para esto vamos a crear el index.jsp, recuperamos y mostramos los valores en el servlet DataFomulario.java.

36 de 85

<%@page contentType="text/html" pageEncoding="UTF-8"%><!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=UTF-8"> <title>JSP Page</title> </head> <body> <form action="http://localhost:8080/PruebaServlet/DataFomulario" method="post"> <table border="0" align="center"> <tbody> <tr> <td>User: </td> <td><input type="text" name="usuario" value="" /></td> </tr> <tr> <td>Password: </td> <td><input type="password" name="pass" value="" /></td> </tr> <tr align="center"> <td colspan="2"><input type="submit" value="OK" /></td> </tr> </tbody> </table> </form> </body></html>

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

public class DataFomulario extends HttpServlet { protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); String usuario = request.getParameter("usuario"); //Recupera el usuario desde el formulario String pass = request.getParameter("pass"); //Recupera el password desde el formulario

37 de 85

PrintWriter out = response.getWriter(); try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet DataFomulario</title>"); out.println("</head>"); out.println("<body>"); out.println("Usuario: " + usuario); out.println("<p>Password: " + pass); out.println("</body>"); out.println("</html>"); } finally { out.close(); } }

@Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }

@Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }

@Override public String getServletInfo() { return "Short description"; }

}

38 de 85

Para probar se tiene:

Luego el servlet muestra:

Laboratorio: Tiempo estimado, 45 minutos

Se pide crear el siguiente formulario y recuperar y mostrar usando un servlet la siguiente información

39 de 85

4.3.2 String[ ] getParameterValues(String name)

Método que recupera los múltiples valores asociados a un parámetro de la request. Devuelve un array de String con todos los valores del parámetro o null en caso de que no exista el parámetro que se intenta recuperar. El típico ejemplo de uso del método es cuando una lista desplegable tien opción para seleccionar más de un valor:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <form action="http://localhost:8080/Ejemplo1_11/RecuperaMultiple" method="POST"> <table align="center"> <tbody> <tr> <td>Color(es): </td> <td><select name="" multiple> //multiple indica que se puede seleccionar más de un valor <option>Rojo</option> <option>Negro</option> <option>Azul</option> <option>Blanco</option> <option>Naranjo</option> <option>Café</option> <option>Verde</option> <option>Lila</option> </select></td> </tr> <tr> <td colspan="2" align="center">

40 de 85

<input type="submit" value="OK" /> </td> </tr> </tbody> </table> </form> </body></html>

package dat;import java.io.IOException;import java.io.PrintWriter;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

@WebServlet(name="RecuperaMultiple", urlPatterns={"/RecuperaMultiple"})public class RecuperaMultiple extends HttpServlet { protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); String[] color = request.getParameterValues("color"); //Recupera los valores PrintWriter out = response.getWriter(); try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet RecuperaMultiple</title>"); out.println("</head>"); out.println("<body>"); for(String colo: color) //Muestra los valores out.println(colo + "<br />"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } }

@Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response);

41 de 85

}



Resultado:

42 de 85

5. Encapsulación (Java Bean)En programación modular, y más específicamente en programación orientada a objetos, se denomina encapsulamiento al ocultamiento del estado, es decir, de los datos miembro, de un objeto de manera que sólo se puede cambiar mediante las operaciones definidas para ese objeto.Cada objeto está aislado del exterior, es un módulo natural, y la aplicación entera se reduce a un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados a un objeto contra su modificación por quien no tenga derecho a acceder a ellos, eliminando efectos secundarios e interacciones.De esta forma el usuario de la clase puede obviar la implementación de los métodos y propiedades para concentrarse sólo en cómo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado de maneras imprevistas e incontroladas.

Otra definición un tanto más simple: La encapsulación consiste en ocultar la complejidad de una clase e impedir accesos no autorizados

Java, como lenguaje orientado a objetos puro que es, implementa la encapsulación (o encapsulamiento) perfectamente. Este concepto consiste en la ocultación del estado, o lo que es lo mismo, de los datos miembro de un objeto, de forma que sólo es posible modificar los mismos mediante las operaciones (métodos, en Java) definidos para dicho objeto. Más específicamente:Para implementar la encapsulación en java debemos:

• Declara nuestras variable de instancia de la clase como private• Inicializar las variables en sus valores por defecto o los convenientes para el desarrollo• Se debe declarar al menos un método constructor de la clase sin parámetros• Para cada variable declarar métodos accesadores (conocidos como métodos get) y

métodos mutadores (conocidos como métodos set)

5.1 Métodos accesadores: getLos métodos que utilizan formas estándar de recuperación de datos de un objeto se denominan accesores.

5.2 Métodos mutadores: setLos métodos estándar establecen, recuperan o cambian los datos de un objeto

43 de 85

5.3 EjemploPor ejemplo, si consideramos la clase estudiante con los atributos “edad” y “nota”, se tiene:

package dat;

public class Estudiante { private int edad=0; private double nota =0.0; public Estudiante(){ }

public int getEdad() { return edad; }

public void setEdad(int edad) { this.edad = edad; }

public double getNota() { return nota; }

public void setNota(double nota) { this.nota = nota; }}

Con estos métodos se pueden incorporar restricciones a los valores ingresados . Por ejemplo, en el caso de la edad se pueden permitir sólo valores > 0 ó cero. Así el método sería ahora:

44 de 85

void setEdad(int edad){ if(edad <= 0) this.edad = 0; else this.edad= edad; }

También se puede, por ejemplo, en el caso de la nota permitir sólo valores entre 1.0 y 7.0, asignado 1.0 para otros casosvoid setNota(double nota){ if (nota >=1.0 && nota <=7.0) this.nota = nota; else this.nota = 1.0 }

45 de 85

6. JDBCJava Database Connectivity, más conocida por sus siglas JDBC, es una API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java, independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto SQL del modelo de base de datos que se utilice.

El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo específico de base de datos. Un manejador de conexiones hacia un modelo de base de datos en particular es un conjunto de clases que implementan las interfaces Java y que utilizan los métodos de registro para declarar los tipos de localizadores a base de datos (URL) que pueden manejar. Para utilizar una base de datos particular, el usuario ejecuta su programa junto con la biblioteca de conexión apropiada al modelo de su base de datos, y accede a ella estableciendo una conexión, para ello provee el localizador a la base de datos y los parámetros de conexión específicos. A partir de allí puede realizar con cualquier tipo de tareas con la base de datos a las que tenga permiso: consulta, actualización, creación, modificación y borrado de tablas, ejecución de procedimientos almacenados en la base de datos, etc.

La especificación se encuentra en:

http://java.sun.com/javase/6/docs/technotes/guides/jdbc/

6.1 ¿Qué la API de JDBC 2.0 IncluyeLa API de JDBC 2.0 incluye todas las de la API que es parte de Java SE, y también la API de JDBC en la extensión estándar de la API. La lista siguiente se definen diversos términos utilizados para hablar de la API de JDBC.

La API de JDBC completa, incluyendo el paquete tanto la java.sql (el API de JDBC 2.0 Core) y el paquete de javax.sql (la extensión estándar de la API de JDBC). El J2EE, incluye el total de la API de JDBC 2.0.

La API de JDBC que es parte de Java SE, que incluye la API de JDBC 1.0, más la nueva API de JDBC añadido en el paquete java.sql. Algunas de las nuevas características de este paquete son los conjuntos de resultados desplazable, actualizaciones de proceso por lotes, actualizaciones de programas, y apoyo los nuevos tipos de SQL3.

46 de 85

La API javax.sql, puede ser descargado de http://java.sun.com/products/jdbc. Este paquete hace que sea más fácil de construir aplicaciones de servidor utilizando la plataforma Java, proporcionando una arquitectura abierta que soporta pool de conexiones y de las transacciones distribuidas que abarcan varios servidores de base de datos. La API de DataSource desempeña un papel integral en estas capacidades y también trabaja con los nombres de JavaTM y Directorio Interfacetm (JNDI) para mejorar la portabilidad y hacer más fácil el mantenimiento del código. El paquete de javax.sql también proporciona la API de RowSet lo que hace que sea fácil de manejar conjuntos de datos desde prácticamente cualquier fuente de datos como componentes JavaBeansTM.

El paquete java.sql el API de JDBC 2.0 Core, que incluye el API de JDBC 1.0, más la nueva API añadido en el J2SE

En consonancia con la política de mantener la compatibilidad hacia atrás, las aplicaciones escritas usando la API de JDBC 1.0 seguirá funcionando tanto con el Java y J2EE, al igual que siempre han corrido. Aplicaciones de las funciones utilizando añadido en la API de JDBC 2.0, por supuesto, deben ser ejecutados con un controlador compatible con estas características.

6.2 ¿Qué es la API de JDBC?La API de JDBC es una API de Java para acceder a prácticamente cualquier tipo de datos. La API de JDBC consiste en un conjunto de clases e interfaces escritas en Java lenguaje de programación que proporciona un API estándar para la herramienta / desarrolladores de bases de datos y permite escribir aplicaciones de bases de datos usando una fuerza industrial de todas las API de Java.

La API de JDBC hace que sea fácil enviar comandos SQL a los sistemas de bases de datos relacionales y apoya todos los dialectos de SQL. Pero la API de JDBC 2.0 va más allá de SQL, también por lo que es posible interactuar con otros tipos de fuentes de datos, como archivos.

El valor de la API de JDBC es que una aplicación puede acceder a prácticamente cualquier fuente de datos y ejecutar en cualquier plataforma con una máquina virtual de Java. En otras palabras, con la API de JDBC, no es necesario escribir un programa para acceder a una base de datos Sybase, otro programa para acceder a una base de datos Oracle, otro programa para acceder a una base de datos DB2 de IBM, y así sucesivamente. Uno puede escribir un solo programa usando el API de JDBC, y el programa será capaz de enviar de SQL u otras declaraciones a la fuente de datos adecuado. Y, con una aplicación escrita en el lenguaje de programación Java, uno no tiene que preocuparse acerca de la escritura para ejecutar las diferentes aplicaciones en diferentes plataformas. La combinación de la plataforma Java y la API de JDBC permite al programador escribir una vez y ejecutar en cualquier lugar.

El lenguaje de programación Java, siendo robusto, seguro, fácil de usar, fácil de entender, y descargar automáticamente en una red, es una base excelente para aplicaciones de lenguaje de base de datos. Lo que se necesita es una manera para las aplicaciones Java para hablar con una variedad de diferentes fuentes de datos. JDBC es el mecanismo para hacer esto.

47 de 85

Directores de MIS, como la combinación de la plataforma Java y la tecnología JDBC porque hace que la difusión de información fácil y económica. Las empresas pueden seguir utilizando sus bases de datos instaladas y acceso a la información fácilmente, incluso si se almacena en distintos sistemas de gestión de bases de datos u otras fuentes de datos. El tiempo de desarrollo de nuevas aplicaciones es corto. De instalación y control de versiones son muy simplificado. Un programador puede escribir una aplicación o una actualización de una vez, lo puso en el servidor, y todo el mundo tiene acceso a la última versión. Y para las empresas que venden servicios de información, la combinación de la tecnología Java y JDBC ofrece una mejor forma de salir actualizaciones de la información a los clientes externos.

6.3 ¿Qué hace la API de JDBC hacer?En términos simples, una tecnología basada en JDBC driver (controlador JDBC ") permite hacer tres cosas:

1. Establecer una conexión con una fuente de datos

2. Enviar consultas y actualizar las declaraciones a la fuente de datos

3. Proceso de los resultados

6.4 Conexión de Información generalUn objeto Connection representa una conexión con una base de datos. Una sesión de conexión incluye las instrucciones SQL que se ejecutan y los resultados que se devuelven en la conexión. Una sola aplicación puede tener una o más conexiones con una sola base de datos, o puede tener conexiones con muchas bases de datos diferentes.

Un usuario puede obtener información sobre la base de datos un objeto de Connection invocando el método de Connection.getMetaData. Este método devuelve un objeto DatabaseMetaData que contiene información sobre tablas de la base de datos, la gramática de SQL que soporta, sus procedimientos almacenados, las capacidades de esta conexión, y así sucesivamente.

6.5 Establecer una conexiónLa forma tradicional de establecer una conexión con una base de datos es llamar a la DriverManager.getConnection método. Este método toma una cadena que contiene una dirección URL. La clase DriverManager conocida como la capa de gestión de JDBC, intenta localizar un controlador que puede conectarse a la base de datos correspondiente a dicha URL. La clase DriverManager mantiene una lista de clases Driver registrados, y cuando el getConnection método se llama, comprueba con cada conductor en la lista hasta que encuentre uno que pueda conectarse

48 de 85

a la base de datos especificada en la URL. El método de Driver connect utiliza esta URL para realmente establecer la conexión.

El código siguiente es un ejemplo de la apertura de una conexión a una base de datos ubicada en la “jdbc:odbc:wombat” con un ID de usuario de “oboy” y “12Java” como la contraseña:

String url = "jdbc:odbc:wombat";Connection con = DriverManager.getConnection(url, "oboy", "12Java");

El JDBC 2.0 proporciona la interfaz DataSource como una alternativa a la DriverManager para establecer una conexión. Cuando una clase DataSource se ha aplicado adecuadamente, el objeto DataSource se puede utilizar para producir objetos Connection que participan en la agrupación de conexiones y / o objetos Connection que pueden participar en transacciones distribuidas. DataSource es la alternativa preferida para la creación de una conexión.

Una aplicación utiliza un objeto Connection producido por DataSource de manera esencialmente es la misma que utiliza un objeto Connection producido por el DriverManager.

Si un objeto Connection es parte de una transacción distribuida, una aplicación no debe llamar a los métodos Connection.commit o Connection.rollback, el modo de confirmación. Estos pudieran interferir con el manejo del administrador de transacciones distribuida.

6.6 URL de Uso GeneralCuando una aplicación que utiliza el DriverManager para crear un objeto Connection debe proveer una dirección URL para el método DriverManager.getConnection. Dado que las direcciones URL a menudo causan una cierta confusión, lo primero que le dará una breve explicación de las direcciones URL en general y luego ir a una discusión de JDBC URL.

La primera parte de una URL especifica el protocolo usado para acceder a la información, y siempre es seguido por dos puntos. Algunos protocolos comunes son ftp que especifica "file transfer protocol" y http que especifica "protocolo de transferencia de hipertexto". Si el protocolo es file se indica que el recurso está en un sistema de archivos local en lugar de en Internet.

ftp://javasoft.com/docs/JDK-1_apidocs.ziphttp://java.sun.com/products/JDK/CurrentReleasefile:/home/haroldw/docs/tutorial.html

El resto de la URL, todo después de los primeros dos puntos, da información sobre dónde se encuentra la fuente de datos. Si el protocolo es file el resto de la URL es la ruta para el archivo. Para el ftp protocolos y http el resto de la dirección identifica al host y, opcionalmente, puede dar una ruta de acceso a un sitio más específico.

49 de 85

6.7 JDBC URLUna URL JDBC proporciona una forma de identificar una fuente de datos para que el controlador apropiado lo reconocerá y establecer una conexión con él. Driver escritores son los que realmente determinar cuál es la URL de JDBC que identifica a un conductor particular será. Los usuarios no tendrán que preocuparse sobre cómo formar una URL JDBC, sino que simplemente utilizan la URL suministrado con los controladores que están utilizando. Papel de JDBC es recomendar algunas convenciones para los escritores de conductor a seguir en la estructuración de sus JDBC URL.

La sintaxis estándar para JDBC URL se muestra aquí. Consta de tres partes, que están separados por dos puntos.

jdbc:<subprotocol>:<subname>

Las tres partes de una URL JDBC se desglosan de la siguiente manera:

1. jdbc en el protocolo. El protocolo en una URL JDBC es siempre jdbc

2. <subprotocol> nombre del conductor o el nombre de un mecanismo de conectividad de

bases de datos, que puede ser apoyado por uno o más conductores. Un ejemplo destacado de un nombre de Subprotocolo es odbc que ha sido reservado para las URL que especifique los nombres de datos ODBC estilo de fuente. Por ejemplo, para acceder a una base de datos a través de un puente JDBC-ODBC, se podría utilizar una URL como la siguiente:

jdbc:odbc:fred

3. <subname> manera de identificar la fuente de datos. El subname puede variar,

dependiendo de la Subprotocolo, y puede tener cualquier sintaxis interna del escritor conductor elija, incluyendo un subsubname. El punto de un subname es dar suficiente información para localizar el origen de datos. En el ejemplo anterior, fred es suficiente porque ODBC proporciona el resto de la información. Una fuente de datos en un servidor remoto requiere más información, sin embargo. Si la fuente de datos es accesible a través de Internet, por ejemplo, la dirección de red debe incluirse en la URL JDBC como parte de la subname y deben adherirse a la dirección siguiente convención de nomenclatura estándar:

//hostname:port/subsubname

6.8 Liberación DBMS RecursosSe recomienda que los programadores de cerrar explícitamente las conexiones y las declaraciones que han creado cuando ya no son necesarios.

Un programador de escribir código en el lenguaje de programación Java y que no utilice

50 de 85

ninguna de recursos externos, no necesita preocuparse por la gestión de memoria. El recolector de basura elimina automáticamente los objetos cuando ya no se utiliza y libera la memoria que se utiliza. Cuando la memoria se está agotando, se reciclan los objetos desechados, haciendo que la memoria que ocupan actualmente disponible para la reutilización rápida.

Sin embargo, si una aplicación utiliza los recursos externos, como lo hace cuando tiene acceso a un DBMS con la API de JDBC, el recolector de basura no tiene manera de conocer el estado de esos recursos. Por lo tanto, se recomienda que los programadores explícitamente cerrar todas las conexiones (con el método Connection.close y declaraciones con el método Statement.close tan pronto como ya no son necesarios, liberando así recursos DBMS tan pronto como sea posible. Esto se aplica especialmente a las aplicaciones que están destinados a trabajar con DBMS diferentes debido a las variaciones de un SGBD a otro.

Tenga en cuenta que el método Connection.isClosed está garantizada para regresar true sólo cuando es llamado por el método de Connection.close ha sido llamado. Como resultado de ello, un programador no puede depender de este método para indicar si la conexión es válida o no. En cambio, un cliente típico de JDBC puede determinar que una conexión no es válida por la captura de la excepción que se produce cuando se intenta una operación de JDBC.

6.9 DriverManager Información generalLa clase DriverManager es la capa de gestión tradicional de JDBC, de trabajo entre el usuario y los controladores. Se realiza un seguimiento de los controladores que están disponibles y se ocupa de establecer una conexión entre una base de datos y el controlador apropiado. Además, la clase DriverManager atiende a aspectos como los plazos de acceso y el controlador de impresión de registro y mensajes de seguimiento.

Para aplicaciones simples, el único método en la clase DriverManager que un programador en general necesita usar directamente es DriverManager.getConnection. Como su nombre lo indica, este método se establece una conexión a una base de datos.

6.10 Crear una conexiónPara esto se va a crear una clase que proporciones el servicio y en la cual se puedan configurar “en duro” sus parámetros.

package conec;

public class ConexionBD { private static String url= "jdbc:mysql://localhost/dgac"; //Se conecta a la base de datos dgac private static String user= "root"; //El usuario es “root”

51 de 85

private static String pass= "root"; //La clave del usuario root es “root” public static String getDriver() { String driver= "com.mysql.jdbc.Driver"; //Declara el Driver a usar return driver; }

public static String getUrl() { //Retorna la url con la ubicación de la base de datos return url; }

public static String getUser() { //Retorna el usuario de conexión a la base de datos return user; }

public static String getPass() { //Retorna el password del usuario de conexión a la base de datos return pass; }}

Insertar datos

Vamos a considera el siguiente formulario para trabajar con la tabla “cliente” en la base de datos “dgac”:

create table alumno(

rut varchar(50),

edad int,

sexo boolean,

primary key(rut)

);

52 de 85

Se debe declarar el driver según se muestra:

53 de 85

El resultado de esto se puede preciar:

EL JSP que pide la información es:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <form action="http://localhost:8080/Ejemplo1_20/ProcesaInsertar" method="POST"> <table border="1" align="center"> <tbody> <tr> <td>Rut: </td> <td><input type="text" name="rut" value="" /></td> </tr> <tr> <td>Edad: </td> <td><select name="edad"> <option>20</option> <option>21</option> <option>22</option> <option>23</option> <option>24</option> <option>25</option> <option>26</option> <option>27</option> <option>28</option>

54 de 85

<option>29</option> <option>30</option> </select></td> </tr> <tr> <td>Sexo: </td> <td><input type="radio" name="sexo" value="1" />Mujer <input type="radio" name="sexo" value="0" />Hombre</td> </tr> <tr align="center"> <td colspan="2"><input type="submit" value="OK" /></td> </tr> </tbody> </table> </form> </body></html>

El siguiente servlet recibe los datos y los procesa llamando a la clase que provoca la conexión:

package proc;

import conec.ConexionBD;import java.io.IOException;import java.io.PrintWriter;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.Statement;import java.util.logging.Level;import java.util.logging.Logger;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

@WebServlet(name="ProcesaInsertar", urlPatterns={"/ProcesaInsertar"})public class ProcesaInsertar extends HttpServlet {

55 de 85

protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); int n=0; String rut = request.getParameter("rut"); //Recupera rut int edad = Integer.parseInt(request.getParameter("edad")); //Recupera edad int sexo = Integer.parseInt(request.getParameter("sexo")); //Recupera sexo PrintWriter out = response.getWriter();

try { Class.forName(ConexionBD.getDriver()); //Declara el driver a usar } catch (ClassNotFoundException ex) { Logger.getLogger(ProcesaInsertar.class.getName()).log(Level.SEVERE, null, ex); } try { Connection con = DriverManager.getConnection(ConexionBD.getUrl(), ConexionBD.getUser(), ConexionBD.getPass()); //Crea el objeto de conexión Statement st = con.createStatement(); //Crear el objeto para proceso

String SQL=" insert into cliente (rut,edad,sexo) values (' "+ rut + "'," + edad + "," + sexo + ");"; //Crear la SQL para insertar el registro n = st.executeUpdate(SQL); //Ejecuta el proceso de insertar el registro st.close(); //cierra el objeto con.close(); //cierra el objeto } catch (SQLException ex) { Logger.getLogger(ProcesaInsertar.class.getName()).log(Level.SEVERE, null, ex); }

if(n==0){ try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("NO se inserto el registro"); out.println("</body>"); out.println("</html>");

56 de 85

} finally { out.close(); } } else { try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("SI se inserto el registro"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } } }




57 de 85

Los datos usados para las pruebas fue:

Observación: Es una mala técnica el ejecutar todo el proceso es una sola clase (en este caso el servlet). En el capítulo II se desarrolla el mismo proceso usando el patrón de diseño MVC que proporciona una mejor estructuración de la programación para ejecutar mantenciones.

6.11 Eliminar datosSiguiendo con el ejemplo anterior vamos a pedir el rut y procedemos a eliminar el registro asociado. Los registros insertados en la tabla son:

58 de 85

El JSP que lee el rut:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Elimina</title> </head> <body> <form action="http://localhost:8080/Ejemplo1_20/ProcesaEliminar" method="POST"> <table border="1" align="center"> <tbody> <tr> <td>Rut: </td> <td><input type="text" name="rut" value="" /></td> </tr> <tr align="center"> <td colspan="2"><input type="submit" value="OK" /></td> </tr> </tbody> </table> </form> </body></html>

El servlet que elimina el registro:

package proc;

import conec.ConexionBD;import java.io.IOException;import java.io.PrintWriter;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;

59 de 85

import java.sql.Statement;import java.util.logging.Level;import java.util.logging.Logger;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

@WebServlet(name="ProcesaEliminar", urlPatterns={"/ProcesaEliminar"})public class ProcesaEliminar extends HttpServlet { protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); int n=0; String rut = request.getParameter("rut"); //Lee el rut PrintWriter out = response.getWriter();

try { Class.forName(ConexionBD.getDriver()); } catch (ClassNotFoundException ex) { Logger.getLogger(ProcesaEliminar.class.getName()).log(Level.SEVERE, null, ex); } try { Connection con = DriverManager.getConnection(ConexionBD.getUrl(), ConexionBD.getUser(), ConexionBD.getPass()); Statement st = con.createStatement();

String SQL=" delete from cliente where rut='" + rut +"';"; //Elimina el registro n = st.executeUpdate(SQL); st.close(); con.close(); } catch (SQLException ex) { Logger.getLogger(ProcesaEliminar.class.getName()).log(Level.SEVERE, null, ex); }

if(n==0){ try { out.println("<html>");

60 de 85

out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("NO se elimino el registro"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } } else { try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("SI se elimino el registro"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } } }



@Override

61 de 85

public String getServletInfo() { return "Short description"; }}

6.12 Actualiza registroEl objeto es recuperar los rut en una “lista desplegable” comenzando por recuperar los datos del primer registro y luego dependiendo de la elección de rut de la “lista desplegable” mostrar los datos correspondientes. Esto se ha programado:

1. Recuperan desde la base de datos en el JSP usando JDBC

2. Almacenar esta información en un Array manejado por Javascript que muestra la

información particular de cada registro.

El código comentado es:

62 de 85

<html> <head> <%@page import="java.sql.*" %> //Importa package <%@page import="java.util.Vector" %> <%@page import="conec.*" %> <%@page import="bean.*" %>

<% Vector<Cliente> dat = new Vector<Cliente>(); //Almacena los datos recuperados try { Class.forName(ConexionBD.getDriver()); } catch (ClassNotFoundException ex) { } try { Connection con = DriverManager.getConnection(ConexionBD.getUrl(), ConexionBD.getUser(), ConexionBD.getPass()); Statement st = con.createStatement(); String SQL=" select rut, edad, sexo from cliente order by 1;"; //Consulta ResultSet rs = st.executeQuery(SQL); //Manda a ejecución la consulta while(rs.next()){ //Recupera los registros String rutRecupera = rs.getString(1); int edadRecupera = rs.getInt(2); int sexoRecupera = rs.getInt(3);

//Almacena la información en el Vector dat.add(new Cliente(rutRecupera, edadRecupera, sexoRecupera)); } st.close(); rs.close(); con.close(); } catch (SQLException ex) { } String[] rut = new String[dat.size()]; //Almacena los rut recuperados int[] edad = new int[dat.size()]; //Almacena las edades recuperados int[] sexo = new int[dat.size()]; //Almacena el sexo recuperado

//Almacena la información en los arreglos anteriores

63 de 85

int i=0; for(Cliente dato: dat){ rut[i] = dato.getRut(); edad[i] = dato.getEdad(); sexo[i] = dato.getSexo(); i++; } %> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Actualizar</title> <script language="javascript" type="text/javascript"> //Array para almacenar los datos desde java a javascript var rutJS = new Array(); var edadJS = new Array(); var sexoJS = new Array(); var rangoEdad = new Array(20,21,22,23,24,25,26,27,28,29,30); //Función que se gatilla en la partida del formulario llamado desde el body del html function partida() {

//Transfiere los datos desde java a Javascript <% for (i=0; i<rut.length; i++) { %> rutJS[<%= i %>] = "<%= rut[i] %>"; edadJS[<%= i %>] = "<%= edad[i] %>"; sexoJS[<%= i %>] = "<%= sexo[i] %>"; <% } %>

//Asigna el largo de la lista desplegable de los rut document.getElementById("Select1").length = rutJS.length; for (i = 0; i < rutJS.length; i++) { //Valor que se devuelve desde el select document.getElementById("Select1").options[i].value = rutJS[i]; //Valor que se muestra en el select document.getElementById("Select1").options[i].text = rutJS[i]; }

//Asigna el largo de la lista desplegable de los años document.getElementById("Select2").length = rangoEdad.length; for (i = 0; i < rangoEdad.length; i++) { //Valor que se devuelve desde el select document.getElementById("Select2").options[i].value = rangoEdad[i]; //Valor que se muestra en el select document.getElementById("Select2").options[i].text = rangoEdad[i]; }

//Busca la edad del primer cliente y la muestra en la lista desplegable

64 de 85

for(i=0;i<rangoEdad.length;i++) if((i+20)==edadJS[0]) document.getElementById("Select2").selectedIndex=i;

//Busca el sexo del primer cliente y la muestra en los RadioButtom if(sexoJS[0]==1) document.getElementsByName("sexo").item(0).checked=true; if(sexoJS[0]==0) document.getElementsByName("sexo").item(1).checked=true; } //Función que se gatilla cada vez que se selecciona un nuevo rut llamado desde Select1 function cambia() {

//Recupera el índice desde el rut (0,1,2,...) var n = document.getElementById("Select1").selectedIndex; //Aquí se desarrollan dos procesos: 1: Busca el índice en el Array rangoEdad que tiene el //valor de edad buscado (edadJS[n]). 2: Ese índice es transferido a la lista desplegable //del la edad y así se muestra el valor asociado for(i=0;i<rangoEdad.length;i++) if((i+20)==edadJS[n]) document.getElementById("Select2").selectedIndex=i; //Recupera el valor del sexo buscado (sexoJS[n]) y dependiendo del valor lo muestra if(sexoJS[n]==1) document.getElementsByName("sexo").item(0).checked=true; if(sexoJS[n]==0) document.getElementsByName("sexo").item(1).checked=true; } </script> </head> <body onload="partida();"> //En la partida del formulario llama los iniciales del primer registro <form id="Form1" name="form1" action="http://localhost:8080/Ejemplo1_20/ProcesaActualizar" method="POST"> <table style="width: 300px;"> <tr> <td> Rut: </td> <td>

//Llama a la función cada vez que se produce un cambio <select id="Select1" name="rut" onchange="cambia();"> <option></option> </select>

65 de 85

</td> </tr> <tr> <td> Edad: </td> <td> <select id="Select2" name="edad"> <option></option> </select> </td> </tr> <tr> <td> Sexo: </td> <td> <input type="radio" name="sexo" value="1" />Mujer <input type="radio" name="sexo" value="0" />Hombre </td> </tr> </table> </form> </body></html>

Los datos en la tabla son:

66 de 85

Al partir el formulario se tiene:

Al hacer clic sobre uno de los rut:

La segunda parte es almacenar los datos recuperados desde el formulario:

package proc;

import conec.ConexionBD;import java.io.IOException;import java.io.PrintWriter;

67 de 85

import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.Statement;import java.util.logging.Level;import java.util.logging.Logger;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

@WebServlet(name="ProcesaActualizar", urlPatterns={"/ProcesaActualizar"})public class ProcesaActualizar extends HttpServlet { protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); int n=0; String rut = request.getParameter("rut"); int edad = Integer.parseInt(request.getParameter("edad")); int sexo = Integer.parseInt(request.getParameter("sexo")); PrintWriter out = response.getWriter();

try { Class.forName(ConexionBD.getDriver()); } catch (ClassNotFoundException ex) { Logger.getLogger(ProcesaEliminar.class.getName()).log(Level.SEVERE, null, ex); } try { Connection con = DriverManager.getConnection(ConexionBD.getUrl(), ConexionBD.getUser(), ConexionBD.getPass()); Statement st = con.createStatement();

String SQL=" update cliente " + " set edad =" +edad+ "," + " sexo="+sexo+ " where rut='"+rut+"';"; n = st.executeUpdate(SQL); st.close();

68 de 85

con.close(); } catch (SQLException ex) { Logger.getLogger(ProcesaEliminar.class.getName()).log(Level.SEVERE, null, ex); }

if(n==0){ try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("NO se actualizo el registro"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } } else { try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ProcesaInsertar</title>"); out.println("</head>"); out.println("<body>"); out.println("SI se actualizo el registro"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } } }


69 de 85



Los datos de prueba son:

70 de 85

Los datos en la base de datos son:

6.13 Listar informaciónEL JSP que llama al servlet que proceso los datos:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <form action="http://localhost:8080/Ejemplo1_20/ListaInformacion" method="POST"> <table border="0" align="center"> <tbody> <tr> <td><input type="submit" value="OK" /></td> </tr> </tbody> </table>

</form> </body></html>

EL servlet de proceso es:

package proc;

import bean.Cliente;import conec.ConexionBD;import java.io.IOException;

71 de 85

import java.io.PrintWriter;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.Vector;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;

@WebServlet(name="ListaInformacion", urlPatterns={"/ListaInformacion"})public class ListaInformacion extends HttpServlet { protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); Vector<Cliente> dat = new Vector<Cliente>();

PrintWriter out = response.getWriter();

try { Class.forName(ConexionBD.getDriver()); } catch (ClassNotFoundException ex) {

} try { Connection con = DriverManager.getConnection(ConexionBD.getUrl(), ConexionBD.getUser(), ConexionBD.getPass()); Statement st = con.createStatement();

String SQL=" select rut, edad, sexo from cliente order by 1;";

ResultSet rs = st.executeQuery(SQL);

while(rs.next()){ String rutRecupera = rs.getString(1); int edadRecupera = rs.getInt(2);

72 de 85

int sexoRecupera = rs.getInt(3); dat.add(new Cliente(rutRecupera, edadRecupera, sexoRecupera)); } st.close(); rs.close(); con.close(); } catch (SQLException ex) {

}

try { out.println("<html>"); out.println("<head>"); out.println("<title>Servlet ListaInformacion</title>"); out.println("</head>"); out.println("<body>"); out.println("<table align='center' border='1'>"); out.println("<tr><td>Edad</td><td>Años</td><td>Sexo</td></tr>"); String sexoTipo = ""; int i=0; for(Cliente dato: dat){ if(dato.getSexo()==1) sexoTipo="Mujer"; else sexoTipo="Hombre"; out.println("<tr><td>"+dato.getRut()+"</td><td>"+dato.getEdad()+"</td><td>"+sexoTipo+"</td></tr>"); i++; } out.println("</table>"); out.println("</body>"); out.println("</html>"); } finally { out.close(); } }

@Override protected void doGet(HttpServletRequest request, HttpServletResponse response)

73 de 85

throws ServletException, IOException { processRequest(request, response); }



El resultado es:

74 de 85

7. Instalación de PostgreSQLVamos a ver la instalación de la versión 8.4.2-1

Paso 1

Paso 2:

75 de 85

Paso 3:

Paso 4: Poner password al super-usuario, por ejemplo “tabu2000”

76 de 85

Paso 5: Seleccionar el puerto

Paso 6:

77 de 85

Paso 7:

Paso 8:

78 de 85

Paso 9:

Paso 9:

79 de 85

Paso 10:

Para bajar el Driver de JDBC2, JDBC3 ó JDBC4 se debe acceder a:

http://www.postgresql.org/download/products/2

80 de 85

Bajar la versión JDBC4 Postgresql Driver, Version 8.4-701

81 de 85

Paso 11:

Paso 12:

82 de 85

Paso 13:

Paso 14:

83 de 85

Paso 15:

Paso 16:

84 de 85

Paso 17:

85 de 85

capítulo 1.2-JSP-Servlet(1)

Documents

Transcript of capítulo 1.2-JSP-Servlet(1)