Uso de JSP y JavaBeansInducciónEste material esta compuesto de un libro de visitas que permite a los usuarios colocar su nombre, apellido dirección en una base de datos.
Después de enviar su información, los usuarios ven una pagina Web que contiene a todos los usuarios en el libro. La dirección de e-mail de cada persona se muestra como un hipervínculo que permite al usuario enviar un mensaje de correo electrónico a esa persona.
Nota, Se necesita saber:
- Manejar o tener una Orientación de POO.
- Manejo básico de html.
www.mysql.org
- El netbeans trae por defecto tomcat apache 5.5.9 además utilizaremos, otra versión la que gusten.
El Libro consiste en los JavaBeans BeanVisitante.java, BeanDatos.java y en las jsp inicoLibro.jsp, vistaLibro.jsp y paginaError.jsp
Introducción
Java
Server
Pages (JSP) combinan HTML con fragmentos de Java para producir páginas web dinámicas.
Cada página es automáticamente compilada a servlet por el motor de JSP , en primer lugar es recogida y a continuación ejecutada.
JSP tiene gran variedad de formas para comunicarse con las clases de Java, servlets, applets y el servidor web; por esto se puede aplicar una funcionalidad a nuestra web a base de componentes.
Resumen de la arquitectura de una página JSP
Una página JSP es archivo de texto simple que consiste en contenido HTML o XML con elementos JSP. Cuando un cliente pide una página JSP del sitio web y no se ha ejecutado antes, la página es inicialmente pasada al motor de JSP, el cual compila la página convirtiéndola en Servlet, la ejecuta y devuelve el contenido de los resultados al cliente.
Es posible ver el código del servlet generado, este código debe estar en el directorio que se informa en la estructura de directorios del servidor
Empecemos….Creamos un proyecto nuevo
Abrimos nuestro netbeans
Puede Utilizar
Cualquier versión de Tomcat pero usaremos la que viene por defecto
Luego Si desean Pueden poner finish….
Este es un punto clave las carpetas
En el Web Pages van nuestras paginas imágenes carpetas de imagenes, archivos .html, jsp, js y subcarpeta de ambos
En la carpeta Web Pages(META-INF Y WEB-INF) se crea todos los archivos de configuracion para que lo ejecute el tomcat, po lo tanto “Don’t touch”, ya que netbans crea todo automáticamente. :D
ademas hay mucho manuales articulos que explcian como hacerlo a manualemnte no entraremos en detalle. :P
En la carpeta Source Package se crean las clases o sea los .java y el paquete contenedor no dejarlo con el nombre de por defecto siempre cambiarlos.
Libraries se colocan librerías por ejemplo, JSTL 1.1 -jsrl.jar, el jconnector de mysql que es = mysql-connector-java5.0.3-bin.jar, etc
Nota: Las demás carpetas no interesan en este material.
Bueno, Empezamos creando nuestro primer archivo BeanVisitante.java
Creamos el archivo BeanVisitante.java
Luego cambian el nombre del paquete que viene por defecto por beans. Define 3 propiedades de los visitantes: nombre, apellido,email. Cada una es una propiedad de lectura y escritura que cuenta con metodos set y get para manipularlas.
package beans;
public class BeanVisitante {
private String nombre, apellido, email;
/** Creates a new instance of BeanVisitante */
public BeanVisitante() {
}
public void setNombre(String Nombre){
nombre=Nombre;
}
public String getNombre(){
return nombre;
}
public void setApellido(String Apellido){
apellido=Apellido;
}
public String getApellido(){
return apellido;
}
public void setEmail(String Email){
email=Email;
}
public String getEmail(){
return email;
}
}
El javaBean BeanDatos se conecta a la BD libros visitantes y proporciona los metodos getLista y agregarVisitante para manipular la BD
package beans;
import java.io.*;
import java.sql.*;
import java.util.*;
public class BeanDatos {
private Connection conexion;
private Statement instruccion;
private String url="jdbc:mysql://localhost/librovisitantes";
/** Creates a new instance of BeanDatos */
public BeanDatos() throws SQLException, ClassNotFoundException {
Class.forName("com.mysql.jdbc.Driver");
conexion=DriverManager.getConnection(url,"root","");
instruccion=conexion.createStatement();
}
public List getLista()throws SQLException{
List lista=new ArrayList();
ResultSet resultado=instruccion.executeQuery("SELECT * FROM visitantes");
while(resultado.next()){
BeanVisitante visitante=new BeanVisitante();
visitante.setNombre(resultado.getString(1));
visitante.setApellido(resultado.getString(2));
visitante.setEmail((resultado.getString(3)));
lista.add(visitante);
}
return lista;
}
public void agregarVisitante(BeanVisitante visitante)throws SQLException{
instruccion.executeUpdate("INSERT INTO visitantes(nombre, apellido, email) VALUES ('"+ visitante.getNombre()+"','"+visitante.getApellido()+"','"+visitante.getEmail()+"')");
}
protected void finalize(){
try{
instruccion.close();
conexion.close();
}
catch(SQLException error){
error.printStackTrace();
}
}
}
El método getLista() devuelve un objeto ArrayList de objeto BeanVisitante, que representa a los invitados en la BD. El método getLista() crea objetos BeanVisitante del objeto Resulset devuelto por le método executeQuery de Statement.
El método agregarVisitante() recibe un objeto BeanVisitante como parámetro y utiliza las propiedades de BeanVisitante como argumento para el método executeUpdate() de Statement.
Este objeto Statement inserta un nuevo invitado en la BD.
Otra cosa interesante es que: ni el constructor de BeanVisitante, ni los métodos getLista() y agregarVisitante() procesan las posibles excepciones.
En este ejemplo se dejo intencionalmente que cualquier excepción que se produzca pase de vuelta a la jsp que invoca el constructor o los métodos. :P
Caundo una jsp realiza una operación que produce una excepcion, puede incluir scriptlets para atrapar la excepción y procesarla.Las excepciones que no se atrapan pueden reenviarse a una pagina de error de jsp para que esta las maneje.
Conceptos Sobre los JavaBeans
El API JavaBeans permite escribir componentes software en Java. Los componentes son unidades software reutilizables y auto-contenidas que pueden ser unirse visualmente en componentes compuestos, applets, aplicaciones y servlets utilizando herramientas visuales de desarrollo de aplicaciones.
Los componentes JavaBean son conocidos como Beans. Una herramienta de desarrollo que soporte JavaBeans, mantiene los Beans en una paleta o caja de herramientas. Se puede seleccionar un Bean de la paleta, arrastarlo dentro de un formulario, modificar su apariencia y su comportamiento, definir su interacción con otros Beans, y componer un applet, una aplicación, o un nuevo Bean, junto con otros Beans.
Creamos una carpeta que se llama Libro
Creamos nuestro jsp En la carpeta Web Pages creamos una carpeta Libro y luego en esa carpeta, creamos nuestro Primer JSP
Creamos nuestro inicioLibro.jsp
Inicio de sesion
body {
font-family: tahoma, helvetica,arial, sans-serif;
}
table,tr,td{
font-size: .9em;
border:3px groove;
padding: 5px;
background-color: #dddddd;
}
Escriba si nombre, apellido y direccion
para registrarlo en el libro de visitas
Primer Nombre
Primer Apellido
Correo Electronico
Explicaremos que lleva nuestro jsp
Directivas:
Las directivas son mensajes para el contenedor de JSP que permiten al programador especificar configuraciones de página (como la pagina de error), incluir contenido de otros recursos y especificar bibliotecas de marcas personalizadas para usarlas en una JSP.
La directiva page
La directiva page especifica las configuraciones globales de la jsp en el contenedor jsps. Puede haber muchas directivas page, siempre y cuando solo haya una ocurrencia de cada atributo. La única excepción a esto es el atributo import, el cual puede usarse repetidamente para importar los paquetes de java que se utilicen en la jsp.
La directiva Page se usa para definir atributos que se aplican a una página JSP entera.
La directiva page se aplica a una página JSP completa, y a cualquier fichero estático que incluya con la directivas include" o , que juntas son llamadas una unidad de traducción.
Observa que la directiva page no se aplica a cualquier fichero dinámico incluido.
Una directiva page puede usarse para establecer valores para distintos atributos que se pueden aplicar a la página JSP. Podemos usar la directiva page más de una vez en una página JSP (unidad de traducción). Sin embargo, (excepto para el atributo import), sólo podemos especificar un valor para atributo una sola vez.
import="package.class" o import="package.class1,...,package.classN".
Esto nos permite especificar los paquetes que deberían ser importados. Por ejemplo:
El atributo import es el único que puede aparecer múltiples veces.
Atributos de la Directiva Page
language="java"
Este atributo define el lenguaje de script usado en los scriptles, declaraciones y expresiones en el fichero JSP y en cualquier fichero incluido. En JSP 1.0 el único lenguaje permitido es Java.
extends="package.class"
Este atributo especifica un nombre totalmente cualificado de una superclase que será extendida por la clase Java en el fichero JSP. Sun recomienda que usemos este atributo con caute, ya puede limitar la habilidad del motor del JSP a proporcionar la superclase especializada que mejora la calidad del fichero compilado.
import= "{ package.class | package.* }, ..."
Esta lista especifica una lista separada por comas de uno o más paquetes o clases que el fichero JSP debería importar. Las clases de los paquetes se ponen a disposición de los scriptlets, expresiones, declaraciones y etiquetas dentro del fichero JSP.
Como cabría esperar, el atributo import debe aparecer antes de cualquier etiqueta que refiera la clase importada. Para importar varios paquetes, podemos usar una lista separada por comas, más de una directiva import o una combinación de ambas.
session="true|false"
Todo cliente debe unirse a una sesión HTTP para poder usar una página JSP.
Si el valor es true, el objeto session se refiere a la sesión actual o a una nueva sesión. Si el valor es false, no podemos utilizar el objeto session en el fichero JSP. El valor por defecto es true.
buffer ="none|8kb|sizekb"
Este atributo especifica el tamaño del buffer en kilobytes que será usado por el objeto out para manejar la salida enviada desde la página JSP compilada hasta el navegador cliente. El valor por defecto es 8kb.
autoFlush="true|false"
Este atributo especifica si la salida sería enviada o no cuando el buffer esté lleno. Por defecto, el valor es true, el buffer será descargado. Si especificamos false, se lanzará una excepción cuando el buffer se sobrecargue.
isThreadSafe="true|false"
Este atributo especifica si la seguridad de threads está implementada en el fichero JSP. El valor por defecto, true, significa que el motor puede enviar múltiples solicitudes concurrentes a la página.
Si usamos el valor por defecto, varios threads pueden acceder a la página
JSP. Por lo tanto, debemos sincronizar nuestros métodos para proporcionar seguridad de threads.
Con false, el motor JSP no envía solicitudes concurrentes a la página JSP.
Probablemente no querremos forzar esta restricción en servidores de gran volumen porque puede dañar la habilidad del servidor de enviar nuestra página JSP a múltiples clientes.
info="text"
Este atributo nos permite especificar una cadena de texto que es incorporada en el página JSP compilada. Podemos recuperar el string más tarde con el método getServletInfo().
errorPage="URLrelativa"
Este atributo especifica un path a un fichero JSP al que este fichero JSP envía excepciones. Si el path empieza con una "/", el path es relativo al directorio raíz de documentos de la aplicación JSP y es resuelto por el servidor Web. Si no, el path es relativo al fichero JSP actual.
isErrorPage="true|false"
Este atributo especifica si el fichero JSP muestra una página de error. Si es true, podemos usar el objeto exception, que contiene una referencia a la excepción lanzada, en el fichero JSP. Si es false (el valor por defecto), significa que no podemos usar el objeto exception en el fichero JSP.
contentType="mimeType [ ; charset=characterSet ]" |"text/html;charset=ISO-8859-1"
Este atributo específica el tipo MIME y la codificación de caracteres que use el fichero JSP cuando se envía la respuesta al cliente. Podemos usar cualquier tipo MIME o conjunto de caracteres que sean válidos para el motor JSP.
El tipo MIME por defecto es text/html, y el conjunto de caracteres por defecto es ISO-8859-1.
jsp:useBean
La forma más sencilla de usar un Bean es usar:
Para cargar el Bean, luego usar jsp:setProperty y jsp:getProperty para modificar y recuperar propiedades del bean. Sin embargo, tenemos dos opciones. Primero, podemos usar un formato de contenedor, llamado:
Body
Para indicar que la porción Body sólo se debería ejecutar cuando el bean es ejemplarizado por primera vez, no cuando un bean existente se encuentre y se utilice. Como se explica abajo, los bean pueden ser compartidos, por eso no todas las sentencias jsp:useBean estan en un Bean. Segundo, además de id y class, hay otros tres atributos que podemos usar: scope, type, y beanName.
Atributo Uso
id
Da un nombre a la variable que reverenciara el bean. Se usará un objeto bean anterior en lugar de ejemplarizar uno nuevo si se puede encontrar uno con el mismo id y scope.
class
Designa el nombre completo del paquete del bean.
scope
Indica el contexto en el que el bean debería estar disponible. Hay cuatro posibles valores: page, request, session, y application. El valor por defecto, page, indica que el bean estará sólo disponible para la página actual (almacenado en el PageContext de la página actual). Un valor de request indica que el bean sólo está disponible para la petición actual del cliente (almacenado en el objeto ServletRequest). Un valor de session indica que el objeto está disponible para todas las páginas durante el tiempo de vida de la HttpSession actual. Finalmente, un valor de application indica que está disponible para todas las páginas que compartan el mismo ServletContext. La razón de la importancia del ámbito es que una entrada jsp:useBean sólo resultará en la ejemplo de un nuevo objeto si no había objetos anteriores con el mismo id y scope. De otra forma, se usarán los objetos existentes, y cualquier elemento jsp:setParameter u otras entradas entre las etiquetas de inicio jsp:useBean y la etiqueta de final, serán ignoradas.
type
Especifica el tipo de la variable a la que se referirá el objeto. Este debe corresponder con el nombre de la clase o ser una superclase o un interface que implemente la clase.
Recuerda que el nombre de la variable se designa mediante el atributo id.
beanName Da el nombre del bean, como lo suministraríamos en el método instantiate de Beans.
Esta permitido suministrar un type y un beanName, y omitir el atributo class.
jsp:setProperty
Usamos jsp:setProperty para obtener valores de propiedades de los beans que se han referenciado anteriormente.
Podemos hacer esto en dos contextos. Primero, podemos usar antes jsp:setProperty, pero fuera de un elemento
jsp:useBean, de esta forma:
...
En este caso, el jsp:setProperty se ejecuta sin importar si se ha ejemplarizado un nuevo bean o se ha encontrado uno ya existente. Un segundo contexto en el que jsp:setProperty puede aparecer dentro del cuerpo de un elemento jsp:useBean, de esta forma:
...
Aquí, el jsp:setProperty sólo se ejecuta si se ha ejemplarizado un nuevo objeto, no si se encontró uno ya existente.
Aquí tenemos los cuatro atributos posibles de jsp:setProperty:
Atributo Uso name Este atibuto requerido designa el bean cuya propiedad va a ser seleccionada. El elemento jsp:useBean debe aparecer antes del elemento jsp:setProperty.
property
Este atributo requerido indica la propiedad que queremos seleccionar. Sin embargo, hay un caso especial: un valor de "*" significa que todos los parámetros de la petición cuyos nombres correspondan con nombres de propiedades del Bean serán pasados a los métodos de selección apropiados.
value
Este atributo opcional especifica el valor para la propiedad. Los valores string son convertidos automáticamente a números, boolean, Boolean, byte, Byte, char, y Character mediante el método estándard valueOf en la fuente o la clase envolvente.
Por ejemplo, un valor de "true" para una propiedad boolean o Boolean será convertido mediante Boolean.valueOf, y un valor de "42" para una propiedad int o Integer será convertido con Integer.valueOf. No podemos usar value y param juntos, pero si está permitido no usar ninguna.
param
Este parámetro opcional designa el parámetro de la petición del que se debería derivar la propiedad. Si la petición actual no tiene dicho parámetro, no se hace nada: el sistema no pasa null al método seleccionador de la propiedad. Así, podemos dejar que el bean suministre los valores por defecto, sobrescribiéndolos sólo cuando el parámetro dice que lo haga. Por ejemplo, el siguiente código dice "selecciona el valor de la propiedad
numberOfItems a cualquier valor que tenga el parámetro numItems de la petición, si existe dicho parámetro, si no existe no se hace nada"
Si omitimos tanto value como param, es lo mismo que si suministramos un nombre de parámetro que corresponde con el nombre de una propiedad. Podremos tomar esta idea de automaticidad usando el parámetro de la petición cuyo nombre corresponde con la propiedad suministrada un nombre de propiedad de "*" y omitir tanto value como
param. En este caso, el servidor itera sobre las propiedades disponibles y los parámetros de la petición, correspondiendo aquellas con nombres idénticos.
Hemos terminado la explicación directiva page y jsp:usebeans.
Y regresamos al ejercicio…
El jsp inicioLibro.jsp muestra un elemento form en donde los usuarios pueden escribir su nombre, apellido y email. Cuando el usuario envía el elemento form se vuelve a pedir la jsp inicioLibro.jsp, de manera que pueda utilizar todos los valores de los datos introducidos. De no ser así, inicoLibro.jsp responde con el elemento form otra vez. Para que el usuario pueda llenar los campos faltantes. Si el usuario lo proporciona completo, inicioLibro.jsp reenvía la petición hacia vistaLibro.jsp la cual muestra el contenido del libro de visitantes.
Se utiliza esta directiva page, la cual define la información que esta globalmente disponible en una jsp. Las directivas estan delimitadas por . En este caso, el atributo errorPage de la directiva page se establece en paginaError.jsp para su procesamiento.
Definimos dos acciones . En las 2 primeras lineas, se crea una instancia de un objeto BeanVisitante llamado visitante. Este bean tiene alcance tipo page (existe para usarse solamente en esta pagina). En los siguiente dos renglones, se crea una instancia de un objeto BeanDatos llamado datos. Este bean tiene alcance tipo request (existe para usarse en esta pagina y en cualquier otra que ayude a procesar una sola petición de un cliente). Por lo tanto, cuando inicioLibro.jsp reenvía una petición hacia vistaLibro.jsp
Se muestra como configurar las propiedades del objeto BeanVisitante llamado visitante mediante los valores de los parámetros de la petición. Los elementos input tienen los mismos nombres que las propiedades de BeanVisitante.
Por lo tanto, utilizamos la habilidad de la acción para relacionar los parámetros de la petición con las propiedades del bean, especificando el valor “*” para el atributo property. Se pudo hacer las propiedades individuales , utilizando las siguiente líneas:
Nota: Si los parámetro de la petición tuvieran nombres distintos a los de las propiedades BeanVisitante, podría cambiarse el atributo param en cada una de las acciones anteriores al nombre de petición apropiado.
Creamos nuestra vistaLibro.jsp
Lista de Visistantes
body{
font-family: tahoma, helvetica,arial,sans-serif;
}
table, tr, td, th{
text-align: center;
font-size: .9em;
border: 3px groove;
padding: 5px;
background-color: #dddddd;
}
Lista de Visitantes
Primer Apellido
Primer Nombre
Correo Electronico
13.- julissa
