Java Server Pages JSP

1
Java Server Pages JSP

• Otra forma de hacer servlets

2
Las JSP

• Son páginas HTML a las que se le inserta código
  que produce servlets
• Se usan cuando la parte estática de la página que
  se debe generar es relativamente importante (la
  parte que no cambia)
• Al cargarse una página JSP esta se compila, se
  genera el servlet y se ejecuta
• Por esto, la primera invocación a una JSP demora
  más que las siguientes

3
Contenido de una JSP

• Una JSP, aparte de código HTML puede contener 3
  tipos de instrucciones
• Elementos de scripting son los elementos que
  definen el comportamiento dinámico del servlet,
  es decir su código
• directivas afectan la estructura general del
  servlet que resulta de la JSP (import, include)
• acciones permiten redirigir el request a otra
  instancia JSP, servlet o página HTML

4
Elementos de scripting

• 1. Expresiones de la forma lt expresión gt, son
  evaluadas e insertadas en el output del servlet
• 2. Scriptlets son instrucciones Java de la forma
  lt code gt, que son insertadas en el método
  _jspService que se llama cuando se contacta a la
  página jsp (el equivalente al doGet)
• 3. Declaraciones de la forma lt! code gt, que son
  insertadas en el cuerpo de la clase del servlet,
  fuera de todo método, definiendo así variables de
  instancia

5
Variables predefinidas

• Para simplificar las expresiones, existen
  variables predefinidas que se pueden usar. Las
  más importantes son
• request, el HttpServletRequest
• response, el HttpServletResponse
• session, el HttpSession asociada al request
• out, el PrintWriter usado para mandar output al
  cliente

6
Un Ejemplo (Ejemplo1.jsp)
ltHTMLgt ltHEADgt ltTITLEgtJSP Expressionslt/TITLEgt lt/HEA
Dgt ltBODYgt ltH2gtJSP Expressionslt/H2gt ltULgt ltLIgtCurren
t time lt new java.util.Date() gt ltLIgtYour
hostname lt request.getRemoteHost() gt ltLIgtYour
session ID lt session.getId() gt ltLIgtThe
ltCODEgttestParamlt/CODEgt form parameter lt
request.getParameter("testParam")
gt lt/ULgt lt/BODYgt lt/HTMLgt
7
Explicaciones

• El servidor crea un servlet, lo compila y llama
  al método _jspService que contiene todas las
  sentencias escritas entre lt y gt
• El texto HTML es mandado al cliente por vía
  out.print(....)
• Las expresiones se evalúan y se insertan en el
  texto que se manda, por lo cual la expresión
• ltLIgtCurrent time lt new java.util.Date() gt
• equivaldría en un servlet a hacer
• out.println(ltLIgtCurrent time new
  java.util.Date() )

8
Scriptlets

• Si se quiere hacer algo más complicado que
  insertar una simple expresión en el output del
  servlet se pueden incluir sentencias JAVA en
  scriptlets que tienen la siguiente estructura
• lt String queryData request.getQueryString()
• out.println("Attached GET data " queryData)
  gt
• Los Scriptlets tienene acceso a a las mismas
  variables definidas automáticamente a las que
  tienen acceso las expresiones
• En particular, esto también se pudo haber
  logrado con
• El string mandado con GET fue lt
  request.getQueryString() gt
• pero hay cosas que no se pueden hacer con
  expresiones
• lt response.setContentType("text/plain") gt

9
Algo más serio (Ejemplo2.jsp)
ltHTMLgt ltHEADgt ltTITLEgtColor Testinglt/TITLEgt
lt/HEADgt lt String bgColor request.getParameter("
bgColor") boolean hasExplicitColor if
(bgColor ! null) hasExplicitColor
true else hasExplicitColor
false bgColor "WHITE" gt ltBODY
BGCOLOR"lt bgColor gt"gt ltH2 ALIGN"CENTER"gtColor
Testinglt/H2gt lt if (hasExplicitColor)
out.println("You supplied color " bgColor )
else out.println("Using background
color WHITE..") gt lt/BODYgt lt/HTMLgt
10
Usando Scriptlets con código HTML
Para entender esto hay que tener claro que el
contenido de un scriptlet se incluye exactamente
como está escrito al método _jspService y las
sentencias HTML se traducen como un
out.println(...contenido de sentencia HTML...) en
el mismo orden en que aparecen en la página jsp
11
Scriptlets para hacer partes del archivo JSP
condicional
Lo siguiente lt if (Math.random() lt 0.5)
gt Have a ltBgtnicelt/Bgt day! lt else gt Have a
ltBgtlousylt/Bgt day! lt gt se traduce en el
servlet que se genera en lo siguiente if
(Math.random() lt 0.5) out.write("\n")
out.write("Have a ltBgtnicelt/Bgt day!\n")
else out.write("\n")
out.write("Have a ltBgtlousylt/Bgt day! \n")
12
ATENCION!!!! los paréntesis sin
absolutamente necesarios
lt if (Math.random() lt 0.5) gt Have a
ltBgtnicelt/Bgt day! lt else gt Have a
ltBgtlousylt/Bgt day! lt gt Debido a que el
servidor genera lo siguiente if (Math.random()
lt 0.5) out.write("\n")
out.write("Have a ltBgtnicelt/Bgt day!\n") else
out.write("\n") out.write("Have a
ltBgtlousylt/Bgt day! \n")
13
Scriptlets para repetir partes del del codigo HTML
ltTABLE BORDER2gt lt for ( int i 0 i lt n i
) gt         ltTRgt ltTDgtNumberlt/TDgt ltTDgt lt i1
gt lt/TDgt lt/TRgt         lt gt lt/TABLEgt Se
traduce en ... out.println(ltTABLE BORDE2gt)
for ( int i 0 i lt 10 i )
out.write(" \n") out.write(" ltTRgt
ltTDgtNumberlt/TDgt ltTDgt\n") out.print( i1
) out.write( \n") out.write("lt/TDgt
lt/TRgt \n") out.write(" \n")
out.write("lt/TABLEgt \n")
14
Declaraciones

• No generan output, se usan para declarar
  variables que más tarde serán usadas en
  expresiones o scriptlets
• Una declaración tiene la siguiente forma
• lt! Java Code gt
• Son variables que se declaran globales para todo
  el servlet
• Un ejemplo (Ejemplo3.jsp) que cuenta cuantas
  veces ha sido accesada una página desde que se
  cargó
• lt! private int accessCount 0 gt
• Accesses to page since server reboot
• lt accessCount gt

15
Se pueden declarar Métodos
lt! int factorial(int x) int aux 1
for (int i 2 iltx i) aux
aux i return aux gt El método
se puede usar después lt int n
(int)(10Math.random())gt El factorial de ltngt
es lt factorial(n) gt
16
Directivas

• Afectan la estructura general del servlet
  generado
• Ejemplo de directiva page-import
• lt_at_ page import java.util." gt

17
El atributo import

• Permite importar clases que no se incluyen
  automáticamente
• Por ejemplo, se pueden importar las usuales para
  java (java.util.)
• Para las clases definidas por el programador,
  estas deben estar en un lugar visible. Este
  lugar depende del servidor
• En tomcat es el mismo directorio en donde están
  los servlets (Ejemplo4.jsp con ServletUtilities.ja
  va y LongLivedCookie.java)
• lt_at_ page importjava.util." gt
• lt_at_ page import"package.class1,...,
• package.classN" gt

18
Usando JDBC en JSP

• lt_at_page import"com.mysql.jdbc.Driver"gt
• lt_at_page import"java.sql."gt
• lt Class.forName("com.mysql.jdbc.Driver").newInsta
  nce()
• String url "jdbcmysql//localhost/bibliotec
  a"
• Connection con
• DriverManager.getConnection(url,"root","r
  oot")
• Statement stm con.createStatement()
• ResultSet rs stm.executeQuery("select from
  personas")
• while(rs.next())
• gt
• ltbrgt RUT ltrs.getInt(rut")gt
• lt
• gt

19
Incluyendo otros archivos

• Es posible hacerlo al momento en que se compila
  la página con la directiva
• lt_at_ include filenombre del archivo" gt
• Esto implica que se incluirá el archivo
  referenciado como parte del actual antes de
  compilarlo
• El problema es que si el archivo referenciado
  cambia, no cambiará en la página que se muestra
  (a menos que se reinicie el servidor) (ver
  contacto.jsp y pprincipal.jsp)
• Se puede hacer que cada vez que se referencie la
  página incluida se vuelva a recargar el contenido
  con la siguiente directiva ltjspinclude
  pagenombre del archivo" flush"true" /gt
• (ver noticias.jsp e item1.html, item2.html,
  item3.html)

20
Controlando el tipo de salida

• Se hace a través de la directiva
• lt_at_ page contetTypetext/plain" gt
• Se puede usar para determinar cualquier tipo de
  salida que no sea text/html
• Puede ir en cualquier parte del archivo, a pesar
  de que en un servlet esto debe ir antes de mandar
  cualquier cosa. Esto es porque primero la página
  se compila, traduce y luego se ejecuta en el
  orden adecuado de las directivas
• ltHTMLgt
• ltBODYgt
• ltH2gtThe contentType Attributelt/H2gt
• lt_at_ page contentType"text/plain" gt
• Esto debe verse como texto plano ltBgtnolt/Bgt como
  HTML.
• lt/BODYgt
• lt/HTMLgt

21
Generando salida para excel

• Se hace a través de la misma directiva pero
  cambiando el tipo de salida que se generará
  (ejemplo5.jsp)
• lt_at_ page contentType"application/vnd.ms-excel"
  gt
• lt- entre columnas poner tabs, no espacios.-gt
• 1997 1998 1999 2000 2001
• 12.3 13.4 14.5 15.6 16.7
• Tambien se puede lograr lo mismo escribiendo
  código HTML para generar una tabla pero poner en
  la directiva que el contentType es ms-excel
  (ejemplo6.jsp)
• ltTABLE BORDER1gt
• ltTRgtltTHgtlt/THgtltTHgtApplesltTHgtOranges
• ltTRgtltTHgtFirst QuarterltTDgt2307ltTDgt4706
• ltTRgtltTHgtSecond QuarterltTDgt2982ltTDgt5104
• ltTRgtltTHgtThird QuarterltTDgt3011ltTDgt5220
• ltTRgtltTHgtFourth QuarterltTDgt3055ltTDgt5287
• lt/TABLEgt

22
Directiva Forward

• Se usa para redirigir el requerimiento a otra
  página
• Cuando se ejecuta se va a esa página sin que se
  tenga que hacer nada en el browser
• Es equivalente a hacer response.sendRedirect(serv
  let2)
• Ejemplo
• lt percent Math.random()
• if (percent lt 0.5)
• gt
• ltjspforward page"/forward/one.jsp"/gt
• lt else gt
• ltjspforward page"two.html"/gt
• lt gt

23
errorPage isErrorPage

• Es posible invocar una determinada página cuando
  en otra sucede un error (se lanza una Exception )
  
• Para ello hay que poner en la página que puede
  generar el ellror la directiva
• lt_at_ page errorPageuna_URL_relativa" gt
• En la página que debe recibir el control
  (una_URL_relativa) debe ponerse lo siguiente
• lt_at_ page isErrorPage"true" gt
• (ver generaError.jsp y muestraError.jsp)

24
Java Beans

• Usar Beans es una buena manera de complementar
  JSP cuando se requiere de estructuras de datos
  (clases) que hagan cosas más complejas, y separar
  el código de programación de estas clases de la
  JSP
• Un Bean es una clase con las siguientes
  características
• Tiene un constructor que no tiene parámetros
• No tiene variables públicas
• Para cierto subconjunto de variables privadas
  llamadas propiedades, si la variable es de tipo
  tipo1 y se llama variable1entonces existe un
  método programado tipo1 getVariable1() que
  retorna el valor actual de la propiedad y otro
  void setVariable1(tipo1 x) que modifica el valor
  de la variable con el que está dado como
  parámetro

25
Usando Beans en JSP

• Para poder usar Beans con JSP en Tomcat estos
  deben ir en el mismo directorio que los servlets
• Creación
• ltjspuseBean idbean1' classNombre_Clase'
  scopevalidez/gt
• Es lo mismo que haber hecho en un programa Java
• Nombre_Clase bean1 new Nombre_Clase()
• Obtención de valores
• ltjspgetProperty namebean1" propertyvariable1"
  /gt
• lt book1.getVariable1() gt
• Modificación valores
• ltjspsetProperty namebean1 propertyvariable1
  valuevalor1" /gt
• lt book1.setVariable1(valor1") gt