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 19: JSTL, parte 2

JSTL

Desde una clase de tipo TagSupport se puede acceder a las propiedades de un servlet, como por ejemplo a las variables de aplicación ya que un Tag viene de un JSP y a su vez un JSP es un Servlet.

HttpSession session = this.pageContext.getSession();
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
ServletResponse response = pageContext.getResponse();

Ejercicio 1:
Para practicar hacemos una etiqueta: RegistroEtiqueta que si en la sesion hay un atributo que es el usuario, entonces la etiqueta pone el nombre de usuario y si no pues que muestre un formulario, donde se envie a usuario y clave.

La clave del ejercicio es usar el session y el request (ya expuestos arribas).
Si no hay ningun valor en la sesión que muestre un formulario, formulario que se enviará a la misma página.
Una vez que se recarge la página una vez que se envió el formulario detectará que hay un parametro con valor, el cual se introducirá en la variable de sesión y por fin entrará como usuario registrado.

Por supuesto no olvidarnos de añadir la etiqueta a nuestra libería de tags (recordemos, el TLD) y en nuestra página añadir la etiqueta sin más.

Ejercicio 2:
Mostrar un menu dependiendo de cada usuario.

Ejercicio 3:
Que genere menus desplegables.

---

doStartTag
Posibles valores que devuelve
EVAL_BODY_INCLUDE: Evalua el cuerpo de dentro.
SKIP_BODY: Saltar el cuerpo de la etiqueta. Si tuvieramos una etiqueta dentro de ésta la saltaría.

doEndTag
Posibles valores que devuelve
EVAL_PAGE: Se sigue evaluando la página.
SKIP_PAGE: Se salta la página.

---

Para terminar investigar por nuestra cuenta un pluggin que nos puede ser de utilidad que es el java2HTML

Día 16: Log, Colecciones, Consejos y Test

loggin
Primeramente recojemos las librerías: commons-logging-1.1.1.jar y log4j-1.2.15.jar y las colocamos en una carpeta "Librerias" de nuestro Workspace del Eclipse (para tenerlo más a mano) y en los proyectos que vayamos a realizar simplemente los seleccionamos y los arrastramos a la carpeta "lib" del proyecto.

La clase Log (del cual crearemos una variable de ésta clase llamado logger) es capaz de mostrar información según el nivel que le pongamos.

De mayor a menor gravedad:
fatal: Para errores fatales.
error: Lanza un mensaje de la causa del error.
warn: Lanza un aviso.
info: Para mostrar alguna información importante.
debug: Imprimir lo que sea para depuración.

Si se quiere ver un mensaje de tipo warn, el info y el debug no se verá.

Crearemos un nuevo xml que sera un archivo de source pero para no mezclar el xml con el código.
Creamos un nuevo source folder, en paralelo al src de toda la vida y creamos un archivo nuevo xml y copiamos: Codigo
Una vez hecho podemos ver la estructura de un xml que configura el logger.
Lo primero que vemos es la configuración que le da al logger, para que la información que queramos mostrar aparezca en la consola, esa parte no la tocamos.
En otro elemento del documentor podemos especificarle el paquete y el nivel de información que se mostrará y con eso nos damos cuenta la gran utilidad de agrupar un proyecto en varios paquetes para que cada uno pueda mostrar un nivel u otro.

---

Hacemos una revisión de las colecciones de objetos: Colecciones

---

---

Tipos de colecciones de objetos
Lista: Colección de elementos que pueden ser repetidos y se ordenan desde 0 en adelante.
Set: Si se le añade dos objetos iguales, pasa de nosotros y sólo mete 1.
Map: Es una colección de claves-valor. Son objetos ambas.
TreeSet o TreeMap: directamente ordena los elementos que les introduzcamos.

Clases de utilidades:
Collections: Conviete una enumeración en una colección, y otras conversiones, ordena listas, etc
Arrays:

---

testNG - Repaso
Creamos un nuevo proyecto, le ponemos el nombre que queramos y ahora:
Le decimos que haga 2 source folder: src y test
En la pestaña de "Libraries" le añadimos un JAR externo: "testng-5.8-jdk15.jar" y finalizamos la creación.
Si esto último nos lo saltamos podemos hacer: boton derecho sobre el nombre del proyecto>Build Path>configure build path>pestaña librerias>add external jars>seleccionaren nuestro disco duro: testng-5.8-jdk15.jar
Creamos en src y en test dos paquetes simétricos: "es.cea"
Creamos una nueva clase llamada "ExamenTest" y lo probamos haciendo un println, no debería saltar ninguna excepción a la hora de arrancarlo (Botón derecho encima de la clase>Run as>TestNG test)

Creamos una clase Examen que tenga 2 campos (1 de ellos lo inicializa el constructor) que sean "referencia" y "numeroPreguntas".
El esquema básico de una prueba es:

Un escenario de prueba
Examen examen1=new Examen("ref1");
Examen examen2=new Examen("ref2");
Examen examen1Bis=new Examen("ref1");

Una invocación
boolean equals1 = examen1.equals(examen2);

Una confirmación
assert(!equals1):" el examen 1 debe ser diferente del 2";

boolean equals2 = examen1.equals(examen1Bis);
assert(equals2):" el examen 1bis debe ser igual a examen 1";

Si ponemos el código así y hacemos el test, fallará, así que implementamos el equals y el hashcode en Examen y ya funcionará el test.

Una vez probado el test lo expandimos haciendo una clase "Pregunta" que como parámetros tendra un Examen y un número de preguntas.
Al hacer una nueva clase, también hacemos su correspondiente clase de test: PreguntaTest, que haga lo mismo, creamos unos cuantos objetos de tipo Pregunta y comparamos si son iguales, etc.

Y como ejercicio debemos hacer un ejercicio para probar los test creando una clase "Aula" y otra clase "Localización"
Aula: Atributos: Localización y Nombre
Localización: Atributos: String referencia y Integer planta.

---

Y para terminar unos consejos para el Eclipse y nuestros proyectos:

Atajos de teclado del Eclipse:
Control+Alt: Copia la linea entera en la que nos encontremos usando los cursores arriba o abajo.
Control+D: Borra la línea en la que nos encontremos.
Alt: Usando también los cursores movemos la línea arriba o abajo.
Control+7: Comenta la línea que nos encontremos.

A partir de hoy en los proyectos que hagamos debemos tener una estructura determinada:
Con respecto a las librerías:
Incluir siempre estas tres librerías:
log4j.jar
commons-logging.jar
testng.jar

Con respecto al código:
Siempre poner la variable logger:
protected final Log logger = LogFactory.getLog(getClass());

Con respecto a los source folders:
Tener siempre el source folder src, resources y test.

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.

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.