Día 20: JSTL - Parte 3, Proyecto2 e Introducción al MVC

JSTL

Etiquetas implícitas

Un primer grupo de etiquetas proporciona funcionalidad a nivel de la página de una manera muy simple:
<jsp:forward>, redirige la request a otra URL
<jsp:include>, incluye el texto de un fichero dentro de la página
<jsp:plugin>, descarga un plugin de Java (una applet o un Bean).

Un segundo grupo permite manipular componentes JavaBean sin conocimientos de Java.
<jsp:useBean>, permite manipular un Bean (si no existe, se creará el Bean), especificando su ámbito (scope), la clase y el tipo.
<jsp:getProperty>, obtiene la propiedad especificada de un bean previamente declarado y la escribe en el objeto response.
<jsp:setProperty>, establece el valor de una propiedad de un bean previamente declarado.

Un Bean tiene un id, un scope y una class.

---

Consejo:
Para poder usar variables de una clase y mostrarlas primeramente invocamos la clase con un "id", después las variables que manejaremos se tienen que colocar en una variable que manejará el jsp y despues mostrarlos ya que el jsp no sabe manejar las variables de las clases, no sabe de qué tipo son. (aunque si ponemos un valor que no corresponde, un int a un String por ej. dará error.)

<jsp:useBean id="miCosa" scope="request" class="es.cea.Cosa"/>
<jsp:setProperty name="miCosa" property="propiedad1" value="hola"/>
<jsp:setProperty name="miCosa" property="propiedad2" value="40"/>
Propiedad1 de miCosa: <jsp:getProperty name="miCosa" property="propiedad1"/>

---

Para crear etiquetas con un cuerpo la clase java tiene que extender de la clase padre "BodyTagSupport" aunque se puede tranquilamente con el "TagSupport"

Ejercicios
Primer ejercicio:
Probar en "functions.jsp" todas los métodos posibles de "jsp:", mirando las apis de java.

Segundo ejercicio:
La página del formulario: que hayan inputs de tipo text, password, inputbutton, etc.
Hacer que haya herencia en los tags.

---

Proyecto 2

Retomamos el proyecto de la biblioteca para expandirlo con lo último que hemos dado.
- Crear menus
- Dividir el proyecto en distintos paquetes segun sus funcionalidades.
- Que haya solo una clase para la manipulación de datos, cuya interfaz se llamará DAO y que en un futuro se usará para manejar bases de datos.

Un ejemplo del último punto:
List lista = new ArrayList();
convertirlo a:
Dao dao = new DaoSimple();
o si accedieramos a una base de datos:
Dao dao = new DaoMySQL();

- Implementar logueo por consola
- Incluir pruebas

Eso es remarcando lo más importante, pero el guión del proyecto es:

El proyecto se desarrollará con las siguientes tecnologías

• Patrón de desarrollo MVC (Modelo Vista Controlador)
• Servlets: Listener, Filters, Servlets
• JSP
• JSTL (tags implicitos en JSP, tags de JSTL y tags personalizados)
• Pruebas

Especial atención a:

• Modularización de la vista con uso de la etiqueta jsp:include
• Paquetes separando aspectos/finalidades/roles de las clases java
• Aislamiento de acceso a datos en una sola clase con una interfaz
• Nomenclatura
• Características standars de proyecto web java.

---

MVC
Cojemos el proyecto mvc y lo abrimos en el Eclipse para ver un ejemplo simple el funcionamiento básico de un Modelo Vista Controlador.

Día 15: Conclusión proyecto y JSP

Proyecto, Conclusiones:

• ¿Qué logica se ha implementado en los listeners?
• ¿Qué logica se ha implementado en los servlets?
• ¿Qué logica se ha implementado en los filtros?
• ¿Qué tienen en común los objetos almacenados en el SevletContext (setAttribute y getAttribute)?
• ¿Qué tienen en común los objetos almacenados en el Session(setAttribute y getAttribute)?
• ¿Qué tienen en común los objetos almacenados en el Request (setAttribute y getAttribute)?

Contestar las preguntas en el googleDoc
POO y Servlets:
El Tomcat es el que crea los filtros, los servlets y los listeners.
Refactorización:
Sirve principalmente para cambiar el nombre de: Clases, parámetros, métodos, etc y que todo que incluya dichos nombres cambie al nuevo cambio.
Resumiendo, que hace que tengamos que renombrar algo 1 sola vez, sin tener que cambiarlo todas las veces que lo usamos en las distintas clases.

Terminar el proyecto
Terminamos el proyecto haciendo lo que faltara y después subirlo al repositorio, el tiempo límite era a las 18:00.

STRUTS y SPRING FRAMEWORK
Trabajan en una capa superior a la del servlet. Lo daremos en otro módulo.

JSP
Hemos trabajado con el modelo 1, que son los servlet.
Ahora trabajaremos con el modelo de desarrollo 2, que son los jsp.

Modelo 1:
Vista: Lo que vemos en la pantalla, que lo tenemos en HTML
Logica de negocio: Las condiciones de las finalidades, que depende del cliente.
Ambas no tienen porque ser siempre la una para la otra.
Por ejemplo tener varias vistas para representar una información.
Tienen que estar separadas.
Modelo 2:
Separar el código html del código java.
Crear una forma para crear las vistas, que es el JSP.
Un JSP es como un servlet, el código se ejecuta en tiempo de ejecución.
El tomcat escanea el jsp y lo transforma a un servlet.

Tambien dimos la sintaxis básica, pero yo añado unos cuantos máss que son importantes y usaremos:

Sintaxis:
Scriptlets - <% %> - Dentro de esas etiquetas se puede poner código java.
Expresiones - <%= %> - Para que se visualicen valores de variables.
Comentarios - <%--... ...--%> - Pues eso, comentarios.
Directivas - <%@... ...%> - Son importantes, por ejemplo
<%@page import=”java.util.*”%> - Para importar una librería
<%@ page include file=”cabecera.jsp” %> - Para incluir otra página jsp (hay otra manera más abajo)
<%@ taglib %> Para incluir una serie de librería de etiquetas
Declaraciones - <%!... ...%> - Solo se ejecutan una vez, la primera vez que carga la pagina

- Incluye una página jsp dentro de otra.
El servletContext() ahora pasa a ser application

Después de esta breve explicación comenzamos a hacer un par de ejercicios en JSP ya prehechos para que le hagamos alguna añadidura más:

jspEjemplo
Con este ejercicio intentamos trasladar nuestros conocimientos y manejo con los servlets a JSP, creando una lista nueva y que mostrara los detalles, al estilo "tienda" (como hicimos anteriormente) pero con jsp.

controladorFrontal
Con este ejercicio aprendemos a manejar tres métodos del objeto "request" que son:

• getRequestURL(): Este método sirve para mostrar la dirección completa que está en nuestro navegador.
  
• getRequestURI(): El método recoje la ruta del contexto de la página.
  
• getQueryString(): Muestra si se pasan parámetros por el método GET y los muestra (pero no los separa.)
  

Con estos métodos empezamos a probar enlaces que redireccionen a otra página y que muestren lo que pasa y creamos un nuevo enlace para practicar.

Día 10: Introducción al proyecto

Anuncio: Proyecto
Empezamos el día con el anuncio del proyecto que tendremos que realizar en breve.
El proyecto es un ejercicio de evaluación (examen en cristiano) nos servirá como práctica para la realización de trabajo en equipo que suele darse en el mundo de los programadores en la "vida real".
La descripcion del proyecto está aquí: Enlace al proyecto
El proyecto estará en googleCode en el repositorio.
Entregar tambien una memoria que explicará el codigo.
Se tiene que entregar el 6 de febrero como fecha límite.
Usar google Docs. Tiene un CVS.

Para la memoria el googleDocs
Para el codigo el CVS

Subversion(SVN)
Es un control de versiones del código y lo normal es que alguien lo instale en un servidor. Google nos ofrece esta herramienta de forma gratuita.

Como obtener archivos y recibirlos usando eclipse.
Instalar el pluggin "subclipse" en Eclipse: Enlace a instalación del pluggin
En el SVN podemos ver el código como autor: con privilegios de escritura y lectura con https (con seguridad) y como lector: con privilegios de lectura con http (sin seguridad).

Para añadir el repositorio de googleCode a Eclipse vamos a nuevo repositorio. En google code le damos a source y copiamos la url https.
Nos pedirá un usuario y una contraseña, ambas vienen en el google code, en source. El usuario viene después de la url que copiamos y la contraseña pulsando el enlace que viene después de éste.

Una vez funcionara el SVN en eclipse nos organizamos en 4 grupos de 4. Mi grupo es el nº 2 y somos: yo, Xelu, María y Manuel.
Terminamos el día (y la mitad de éste) organizandonos los grupos internamente sobre qué haremos cada uno.

Novedo día: De tiendas, ...

Repaso
Como todos los dias hicimos un breve repaso sobre lo que hemos dado.
Primeramente se hizo un esquema con lo básico para poder hacer una aplicación web en perfectas condiciones:

Java src

• Modelo -> Es una clase java para encapsular datos. Por ejemplo una clase productos de atributos: id, nombre, precio, etc.
  
• Servlet
  
• Listener
  
• Filter
  

Implicit Objetcts+ Atributos

• Request -> Parametros | Atributos
  
• Response -> PrintWriter
  
• Session -> Atributos
  
• ServletContext -> Atributos
  

XML /WEB-INF:

• web.xml

Tienda
Hoy haremos una aplicación web orientada a una tienda, en la que se basa principalmente en la visualización y almacenamiento de los productos.
Este ejercicio es el mismo que el del Octavo dia solo que vamos a perfeccionarlo a más no poder.
Para no poner un hipertochopost (xD) mejor pongo un enlace donde se muestra toda la aplicación paso por paso: Tienda

Octavo día: Recopilación

Inicio: Repaso
Como siempre, hicimos un repaso del día anterior.
Recordamos el uso de un filtro, la de filtrar las peticiones de los usuarios, las intercepta y dependiendo de lo que queramos hará una cosa u otra con las peticiones.

Expansión del ejercicio del contador:
Crearemos una nueva clase llamada "FiltroSeguridad", en la misma ventana para crear una clase (a pelo) le diremos que implemente una interfaz de tipo "Filter" que importa el paquete "javax.servlet.Filter".
La clase HttpServletRequest es una clase hija de ServletRequest y lo mismo con el de Response. Decimos esto porque necesitaremos manejar atributos de sesión que ServletRequest no puede hacer mientras que su clase hija si, asi que creamos un objeto de tipo HttpServletRequest haciendo un casting a ServletRequest.
Creamos un repartidor de solicitudes (RequestDispatcher) y le decimos que nos de la dirección a la que queremos enviar y que rediriga al usuario a esa dirección. En este caso sería si un usuario no está registrado, que lo redireccione a la página de registro.
Código:
RequestDispatcher dispatcher= request.getRequestDispatcher("/registro");
dispatcher.forward(servletRequest, servletResponse);

Por supuesto, se me olvidó comentar, que seguiremos usando el filtro que ya hicimos ayer que imprima la cabecera y el pie de la página web.

Ejercicio sobre catálogo de productos:
Terminado el contador hicimos un ejercicio para poner en práctica lo aprendido.
El ejercicio consiste en hacer un catálogo de productos, manejando un listener, 2 servlet y una clase.
Un servlet escuchara la url /catalogo que expondrá un listado de productos (sólo el nombre) a modo de enlace.

• Los productos se mostrarán gracias a un "List" que está guardada en una variable de aplicación, que creamos en un Listener de aplicación.
  Al mostrar los productos también debemos generar unos enlaces para cada uno, añadiendo ?id=x al enlace, para ello tendremos que hacer un bucle "for" recorriendo todos los elementos del List. for(Productos p:listaProductos){ p.id; etc }
  
• El otro servlet recojerá la petición /detalle más el id que le pasamos por parámetro y buscando en el list accederemos a las propiedades del producto y las mostramos.
  

Una vez hecho esto rizamos el rizo: crearemos un filtro que detecte si el usuario está "registrado" y si no lo está que le redirija a una página de registro.

Séptimo día: Filtros

Empezamos con un repaso del ejercicio del contador sobre los listener.
Después del repaso tendremos que modificar el ejercicio de contador de esta manera:

• El Contador contabilizara todas las peticiones de todos los usuarios.
• ContadorUsuarios contabilizará los usuarios que se han conectado a la aplicación desde que se inicia la Aplicación.
• ContadorUsuriosConectados contabilizará los usuarios conectados en el momento actual a la aplicación.

Simplemente es crear un escuchador de sesión y que incremente la variable de aplicación del número de usuarios y que al destruirse la sesión se decremente.

Filtros
La función principal de los filtros es la de filtrar las peticiones de un usuario a un servlet y sus respuestas.
Unos buenos apuntes sobre filtros son estos: Apuntes en PDF

Contador con filtro
Empezamos a practicar lo nuevo que estamos aprendiendo en el ejercicio del contador, aplicando un filtro para que intercepte todas las peticiones.
Nuestro primer filtro lo que hará será imprimir por pantalla la cabecera de la página web en la petición y en la respuesta el pie de la página. Todo esto lo haremos en el método que implementamos "doFilter".
Indispensable el "arg2.doFilter(arg0, arg1);" , que hace que continue la petición al servlet.

Contador con filtro(2)
Mejoraremos el filtro del contador para que un usuario que no este registrado lo redirija a una página con un formulario para registrarse y una vez registrado que entre al contador.

Sexto día: Eventos con Servlets

Listeners en Servlets
Por parte del usuario se comunica con dos tipos de eventos: por url y botones.
Por parte de la aplicación puede haber una serie de eventos.

• Unos relacionados con la aplicación. (ServletContext)
• Por la sesión.
• Por la solicitud. (request)

Tipos de listener (correspondientemente):

• ServletContextListener. - Cuando la aplicación arranca, salta un evento.
• HttpSessionListener. - Oir la entrada de un usuario.
• ServletRequestListener. -Interceptar la petición y realizar operaciones.

Zoo mejorado:
Mejorar nuestro ejercicio del zoo aplicando un listener de sesión y dar de alta en el web.xml el listener.
El objetivo del ejercicio es que un listener de sesión escuche que se creó una sesión y coloque en una variable de sesión un listado vacío, listado que recogerá el servlet principal si se accede a él sin ningún animal introducido, para que no sea nulo.
Para añadir un listener a un web.xml sólo hará falta introducir un par de etiquetas (una dentro de otra): listener y listener-class. Usando el famoso Control+espacio en el Eclipse nos aparecerán todas las etiquetas posibles a colocar, así que será fácil reconocerlo.

Si queremos colocar una variable de tipo aplicación, en el escuchador (de tipo aplicación, por supuesto xD) usaremos:
arg0.getServletContext().setAttribute("Nombre", Objeto);
En Nombre pondremos un nombre que podamos reconocer para el Objeto que le pasemos, como hariamos con el nombre de una variable.
Por supuesto, en nuestro servlet principal, cuando queramos recojer el valor de esa variable de aplicación usaremos un request.getServletContext().getAttribute("Nombre");

En el escuchador de sesión haremos lo mismo, pero en vez de "getServletContext" esta vez será "getSession()" en la secuencia de comandos.

Contador de visitas y Chat:
Los siguientes ejercicios es poner en práctica los eventos escuchadores de sesión y de aplicación.
El contador de visitas se centra en el evento de aplicación que crea una variable global de aplicación que se va incrementando cada vez que se accede a la página mediante un escuchador de tipo ServletRequestListener.
El Chat es más de lo mismo. Utilizaremos un formulario de entrada que va introduciendo en una variable de aplicación un texto que se mostrará para todos los usuarios.

Quinto día: Sobrescritura de métodos 2

Comenzamos haciendo un repaso del día anterior y se habló de los métodos heredados del objeto "Object"

• clone() - para clonar los objetos.
• finalize() - últimas operaciones antes de cerrar un objeto.
• toString() - devuelve una cadena de texto cuando se intenta imprimir un objeto.
• equals() - compara los objetos entre sí.

Ejemplo de añadir objetos en un conjunto:
Set coleccion=new HashSet();
coleccion.add(gato1);
coleccion.add(gato2);

Tipos de colecciones: Map, List, Set.
¿Porque existen tres tipos de colecciones?, porque cada uno tiene internamente unos comportamientos diferentes.
Set-> No permite objetos repetidos. De forma transparente mira el método equals(). Recomendable sobrescribir el método equals para así ahorrarnos más código a la hora de introducir objetos en el Set.
List-> Permite duplicados.
Map-> Permite duplicados.

Ejercici0 de servlet, clases y Listas:
El objetivo del ejercicio es la de dominar la herencia, la sobreescritura de los métodos toString() y el equals(), usando como clase base "Disco", tener un servlet que sea un formulario de entrada y un último servlet que es el que guardará la información del formulario en una Lista de tipo Disco y posteriormente se mostrará.
El guión del ejercicio:

• Comenzamos definiendo la clase Disco con las propiedades: titulo, cantante y referencia.
• Seguimos con el formulario de nuevo disco que se enviara a la discoteca..., es decir, creamos un nuevo servlet que pintará el formulario y lo damos de alta en el web.xml para que escuche las peticiones en /disco
• Creamos el servlet discoteca y lo damos de alta en el web.xml
• El servlet discoteca en esta primera fase de desarrollo, lo unico que hace es comprobar que la discoteca (List ) esta en la session y en caso contrario la crea. Posteriormente la pinta en pantalla (aunque por ahora siempre estará vacía)
• En dicho servlet accedemos al objeto session (HttpSession) a través del objeto request.getSession(), obteniendo con este objeto la capacidad de acceder a atributos session.getAttribute("clave") o incluir atributos session.setAttribute("clave", objeto).
• Una vez que esto funciona, modificamos el codigo para que: si recibimos el formulario de /disco entonces creamos un nuevo Disco y lo metemos en la coleccion.
• Sobreescribimos el metodo toString() de la clase Disco para que imprima el nombre y autor del disco
• Limitamos los discos duplicados (implementamos metodo equals y hascode en la clase Disco) para poder utilizar el metodo de la clase List contains: boolean existe=coleccion.contains(object)

Otro Ejercicio del mismo tipo, pero en vez de una Lista son tres.
Esta vez consiste crear tres listados de animales, animales de tres tipos: Jirafas, Panteras y Leones, que mediante un formulario individual para cada uno (es decir, 3 servlets) le envíe la información a uno principal que distinga quién le envía la información y mostrar el contenido de las tres listas.
Los pasos que hay que hacer son:

• Creamos en eclipse un nuevo proyecto web dinamico. Como nombre le indicamos "zoo"
  
• seleccionamos la pestañita de "servers" dentro de eclipse y boton derecho ->add and remove projects... y le añadimos el recien creado
• Los animales que tendremos que gestionar en el zoo serán: leones, jirafas, panteras. Cada animal tendra un nombre y una edad
  
• Creamos un servlet que responda a la peticion "/visita" y nos pinte en pantalla la coleccion de leones, de jirafas y de panteras (en tres lineas, una debajo de la otra)
• Creamos un servlet que pinte un formulario para introducir una nueva jirafa en la URL: '/jirafa', con los datos: nombre y edad. Dicho formulario se enviará a '/visita'
  
• Creamos un servlet que pinte un formulario para introducir una nueva pantera en la URL: '/pantera', con los datos: nombre y edad. Dicho formulario se enviará a '/visita'
• Creamos un servlet que pinte un formulario para introducir un nuevo leon en la URL: '/leon', con los datos: nombre y edad. Dicho formulario se enviará a '/visita'
• Cuando el servlet encargado del URL: '/visita' reciba los parametros del formulario '/jirafa', entonces creará una nueva jirafa y la incluira a la coleccion de jirafas existentes
  
• Cuando el servlet encargado del URL: '/visita' reciba los parametros del formulario '/pantera', entonces creará una nueva pantera y la incluira a la coleccion de panteras existentes
• Cuando el servlet encargado del URL: '/visita' reciba los parametros del formulario '/leon', entonces creará un nuevo leon y lo incluira a la coleccion de leones existentes
• Modificar el metodo equals de las clases correspondientes (Leon, Jirafa, Pantera) para que al incluirlas a la coleccion no existan duplicados [dos animales se consideran iguales si su nombre y edad es igual*]
• aplicar herencia entre las diferentes clases de animales para eliminar el codigo redundante

Cuarto dia: Herencia y sobrescritura

Repaso
Empezamos el día con un repaso del día anterior sobre el html y durante media hora (en realidad fue algo más) terminar el último ejercicio expuesto.
Después de recordarnos que en java todo son objetos, que las clases se colocan dentro de la carpeta "src" y que tienen que ser dentro de un paquete, empezamos con unos ejercicios de herencia y sobreescritura de métodos.

Herencia y sobreescritura
Primeramente creamos 3 clases. Una clase Persona, otra clase Futbolista y la clase principal.
Hicimos una serie de modificaciones por cada ejemplo que tuvieramos que aprender así que lo he enumerado para cada clase, primeramente se lee los 1 de todas las clases, despues todos los 2, y así.

Clase Persona

1. Crearemos un método que se llame saludo que haremos un System.out.println("Hola soy una persona");
   Añadir que si escribimos "syso" y pulsamos control+intro, el Eclipse directamente nos escribirá todo el System...
2. Como todo objeto hereda de la clase Objetc procedemos a sobreescribir el método que tiene la clase Objetct "toString()" que lo que hace es devolver una cadena de texto con la dirección de memoria en donde está guardado el objeto. Lo sobreescribiremos para que aparezca el nombre de la persona usando una variable global de la clase llamado "nombre".
3. Botón secundario en el texto, "source", "Generate HashCode and equals()" y se sobrescribirán los métodos hashCode() y equals(), pero antes de que aparezcan los métodos nos preguntará qué propiedad de la Clase Persona es la clave identificativa (mmm, me suena al primary key de las BB.DD).
   

Clase Futbolista

1. Esta clase heredará de Persona (...extends Persona)
   En esta clase sobreescribiremos el método saludo de Persona, para ello hacemos click con el botón secundario del ratón en el texto vacío, seleccionamos "source" y pulsamos "Override/Implement" y seleccionamos "saludo()" de la clase Persona.
   Borramos su contenido y volvemos a escribir el "println" con la diferencia que en vez de decir "soy una persona", diga que es un futbolista.
2. Hacemos igual que en Persona pero simplemente hacer un return con la cadena "futbolista".
   

Clase principal

1. Aquí simplemente creamos 2 objetos, 1 de tipo persona y otro de tipo futbolista y llamar de cada uno su método "saludo()".
   Evidentemente aparecerá "Hola soy una persona" y "Hola soy un futbolista".
   
2. Aquí lo que haremos sera asignar a la variable global de la clase que hayamos creado de tipo persona "nombre" con un nombre cualquiera y hacer un println con el objeto (si, a pelo) e igualmente con futbolista (recordemos que está heredando y tambien tiene una propiedad "nombre")
   Después crearemos un HashMap que introduciremos como key un "1" y un "2" y los objetos serán personas. El resultado será que nos aparecerá el texto que hicimos en el toString()
   Map mapa=new HashMap();
   mapa.put("1", p1);
   mapa.put("2", p2);
   System.out.println(mapa);
   
3. Crearemos un nuevo archivo que se llame prueba2, o podemos usar éste mismo si queremos.
   Crearemos 3 objetos de tipo persona, dos de ellos se inicializará la propiedad "nombre" con un mismo String y el 3º con uno distinto.
   Al final del código, mediante booleanos y haciendoles println, igualaremos los objetos tal que:
   boolean identicos=objetoPersona1==x;
   boolean iguales=objetoPersona1.equals(objetoPersona1-bis);
   boolean diferentes=objetoPersona1.equals(objetoPersona2);
   System.out.println("Identicos: "+identicos); //saldrá true
   System.out.println("Iguales: "+iguales); //Saldra true
   System.out.println("Diferentes: "+diferentes); //Saldra false (false, que son diferentes)
   Con esta última modificación veremos la diferencia entre los tipos de "igualdades" que podemos hacer y cuando usar cada una en su respectivo contexto.
   

Y por último tuvimos que adaptar este mismo ejercicio, la clase principal, en un servlet, fue fácil, simplemente sustituir el "System.out" por el PrintWriter y dar de alta el servlet en el web.xml.

Tercer día: Ronda de Servlets

HTML
Comenzamos el día con un repaso del lenguaje HTML, que es vital para poder seguir avanzando en el módulo.
El lenguaje HTML es por etiquetas y cada etiqueta tiene una función específica.
Todas las etiquetas se abren y también se tienen que cerrar, aunque hay algunas que simplemente no se cierran.
Las etiquetas más básicas que hay son (lo que muestro se debe incluir dentro de los caracteres < >):

• html - etiqueta contenedora de todo el código html
  
• head - etiqueta contenedora de la cabecera de la página
  
• title - etiqueta para poner título a la página web
  
• body
• hr - etiqueta para colocar una barra horizontal
• br - etiqueta para crear un salto de línea.
  
• a href=enlace_que_queramos - etiqueta para crear un enlace a otra página
  

Los subapartados de la lista indican cuales etiquetas deben estar dentro de otras.

Sobre los servlet
A continuación un diagrama del funcionamiento de un servlet. Un navegador web realiza una solicitud http, el servlet lo recoje, procesa la información que deba procesar y devuelve una página hml para el navegador.




Para el correcto funcionamiento de una aplicación web es necesario que tenga una estructura determinada, tal que así:

aplicacion/
_______/archivo.html
_______/archivo.jsp
_______/imgs/...
_______/css/...
_______/masjsps/archivo.jsp
_______/mashtmls/archivo.jsp
_______/WEB-INF/web.xml
_______/WEB-INF/classes/es.cea...
_______/WEB-INF/lib/librerias.jar

Los 6 primeros son archivos accesibles para la página, como son las propias páginas html o jsp, imágenes y las hojas de estilo y también hay una estructura interna para el funcionamiento de la aplicación web.
En WEB-INF se encuentra el archivo de configuración que lee el servidor web Tomcat que es el "web.xml" que sirve principalmente para dar de alta a los recursos de la aplicación.
Dentro de WEB-INF existen dos subcarpetas que son la carpeta "classes", que sirve para introducir las clases de nuestros programas, y la carpeta "lib" que son las librerías que necesiten las aplicaciones.
Como anotación, decir, que los archivos con extensión ".war" son aplicaciones web empaquetadas.

Ronda de ejercicios y explicación
Despues de las explicaciones vino una ronda extensa de ejercicios simples para saber crear un servlet.
Cito aquí las explicaciones y los enunciados de los ejercicios del blog del curso:

---

¿Cómo crear un servlet?

1. Se crea una clase java que herede (extienda) de HttpServlet (javax.servlet.http.HttpServlet)
2. se sobreescriben los dos metodos encargados de procesar las solicitudes via GET y via POST
3. public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
   
4. public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
   
5. Se reenvia todo lo que pase por doPost a doGet incluyendo en la implementacion del metodo doPost la siguiente linea: doGet(req,res);
6. Se escribe la respuesta en el metodo doGet utilizando el objeto Writer a traves del objeto response: res.getWriter()
   
7. Se da de alta el servlet en el archivo de configuración de la aplicación web: web.xml
8. Se despliega la aplicación
9. Consultamos el servlet en la dirección http://localhost:8090/nombreAplicacion/bienvenida
   

¿cómo imprimimos los resultados del servlet en la pagina web?

1. Accedemos al objeto PrintWriter para imprimir los resultados: PrintWriter pw = res.getWriter();
2. Imprimimos lineas con el metodo println("mensaje"): pw.println("HOLA SOY UN SERVLET ");
3. Cerramos el objeto de impresion pw.close();
   

Ejercicios

1. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/ciudad y que imprima la palabra SEVILLA
2. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/academia y que imprima la palabra CEA
3. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/enlaces y que imprima los enlaces del blog del curso
   
4. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/formulario y que imprima este formulario
   
5. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/calculadora y que imprima este otro formulario
6. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/registro y que imprima un formulario con los campos usuario y clave y se envie(atributo action) a la direcion /registrar

¿cómo recuperamos los parametros que el usuario nos envia a traves de URLs?

1. Accedemos al objeto request y utilizamos su metodo getParameter("nombreParametroEsperado")
2. El valor que retorna se lo asignamos a una variable
3. si la variable es diferente de null entonces lo imprimios en el resultado

Ejercicios

1. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/envioFormulario y que imprima los valores nombre y apellidos
   
2. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/calcular y que imprima el resultado de los parametros sumando1 y sumando2
3. crear otro servlet que responda a la peticion http://localhost:8090/nombreAplicacion/registro y que imprima el resultado de los parametros usuario y clave.

---

Por último remarcar que en todas las aplicaciones web que realicemos nos pueden saltar excepciones y los tres más frecuentes son:

• NullPointerException - Se intenta invocar, por ejemplo, un método de un objeto no inicializado.
  
• ClassCastException - El casting de una clase no es la que esperaba.
  
• ClassNotFoundException - Clase no encontrada.
  

Segundo día: introducción a jsp

Introducción
Empezamos el día con una introducción sobre los distintos tipos de objetos que más se suelen usar para desarrollar páginas en JSP, véase la siguiente tabla:

Contexto	JSP	Servlet
Aplicación	application	ServletContext
Sesión	Session	HttpSession
Evento (Click)	request	HttpServletRequest

Tantos los objetos de tipo aplicación, como los de tipo sesión son contenedores de datos.
Los de tipo sesión perduran hasta que el usuario cierra una sesión, mientras que los de tipo evento que dura hasta que se muestra, después se destruye.
Los del último tipo encapsula los eventos del usuario que son:

• Click en datos
• Click en enlaces
• Dirección url
• Envio de formulario

Añado que una manera de pasar datos en páginas jsp es pasarlos mediante su propia dirección. Añadir "?" para añadir el nombre de un campo, se iguala a algún valor y si queremos añadir más campos usamos "&", por ejemplo: miPagina.jsp?nombre=pepe&apellidos=nadiez

A la hora de añadir un script Java en JSP (que es código html con código java embuido) hay que marcarlos con las etiquetas <% %> o si queremos mostrar el valor de una variable solamente, sería <%= %>

Volviendo a los eventos, éstos se pueden enviar por un método GET (todos los parámetros de los formularios por url) o por un método POST (se envía de forma transparente o invisible). Una URL+parámetros es lo que se encapsula en el objeto evento.

Primer JSP
Creamos un nuevo proyecto del tipo "dynamic web", cuyo nombre y ruta sea "cea01" y crearemos un archivo jsp llamado "bienvenida" y otro llamado "registro".
El objetivo del ejercicio es crear un enlace simple de html en bienvenida hacia registro y ahí hacer un formulario que le pasaríamos nuestro nombre y una vez enviado (que se envía a sí misma) no mostrar el formulario de nuevo porque ya estamos "registrados" en la página.

• El enlace en html sería así:
• El formulario sería:
• Los métodos de eventos que utilizaremos son:
  • request.getParameter("parametroPasadoDelFormulario"); -> Devuelte un String
  • session.setAttribute("nombreDeLaVariableDeSesion",Objeto a pasar); -> En Objeto a pasar podríamos usar un request.getParameter("x");
  • session.getAtribute("nombreDelAtributo");

Usando sentencias de control (if(){}else{}) y colocando ingeniosamente los métodos de los eventos conseguiremos el resultado deseado.

Primer Servlet
Para crear nuestro primer servlet crearemos un nuevo paquete en "Java Resources:src" que se llame "cea" y dentro crear una nueva clase llamado "saludo".
La clase deberá heredar de HttpServlet. Marcamos HttpServlet y pulsamos Control+1 y nos importará automáticamente la librería adecuada en la clase.
Hacemos click con el botón secundario en la clase, y en source pulsamos "Overdrive/Implement..." y marcaremos solamente "doGET" y "doPOST"
Modificaremos el método "doPOST": quitaremos "super.doPOST" por "doGET" para que cualquier entrada de datos se canalice por un único método.
Escribimos una bienvenida cualquiera para ver que funciona.

Ahora procederemos a configurar el xml para que funcione el servlet.
Abrimos el "web.xml" y lo ponemos en modo "source" y allí (usando Control+espacio para ahorrarnos escribir) escribiremos:



Y una vez hecho esto, lo guardamos todo y reseteamos el TomCat, escribimos en la barra de dirección del navegador "localhost:8090/cea01/Saludo" y nos aparecerá el mensaje de bienvenida.