Practica JSP AJAX JPA NETBEANS 8 2 2016

UNIVERSIDAD AUTONOMA DE COLOMBIA
FUAC
FACULTAD DE INGENIERIA
PROGRAMA INGENIERÍA DE SISTEMAS
PRACTICA JSP_AJAX_JPA NETBEANS 8.XX
MARIO DUSTANO CONTRERAS CASTRO
DOCENTE CATEDRA
BOGOTA, COLOMBIA OCTUBRE DE 2016
PRIMER ANTECEDENTE. Interfaz de Persistencia Java (JPA) - Entidades y
Managers
Tomado de: http://www.lab.inf.uc3m.es/~a0080802/RAI/jpa.html
Java Persistence API (JPA) proporciona un modelo de persistencia basado en
POJO's para mapear bases de datos relacionales en Java. Para ello, combina
ideas y conceptos de los principales frameworks de persistencia, como
Hibernate, Toplink y JDO. El mapeo objeto-relacional (es decir, la relación entre
entidades Java y tablas de la base de datos, queries con nombre, etc) se
realiza mediante anotaciones en las propias clases de entidad.
Pero para entender JPA, tendremos que tener claro el concepto "persistencia"
La persistencia o el almacenamiento permanente, es una de las necesidades
básicas de cualquier sistema de información de cualquier tipo. En primer lugar,
se propuso que el programa tratara los datos haciendo consultas directas a la
base de datos. Después, se propuso trabajar con objetos, pero las bases de
datos tradicionales no admiten esta opción.
Debido a esta situación, aparecieron los motores de persistencia, cuya función
es traducir entre los dos formatos de datos: de registros a objetos y de objetos
a registros. Persistir objetos Java en una base de datos relacional implica
serializar un árbol de objetos Java en una base de datos de estructura
tabular y viceversa. Esencial es la necesidad de mapear objetos Java para
optimizar velocidad y eficiencia de la base de datos
Unidades de persistencia
La unidad de persistencia define un conjunto de todas las entidades (clases)
que son gestionadas por la instancia del EntityManager en una aplicación. Este
conjunto de clases de entidad representa los datos contenidos en una única
BBDD.
Las unidades de persistencia se definen en el fichero de configuración
persistence.xml. Aquí les mostramos un ejemplo:
<persistence>
<persistence-unit name="OrderManagement">
<description>...</description>
<jta-data-source>jdbc/MyOrderDB</jta-data-source>
<jar-file>MyOrderApp.jar</jar-file>
<class>com.widgets.Order</class>
<class>com.widgets.Customer</class>
</persistence-unit>
</persistence>
Este archivo define una unidad de persistencia llamada OrderManagement
Jar-file especifica los ficheros JAR en los que se encuentran las clases
persistentes
jta-data-source especifica el nombre global JNDI de la fuente de datos que
utiliza el contenedor.
La persistencia puede tener 4 estados diferentes:
Transient: Un objeto recién creado que no ha sido enlazado con el
gestor de persistencia.
Persistent: Un objeto enlazado con la sesión (Todos los cambios serán
persistentes).
Detached: Un objeto persistente que sigue en memoria después de que
termina la sesión: existe en java y en la BDD.
Removed: Un objeto marcado para ser eliminado de la BBDD: existe en
java y se borrará de la BDD al terminar la sesión.
JPA - Entity Manager
Antes que nada tenemos que tener bien en claro dos temas muy importanes
que son:
Application-managed entity manager
Container-managed entity manager
Para las situaciones en donde no requerimos los servicios ofrecidos por un EJB
Container, pero querremos utilizar el modelo de persistencia de JPA, el API
JPA provee el Application-managed entity manager. En estos casos las
aplicaciones son denominadas aplicaciones standalone. Estas aplicaciones que
corren fuera de un EJB container (porque no lo necesitan) usaran el resourcelocal transaction provisto por el entity manager, lo que permite que la aplicacion
será la encargada de manejar el ciclo de vida del entity manager. Para las
situaciones en donde si se requiera de los servicios de un EJB container (como
por ejemplo JBoss ó WebLogic application server), el API JPA provee el
Container-managed entity manager.
Siempre que una transacción sea iniciada, un nuevo contexto de persistencia
(persistence context) es creado. Esto es así tanto para el Application-managed
entity manager como también para el Container-managed entity manager: Para
el caso del Application-managed entity manager (cuando no usamos un
application server), la aplicación es la encargada de abrir y cerrar la
transacción.
Para el caso del Container managed entity manager (cuando utilizamos un ejb
container), por defecto, la transacción es iniciada cuando se invoque desde el
cliente al EJB (a un stateless session bean, ahora bien, para los stateful
session bean el comportamiento de las transacciones es distinto). La
transacción termina cuando finaliza la ejecucion del metodo del session bean.
Interfaces JPA
Los 4 tipos de interfaces de las que se compone JPA son:
javax.persistence.Persistence: Contiene métodos estáticos de ayuda
para obtener una instancia de Entity Manager Factory de una forma
independiente al vendedor de la implementación de JPA. Una clase de
inicialización que va proporcionar un método estático para la creación de
una Entity Manager Factory.
javax.persistence.EntityManagerFactory: La clase
javax.persistence.Entity.Manager.Factory nos ayuda a crear objetos de
EntityManager utilizando el patrón de diseño del Factory. Este objeto en
tiempo de ejecución representa una unidad de persistencia particular.
Generalmente va a ser manejado como un singleton y proporciona
métodos para la creación de instancias EntityManager.
javax.persistence.EntityManagerFactory: La clase
javax.persistence.Entity es una anotación Java que se coloca a nivel de
clases Java serializables y que cada objeto de una de estas clases
anotadas representa un registro de una base de datos.
javax.persistence.EntityManager: Es la interfaz principal de JPA
utilizada para la persistencia de las aplicaciones. Cada Entity Manager
puede realizar operaciones CRUD (Create, Read, Update, Delete) sobre
un conjunto de objetos persistentes. Es un objeto único, no compartido
que representa una unidad de trabajo particular para el acceso a datos.
Proporciona métodos para gestionar el ciclo de vida de las instancias
entidad y para crear instancias Query.
javax.persistence.Query: La interface javax.persistence.Query está
implementada por cada vendedor de JPA para encontrar objetos
persistentes manejando cierto criterio de búsqueda. JPA estandariza el
soporte para consultas utilizando Java Persistence Query Language
(JPQL) y Structured Query Language (SQL). Podemos obtener una
instancia de Query desde una instancia de un Entity Manager.
javax.persistence.EntityTransaction: Cada instancia de Entity
Manager tiene una relación de uno a uno con una instancia de
javax.persistence.EntityTransaction, permite operaciones sobre datos
persistentes de manera que agrupados formen una unidad de trabajo
transaccional, en el que todo el grupo sincroniza su estado de
persistencia en la base de datos o todos fallan en el intento, en caso de
fallo, la base de datos quedará con su estado original. Maneja el
concepto de todos o ninguno para mantener la integridad de los datos.
Entidades
Una entidad es un objeto de dominio de persistencia. Normalmente, una
entidad representa una tabla en el modelo de datos relacional y cada instancia
de esta entidad corresponde a un registro en esa tabla.
El estado de persistencia de una entidad se representa a través de campos
persistentes o propiedades persistentes. Estos campos o propiedades usan
anotaciones para el mapeo de estos objetos en el modelo de base de datos.
El estado persistente de una entidad puede ser accesible a través de variables
de instancia a la entidad o bien a través de las propiedades de estilo de
JavaBean.
Las entidades podrán utilizar campos persistentes o propiedades. Si las
anotaciones de mapeo se aplican a las instancias de las entidades, la entidad
utiliza campos persistentes, En cambio, si se aplican a los métodos getters de
la entidad, se utilizarán propiedades persistentes. Hay que tener en cuenta que
no es posible aplicar anotaciones tanto a campos como a propiedades en una
misma entidad.
Una entidad pasara a ser manejada por el contexto de persistencia de JPA
cuando ésta sea persistida (mediante el metodo persist() del Entity Manager).
En este punto, la entidad pasara a estar asociada a lo que comunmente
llamamos el contexto de persistencia. En este caso, y mientras la entidad sea
manejada/asociada por el contexto de persistencia (tambien se las conoce
como entidades atachadas o attached entities), el estado (valores de la
propiedades) de la entidad sera automaticamente sincronizado con la BD.


Campos de persistencia permanente: Si la entidad utiliza campos
persistencia permanente, los accesos se realizan en tiempo de ejecución.
Aquellos campos que no tienen anotaciones del tipo
javax.persistence.Transient o no han sido marcados como Java transitorio
serán persistentes para el almacenamiento de datos. Las anotaciones de
mapeo objeto/relación deben aplicarse a los atributos de la instancia.
Propiedades de persistencia permanente: Si la entidad utiliza
propiedades de persistencia permanente, la entidad debe seguir el método de
los convenios de componentes JavaBeans. Las propiedades de JavaBean
usan métodos getters y setters en cuyo nombre va incluido el atributo de la
clase al cual hacen referencia. Si el atributo es booleano podrá utilizarse
isProperty en lugar de getProperty.
Clases con claves primarias
Una clase con clave primaria debe cumplir los siguientes requerimientos:
El modificador de control de acceso de la clase debe ser público
Las propiedades de la clave primaria deben ser públicas o protected si
se utiliza el acceso a la base de la propiedad.
La clase debe tener un constructor público por defecto.
La clase debe implementar los métodos hashCode() y equals(Object
other)
La clase debe ser serializable.
Una clave primaria debe representarse y mapearse por campos múltiples o
propiedades de la clase de la entidad, o debe representarse y mapearse como
una clase embebida. Si la clave primaria está compuesta por varios campos o
propiedades, los nombres y tipos de campos de la clave primaria o propiedades
en la clave primaria debe coincidir con las de la entidad.
Relaciones múltiples de la entidad
Hay cuatro tipo de relaciones: uno a uno, uno a muchos, muchos a uno, y
muchos a muchos.
Uno a uno: Cada entidad se relaciona con una sola instancia de otra
entidad. Las relaciones uno a uno utilizan anotaciones de la persistencia
de java "OneToOne".
Uno a muchos: Una entidad, puede estar relacionada con varias
instancias de otras entidades. Las relaciones uno a muchos utilizan
anotaciones de la persistencia de java "OneToMany" en los campos o
propiedades persistentes.
Muchos a uno: Múltiples instancias de una entidad pueden estar
relacionadas con una sola instancia de otra entidad. Esta multiplicidad
es lo contrario a la relación uno a muchos. Las relaciones muchos a uno
utilizan anotaciones de la persistencia de java "ManyToOne" en los
campos o propiedades persistentes.
Muchos a muchos: En este caso varias instancias de una entidad
pueden relacionarse con múltiples instancias de otras entidades.Este
tipo de relación utiliza anotaciones de la persistencia de java
"ManyToMany" en los campos o propiedades persistentes.
SEGUNDO ANTECEDENTE. AJAX
Tomado de: http://librosweb.es/libro/ajax/capitulo_1.html
AJAX es el acrónimo de Asynchronous Javascript and XML, es decir: Javascript y
XML Asincrono. Este acrónimo fue utilizado por primera vez por Jesse James Garret
en 2005, en su publicación Ajax: a New Approach to Web Applications si bien los
componentes en que se basan y los recursos técnicos de que hace uso ya existían
desde muchos años antes.
En realidad, el término AJAX es un acrónimo de Asynchronous JavaScript + XML, que
se puede traducir como “JavaScript asíncrono + XML”.
El artículo define AJAX de la siguiente forma:
Ajax no es una tecnología en sí mismo. En realidad, se trata de varias tecnologías
independientes que se unen de formas nuevas y sorprendentes AJAX es el resultado
de la unificación de varias especificaciones y tecnologías que se han definido a partir
de los estándares que el consorcio W3C ha planteado para el diseño web; estas
integran elementos como lenguajes que permiten crear las páginas web, por ejemplo
HTML y XHTML, el conjunto de reglas de estilo que permite mejorar y separar la
apariencia de estas páginas de su contenido usando hojas de estilo CSS, lenguajes
que facilitan la incorporación de metadatos como XML y XSLT, elementos que
permiten hacer la transferencia asíncrona de datos entre el cliente y el servidor por
medio del objeto XMLHttpRequest y el uso de los scripts que agregan la funcionalidad
requerida para ejecutar las peticiones por medio de JavaScript.
Las tecnologías que forman AJAX son:





XHTML y CSS, para crear una presentación basada en estándares.
DOM, para la interacción y manipulación dinámica de la presentación.
XML, XSLT y JSON, para el intercambio y la manipulación de información.
XMLHttpRequest, para el intercambio asíncrono de información.
JavaScript, para unir todas las demás tecnologías.
Figura 1 Tecnologías agrupadas bajo el concepto de AJAX
Desarrollar aplicaciones AJAX requiere un conocimiento avanzado de todas y cada
una de las tecnologías anteriores.
Normalmente, AJAX se define como una técnica para el desarrollo de páginas (sitios)
web que implementan aplicaciones interactivas. No obstante, analicemos un poco
cada una de las palabras que la forman:
XHTML eXtensible Hyper Text Markup Language (lenguaje extensible de
marcado de hipertexto): es un lenguaje de etiquetas que sirve para crear páginas
web, aunque mejora la estructura que se ha definido en el lenguaje HTML.
Como ya se conoce, todas las páginas están hechas en lenguaje HTML
(HyperTextMarkup Language), pero dado el desarrollo del diseño web y la necesidad
de cubrir nuevos requerimientos de los usuarios, las entidades que definen las pautas
en esta área,como el consorcio W3C, pretenden crear páginas con significado, es
decir que las páginas no solo sean un conjunto de elementos,como texto, imágenes y
vínculos, sino que estén asociadas a un significado y además permitan separar
claramente las características que definen la apariencia y la información que se va a
presentar. Por lo cual se desarrolló el estándar XHTML, que es una adaptación de
HTML agregando las capacidades del lenguaje XML, el cual permite que las páginas
contengan elementos con una estructura bien definida y se puedan configurar para ser
presentarlas desde cualquier dispositivo o navegador haciéndolas más flexibles.
CSS Cascading Style Sheets (hojas de estilo en cascada): este estándar, también
definido por el W3C, está muy relacionado con los lenguajes HTML y XHTML, ya que
se encarga de definir el estilo o apariencia de la página web; permite manipular los
formatos de los elementos teniendo en cuenta características como color, posición y
fuentes y mejora la presentación de la información que contiene la página de acuerdo
con el tipo de dispositivo donde se va a visualizar, por lo cual es fácil acceder a las
páginas desde un teléfono celular, una tableta o un computador personal sin que la
presentación se altere.
Las hojas de estilo facilitan el mantenimiento de las páginas web ya que se definen de
forma independiente y separada de la estructura de estas y se convierten en en una
buena práctica para el desarrollo web.
DOM Document Object Model (Modelo de Objetos del Documento): el W3C:
“define la estructura lógica de los documentos y el modo en que se accede y
manipula”; es un API
(Interfaz de Programación de Aplicaciones) que permite a los desarrolladores web
realizar operaciones sobre una página también llamada documento, para agregar,
modificar
o eliminar cualquier objeto o contenido que contenga esta. Por lo general la estructura
de los objetos dentro de la página está definida por una jerarquía de objetos que
tienen relacionadas características y funciones que hacen más fácil su uso desde
cualquier lenguaje de programación.
XML y XSLT XML Stylesheets Language for Transformation (Lenguaje de Estilo
Extensible): es una especificación del W3C que permite definir una plantilla para
transformar documentos XML en otro tipo de documentos, como páginas Web en
HTML y XHTML. Con este lenguaje se pueden crear plantillas que contienen un
conjunto de reglas de transformación aplicadas al documento XML, que también se
llaman reglas de estilo XSLT; estas luego son analizadas por un procesador de XSLT,
el cual hace la transformación para generar el archivo correspondiente para
visualizarlo en un dispositivo específico .Este tipo de transformaciones favorece
separar el contenido de la presentación.
XML HttpRequest (Extensible Markup Language/Hypertext Transfer Protocol): es
un objeto que permite hacer peticiones al servidor de forma asíncrona y sin tener que
actualizar las páginas en las que se hacen dichas peticiones. Este objeto está definido
en todos los navegadores para realizar las acciones de transferencia de datos.
JavaScript: es un lenguaje basado en script desarrollado por Netscape y Sun
Microsystems, que permite agregar funcionalidad y hacer más dinámicas las páginas
web. Los scripts se pueden insertar en el código HTML y este es interpretado por
cualquier navegador, por lo cual se dice que JavaScript se implementa y ejecuta del
lado del cliente, pero también se puede usar del lado del servidor como Server-side
JavaScript o SSJS. Aunque su nombre hace que se relacione con el lenguaje de
programación Java, no son lo mismo, su sintaxis es similar al lenguaje C y permite
definir prototipos de objetos sin necesidad de definir tipos de datos
¿Para qué sirve AJAX?
En esencia, AJAX permite que una página web que ya ha sido cargada solicite
nueva información al servidor. Dicho así, no supondría en realidad ningún invento
novedoso. Una página web que contiene un enlace permite que se solicite al servidor
nueva información cada vez que se pincha dicho enlace. Una página web que contiene
un formulario envía información al servidor y recibe de él nueva información,
normalmente la respuesta ante los datos que se han enviado. En ambos casos hay
una conexión entre el cliente y el servidor.
¿Cuál es la diferencia cuando usamos AJAX? La diferencia es que con AJAX no es
necesario recargar toda la página web, como ocurre cuando pinchamos en un
enlace o cuando pulsamos el botón submit de un formulario. Con AJAX es posible
realizar una conexión a un servidor desde dentro de una página web usando un
programa Javascript. Dicho servidor enviará una respuesta; esta respuesta se
almacenará en una variable del programa Javascript y, una vez almacenada en la
variable, podremos hacer con ella lo que deseemos.
Figura 2: Compración de Modelos de Aplicación Web clásico y basado en Ajax
(imagen original de Adaptive Path)
Por ejemplo, podemos pedirle al servidor que nos indique qué hora tiene y mostrar
dicha hora en el cliente, en una capa dedicada sólo para visualizar este dato. De esta
forma, el usuario podría ver la hora correcta que hay en el servidor (posiblemente
sincronizada por NTP) y esta sería la misma para todos los usuarios conectados a
dicho servidor, sin tener en cuenta la hora que tengan en su ordenador (posiblemente
errónea o susceptible de ser modificada por el usuario). Si actualizamos la hora cada
minuto, sin usar AJAX, tendremos que recargar toda la página cada 60 segundos. Sin
embargo, con AJAX, simplemente actualizaremos la capa que hemos dedicado a
imprimir la hora sin necesidad de alterar el resto de la página.
Funcionamiento del AJAX
El objetivo principal de AJAX es que el usuario pueda disponer del contenido de una
página sin que los tiempos de respuesta hagan que la página esté inactiva por mucho
tiempo. En la figura 3 se puede observar la línea de tiempo que muestra los tiempos
de uso, procesamiento y respuesta que se generan cuando el usuario realiza una
solicitud desde el navegador hacia el servidor, los cuales varían cuando las
aplicaciones web implementan, o no, AJAX.
Figura 3. Lineas de Tiempo AJAX
En el caso en que el usuario accede a una aplicación que no utiliza AJAX, esta es enviada desde el
servidor al navegador donde el usuario puede visualizar y manipular los elementos de la o las
paginas (tiempo de uso de la página en el navegador), y cuando el usuario activa una acción que
requiera ser ejecutada por el servidor, este deberá actualizar la página nuevamente hasta que se
genera la nueva respuesta (tiempo de procesamiento del servidor). Este proceso
incluye el momento en el que se envía la solicitud hasta que la página completa es
visualizada nuevamente en el navegador y depende del tipo de operación que deba
resolver el servidor, lo que genera un tiempo de inactividad en el navegador en el cual
el usuario no recibe ninguna información y se mantiene una página en blanco (tiempo
inactivo en el navegador); es en este tiempo cuando se presentan las demoras que
disminuyen la eficiencia de este tipo de aplicaciones.
Por otra parte, cuando se implementan aplicaciones con AJAX, este proceso tiene
algunas variaciones. Inicialmente el servidor también envía la página completa y el
usuario puede actuar sobre esta, de la misma manera que en el caso anterior, pero
cuando el usuario activa una o varias acciones, estas se realizan con peticiones
asíncronas al servidor generando un proceso que se puede decir que se ejecuta en
paralelo, es decir, mientras el servidor se encarga de procesar la parte de la página
que requiere ser actualizada, en el navegador se mantiene el resto de la página para
que el usuario pueda seguir usando la aplicación. Cuando se obtiene la respuesta del
servidor se podrá actualizar la sección de la página que mostrará los resultados; este
proceso es implementado en Javascript, el cual permite activar un manejador de
eventos que verifica cuándo se ha generado dicha respuesta para realizar la
actualización.
Este proceso hace que el tiempo de procesamiento en el servidor no interfiera con el
tiempo de uso de la página en el navegador, por lo cual hace más rápidos los tiempos
de respuesta.
Curso Completo de AJAX:
http://librosweb.es/libro/ajax/capitulo_1.html
CREACION DE UNA APLICACIÓN CON BASE DE DATOS EN NETBEANS 8.0
INTRODUCCIÓN
Esta Práctica lo orientará cómo utilizar NetBeans con un Framework Básico para
generación de Interfaces de Captura y Consulta de Tablas de una Base de Datos
MySQL
Requisitos



Servidor glassfish
MySQL Server
NetBeans con JRE (Java Runtime Environment).
PRIMER MOMENTO. INSTALACIÓN MySQL Server
Hacer uso del Taller Como instalar MySQL Server 5.5 para instalar el MySQL
Server si en la maquina no ha sido instalado este servidor.
Haciendo uso de MySQL command Line
Es una interfaz de línea de comandos para los usuarios finales gestionar los
objetos de datos de usuario. “Mysql” tiene las siguientes características
principales:








“Mysql” es la interfaz de línea de comandos. No se trata de una interfaz
gráfica de usuario (GUI).
“Mysql” soporta todos los estándares SQL Data Definition Language
(DDL) para el servidor de comandos para ejecutar.
“Mysql” apoya todos los estándares SQL Lenguaje de manipulación de
datos (DML) instrucciones al servidor a ejecutar.
“Mysql” apoya muchas de no SQL comandos “mysql” se ejecutará por sí
mismo.
“Mysql” proporciona acceso al sistema de ayuda del lado del servidor.
“Mysql” permite que los archivos de comandos que se ejecuta en un
modo por lotes.
“Mysql” permite salida de la consulta para tener el formato de las tablas
HTML.
“Mysql” permite salida de la consulta para tener el formato de elementos
XML.
Se ejecuta de la siguiente manera:
Pasaporte root
Se inicia sesión.
DROP DATABASE IF EXISTS `polizas`;
CREATE DATABASE `polizas`;
USE `polizas`;
CREATE TABLE `cliente` (
`idcliente` BIGINT( 10 ) UNSIGNED NOT NULL DEFAULT 1 ,
`nomcliente` VARCHAR( 30 ) NOT NULL ,
`telcliente` INT( 10 ) NOT NULL ,
`domcliente` VARCHAR( 30 ) NOT NULL ,
PRIMARY KEY ( `idcliente` ) ) ENGINE = InnoDB ;
CREATE TABLE `poliza` (
`idcliente` BIGINT( 10 ) UNSIGNED NOT NULL ,
`idpoliza` INT( 6 ) UNSIGNED NOT NULL ,
`fecha` VARCHAR( 10 ) NOT NULL ,
`valor` INT( 10 ) NOT NULL ,
PRIMARY KEY ( `idpoliza` ) ) ENGINE = InnoDB ;
CREATE TABLE `hospedaje` (
`idpoliza` INT( 6 ) UNSIGNED NOT NULL ,
`numero` INT( 6 ) UNSIGNED NOT NULL ,
`fecha` VARCHAR( 10 ) NOT NULL ,
`habitacion` INT( 2 ) NOT NULL ,
PRIMARY KEY ( `numero` ) ) ENGINE = InnoDB ;
INSERT INTO cliente VALUES (2020,'James Rodriguez',60000,"Madrid");
INSERT INTO cliente VALUES (2222,'Falcao Garcia',50000,"Manchester");
select * from cliente;
SHOW VARIABLES WHERE Variable_name IN ('hostname','port');
SEGUNDO.SERVLETS HTTP Y JSP
Tomado de: http://www.altatorre.com/webclase/jsp/jsp0.htm
Los primeros programas de Java que se crearon fueron las aplicaciones de Escritorio
que podían funcionar en la consola de DOS o con ventanas de Windows, luego vienen
los applets que son fragmentos de código en Java que se incrustan en páginas web y
que envían un archivo *.class desde el servidor para que se ejecute en el servidor.
El tercer gran grupo de programas que pueden realizarse en Java son los servlets.
Estos son programas que se parecen más a las aplicaciones básicas de escritorio que
a los applets que antes estudiabamos. Sin embargo, que contienen una complejidad
mucho mayor y por eso se dió un paso más allá llamado JSP que mantiene el poder
de los servlet pero recortando su complejidad.
Servlets de Java
Los servlets son programas que se ejecutan en el servidor pero que se conectan con
el cliente desde allí. El servlet no tiene pantallas locales en el servidor, sino que
reciben y responden datos a través del servidor web. Siempre escriben sobre la
máquina de cliente en HTML/CSS.
Es decir, los servlets son programas de Java que generan HTML/CSS al vuelo y lo
envían desde el servidor al cliente. Para entender qué pasa con el JSP debemos
estudiar un poco qué es lo que pasa con el protocolo HTTP.
Protocolo HTTP: Request, Response y Headers
HTTP es un protocolo simple y sin estados. Un cliente, por ejemplo un web browser,
hace una petición (Request), el servidor web responde y la transacción está hecha.
Cuando el cliente envía una petición, la primera cosa que especifica en un comando
HTTP llamado un método, que dice al servidor qué tipo de acción quiere realizar. Esta
primera Línea de la petición también especifica la dirección de un documento (una
URL) y la versión del protocolo HTTP que está usando. Por ejemplo:
GET /intro.html HTTP/1.0
GET Y POST
Cuando un cliente se conecta a un servidor y hace una petición HTTP, la petición
puede ser de diferentes tipos, llamados métodos. Los métodos más frecuentemente
usados son GET y POST. Para colocarlo de una manera simple GET está hecho para
obtener información, mientras que POST está diseñado para enviar información.
El método GET a pesar de ser hecho para pedir información dentro de su petición
puede incluir información de la petición. Esta información son parámetros de la
dirección URI que se está usando. Por ejemplo:
Ejemplo 1: http://www.server.com/ordenes.htm?cliente=1983
Ejemplo 2: http://www.server.com/ordenes.htm?cliente=1983&ID=1112
Los parámetros se dividen de la dirección con un signo "?". En este caso se añade un
par atributo-valor así: cliente=1983, esta seguramente es una referencia que lleva
información de la petición que se está haciendo. Sin embargo, la cantidad de
información que se puede enviar en la URI es limitada.
Las direcciones anteriores se llaman URI (Uniform Resource Identifier) y usan los
parámetros para puntualizar la petición GET que se está haciendo.
El método POST puede enviar mucha más información y no lo hace de manera visible
como el método GET, por lo que es emás seguro.
La API de Servlets
Habiendo recordado lo anterior, podemos hablar sobre el API de los servlets que se
usa con los servlets HTTP. Los servlets usan dos paquetes, javax.servlet y
javax.servlet.http de la extensión javax de los API. Le recomendamos dar una ojeada a
la definición del API que le permite ver los objetos que tiene disponibles para trabajar
con JSP.
A diferencia de las aplicaciones de escritorio y los applets, un servlet no tiene un
método main(). En su lugar, ciertos métodos son invocados por el servidor al manejar
las peticiones de los usuarios. Cada vez que un servidor despacha una petición a un
servlet, invoca el método service().
Un servlet genérico debería sobreescribir su método service() para manejar sus
peticiones del usuario, pero no lo hace sobreescribe los métodos doGet() y doPost().
Los servlets generan páginas web, es por eso que se usan en las mismas tareas que
un CGI.
Java Server Pages 1.0
JSP es un lenguaje que queda embebido dentro del HTML, y en el que se crean unas
plantillas usadas con un servlet genérico que el programador nunca ve. Estas plantillas
están escritas en HTML/CSS/JavaScript y en Java. Teniendo en cuenta que el
JavaScript se ejecuta en el cliente y el Java en el servidor. En el servidor puede
comunicarse con aplicaciones de escritorio y objetos de Java, así como con applets.
La especificación JSP 1.1 extiene la API de Java Server. Como hemos visto, ambas
forman parte de la Java 2 Platform Enterprise Edition (J2EE). Información específica
de JSP se puede conseugir en el sitio web de Sun en http://java.sun.com/products/jsp.
1. Directivas
Una directiva de JSP es una estamento que proporciona la información del motor de
JSP para la página que la pide. Su sintaxis general es <%@ directiva {atributo
="valor"} %>
dónde la directiva debe tener un número de atributos. Cada directiva tiene un XML
opcional equivalente, pero esto son intentos para una futura herramienta JSP, por esto
no lo consideraremos ahora.
Posibles directivas en JSP 1.0 son:
Page: Información para la página.
Include: Incluye archivos completos palabra por palabra.
Taglib: La dirección de la librería de tags que se usará en la página.
Tal y como esperabamos, la directiva Page posee varios atributos.
Atributos y posibles valores Descripción
- language="java". Comunica al servidor el lenguaje que va a ser utilizado en el
archivo. Java es el único posible es esta especificación
- extends="package.class". La variale extends, define la clase padre del
servlet generado. Normalmente no es necesario utilizar otras que no sean las clases
base del proveedor.
-import="package.*,package.class". Sirve para especificar los paquetes y clases que
se
quieran utilizar.
- session="true|false". Por defecto session vale true, manteniendo los datos de las
sesión para la página.
- isThreadSafe="true|false". Por defecto vale true, le hace señales al motor de
JSP para que multiples pedidos del cliente puedan ser tomadas como una.
-info="text". Información en la página a la que puede accederse a través del método
Servlet.getServletInfo()
- errorPage="pagina_error" Página que manejará las excepciones de errores.
isErrorPage="true|false" Marca a la página como la página que manejará
2. Declaraciones
Una declaración de JSP, puede definirse como una definición de variables y métodos
a nivel de clase que son usadas en la página.
Un bloque de declaraciones típico sería <%! declaración %>
Un ejemplo de declaración de script sería el siguiente:
<HTML>
<HEAD>
<TITLE>Página simple JSP</TITLE>
</HEAD>
<BODY>
<%! String strCadena = "x";
int intContador = 0;
%>
</BODY>
</HTML>
3. Scripts de JSP
Los Scripts son bloques de código Java residentes entre los tags <% y %>.
Este bloques de código estarán dentro del servlets generado incluídos en método
_jspService().
Los Scripts pueden acceder a cualquier variable o Beans que haya sido declarado.
También hay algunos objetos implícitos disponibles para los Scripts desde entorno del
Servlet. Vamos a verlos a continuación.
- request. Es la petición del cliente. Es normalmente una subclase de la case
HttpServletRequest.
-request.getParameter(String arg). Retorna el valor del Atributo (objeto) almacenado
en la sesión actual, y cuyo nombre es arg( que corresponde a un objeto String). Este
método retorna el valor null si el atributo no existe.
String cedula= request.getParameter(“Cedula”);
- request.setAttribute(String nombre, Object valor): almacena un Atributo (objeto) en la
sesión haciendo uso del nombre como del valor en el argumento.
request.setAttribute("area", new String().valueOf(area));
request.setAttribute("formula", tipoArea);
- response. Es la página JSP de respuesta y es una subclase de HttpServletResponse.
- pageContext. Los atributos de la página y los objetos implícitos necesitan ser
accesibles a través de API, para permitir al motor de JSP compilar la página. Pero
cada servidor tiene implementaciones específicas de cada uno de esos atributos y
objetos.
Para solucionar este problema, el motor de JSPutilizar la clase Factory para devolver
la implementación de clase PageContext del servidor. Esta clase PageContext es
inicializada con los objetos response y request y algunos atributos de la directiva de la
página (erropage,session,buffer and autoflush) y facilita los otros objetos implícitos
para la pagina de petición.
- session El objeto de sesión HTTP asociado a la petición.
- application. Lo que devuelve el servlet cuando se llama a
getServletConfig().getContext()
- out. El objeto que representa la salida de texto por pantalla.
- config. El objeto ServletConfig de la página.
- page. Es la forma que tiene la página para referirse a si misma. Se usa como
alternativa al objeto this
- exception. Es una subclase libre de Throwable que es pasada a la página que
maneja los errores
4. Catálogo de tipos de tags JSP
Las páginas en JSP se escriben básicamente en DHTML (HTML +CSS+JavaScript),
pero con introducción de partes adicionales que son scripts de servidor escritos en
Java. Estos scripts de servidor vienen incluidos con los tags <% .. %>
Scriptlets
1. Hacer una página en JSP que liste los 10 primeros números enteros.
<html>
<body>
<%
int i;
for (i=0; i<10; i++) {
out.println(i+"
");
}
%>
</body>
</html>
2. Hacer una página JSP que liste los 100 primeros cuadrados
<html>
<head>
<style>
td { font-family:verdana; font-size:9pt; }
</style>
</head>
<body>
<table>
<%
int i;
for (i=0; i<100; i++) {
out.println("<tr><td>" + i + "</td><td>" + (i*i) + "<br>");
}
%>
</table>
</body>
</html>
3. Hacer una página JSP que muestre el resultado del juego 7 pum hasta 100. El juego consiste en ir
contando y cada vez que el número sea divisible por 7 o terminado en 7 entonces se reemplaza por PUM
y se salta de línea.
<html>
<head>
<style>
body { font-family:verdana; font-size:9pt; }
i { color:red; font-weight:bold; }
</style>
</head>
<body>
<%
int i;
for (i=1; i<100; i++) {
if ( ( i % 7 == 0 ) || ( i % 10 == 7 ))
out.println("<i>PUM</i><br>");
else
out.println( i + " " );
}
%>
</body>
</html>
Expresiones
Cuando necesitamos mostrar una expresión debemos usar los tags <%= ... %>
Así:
Archivo (inicial.jsp)
<%@ page language=java %>
<html>
<body>
Vamos a crear una variable en JSP<br>
<% int variablePrueba = 10; %>
<p> Y ahora mostramos que la variable es <%= variable %> </p>
</body>
</html>
En el cliente la página que llega es solo HTML:
<html>
<body>
Vamos a crear una variable en JSP<br>
<p> Y ahora mostramos que la variable es 10 </p>
</body>
</html>
Puede ser un cálculo que se va a hacer a través de Java, ya sea usando Java Local o
un bean o un servlet.
Hay otros como <jsp:UseBean ... />, <jsp:getProperty ... />, <jsp:setProperty ... />
Declaraciones
Las variables que son globales a la clase y los métodos que tienen ámbito de clase se
declaran entre los tags <%! ... %>
<html>
<body>
<h1> hola Declaración </h1>
</body>
</html>
<%!
private int i=4;
public void MiMetodo () {
// Ejecuta alguna acción aquí.
}
%>
5. Acciones
Las acciones son etiquetas HTML que se interpretan en la fase de traducción y que
realizan diferentes operaciones.
jsp:include
Sintaxis:
<jsp:include page="direccion de la otra página">
<jsp:param name="nombreParametro1" value="valorParametro1"/>
<jsp:param name="nombreParametro2" value="valorParametro2"/>
</jsp:include>
Delega “temporalmente” el procesamiento de la sesion al recurso especificado en el
atributo page sobre el que se aplica. Esta acción admite especificar parámetros
mediante la accion jsp:param.
Por ejemplo, si queremos ir temporalmente a una pagina2 y pasar como parámetro
una variable llamada “x” que tenga un valor “y”, bastaría con hacer:
<jsp:include page=”pagina2?>
<jsp:param name=”x” value=”y”/>
<jsp:include/>
jsp:forward
Sintaxis
<jsp:forward page="direccion de la otra página">
<jsp:param name="nombreParametro1" value="valorParametro1"/>
</jsp:forward>
Delega el procesamiento de la sesion al recurso especificado en el atributo page sobre
el que se aplica. Esta acción admite especificar parámetros mediante la acción
jsp:param.
Por ejemplo, si queremos ir a una pagina2 y pasar como parámetro una variable
llamada “x” que tenga un valor “y”, bastaría con hacer:
<jsp:forward page=”pagina2?>
<jsp:param name=”x” value=”y”/>
<jsp:forward/>
TERCER MOMENTO. REGISTRO DEL SERVIDOR MySQL
Ejecute NetBeans
Botón Derecho del Ratón sobre Databases. Seleccione New Connection
Seleccione MySQL(Connector/J driver). Pulse boton next
Diligenciar los campos:
Host: localhost
Puerto:3307
Base de Datos: polizas
User: root
Password: root
Pulsar el Botón Finish
Aparece la conexión MySQL
QUINTO MOMENTO. CONEXIÓN A LAS BASE DE DATOS MySQL
Seleccionar la opción
Botón Derecho del Ratón. Seleccione la opción Connect (si está habilitada)
Password: root. Pulsar el Botón OK
Botón Derecho del Ratón. Seleccione la opción properties(propiedades)
Aparecen las propiedades, definidas en el pool de conexión. Pulsar botón close (cerrar)
SEXTO MOMENTO. CREACION DE LA APLICACION
Pulsar la opción New Project
Java >> Web Application. Botón Next
Nombre del Proyecto: JSPServletCliente.
Pulsar el Botón Next
Pulsar el Botón Finish
Se genera un Proyecto
ANTECEDENTE. Adicion de MySql Connector
Para evitar errores como:
Normalmente se encuentra en:
C:\Program Files\NetBeans xxx\ide\modules\ext
Sobre Libraries
PRIMER PASO. ACTIVIDADES SOBRE <default package>
Actividad 1. Creación Paquete
Sobre <default package> >>New>>java Package
Nombre Paquete: JSPCliente. Pulsar Tecla Finish
Segunda Actividad. Creación de la entidad Cliente
La entidad debe representar la tabla cliente:
Mouse derecho sobre Paquete JSPCliente >>New>>Entity Classes from Database
El asistente se ocupó de crear la clase entidad Cliente capaz de realizar el mapeo
objeto-relacional en la base de datos Polizas
Se verifica la carpeta Configuration Files. Aparece el archivo persistencia.xml




1.
2.
3.
4.
persistence-unit, atributo name: define una unidad de persistencia, es
obligatorio darle un nombre, para poder crear un EntityManager. El EntityManager es
el encargado de manejar la persistencia de los datos.
provider: aquí indicamos si se desea usar Hibernate o no como implementación
de JPA. En esta practica se selecciona el proveedor eclipse
class: debe existir una etiqueta class por cada clase que queramos persistir, es
decir, una por cada entidad que formará nuestra unidad de persistencia.
Dentro de las etiquetas properties, definimos propiedades propietarias de la
implementación JPA. De entre ellas cabe destacar:
hibernate.connection.url: define la URL de conexión a la base de datos.
User
Password
Driver
Tercera Actividad. Creación del Controlador de Cliente
Sobre el paquete JPScliente>>New>>Other>>Persistence>>JPA Controller From
Entity Classes. Boton Next
El asistente genero el código que creara la unidad de persistencia y los objetos que
permitirán realizar consultas y persistir objetos la base de datos Polizas. Basta con escribir
las siguientes líneas de código:
EntityManagerFactory factory = Persistence.createEntityManagerFactory("UnidadPersistencia");
EntityManager manager = factory.createEntityManager();
El método createEntityManagerFactory toma el nombre de la unidad de persistencia, la
crea y devuelve un objeto EntityManagerFactory, que es utilizado para crear objetos
EntityManager. Los objetos EntityManager tienen métodos que permiten realizar consultas,
persistir, actualizar y eliminar(crud) objetos en la base de datos (obviamente lo que se
modifican son los registros de las tablas) y muchas otras cosas más. Para realizar una
consulta se utiliza el lenguaje JPQL (Java Persistence Query Language), que es similar a
SQL, pero trabaja con objetos y sus propiedades (Ver Anexo JPA basico).
Cuarta Actividad. Creación AdmonCliente
Sobre el paquete JSPCliente >>New>>Java Class
Nombre de Clase: AdmonCliente . Pulsar Botón Finish
Reemplazar el contenido por:
package JSPCliente;
import javax.ejb.SessionContext;
import javax.persistence.*;
import javax.persistence.EntityManagerFactory;
public class AdmonCliente {
long cedula;
int telefono;
String nombre, domicilio;
ClienteJpaController ayuda;
SessionContext contexto;
String P[];
Cliente cliente=null;
public String registro(String id) {
long ced=Long.parseLong(id);
inicio();
cliente=ayuda.findCliente(ced);
if(cliente==null)
return "";
else
{
String cadena="";
cadena+=cliente.getIdcliente()+",";
cadena+=cliente.getNomcliente()+",";
cadena+=cliente.getDomcliente()+",";
cadena+=cliente.getTelcliente()+";";
return cadena;
}
}
public String adicion(String campos) {
inicio();
P=campos.split(",");
if(P.length!=4)
return "No estan los campos completos";
pasar();
cliente=ayuda.findCliente(cedula);
if(cliente!=null)
return "Existe cedula";
else
{
try
{
cliente=new Cliente(cedula,nombre,telefono,domicilio);
ayuda.create(cliente);
}
catch(Exception e){}
return "Exito en adicion";
}
}
public String edicion(String campos) {
inicio();
P=campos.split(",");
if(P.length!=4)
return "No estan los campos completos";
pasar();
cliente=ayuda.findCliente(cedula);
if(cliente==null)
return "No Existe cedula";
else
{
try
{
cliente=new Cliente(cedula,nombre,telefono,domicilio);
ayuda.edit(cliente);
}
catch(Exception e){}
return "Exito en edicion";
}
}
public String borrar(String id) {
long ced=Long.parseLong(id);
inicio();
cliente=ayuda.findCliente(ced);
if(cliente==null)
return "No Existe cedula";
else
{
try
{
ayuda.destroy(cedula);
}
catch(Exception e){}
return "Exito en edicion";
}
}
void inicio()
{
EntityManagerFactory factoria;
factoria = Persistence.createEntityManagerFactory("JSPServletClientePU");
ayuda = new ClienteJpaController(factoria);
}
void pasar()
{
cedula=Long.parseLong(P[0]);
nombre= P[1];
telefono= Integer.parseInt(P[2]);
domicilio= P[3];
}
}
Quinta Actividad. Creación Clase Token
Sobre el paquete JSPCliente >>New>>Java Class
Nombre de Servlet: Token
Reemplazar contenido por:
package JSPCliente;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.*;
import java.text.*;
public class Token
{
int i;
public boolean soloFecha(String P)
{
DateFormat FormatoFecha=DateFormat.getDateInstance(DateFormat.SHORT, new
Locale("es"));
if (P == null)
{
return false;
}
FormatoFecha.setLenient(false);
try {
FormatoFecha.parse(P.trim());
}
catch (ParseException pe)
{
return false;
}
return true;
}
public boolean soloCorreo(String P)
{
Pattern correo = Pattern.compile("^([0-9a-zA-Z]([_.w]*[0-9a-zA-Z])*@([0-9a-zA-Z][w]*[0-9a-zA-Z].)+([a-zA-Z]{2,9}.)+[a-zA-Z]{2,3})$");
Matcher m = correo.matcher(P);
return m.find();
}
public boolean soloNumero(String P)
{
Pattern numero = Pattern.compile("^([0-9])+$");
Matcher m = numero.matcher(P);
return m.find();
}
public boolean soloTitulada(String P)
{
Pattern titulada = Pattern.compile("^[A-Z]{1}[a-z]+$");
Matcher m;
String cadena[]=P.split(" ");
for(i=0;i<cadena.length;i++)
{
m=titulada.matcher(cadena[i]);
if(!m.find())
{
return false;
}
}
return true;
}
}
PASO 2. ACTIVIDADES SOBRE web Pages
Primera Actividad. Archivo css
Adicionar Hoja de Estilo en Cascada (CSS).
Web Pages>>new>>Other>>Web>>Cascading Style Sheet
Botón Next>
Nombre de Archivo: estilos. Pulse el Botón Finish
Reemplazar estilos.css por el siguiente código:
body {
font-size: 0.875em;
font-weight: normal;
font-family: Tahoma, Arial, Helvetica,
Verdana, sans-serif;
background: #edeae8;
color: inherit;
}
#encabezado, #contenido{
float: left;
width: 100%;
text-align: left;
}
#contenido{
float: left;
margin: 0 0 0 2em;
}
h1, h2 {
font-weight: normal;
margin: 1em 0 2em 0;
line-height: 100%;
font-family: ‘Oxygen’, sans-serif; }
th { font-weight: bold; }
th, td {
border: 1px solid #181e23;
font-size: 1em;
padding: 0.5em;
}
label, button, input {
font-size: 1.125em;
margin: 0 0.5em 0 0;
width:6em;
}
table tr td
{ background: #F0EFE2;
color: #47433F;
border-top: 1px solid #FFF;
}
Segunda Actividad. Editar Archivo index.html
Seleccione index.html. Se reemplace el contenido con el siguiente código html:
<!DOCTYPE html>
<html>
<head>
<title>JSP AJAX</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<center>
<a href='/JSPServletCliente/Captura.jsp'>Captura de Jugadores</a>
</center>
</body>
Tercera Actividad. Archivo Captura.jsp
Adicionar JSP.
Web Pages>>new>>Other>>Web>>JSP
Nombre de JSP: Captura . Pulsar Finish
Reemplazar contenido por:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<TITLE> CLIENTES </TITLE>
<link rel="stylesheet" type="text/css" href="estilos.css" title="style" />
<script Language="Javascript" src="ajax.js"></script>
</head>
<body>
<center>
<div id="encabezado">
<h1> EMPRESA LOS LAURELES</h1>
<h3> BOGOTA D.C </h3>
<h5> Nit 133-1223433-3</h5>
</div>
<br>
</center>
<div id="contenido">
<form action="http://localhost:8080/JSPServletCliente/JSPToken.jsp" method="POST">
<table width="600">
<tr>
<th>Cedula:</th>
<td><input name="Cedula" type="text" id="cedula"></td>
</tr>
<tr>
<th>Nombre:</th>
<td><input name="Nombre" type="text" id="nombre"></td>
</tr>
<tr>
<th>Domicilio:</th>
<td><input name="Domicilio" type="text" id="domicilio"></td>
</tr>
<tr>
<th>Telefono:</th>
<td><input name="Telefono" type="text" id="telefono"></td>
</tr>
<tr>
<th>Boton de Busqueda</th>
<td><button onclick="enviar();return false;"> Pulse Aqui </button></td>
</tr>
<tr>
<th>Boton de Envio</th>
<td><input type="submit" name="envio" id="envio">
</tr>
</table>
<br>
</form>
</div>
</body>
</html>
Cuarta Actividad. Archivo Visita.jsp
Adicionar JSP.
Web Pages>>new>> JSP…
Nombre de JSP: Visita . Pulsar Finish
Reemplazar el Contenido por:
<%@page contentType="text/plain" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<%!
JSPCliente.AdmonCliente A=new JSPCliente.AdmonCliente();
String cedula;
%>
<%
cedula=(String) request.getParameter("cedula");
response.setContentType("text/plain");
response.getWriter().write(A.registro(cedula));
%>
</body>
</html>
Quinta Actividad. Archivo JSPToken.jsp
Adicionar JSP.
Web Pages>>new>> JSP…
Nombre de JSP: JSPToken . Pulsar Finish
Reemplazar contenido por:
<%@page contentType="text/plain" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<%
JSPCliente.Token T=new JSPCliente.Token();
String Cedula=request.getParameter("Cedula");;
String Nombre=request.getParameter("Nombre");
String Domicilio=request.getParameter("Domicilio");
String Telefono=request.getParameter("Telefono");
String cumple="SI";
boolean transmite=true;
transmite=transmite & T.soloNumero(Cedula);
transmite=transmite & T.soloTitulada(Nombre);
transmite=transmite & T.soloTitulada(Domicilio);
transmite=transmite & T.soloNumero(Telefono);
if(!transmite)
{
cumple="NO";
if(!T.soloNumero(Cedula))
Cedula=Cedula+" no es numero";
if(!T.soloTitulada(Nombre))
Nombre=Nombre+" no es titulada";
if(!T.soloNumero(Telefono))
Telefono=Telefono+" no es numero";
if(!T.soloTitulada(Domicilio))
Domicilio=Domicilio+" no es titulada";
}
%>
<jsp:forward page="ActualCliente.jsp">
<jsp:param name="Cedula" value="<%=Cedula%>"/>
<jsp:param name="Nombre" value="<%=Nombre%>"/>
<jsp:param name="Domicilio" value="<%=Domicilio%>"/>
<jsp:param name="Telefono" value="<%=Telefono%>"/>
<jsp:param name="cumple" value="<%=cumple%>"/>
</jsp:forward>
%>
</body>
</html>
Sexta Actividad. Archivo ActualCliente.jsp
Adicionar JSP.
Web Pages>>new>> JSP…
Nombre de JSP: ActualCliente. Pulsar Finish
Reemplzar contenido por:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<%
JSPCliente.AdmonCliente A=new JSPCliente.AdmonCliente();
String campos;
String Cedula=request.getParameter("Cedula");;
String Nombre=request.getParameter("Nombre");
String Telefono=request.getParameter("Telefono");
String Domicilio=request.getParameter("Domicilio");
campos=Cedula+","+Nombre+","+Telefono+","+Domicilio;
String cumple=request.getParameter("cumple");
if(cumple.indexOf("SI")!=-1)
{
String registro=A.registro(Cedula);
if(registro=="")
A.adicion(campos);
else
A.edicion(campos);
}
%>
Cedula: <%=Cedula%> <br>
Nombre: <%=Nombre%> <br>
Domicilio: <%=Domicilio%> <br>
Telefono: <%=Telefono%> <br>
Se cumple las validaciones: <%=cumple%> <br>
<center>
<a href='/JSPServletCliente/Captura.jsp'>Captura de Jugadores</a>
</center>
</body>
</html>
Septima Actividad. Adición De Archivo ajax.js
Web Pages>>new>>Other>>web>>Java Script File
Nombre Archivo: ajax. Pulse boton Finish
Archivo del script ajax: el archivo ajax.js es el script que se agrega en la página principal, contiene la
definición de las funciones de JavaScript que permiten realizar las siguientes tareas:
• Definir el objeto XMLHttpRequest mediante function objetoAjax().
• Definir la función para enviar la información al servidor mediante la sentencia
open("POST","Visita",true) como el parametro a enviar send("cedula="+cedula);
• Validar (metodo getReadyStateHandler ) y publicar la información en el cliente en este caso en la
capa vistaConsulta de index.html mediante:
vistaconsulta=document.getElementById("vistaConsulta");
vistaconsulta.innerHTML= objeto XMLHttpRequest.responseText;
Definición objeto XMLHttpRequest: este objeto permite generar las peticiones asíncronas desde la
página, aunque se obtiene de forma diferente en cada tipo de navegador, por lo cual es necesario
validar la creación de este.
Reemplace el contenido por:
//Para hacer frente a todos los navegadores modernos, incluyendo IE5 y IE6, se
comprueba si el navegador es compatible con el objeto XMLHttpRequest.
//Si lo hace, se crea un objeto XMLHttpRequest, si no, se crea una ActiveXObject
var txt;
var objetoajax;
function objetoAjax()
{
var xmlhttp;
if (window.XMLHttpRequest)
{// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else
{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
return xmlhttp;
}
function enviar()
{
var cedula=document.getElementById("cedula").value;
var parametro= "cedula=" + cedula;
objetoajax=objetoAjax();
objetoajax.open("POST","Visita.jsp","true");
objetoajax.onreadystatechange=getReadyStateHandler(objetoajax);
objetoajax.setRequestHeader("Content-type","application/x-www-form-urlencoded");
objetoajax.setRequestHeader("Content-length", parametro.length);
objetoajax.send(parametro);
pasar();
}
function pasar()
{
txt=objetoajax.responseText + "";
txt.replace(/<[^>]*>/g, "");
k=txt.indexOf(';',0);
txt=txt.substr(0,k);
var arreglo=txt.split(",");
if(arreglo[0]!=="")
{
document.getElementById("cedula").value=arreglo[0];
document.getElementById("nombre").value=arreglo[1];
document.getElementById("domicilio").value=arreglo[2];
document.getElementById("telefono").value=arreglo[3];
}
}
function getReadyStateHandler(xmlHttpRequest) {
return function() {
if (xmlHttpRequest.readyState === 4)
{
if (xmlHttpRequest.status === 200)
{
document.getElementById("cedula").value="";
pasar();
}
else
{
alert("HTTP error " + xmlHttpRequest.status + ": " +
xmlHttpRequest.statusText);
}
}
};
}
TERCER PASO. EJECUCION DEL PROGRAMA
Primer Paso. Detener Servidor
Segundo Paso. Clean and Build
Tercer Paso. Deploy
Cuarto Paso. Run