Tutorial de JSP

Tutorial de JSP (22): Altas, Bajas y Modificaciones en una tabla de una base de datos mySQL con JSP.LICENCIA

Apache 2 Apache HTTP avi AWTComponentes Conector/J Conector J - MySQL Crystal ReportCurso

JSP Ejemplo Ejemplo JSP/NetbeansExpresiones FileZilla FTP Server FormatHM NIS Edit Hola

Mundo IDE J2EEJava JButton JCheckBoxJComboBox JDBC JDK 6 update 11 JDK

6 update 14 JDK 6 update 20 JDK 6 update 20

(Linux)jFrame JLabel JPanel JRadioButtonJSP/SERVLETSJTextField JvDBSearchCombo

BoxKENAI Linux Mercury Mail Transport System MySQL MySQL 5.1 NetbeansNetbeans 6.5 NetBeans

6.7NetBeans 6.8 Netbeans 6.9Netbeans 6.9 (Linux) Netbeans 7.0 NetBenas 6.8 NSIS Palabras

reservadas PHP PHP5 phpMYAdminPOO servlet StringToWideCharStrToCrr StrToDate StrToDateTimeStrToInt StrToInt64 StrToInt64DefStrToIntDef StrToTime Sun

Microsystemswing TButton TComboBoxTDBNavigator TEdit TJvDateEditTPageControl TTabSheet Workbenc

hXAMPP XDEBUG

BLOGROLL

IES Gonzalo NazarenoDELPHI

About.com Club delphi Delphi Resource Center Dr.Bob's Delphi ClinicIDE

Eclipse IDE NetBeans IDEJAVA

GUJ (Mexico) GUJ (Uruguay) Java Hispano Java User Groups(JUGs) java.net Univ. Navarra – Aprenda Java desde 1ºJSP/SERVLETS

http://creativecommons.org/licenses/by-sa/3.0/

Eclipse + JSP Recursos JSP Univ. Huelva – JSP v2.0 / Servlets v2.4 Univ. Navarra – Aprenda Servlets de JavaPHP

Manual PHP PHP Classes Repository Recursos PHPPYTHON

Python – Official WebsiteSGBD

MySQL Oracle Corporation (Java) PostgreSQLVISITAS:

380,546 hits

buscar

1 Votes

Realizaremos en esta entrada un ejercicio de utilización de JSP para resolver la creación,

modificación y eliminación de registros en una tabla denominada libros de una base de datos

denominada biblioteca diseñada en mySQL. El ejemplo es un mero ejercicio didáctico de

cómo utilizar JSP, advirtiendo que dicho ejercicio en sentido estricto habría que resolverlo con

cierto carácter científico con ayuda de un servlet y respetando el Modelo Vista Controlador

(que dejaremos para más adelante).

La tabla es la que sigue,

con

http://jtagua.wordpress.com/2012/12/26/tutorial-de-jsp-22-altas-bajas-y-modificaciones-en-una-tabla-de-una-base-de-datos-mysql-con-jsp/image1-59/#main


Iniciamos seguidamente una sesión de Netbeans y hacemos desde el menú principal Archivo,

Proyecto nuevo, Java Web, Web Application, llamamos al proyecto GesTablaJSP y

sustituimos el archivo index.jsp plantilla por el siguiente código:

<%--

Document   : index

Created on : 25-dic-2012, 10:05:15

Author     : Jtaguaa

--%>

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

html>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Actualizar, Eliminar, Crear registros.</title>

</head>

<body>

<form action="AECTabla.jsp" method="post" name="Actualizar"></form>

<table>

<tr>

<td>ISBN</td>

<input type="text" name="isbn" value="" size="40"/>

</tr>

<tr>

<td>Título</td>

<input type="text" name="titulo" value="" size="50"/>

</tr>

<tr><td> Action </td>

<td>

<input type="radio" name="Action" value="Actualizar" /> Actualizar

<input type="radio" name="Action" value="Eliminar" /> Eliminar

<input type="radio" name="Action" value="Crear" checked /> Crear

</td>

</tr>

<input type="SUBMIT" value="Submit" />

</tr>

</table>

</form>

</body>

</html>

donde puede verse que se trata de código HTML con JSP que describe un formulario. Esto es

lo que más tarde en el Modelo, Vista Controlador será la “Vista”, es decir, la presentación de

los datos de los distintos campos de la tabla.

La ejecución de dicho archivo presenta en el cliente o en el browser la pantalla

Si en esta pantalla pulsamos Submit enviaremos una petición al servidor de la página

AECTabla.jsp, amén de la cabecera de la petición, enviaremos los tres variables implicadas

en el formulario, es decir: isbn, titulo y Action.

Tenemos pues que crear en el mismo proyecto otro archivo jsp que resuelva la cuestión del

alta, modificación o eliminación de los registros. Para ello, una vez seleccionado el proyecto,

hacemos click con el botón derecho para mostrar el menu contextual


Damos nombre AECTabla al nuevo archivo jsp y sustituimos seguidamente el código de la

plantilla por el siguiente,

<%--

Document   : AECTabla

Created on : 25-dic-2012, 10:11:06

Author     : Jtaguaa

--%>


<%@page import = "java.sql.*" %>

<%

/* Paso 1) Obtener los datos del formulario */

String ls_isbn = request.getParameter("isbn");


String ls_titulo = request.getParameter("titulo");

String ls_action = request.getParameter("Action");

/* Paso 2) Inicializar variables */

String ls_result = "Base de datos actualizada...";

String ls_query = "";

String ls_dburl = "jdbc:mysql://127.0.0.1:3306/biblioteca";

String ls_usuario = "root";

String ls_password = "";

String ls_dbdriver = "com.mysql.jdbc.Driver";

/* Paso 3) Crear query */

if (ls_action.equals("Crear")) {

ls_query = " insert into libros (isbn, titulo)";

ls_query += " values (";

ls_query += "'" + ls_isbn + "',";

ls_query += "'" + ls_titulo + "')";

}

if (ls_action.equals("Eliminar")) {

ls_query = " delete from libros where isbn = ";

ls_query += "'" + ls_isbn + "'";

}

if (ls_action.equals("Actualizar")) {

ls_query = " update libros";

ls_query += " set titulo= " + "'" + ls_titulo + "',";

ls_query += " where isbn = " + "'" + ls_isbn + "'";

}

/* Paso4) Conexión a la base de datos */

Connection l_dbconn = null;

try {

Class.forName(ls_dbdriver);

/* getConnection(URL,User,Pw) */

l_dbconn =

DriverManager.getConnection(ls_dburl,ls_usuario,ls_password);

/*Creación de SQL Statement */

Statement l_statement = l_dbconn.createStatement();

/* Ejecución de SQL Statement */

l_statement.execute(ls_query);

} catch (ClassNotFoundException e) {

ls_result = " Error creando el driver!";

ls_result += " <br/>" + e.toString();

} catch (SQLException e) {

ls_result = " Error procesando el SQL!";


} finally {

/* Cerramos */

try {

if (l_dbconn != null) {

l_dbconn.close();

}

} catch (SQLException e) {

ls_result = "Error al cerrar la conexión.";


}

}

%>

html>

<html>

<head><title>Updating a Database</title></head>

<body>

La siguiente instrucción fue ejecutada:

<br/><br/>

<%=ls_query%>

<br/><br/>

El resultado fue:

<br/><br/>

<%=ls_result%>

<br/><br/>

<a href="index.jsp">Entre otro valor</a>

</body>

</html>

Para dar de alta un libro entraremos la información correspondiente al libro cuyo título es Java

Servlet Programming (2ed) y el isbn 0596000405, es decir

Si pulsamos “Submit”,

y vemos con phpAdmin que se ha creado un resgistro.

De forma similar se resolvería la Actualización o Eliminación del registro.




Obsérvese que no se han previsto, de manera razonable, las incidencias correspondientes a

1. La Alta de un registro ya existente.

2. La Baja de un registro inexistente.

3. La Actualización de un registro no existente.

Se le sugiere al lector que estudie estos casos y modifique convenientemente el archivo

AECTabla. Como ayuda, intente controlar el objeto e del tipo SQLException a través del

método e.getErrorCode(), y a partir de ahí muestre un mensaje más específico.

Cuaderno 1: Ejercicios Básicos JSPDescargar cuaderno: https://www.dropbox.com/s/71mmhuk2g6zvqpz/Ejemplos_servlets_jsp_1.docx


<%@page import="java.text.*, java.util.*"%>

<!DOCTYPE html>

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>JSP Page</title>

</head>

<body>

<h1>Fecha</h1>

<%

Date d = new Date();

String hoy = DateFormat.getDateInstance().format(d);

%>

Hoy es <%=hoy%>

</body>

</html>

<%

String nombre = request.getParameter("NOMBRE");

if(nombre!=null && nombre.length()>0){

out.println("Hola " + nombre);

}else{

out.println("No tienes acceso. ");

}

%>

Ejemplo 1: Hola Mundo.

Página HTML

<html>

<head><title>Primer Servlet</title>

</head>

<body><center><h2>Ejemplo de Ejecución de un Servlet</h2></center><br><br><form action=/PrimerServlet/PrimerServlet method=GET><Center>

<BR><input type=submit value="Ejecutar el Servlet"></form></center></body>

</html>

Código del Servlet

//Primer Servlet.//Muy sencillo.

import java.io.*;import javax.servlet.*;import javax.servlet.http.*;

public class PrimerServlet extends HttpServlet{

public void doGet (HttpServletRequest req, HttpServletResponsethrows ServletException, IOException{

res.setContentType("text/html");PrintWriter out = new PrintWriter(res.getOutputStream());out.println("<html>");out.println("<head><title>HolaMundoServlet</title></head>");out.println("<body>");out.println("<h1><center>Hola Mundo desde el servidor

WEB</center></h1>");out.println("</body></html>");out.close();

}

public String getServletInfo(){

return "Crea una página HTML que dice HolaMundo";}

}

Ejemplo 2: Acceso básico a formularios.

Página HTML

<html><head>

<title>Segundo Servlet</title></head><body>

<h2><center>Segundo Servlet</center></h2><form action=/SegundoServlet/SegundoServlet method=POST><BR><BR><center>Introduzca su nombre y pulse el botón de enviar<BR><BR><input type=text name=NOMBRE><BR><BR><input type=submit value="Enviar Nombre">

<input type=reset value="Borrar"></center></form>

</body></html>

Código del Servlet

//// SegundoServlet.java//import javax.servlet.*;import javax.servlet.http.*;import java.io.*;

public class SegundoServlet extends HttpServlet{

String nombre;

public void service( HttpServletRequest peticion, HttpServletResponserespuesta )

throws ServletException, IOException{

nombre = peticion.getParameter("NOMBRE");ServletOutputStream out = respuesta.getOutputStream();

out.println("<html>");out.println("<head><title>HolaTalServlet</title></head>");out.println("<body>");out.println("<p><h1><center>Su nombre es:

<B>"+nombre+"</B></center></h1></p>");out.println("</body></html>");

out.close();}

}

Ejemplo 3: Calculadora.

Página HTML

<HTML>

<HEAD><TITLE>Calculadora con Servlet</TITLE>

</HEAD>

<BODY BGCOLOR = "#E0FFE0" TEXT= "green" LINK="blue"

<CENTER><HR style = "color:green; heigth:6px; width:500"><FONT size = 5> CALCULADORA </FONT><HR style = "color:green; heigth:6px; width:500"><BR><BR>

<FORM action=/CalculadoraServlet/CalculadoraServlet method=POST><TABLE border = "3" WIDTH = "400" >

<TR><TD aling = "rigth"> <INPUT name="operando1" type="text">

</TD><TD> <SELECT name="operacion">

<OPTION value= "1" selected >  +

  </OPTION><OPTION value= "2" >   -

  </OPTION><OPTION value= "3" >   *

  </OPTION><OPTION value= "4" >   /

  </OPTION></SELECT>

<TD aling = "rigth"> <INPUT name="operando2" </TD>

</TR></TABLE><BR><BR><input name="Calcular" value="Calcular" type="submit">     <input name="limpiar" value="Limpiar" type="reset">

</FORM></CENTER>

</BODY>

</HTML>

Código del Servlet

//// CalculadoraServlet//

import java.io.*;import javax.servlet.*;import javax.servlet.http.*;

public class CalculadoraServlet extends HttpServlet{

public void service (HttpServletRequest req, HttpServletResponseres)


double op1, op2, result;int operacion;String simb_op[] = {"+", "-", "*","/"};

ServletOutputStream out = res.getOutputStream();

op1 = Double.parseDouble(req.getParameter("operando1"));op2 = Double.parseDouble(req.getParameter("operando2"));operacion = Integer.parseInt(req.getParameter("operacion"));

result = calcula(op1, op2, operacion);

out.println("<html>");out.println("<head><title>Resultado de calcular con

Servlet</title></head>");out.println("<body BGCOLOR = \"#E0E0FF\" TEXT=out.println("<h1><center>La operacion efectuada

es:</center></h1>");out.println("<h2> <b><center>"+ op1+" "+ simb_op[operacion-

1] +" "+ op2 +" = "+ result +

"</center></b></h2>");out.println("</body>");out.println("</html>");out.close();

}

public double calcula(double op1, double op2, int operacion){

double result = 0;

switch (operacion){

case 1:return op1 + op2;

case 2:return op1 - op2;

case 3:

return op1 * op2;case 4:

return op1 / op2;}

return result;}

}

Ejemplo 4: Primitiva.

Página HTML

<html><head>

<title>Primitiva Servlet</title></head><body>

<h2><center>Primitiva Servlet</center></h2><form action=/PrimitivaServlet/PrimitivaServlet method=POST><BR><BR><center>Introduce tu combinación y pulsa el botón de enviar<BR><BR>NUM1:<input type=text name=NUM1><BR>NUM2:<input type=text name=NUM2><BR>NUM3:<input type=text name=NUM3><BR>NUM4:<input type=text name=NUM4><BR>NUM5:<input type=text name=NUM5><BR>NUM6:<input type=text name=NUM6><BR><BR><input type=submit value=Enviar Combinación>

<input type=reset value=Borrar></center></form>

</body></html>

Código del Servlet

//// PrimitivaServlet.java//import javax.servlet.*;import javax.servlet.http.*;import java.io.*;import java.util.*;

public class PrimitivaServlet extends HttpServlet{

int primi[] = new int[6], combiUsuario[] = new int[6];int i, contador=0, aux, aciertos=0;Random rand = new Random();

public void init(ServletConfig config) throws ServletException{

super.init(config);

//generamos los númeroswhile (contador<6){

aux = rand.nextInt(48) + 1;if (!comprueba(primi,aux)){primi[contador] = aux;

contador++;}

}//ordenamos el arrayArrays.sort(primi);

}

private boolean comprueba(int array[], int num){

for (int i=0; i<=5; i++){

if (primi[i]==num) return true;}return false;

}

public void service( HttpServletRequest peticion, HttpServletResponserespuesta )


aciertos=0;

ServletOutputStream out = respuesta.getOutputStream();

combiUsuario[0] =Integer.parseInt(peticion.getParameter("NUM1"));




combiUsuario[4] =

Integer.parseInt(peticion.getParameter("NUM5"));combiUsuario[5] =

Integer.parseInt(peticion.getParameter("NUM6"));

out.println("<h2><center>Primitiva Servlet</center></h2>");

//imprimimos todos los números de la combinación del usuario

out.print("<p>Tu combinación es:</p><B>");

for (i=0; i<6; i++){

out.print(" "+combiUsuario[i]);}out.print("</B>");

//comprobamos la combinaciónfor (i=0; i<=5; i++){

if (Arrays.binarySearch(primi,combiUsuario[i])>=0){

out.println("<p>Número acertado:<B>"+combiUsuario[i]+"</B></p>");

aciertos++;}

}out.println("<p>Números acertados: <B>"+aciertos+"</B></p>");

//imprimimos todos los números de la combinación ganadora

out.print("<p>La combinación ganadora es:</p><B>");

for (i=0; i<6; i++){

out.print(" "+primi[i]);}out.print("</B>");

out.close();}

}

Ejemplo 5: Acceso a Ficheros de Texto Plano.

Página HTML

<html><head>

<title>Segundo Servlet</title></head><body>

<h2><center>Segundo Servlet</center></h2><form action=/FicheroServlet/FicheroServlet method=POST><BR><BR><center>Introduzca su nombre y pulse el botón de enviar<BR><BR><input type=text name=TEXTO><BR><BR><input type=submit value=Enviar Nombre>

<input type=reset value=Borrar></center></form>

</body></html>

Código del Servlet

//// FicheroServlet.java//import javax.servlet.*;import javax.servlet.http.*;import java.io.*;

public class FicheroServlet extends HttpServlet{

StringBuffer mensaje = null;FileOutputStream fos = null;String[] strTEXTO;

public void init(ServletConfig config) throws ServletException{

super.init(config);

FileInputStream fis = null;try{

fis = new FileInputStream("c:\\tmp\\texto.txt");}catch(java.io.FileNotFoundException e){

e.printStackTrace();}

mensaje = new StringBuffer();

try{

int caracter;while ( (caracter = fis.read()) != -1 ){

mensaje.append((char)caracter);}fis.close();

}catch(java.io.IOException e){


try{

fos = new FileOutputStream("c:\\tmp\\log.txt");}catch(java.io.IOException e){


}

public void service( HttpServletRequest peticion,HttpServletResponse respuesta )


strTEXTO = peticion.getParameterValues("TEXTO");ServletOutputStream out = respuesta.getOutputStream();

out.println("<p>"+mensaje+"</p>");out.println("<p>Su nombre es: "+strTEXTO[0]+"</p>");out.close();

registrar();}

public void destroy(){

try{

fos.close();}catch(java.io.IOException e){


}

public synchronized void registrar(){

try{

fos.write(strTEXTO[0].getBytes());}catch(java.io.IOException e){


}

}

Ejemplo 6: Ejemplo JSP de uso de la directiva INCLUDE

<HTML>

<head><title> Página de prueba de directivas de compilación </title></head>

<body><h1> Página de prueba de directivas de compilación </h1>

<%@ include file=”/fich1.html” %>

<%@ include file=”/fich2.jsp” %>

</body>

</HTML>

· fich1.html<HTML><head> <title> Hola, Mundo </title> </head><body> <h1> ¡Hola, Mundo! </h1></body></HTML>

· fich2.jsp<%@ page info="Un ejemplo Hola Mundo" import="java.util.Date"La fecha de hoy es: <%= new Date().toString() %>

Ejemplo 7: Ejemplo JSP de uso de formularios

Página comprobar.html.

<HTML><head> <title> Ejemplo de uso del forward </title></head>

<body>

<h1> Ejemplo de uso del forward </h1><form method=“post” action=“comprobar.jsp”>

<input type=“text” name=“Nombre”><br> y clave:<input type=“password” name=“password”> </p><p><input type=“submit” name=“login”></form>

</body></HTML>

Página comprobar.jsp.

<% if((request.getParameter(“Nombre”).equals(“Roberto”)) &&

(request.getParameter(“password”).equals(“xyzzy”))) {%>

<jsp:forward page=“saludoforward.jsp”/>

<% } else { %><%@ include file=“comprobar.html”%><% } %>

Página saludoforward.jsp.

<HTML><head><title> Saludo al cliente </title></head>

<body><h1> Saludo al cliente</h1>

<%out.println(“Bienvenido a la nueva aplicación");%>

</body></HTML>

Ejemplo 8: Ejemplo JSP de uso de objetos implícitos

Página HTML

<HTML><head><title> Formulario de petición de nombre </title></head>

<body><h1> Formulario de petición de nombre </h1>

<form method="post" action="saludo.jsp"><p> Por favor, introduce tu nombre:<input type="text" name="nombre"></p><p> <input type="submit" value="enviar información"></form>

</body>

</HTML>

Página JSP –saludo.jsp

<HTML><head> <title> Saludo al cliente </title>

</head>

<body><h1> Saludo al cliente</h1><%-- Los parámetros que le pasa el cliente en la petición seobjeto implícito request --%>

<%String nombre = request.getParameter(”nombre");out.println(”Es un placer conocerte, “ + nombre);%>

<%-- Al evaluarse el código hay que escribir explícitamente en(objeto implícito out) --%></body></HTML>

Los frijoles y el procesamiento de formularios

Los formularios son un método muy común de las interacciones en los sitios web. JSP hace procesamiento de formularios especialmente fácil.

La forma estándar de manejo de formularios en JSP es definir un

"grano". Esto no es un grano completo de Java. Sólo tiene que definir una clase que tiene un campo correspondiente a cada campo en el formulario. Los campos de clase deben tener "setters" que responden a los nombres de los campos del formulario. Por ejemplo, vamos a modificar nuestro GetName.html recoger también dirección de correo electrónico y edad.La nueva versión de GetName.html es<HTML><BODY><FORM Method=post ACTION="SaveName.jsp">¿Cómo te llamas? <INPUT Type=text NAME=username SIZE=20> <BR>¿Cuál es su dirección de correo electrónico? <INPUT Type=text NAME=email SIZE=20> <BR>¿Cuál es su edad? <INPUT Type=text NAME=age size=4><P> <INPUT Type=submit></ FORM></ BODY></ HTML>Para recopilar estos datos, se define una clase Java con los campos " nombre de usuario "," email "y" edad "encontrarás métodos setter"setUsername "," setEmail "y" setAge ", tal como se muestra. Un método "setter" es sólo un método que empieza con " set "seguido por el nombre del campo. El primer carácter del nombre del campo es en mayúscula. Así que si el campo es " email ", su" setter método "será" setEmail ". Los métodos Getter se definen de manera similar, con "get" en lugar de "set". Tenga en cuenta que los setters y getters () deben ser públicos.

usuario del paquete;

Clase pública UserData { Cadena nombre de usuario; Email String; int edad;

setUsername public void (String value) { username = valor; }

public void setEmail (valor de cadena) { email = valor; }

void setAge público (int valor) { edad = valor; }

getUsername public String () {return nombre de usuario;}

public String getEmail () {email return;}

ObtenerLongevidad public int () {edad return;}}Los nombres de los métodos deben ser exactamente como se muestra. Una vez definida la clase, compilarlo y asegúrese de que está disponible en la ruta de clase del servidor Web. El servidor también puede definir carpetas especiales donde se pueden colocar las clases de frijol, por ejemplo, con Blazix puede colocarlos en el " clases carpeta ". Si tiene que cambiar la ruta de clase, tendría que ser detenido y reiniciado si ya se está ejecutando el servidor web. (Si usted no está familiarizado con la creación / modificación ruta de clase, consulte las notas sobre el cambio de ruta de clases .)

Tenga en cuenta que estamos usando el nombre del paquete de usuario , por lo tanto, el archivo UserData.class debe ser colocado en una carpeta con el nombre del usuario en la entrada classpath.Ahora vamos a cambiar " SaveName.jsp "utilizar un bean para recopilar los datos.<jsp:useBean id="user" class="user.UserData" Scope="Session"/><jsp:setProperty name="user" property="*"/><HTML><BODY><A HREF="NextPage.jsp"> Continuar </ A></ BODY></ HTML>Todo lo que necesitamos hacer ahora es añadir el jsp: useBean etiqueta y el jsp: setProperty etiqueta! La etiqueta useBean buscará una instancia de la " user.UserData "en la sesión. Si la instancia que ya está ahí, se actualizará la instancia anterior. De lo contrario, se creará una nueva instancia de user.UserData (la instancia del user.UserData se llama un grano), y lo puso en la sesión.

El setProperty recogerá automáticamente los datos de entrada, haga coincidir los nombres con los nombres de los métodos de frijol, y colocar los datos en el bean!Vamos a modificar NextPage.jsp para recuperar los datos de frijol ..<jsp:useBean id="user" class="user.UserData" Scope="Session"/><HTML><BODY>

http://www.jsptut.com/Classpath.html

http://www.jsptut.com/Classpath.html

Ha introducido <BR>Nombre: <% = user.getUsername ()%> <BR>Email: <% = user.getEmail ()%> <BR>Edad: <% = user.getAge ()%> <BR></ BODY></ HTML>Tenga en cuenta que la misma etiqueta useBean se repite. El grano está disponible como la variable llamada " usuario "de la clase" user.UserData ".Los datos introducidos por el usuario se recogieron en todo el grano.

En realidad no necesitamos el " SaveName.jsp ", el objetivo de GetName.html podría haber sido NextPage.jsp , y los datos todavía estaríamos disponibles de la misma manera, siempre y cuando añadimos un jsp: setProperty tag. Pero en el siguiente tutorial, que realmente utilizaremosSaveName.jsp como un controlador de errores que automáticamente reenvía la solicitud al NextPage.jsp , o le pide al usuario que corrija los datos erróneos.

Ejercicio: 1) Escriba un conjunto JSP / HTML que permite al usuario introducir el nombre de una propiedad del sistema y, a continuación, muestra el valor devuelto por System.getProperty para ese nombre de propiedad (controlar los errores appripriately) 2) Volver a los ejercicios. que ha modificado manualmente las variables booleanas. En lugar de una variable booleana, hacer que estos vienen de un campo de formulario oculto que se puede establecer en true o false.

ControladoresA veces, algunas necesidades de tratamiento previo, de que hay que hacer después de que el usuario ha enviado un formulario. El resultado de esta pre-procesamiento decide donde el flujo de control debe ir a continuación. Dicho código de pre-procesamiento se refiere con frecuencia como un "controlador".

JSP son muy muy apropiados para escribir controladores simples. Para la lógica del controlador más complejo, JSP pueden llamar fácilmente el código Java en otras clases. Un controlador de ejemplo se muestra a continuación:

<jsp:useBean id="user" class="user.UserData" Scope="Session"/><jsp:setProperty name="user" property="*"/><% Cadena tgtPage = null;

if (user.choice.equals ("Choice1")) tgtPage = "tgt1.jsp"; else if (user.choice.equals ("elección2")) tgtPage = "tgt2.jsp"; más tgtPage = "tgtDefault.jsp"; response.sendRedirect (tgtPage);%>He aquí un fragmento de código muy simple, que es determinar la siguiente JSP para transferir el control a. (Tenga en cuenta que no se utiliza realmente cualquier salida generada por este JSP, ya que el navegador se enviará a una ubicación diferente!)

Si la lógica fue más complicado, que podría haber sido puesto en una clase de Java y JSP podría haber hecho llamadas a la clase Java.Algunos marcos utilizan mecanismos mucho más complicadas de hacer algo tan simple como esto. Por ejemplo, estos mecanismos complicados pueden requerir archivos de configuración que tienen que ser cambiado para cada cambio en el flujo de llamadas, y pueden implicar las clases de Java con determinadas reglas complicadas.Sin embargo, una revisión objetiva revela que no hay ninguna ventaja real de estos mecanismos excesivamente complicados. Simplemente introduce muchos más lugares donde las cosas pueden y llegan a salir mal.A veces, el deseo de utilizar estos mecanismos más complicados se debe a un malentendido - que JSPs son para exhibición, por lo tanto, nunca pueden ser usados cuando su producción no es de interés. Esto no es correcto.Es cierto que las páginas JSP son principalmente HTML con código incrustado. Sin embargo, tienen muchas ventajas, como la necesidad de una configuración menos (por lo general ninguno), y que es fácil de modificar y distribuir. Por lo tanto, pueden prestarse a otros usos, tales como escribir controladores simples y directas. En última instancia, JSP son sólo una herramienta en su caja de herramientas. Usted debe mirar y evaluar cada herramienta de manera objetiva, y con ellos hará de la mejor manera. Eso significa que el uso de JSP como controladores, mientras que proporcionan el medio más sencillo y más eficaz de hacerlo.Esto es aún más importante para proyectos grandes. Los grandes proyectos suelen tener ya una gran complejidad. La adición de más complejidad a través de marcos complicados no se recomienda. Como veteranos experimentados y exitosos de grandes proyectos saben, es especialmente importante en grandes proyectos para evitar la complejidad y encontrar soluciones simples y elegantes.

Bibliotecas de etiquetas

JSP 1.1 introduce un método de extender etiquetas JSP, llamadas "bibliotecas de etiquetas". Estas bibliotecas permiten la adición de etiquetas similares ajsp: include o jsp: forward , pero con diferentes prefijos que no sean jsp: y con características adicionales.

Para presentarle a bibliotecas de etiquetas, en este tutorial se utiliza la biblioteca de etiquetas Blazix como ejemplo. Esta biblioteca de etiquetas viene incluido con el servidor Blazix . Si no está utilizando el servidor Blazix, es posible que sólo desee revisar el material para familiarizarse con la sintaxis, y continuar a la siguiente página.Cada etiqueta-biblioteca tendrá su propia documentación específica tag-biblioteca. Para utilizar la biblioteca de etiquetas, se utiliza la directiva "taglib" para especificar donde reside "descripción" de la biblioteca de etiquetas. Para la biblioteca de etiquetas Blazix, la Directiva (recomendado) es el siguiente:<% @ Taglib prefix = uri "BLX" = "/ blx.tld"%>El "uri" especifica dónde encontrar la descripción de biblioteca de etiquetas. El "prefijo" es único para la biblioteca de etiquetas. Esta directiva está diciendo que vamos a utilizar las etiquetas de esta biblioteca, comenzando con BLX:

La biblioteca de etiquetas Blazix proporciona una BLX: tag getProperty. Esta etiqueta se puede utilizar para permitir al usuario editar los datos del formulario. En nuestro archivo GetName.jsp, ahora vamos a añadir un jsp: useBean y colocar el formulario en BLX: getProperty.El nuevo GetName.jsp es<% @ Taglib prefix = uri "BLX" = "/ blx.tld"%><jsp:useBean id="user" class="user.UserData" Scope="Session"/><HTML><BODY><blx:getProperty name="user" property="*"><FORM Method=post ACTION="SaveName.jsp">¿Cómo te llamas? <INPUT Type=text NAME=username SIZE=20> <BR>¿Cuál es su dirección de correo electrónico? <INPUT Type=text NAME=email SIZE=20> <BR>¿Cuál es su edad? <INPUT Type=text NAME=age size=4><P> <INPUT Type=submit></ FORM></ BLX: getProperty></ BODY></ HTML>Tenga en cuenta que la BLX: getProperty no termina con /> sino que se denuncie por uno <separada / BLX: getProperty> line. Esto pone a todos los campos de entrada del formulario dentro del BLX: getProperty para que puedan ser

http://www.blazix.com/blazixserver.html

modificados apropiadamente por la biblioteca de etiquetas.

Trate de poner un enlace a GetName.jsp del NextPage.jsp, y verá que los datos del bean aparece automáticamente en los campos de entrada.Ahora el usuario puede editar los datos.Todavía tenemos un par de problemas. El usuario no puede limpiar el campo de nombre. Por otra parte, si el usuario introduce un mal elemento en el campo "edad", algo que no es un entero válido, se produce una excepción de Java.Usaremos otra etiqueta de la biblioteca de etiquetas Blazix para cuidar de esto. Blazix ofrece una BLX: setProperty que se puede utilizar para hacerse cargo de esos problemas. BLX: setProperty nos permite definir un método de controlador de excepciones. Si se produce una excepción, se puede recoger un mensaje de error al usuario y seguir procesando.A continuación se presenta una versión de SaveName.jsp que procesa los errores, y, o bien muestra la GetName.jsp usuario nuevo para el usuario puede introducir los datos correctamente o reenvía automáticamente a NextPage.jsp.<% @ Taglib prefix = uri "BLX" = "/ blx.tld"%><%! booleano haveError; Errores StringBuffer;

errorHandler public void (campo Cadena, Valor de cadena, Exception ex) { haveError = true; if (errores == null) errores = new StringBuffer (); más errors.append ("<P>"); errors.append ("Valor <P> para el campo \" "+ campo + "\" no es válido ").; if (java.lang.NumberFormatException ex instanceof) errors.append ("El valor debe ser un número."); }%><% / / Las variables se deben inicializar fuera declaración! haveError = false; errors = null;%><HTML><BODY><jsp:useBean id="user" class="user.UserData" Scope="Session"/><BLX: Nombre setProperty = "user" propiedad = "*" onError = "errorHandler" /><% if (haveError) {

out.println (errors.toString ()); pageContext.include ("GetName.jsp"); } Else pageContext.forward ("NextPage.jsp");%></ BODY></ HTML>Tenga en cuenta que haveError y errores deben ser re-inicializado cada vez, por lo que se están inicializando fuera de la declaración.

[Observe también el uso de pageContext.include y pageContext.forward . Estos son como jsp: include y jsp: forward , pero es más cómodo de usar desde dentro de los bloques de Java. p ageContext es otra variable predefinida que hace que sea fácil de hacer ciertas operaciones dentro de los bloques de Java.]En este caso, si se produce un error durante el procesamiento de BLX: setProperty , se muestra el error y, a continuación incluimos el GetName.jspvez que el usuario pueda corregir el error. Si no se producen errores, se transmitirá de oficio al usuario NextPage.jsp .

Todavía hay un problema con las formas, la "edad" se muestra como cero inicial en lugar de estar vacía. Esto se puede solucionar mediante la adición de " emptyInt = 0 " tanto a la BLX: getProperty y BLX: setProperty etiquetas (. campos de frijol deben ser inicializados a 0) Sucede que "0" no es un valor válido para la edad, por lo que podemos utilizar "0" para marcar las cadenas vacías. Si "0" fuera un valor válido para la edad, podríamos haber añadido " emptyInt = -1 "(y se aseguró para inicializar los campos de frijol a -1).Otro pequeño problema es que la etiqueta "<HTML>" se duplica si se produce un error y terminamos como "GetName.jsp". Una solución más elegante es quitar el out.println, y pasar de nuevo el error, como se muestra<% if (haveError) { request.setAttribute ("errores", errors.toString ()); pageContext.forward ("GetName.jsp"); } Else pageContext.forward ("NextPage.jsp");%>Podemos entonces hacer un " request.getAttribute "en el GetName.jsp , y si el valor devuelto no es nulo, visualice el error.

Pasar datos entre JSPs y Servlets. Page, Request, Session y Application scope

Veamos aquí cómo pasar datos entre las páginas JSP y los Servlets. Aprovechamos para

comentar los cuatro tipos posibles de scope (alcance) de las variables.

Page Scope

Son variables que solo se ven dentro de nuestro JSP o Servlet mientras se está ejecutando. Una

vez construída y enviada la respusta al navegador, desaparecen. Su única utilidad es ayudarnos a

construir la página que queremos mostrar en el navegador. Dentro del JSP serían variables

normales de JSP

<% int variable = 33; %>...<p>La variable vale <%= variable %></p>

y dentro de un Servlet no serían más que variables locales de nuestros métodos doGet() o

doPost().

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { int variable = 33; ... resp.getWriter().print("<p> La variable vale " + variable + "</p>");

Request Scope

Estas variables son más útiles. Las guardamos en la petición que nuestro JSP/Servlet van a hacer

a otro JSP/Servlet de nuestra aplicación, y este segundo JSP/Servlet puede recogerlos para hacer

cosas con ellas.

Dentro del objeto request, podríamos fijar estas variables con setParameter() o con setAttribue(). y

obtener los valores ocn los getParameter() o getAttribute().

request : set y get parameter

En principio no debemos usar este método. Está reservado para los form de html de nuestras

páginas jsp. Cuando pulsemos el botón "submit" del formulario, él se encargará de rellenar los

setParameter()

<form action="destino.jsp"><input type="text" name="variable" /><input type="submit value="Enviar" /></form>

En el formulario anterior, al pulsar el submit "Enviar", automáticamente se hará un

request.setParameter("variable", valor en la caja de texto) que luego podrá leer nuestra página de

destino (destino.jsp en nuestro ejemplo) o el servlet. "variable" es el name del input type="text". Se

guardará uno por cada input que tengamos en el form, cada uno con el nombre que diga su

atributo "name".

En la página jsp de destino podemos recoger los valores del formulario de esta forma

<% String variable = request.getParameter("variable"); %><p>Me han pasado <%= variable %></p>

y en un servlet lo recogeríamos del parámetro HttpRequest que nos pasan

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String variable = req.getParameter("variable"); ... resp.getWriter().print("<p> La variable vale " + variable + "</p>");

Un detalle a tener en cuenta es que estos "parameter" sólo pueden guardar valores de tipo "String".

request : set y get Attribute

Dentro de request, los attribute son lo que nosotros como programadores podemos usar a gusto.

Podemos guardar y recibir cualquier Object java que queramos sin más que ponerles un nombre.

Sin embargo, el request desaparece en cuanto terminamos de procesar la página/Servlet actual,

así que la única forma de pasar estos attributes a la siguiente es haciendo un fordward() desde

nuestro request. Por ejemplo, en una página jsp podemos poner

<% request.setAttribute("unEntero", new Integer(22)); request.getRequestDispatcher("destino.jsp").forward(request, response); %>

y en destino.jsp recibiríamos unEntero de esta forma

<p>Me ha llegado <%= request.getAttribute("unEntero") %></p>

Igualmente, desde un Servlet, poddríamos hacer la siguiente redirección

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.setAttribute("unEntero", new Integer(22)); ... resp.getRequestDispatcher("destino.jsp").forward(req, resp);

y en un Servlet recogeríamos estos attribute, vengan de un jsp o de otro servlet, así

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Integer variable = (Integer)req.getAttribute("unEntero"); ... resp.getWriter().print("<p> La variable vale " + variable + "</p>");

Session scope

Las variables Session scope se mantienen durante lo que se conoce como una sesión. Cuando un

usuario visita nuestra aplicación por primera vez, automáticamente se crea una sesión para ese

usuario. Esta sesión suele estar abierta mientras el usuario va navegando por las páginas de

nuestra aplicación y desaparece cuando el usuario deja de navegar por nuestra aplicación durante

un tiempo predeterminado.

Dicho de otra forma, cualquier valor que guardemos en la sesión del usuario, sólo será visible por

las páginas que visite ese usuario y mientras el usuario esté activo. Son las variables típicas donde

guardar si un usuario ha entrado en sesión, su nombre, su carrito de la compra si nuestra

aplicación es de comercio electrónico, etc.

En una página JSP guardaríamos los objetos java que queramos por medio de la variable session

ya predefinida

<% session.setAttribute("variable", new Integer(22));

y en otra página JSP lo obtendríamos con

<p>Me ha llegado <%= session.getAttribute("variable") %></p>

Y en un Servlet, igual de fácil obteniendo la session del request que nos llega como parámetro

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.getSession().setAttribute("variable", new Integer(22)); ...

y para leer

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Integer variable = (Integer)req.getSession().getAttribute("variable"); ... resp.getWriter().print("<p> La variable vale " + variable + "</p>");

Application scope

Estas variables son válidas para la aplicación. Permanecen hasta que repleguemos nuestra

aplicación del servidor o echemos el servidor abajo. Son compartidas para todos los usuarios que

visiten nuestra página web.

Dentro de un JSP podemos fijarlas o leerlas con la variable application que viene predefinida en

cualquier JSP, usando los conocidos métodos setAttribute() y getAttribute().

<% // Para fijar una variable en un jsp application.setAttribute("variable", new Integer(22));

// Para leerla en otro o el mismo JSP Integer valor = (Integer)application.getAttribute("variable");%>

Y en un Servlet, se puede acceder obteniendo el ServletContext y llamando a sus métodos

setAttribute() o getAttribute()

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

// Para fijar la variable getServletContext().setAttribute("PI", new Double(3.1416)); ... // Y para leerla en otro o el mismo servlet Double pi = (Double)getServletContext().getAttribute("PI");

jsp:useBean

Ya hemos visto como guardar variables en distintos sitios para pasarlas de un jsp/servlet a otro

jsp/servlet y si queremos que esta variable sólo sea válida durante el paso de una página a otra

(request), para un usuario en cualquier página (session) o para todos los usuarios mientras el

servidor siga levantado (application).

Imagina ahora que estamos haciendo una aplicación que lleva un listado de personas. Esas

personas tienen varios atributos como nombre, apellido, teléfono, dirección, etc, etc. Puede ser un

poco tedioso y sobre todo poco elegante tener que meter todos esos atributos uno a uno en los

sitios (request, session, application) que necesitemos. Una solución más elegante es hacer un

bean Persona con esos atributos. Algo como esto (solo un par de atributos para simplificar)

package com.chuidiang.ejemplos;

public class Persona { private String nombre; private String apellido; // setters y getters}

Tanto en el servlet como en un jsp podemos guardar este bean en cualquiera de los sitios

indicados con setAttribute() y obtenerlo con getAttribute(). Por ejemplo, en un jsp

<% Persona p = new Persona(); p.setNombre("Pedro"); p.setApellido("Lopez"); session.setAttribute("unaPersona", p); // y para obtenerla, en otro jsp o el mismo Persona q = (Persona)session.getAttribute("unaPersona");

y en un Servlet de igual manera

public class UnServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Persona p = new Persona(); p.setNombre("Pedro"); p.setApellido("Lopez"); req.getSession().setAttribute("unaPersona", p); ... // y para leer en el mismo Servlet u otro Persona q = (Persona)req.getSession().getAttribute("unaPersona");

Sin embargo, en jsp tenemos unos tag especiales que nos permiten trabajar con estos bean más al

estilo de una página html, sin meter el código java directamente. Estos tag son <jsp:useBean>,

<jsp:getProperty> y <jsp:setProperty>

Para obtener un bean dentro de jsp lo hacemos así

<jsp:useBean id="unaPersona" scope="session" class="com.chuidiang.ejemplos.Persona"></jsp:useBean>

Aquí ponemos en scope dónde queremos guardar o recoger el bean, es decir, "page", "request",

"session" o "application". El id es el nombre que usábamos antes como nombre de atributo, es

decir "unaPersona". Si ese bean ya existe lo obtenemos, si no existe se crea y se guarda ahí.

Finalmente, en class debemos indicar la clase del bean con paquete y todo, en nuestro caso

"com.chuidiang.ejemplos.Persona".

Dentro del jsp y una vez obtenido el bean, podemos meter valores en sus propiedades o acceder a

ellas

<jsp:setProperty name="unaPersona" property="nombre" value="Pedro"/>...<p>El nombre es <jsp:getProperty name="unaPersona" property="nombre"/></p>

Esta vez name es el nombre del bean, que en jsp:useBean era el id. En property se pone el

nombre de la propiedad (nombre, apellido, etc) y en value, en el caso del setProperty, lo que

queremos que valga. Java es listo y si el atributo de la clase es de tipo boolean, entero, etc, java

convertirá automáticament la cadena de texto al tipo adecuado. Por ejemplo, si nombre fuese

booelan, podríamos poner value="true" y se haría la conversión automáticamente.

En el caso concreto de formularios, jsp:setProperty nos permite recoger fácilmente en la página jsp

de destino los campos del formulario. Imagina el formulario para persona

<form action="salva.jsp">Nombre : <input type="text" name="nombre"/><br/>Apellido : <input type="text" name="apellido"/><br/><input type="submit" value="Salvar"/></form>

Pues bien, en la página salva.jsp que recibe este formulario, podemos crear el bean y rellenar sus

valores así

<jsp:useBean id="nuevaPersona" class="com.chuidiang.ejemplos.Persona" scope="page"/><jsp:setProperty name="nuevaPersona" property="nombre" param="nombre"/><jsp:setProperty name="nuevaPersona" property="apellido" param="apellido"/>

Es decir, en vez de value, indicamos param, siendo param el nombre del campo en el formulario.

Si el nombre del param y del property coinciden, podemos no poner param, que por defecto valdrá

lo mismo que property. Al ser el caso anterior, podríamos escribir

<jsp:useBean id="nuevaPersona" class="com.chuidiang.ejemplos.Persona" scope="page"/><jsp:setProperty name="nuevaPersona" property="nombre"/><jsp:setProperty name="nuevaPersona" property="apellido"/>

y existe aun una facilidad más. Si todos los nombres de los campos coindicen con todos los

nombres de los atributos del bean, entonces con un property="*" los rellenamos todos de un

plumazo, tal que así

<jsp:useBean id="nuevaPersona" class="com.chuidiang.ejemplos.Persona" scope="page"/><jsp:setProperty name="nuevaPersona" property="*"/>

En este ejemplo le hemos puesto scope="page", es decir, esa "nuevaPersona" sólo existirá en

nuestra página jsp y posiblemente la salvemos en base de datos o hagamos cualquier otra cosa

con ella. Podríamos de igual forma haber cogido/creado esa "nuevaPersona" en request, session o

application.

Documents

Tutorial de JSP