Día 12: Continuación del 11

Calendar
Empezamos con un pequeño inicio sobre la clase de tipo Calendar, ya que lo utilizaremos en el proyecto.
Para tener un ejemplo escribimos:

Calendar fecha = Calendar.getInstance(); //da la instancia actual.
fecha.set(Calendar.YEAR, 2008);
fecha.set(Calendar.MONTH, 05);
fecha.set(Calendar.DAY_OF_MONTH,13);
System.out.println(fecha.get(Calendar.YEAR));
Date miDate = fecha.getTime();
System.out.println(miDate);
fecha.roll(Calendar.YEAR, +3); //Sirve para mover el campo adelante o hacia atras en el tiempo
System.out.println(fecha.get(Calendar.YEAR));

Todo esto servira para mostrar el año, la fecha actual y ver el año incrementado en 3. El método usado en éste último lo usaremos en las reservas de los usuarios.

Continuación con el proyecto
Continuamos con el proyecto de la biblioteca.

Día 11: Iniciación del subversion

Empezamos el día instalando un complemento para el firefox: firebug (si no se llegó a instalar en su dia)
Una vez instalado veremos las posibilidades que tiene.

Subversion
Después nos pusimos a practicar cómo se usa el SVN o subversion.
Para ello subiremos cualquier proyecto que queramos.
Botón secundario en el proyecto que queramos subir al subversion de google, pulsamos Team > Share project, seleccionamos que es de tipo SVN y despues un comentario.
La carpeta ".settings" no se subirán al subversion ya que son archivos del Eclipse.
Para ignorar una carpeta entera, como es el caso del ".settings" le damos a ignorar.
Si realizamos algún cambio en un proyecto sincronizado nos aparecerá un símbolito negro que nos indica que hemos hecho un cambio y no está en el SVN de google, así que haremos botón secundario en la carpeta del proyecto, Team > Commit, añadimos un comentario si queremos y marcamos los archivos a actualizar.
También se puede hacer que al realizar un commit que envie un mail a los otros programadores que también hacen el proyecto.
Descargar un proyecto: Hacer un proyecto nuevo de tipo SVN e indicar la ruta del subversion.

commit -> Subir cambios
ignore -> No subir
update -> Antes de hacer un commit revisa si alguien subió una versión más actualizada.

Proyecto: Biblioteca
Continuamos donde lo dejamos ayer con el proyecto de cada grupo. Hoy comenzamos a crear los repositorios y las documentaciones y agregandonos a cada miembro del grupo.

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.

Primer dia: Instalación de herramientas

Hoy ha sido el primer día del módulo nuevo "Desarrollo de Componentes Web con Tecnología Java", con nuestro nuevo profesor Juan Antonio Ruz.
Lo primero que hemos hecho en el día ha sido:

1. Crear una cuenta de Gmail (el cual ya tenía una cuenta, así que sin problemas)
2. Crear un blog en blogger. El blog tiene que ser el nombre que queramos junto a: "-cea2".
   
3. Enviar un Email a Juan Antonio sobre lo que hemos hecho, lo que hemos cursado, lo que nos gusta, qué queremos hacer y porqué entramos en la CEA.
4. Copiar una carpeta que estaba compartida con el Apache Tomcat, el Eclipse y un plugin de éste.

También teníamos que instalar unos plugins al firefox

1. El delicious, para compartir enlaces importantes de Internet que tengamos que utilizar. Teníamos que crearnos una cuenta y empezar a agregar unos enlaces como es: http://cursoj2ee.blogspot.com/ y http://code.google.com/hosting/, el primero es el blog que lleva Juan Antonio sobre apuntes para la clase y el segundo para subir repositorios.
   
2. El Firebug, herramienta de edición de páginas web en el mismo navegador, que utilizaremos más adelante.

Tenemos que añadir una nueva variable de entorno en el sistema para el correcto funcionamiento del Eclipse (Botón secundario en "MiPC">"Propiedades">"Opciones Avanzadas">"Variables de Entorno" y agregar "nuevo") el nombre es: "JAVA_HOME" y el valor es la ruta del jdk que tenemos instalado, que es: "C:\Archivos de programa\Java\jdk1.6.0_02"

Apache-Tomcat
Colocaremos el archivo comprimido en el escritorio dentro de una carpeta llamada "JAVA" y otra "servers"
Para que arranque el apache tenemos que ejecutar el archivo por lotes: startup.bat, en la carpeta bin (ya colocada en .../escritorio/JAVA/servers).
Si escribieramos en nuestro navegador "localhost:8080" veríamos que funciona.
Cerramos el apache y procedemos a añadir el usuario administrador en el servidor apache, para ello entramos en la carpeta "conf" y modificamos el archivo "tomcat-users.xml" con el programa de edición que queramos y le añadimos 2 líneas nuevas:


Por último añadir que el Tomcat es un servidor web que muestra aplicaciones servlets y JSP, pero como tiene el apache, también muestra páginas web hechas en html, etc.

Eclipse
Primeramente creamos una carpeta llamada "workspace" en la raíz (C:\) que será la carpeta por defecto de nuestros proyectos hechos en eclipse.
El Eclipse es un IDE, un Espacio de Desarrollo Integrado, al igual que el NetBeans y el IntellyIdea.
Al arrancar el Eclipse por primera vez nos preguntará dónde queremos que se guarden los proyectos, y les especificaremos la ruta que antes hicimos "C:\workspace"

• Para comunicar el Eclipse con el Tomcat deberemos hacer click con el botón derecho del ratón en la parte inferior de la pantalla, con la pestaña abierta de "Servers", en el espacio de "Server" y pulsamos "new" y "server".
• Le especificamos el "Tomcat v6.0 Server" que es el Apache que hemos instalado y despues pulsamos en "Add..." para añadir el servidor de Tomcat.
• Pulsamos en "Browse..." y le especificamos la ruta "Escritorio\JAVA\servers\apache-tomcat-6.0.18" que fue donde descomprimimos el apache.
  
• Pulsamos en "Installed JREs" y le añadimos uno nuevo, marcando en "Next >" y después señalando la ruta en donde está el JRE (Archivos de programa/Java/jre1.6.0_02) y pulsamos a "Finish", marcamos el que hemos añadido y le damos a "Ok"
• Le damos a "Finish" o a "Next >" si es que tenemos algún proyecto web ya creado en Eclipse.

El servidor no debería de dar problemas, pero si los llegara a dar tendríamos que hacer doble click en el servidor (dentro de la pestaña) y cambiarle los puertos (curiosamente añadiendo 10 xD) p.e: 8080 -> 8090

JBossTools
Es un plugin que añadiremos al Eclipse, simplemente descomprimiendolo y copiando el contenido de las carpetas del archivo comprimido en las carpetas correspondientes del Eclipse.

El Primer JSP
Creamos nuestro primer JSP pulsando en nuevo proyecto y del tipo "Dynamic Web Project"

• Ponemos el nombre del proyecto, que tiene que ser con la técnica del camello (primera palabra el minúscula y si tiene más de una palabra empiezan en Mayúsculas y juntas), por ejemplo "holaMundo"
• En "ContextRoot" escribimos la raíz del proyecto para que podamos visualizarlo desde el navegador, que al final sería por ejemplo: "localhost:8080/holaMundo/"
• En la carpeta "WebContent" creamos un nuevo archivo JSP de nombre "index", nos despreocuparemos de la extensión porque Eclipse ya lo pone solo.
• Añadimos en el código html "Hola <%=request.getParameter("nombre") %>"
  
• Para visitar nuestro nuevo JSP tendríamos que escribir en la barra de dirección: "localhost:8080/holaMundo/index.jsp?nombre=jose" y veríamos que nos muestra "Hola Jose"

Y así fue el día.

Creo que me he extendido demasiado, pero por ser el primer día y ser tan importante por la instalación y configuración de los programas que usaremos de ahora en adelante, creo que merece la pena.