Crear un proyecto Tapestry 5 con Maven

1) Hay que ejecutar el siguiente comando:
mvn archetype:generate -DarchetypeCatalog=http://tapestry.formos.com/maven-repository

Al ejecutar este comando en consola, nos pedirá los siguientes parámetros:

• groupId
• artifactId
• version
• package

Al terminar de generar el proyecto nos creará una carpeta con el nombre indicado en artifactId.

Para preparar el proyecto para Eclipse nos introduciremos en la carpeta del proyecto y ejecutaremos el siguiente comando:

mvn eclipse:eclipse -DdownloadSources=true -DdownloadJavadocs=true

Ya sólo queda copiar la carpeta creada a nuestra carpeta de proyectos de Eclipse y crear un nuevo proyecto java en eclipse con el mismo nombre. Después de crearlo tendremos que habilitar Maven para el nuevo proyecto.

Para más información visitar el siguiente enlace.

Instalación de testNG en Eclipse

¿QUÉ ES TESTNG?

TestNG es un framework para pruebas y testing que nos permite desarrollar nuestro proyectos usando TDD (Test Driven Development -desarrollo guiado por pruebas). Esta técnica de desarrollo se podría resumir en los siguientes pasos:

• Se crea una prueba unitaria
  
• Se verifica que falle
• Se implementa el código que hace que la prueba no falle
• Se verifica que no falle
• Se refactoriza el código
  

TRABAJAR CON TESTNG EN ECLIPSE

Para descargar el proyecto:

• Nos dirigimos al sitio http://testng.org/doc/download.html
• Descargamos el fichero *.zip que contiene el proyecto

Para instalar el plugin en Eclipse:

• Abrimos Help->Software Updates
• Pulsamos sobre Add Site...
• En el diálogo escribimos la dirección http://beust.com/eclipse
• Seleccionamos el nuevo sitio y pulsamos sobre Install
• Seguimos el asistente de instalación
• Reiniciamos Eclipse

Para crear un proyecto con testNG:

• Descomprimimos el *.zip del proyecto en nuestra carpeta de trabajo de Eclipse
• Creamos un nuevo proyecto, por ejemplo, un proyecto java
  
• Le damos el nombre, por ejemplo, testeo y pulsamos siguiente
• Creamos dos nuevas carpetas de fuentes pulsando sobre Create new source folder: a una la llamamos java/src y a la otra java/test. Lo importante es que ambas carpetas tengan la misma raíz, es decir, java (o el nombre que elijamos).
• En la pestaña Libraries del mismo cuadro de diálogo pulsamos sobre Add External JARs...
• En el cuadro de selección de ficheros nos dirigimos a la carpeta del proyecto testng que está en la carpeta workspace de Eclipse y seleccionamos el fichero testng-5.8-jdk15.jar
• Pulsamos sobre finalizar
• En nuetro nuevo proyecto, dentro de la carpeta java/src creamos un nuevo paquete, por ejemplo, es.cea y dentro de la carpeta java/test creamos exactamente el mismo (es.cea). Es muy importante que ambas carpetas el nombre del paquete sea el mismo

Para abrir la perspectiva TestNG:

• Pulsamos sobre Window->Show View->Other...
• En el campo de texto del diálogo que nos aparece, escribimos testng y nos debe aparecer la vista
• La seleccionamos y listo

Para lanzar un test:

• Seleccionamos la clase que queremos comprobar
• Abrimos el menú contextual y seleccionamos Run As->TestNG Test
  

Instalacion del plugin SVN en Eclipse

¿QUÉ ES SVN?

SVN es un sistema de control de versiones que nos permite tener un historial de los distintos cambios que hacemos sobre nuestro código y, por tanto, mantener guardado en un lugar centralizado las distintas versiones de nuestros proyectos.

INSTALACIÓN DEL CLIENTE SVN EN ECLIPSE

• Vamos a Help->Software Updates->Add Site...
• Introducimos la dirección http://subclipse.tigris.org/update_1.4.x
• Le damos a instalar

AGREGAR UN REPOSITORIO

• Abrimos la vista de SVN: Window->Show View y escribimos SVN
• En el panel SVN Repositories: Menú contextual->New->Repository Location...
• Introducimos la URL del repositorio y aceptamos

DESCARGAR UN PROYECTO DE UN REPOSITORIO

• En la vista Project Explorer: Menú contextual->New->Project
• En el nuevo diálogo elejimos SVN->Checkout Projects from SVN
• En el siguiente diálogo seleccionamos el repositorio del que queremos descargar
• Elejimos el proyecto y aceptamos
• En el siguiente diálogo elejimos el nombre para el proyecto

SUBIR UN PROYECTO A UN REPOSITORIO

• En la vista Project Explorer seleccionamos el proyecto: Menú contextual->Team->Share Project...
• En el siguiente diálogo seleccionamos el sistema de versiones SVN.
• Seleccionamos el repositorio
• En el siguiente diálogo seleccionamos el nombre para el proyecto y aceptamos
• Una vez creado nos vamos al proyecto: Menú contextual->Team->Commit...

SUBIR UN PROYECTO A UN REPOSITORIO DISTINTO

• Sobre el proyecto: Menú contextual->Team->Disconnect...
• Seguimos los pasos para subir un proyecto
  

Limpiar la caché del servidor

Cuando estamos realizando muchos cambios en nuestro código, es aconsejable limpiar la caché del servidor de manera eventual porque puede que no esté actualizando dichos cambios y nos lleve a situaciones en las que nuestra aplición no se ejecute como se podría esperar.

Atajos de teclado en Eclipse I

Eclipse nos provee de una serie de atajos de teclado que facilita nuestro trabajo

• Ctrl+1 sobre un elemento del código (variable, método, atributo, clase,...) nos ofrece sugerencias sobre él.
• Escribir syso y después teclear Ctrl+Espacio nos genera la instrucción System.out.println
• Si pulsamos Ctrl+click sobre cualquier elemento del código nos permite navegar por el código como si de una página web se tratase. Por ejemplo, si hacemos esta operación sobre una variable de tipo Persona declarada en una clase Agenda nos llevaría al código de la clase Persona. Con Alt+flecha izquierda volvemos al código donde ejecutamos Ctrl+click.
• Si estamos tecleando código y pulsamos Ctrl+Espacio nos aparece el diálogo de sugerencia de código para poder autocompletar.
  

Sobreescritura de métotos desde Eclipse

Eclipse nos provee de las opciones necesarias para sobreescribir o implementar ciertos métodos. Siguiendo con la línea de la anterior entrada, podemos sobreescribir los métodos toString() y equals(Object) de la siguiente manera:

• Elegimos la opción Source->Override/Implements Methods...
• En el diálogo que nos aparece elegimos los métodos que queremos sobreescribir
• Nos aparece el código de los métodos elegidos y sólo queda implementar el código

En el caso del método equals(Object) tenemos una opción aún mejor:

• Elegimos la opción Source->Generate hashCode() and equals()...
• En el diálogo elegimos los atributos que servirán de criterio para la igualdad
• Se genera en nuestra clase los métodos correspondientes y su código.

Otras dos opciones muy útiles del menú Source son:

• Generate Getters and Setters...
• Generate Constructor using Fields...

La primera opción nos genera el código de los métodos getAtributo()-setAtributo() para cada uno de los atributos que le indiquemos en el cuadro de diálogo que se nos muestra. En el segundo caso se nos genera el código de un constructor que inicializa los atributos que le indiquemos en el cuadro de diálogo que nos aparece.

Sobreescritura de métotos heredados de Object

Todas las clases en Java (incluidas las que creamos nosotros) heredan implícitamente de la clase Object. De esta clase heredamos los siguientes métodos:

• toString()
• equals(Object)
• hashCode()
• finalize()
• clone()

De los métodos antes mencionados es interasante la sobreescritura de dos de ellos. Al igual que imprimimos un String o cualquier variable primitiva en pantalla, podemos imprimir un objeto. Cuando imprimimos un objeto lo que ocurre es que se llama al método toString() del objeto y se imprime la cadena que este método nos devuelve. Según como esté implementado, la salida será una u otra. Por defecto este método imprime en pantalla la clase a la que pertenece el objeto y la dirección de memoria del mismo en el siguiente formato:

paquete.Clase@direccion

En el caso de las clases de envoltorio este método está sobreescrito para que muestre una cadena con el valor primitivo que encapsula. En nuestras clases podemos sobreescribirlo para que muestre el valor de los atributos que nos interese mostrar en vez de recurrir a métodos getVariable() y tener que transformar la salida en un String. En este ejemplo lo vemos:

public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
System.out.println(p1);
}
}

La salida de la anterior clase nos daría como resultado:

NOMBRE: Pepe
EDAD: 30

En el caso de las colecciones de objetos, esto nos permitiría recorrer la colección e imprimir el valor de las variables con sólo llamar a nuestro método toString() sobreescrito.

El otro método que nos puede interesar sobreescribir es el método equals(Object). Este método compara dos objetos y nos devulve true o false en caso de que sean iguales o no. Según como esté implemetado el método en cada clase, los criterios de igualdad variarán. Nos puede interesar en las clases que creamos determinar los criterios a tener en cuenta para establecer esa igualdad sobreescribiendo el método equals(Object). Siguiendo con el ejemplo anterior:

public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
Persona p2=new Persona("Pepe",new Integer(25));
boolean igual=p1.equals(p2);
System.out.println(p1);
System.out.println(p2);
System.out.println("\nEs igual: "+igual);
}
}

El ejemplo anterior nos devolverá que la variable igual es true ya que el criterio de igualdad que hemos definido es el atributo nombre:

NOMBRE: Pepe
EDAD: 30
NOMBRE: Pepe
EDAD: 25

Es igual: true

Introducción a los Servlets

Un servlet no es más que una clase java capaz de procesar peticiones http por parte de un cliente. Para crear un servlet seguimos los siguientes pasos:

1- En Eclipse, dentro de nuestra aplicación web, en JavaResources: src creamos un nuevo paquete y le damos el nombre que queramos p.e. es.cea
2- Dentro de ese paquete creamos nuestra clase Servlet p.e. Saludo
3- Esa clase debe heredar de HttpServlet y sobreescribir los métodos doGet() y doPost(). Estos métdos se encargan de realizar las operaciones necesarias como respuesta a la solicitud.

¡¡Truquito!!
Cuando heredamos una clase o implementamos una interfaz, podemos ahorrarnos escribir el código de los miembros que queremos sobreescribir de la siguiente manera.
- Abrimos el menú contextual dentro del cuerpo de la declaración de la clase
- Elegimos la opción Source->Override/Implements Methods
- Nos sale un cuadro de diálogo con todos los métodos disponibles
- Marcamos los que queremos implementar y aceptamos
- Ahora aparce en nuestra clase el código con los métodos.

4- Editamos el fichero web.xml de nuestra aplicación y damos de alta nuestra clase en Tomcat.

Procesar peticiones en JSP

CREAR PROYECTO DE TRABAJO

Para la clase de hoy se creará un nuevo proyecto en Eclipse:
1- Crear un nuevo proyecto web dinámico llamado cea01.
2- Creamos dentro de WebContent el fichero bienvenida.jsp
3- Desplegamos el fichero en Tomcat
4- Accedemos a la URL http://localhost:8090/cea01/bienvenida.jsp para comprobarlo.

TEORIA: OBJETOS IMPLÍCITOS EN JSP Y SERVLETS



Los objetos mostrados en la anterior tabla son implícitos ya que no es necesario instanciarlos, la máquina virtual se encarga de ello, y así podemos hacer un uso directo de sus métodos y atributos. Cada uno de esos objetos se utilizan dentro de un contexto:

A) EVENTO

Un evento es toda acción que el usuario realiza sobre nuestra página y que genera URL más sus parámetros (si los hay), es decir, pulsar sobre un botón, un enlace, escribir directamente una URL, enviar un formulario,etc. Los eventos son manejados en JSP mediante el objeto request. El esquema siguiente muestra dicho proceso:




De esta manera, cada vez que se genera un evento, se crea un nuevo objeto request que se encarga de procesar dicho evento y que se destruye en el momento que procesa los datos que recibe. Para procesar los datos tenemos dos métodos:

-String getParameter(String parámetro): nos devuelve el valor del parámetro indicado
-String getRequestURL(): nos devuelve la URL que recibe los parámetros(el fichero)

Para entender estos dos métodos hay que tener en cuenta que el formato de petición de una URL con parámetros es: url_destino?parametro1=valor1&parametro2=valor2&... Por ejemplo:
bienvenida.jsp?nombre=raul&edad=27. Usando los dos métodos mencionados obtendríamos:

getParameter(“nombre”) devuelve “raul”
getParameter(“edad”) devuelve “27”
getRequestURL() devuelve “bienvenida.jsp”



B) SESIÓN

Este contexto se produce desde que un usuario accede a nuestra aplicación hasta que la abandona. Las sesiones son procesadas en JSP mediante el objeto session. Por tanto, se creará un nuevo objeto session por cada usuario que acceda a la aplicación y se destruirá dicho objeto cuando el usuario abandone la aplicación. Con respecto a esto hay que tener en cuenta que si un usuario accede a una aplicación desde dos navegadores distintos se crean dos sesiones ya que el usuario de nuestra aplicación es el programa navegador y no la persona que lo utiliza. En resumen, el objeto session nos permite encapsular aquellos recursos que podamos necesitar durante la sesión. Para ello tenemos los siguientes métodos:

-void setAttribute(String clave,String valor): definimos un parámetro y su valor
-String getAttribute(String clave): obtenemos el valor de un parámetro

C) APLICACIÓN

Este contexto se produce por la propia aplicación en sí y se mantiene mientras la aplicación se ejecute en el servidor. Por tanto, sólo hay un objeto application por cada aplicación. Este objeto encapsula todos los recursos necesarios durante la ejecución de nuestro programa.

EN RESUMEN:

- Los recursos comunes a todos los usuarios son manejados por application
- Los recursos comunes a un usuario durante su sesión son manejados por session
- Los recursos propios de un evento son manejados por request
- Sólo hay un objeto application por cada aplicación
- Hay un objeto session por cada usuario de la aplicación
- Se genera un objeto request por cada evento

Instalación de herramintas

1- Creación del presente blog desde blogger.com. La direccion del blog es
raultinoco-cea2.blogspot.com.

2- Crear una cuenta en del.icio.us para gestionar marcadores y hacer seguimiento de los distintos enlaces que visitamos cuando investigamos a cerca de un tema. La cueanta creada es ul2mac.

3- Crear un sistema de subversión en code.google.com para poder subir el código de los ejercicios propuestos. Para ello sólo es necesario tener una cuenta con gmail. El sistema de subversión creado es raultinoco-cea2.

4- Instalación de Apache Tomcat 6.0: para ello se ha creado una carpeta servers dentro de la carpeta JAVA y en su interior se ha descomprimido la estructura de ficheros de Tomcat. Posteriormente se ha creado el usuario "tomcat" con el "manager" editando el fichero tomcat-users.xml de la carpeta conf en el directorio de Tomcat y se ha añadido la variable de entorno JAVA_HOME con la URI de la carpeta donde se encuentra Tomcat.

5- Instalación del IDE eclipse. Para ello se siguieron los siguientes pasos:
a) Descomprimir en la carpeta JAVA el fichero con la estructura de directorios de dicho IDE.
b) Crear la carpeta C:\workspace.
c) La primera vez que abrimos eclipse asignamos la carpeta anterior como carpeta de trabajo
por defecto y activamos la casilla para que no vuelva a preguntar el espacio de trabajo.

6- Agregar en Eclipse el servidor web Apache Tomcat. Para ello se siguieron los siguientes pasos:
a) Abrir eclipse.
b) Agregar la vista de servidores: Window->Show View->Servers.
c) Dentro de la pestaña Servers que ahora nos aperece abrir el menú contextual y seleccionar:
New->Server.
d) En el nuevo cuadro de diálogo elegir Apache->Tomcat v6.0 Server y pulsar siguiente.
e) En el nuevo cuadro de diáogo indicar la ruta donde se encuntra Tomcat, en nuestro caso
está en C:\...\JAVA\servers\apache-tomcat-6.0.18.
f) Cambiar el JRE con el que trabajamos por JDK. Para ellos pulsamos sobre Installed JREs,
en el nuevo diálo pulsamos sobre Add, en el nuevo diálogo elegimos Standard VM y
pulsamos siguiente, seleccionamos la ruta del JDK: C:\Archivos de Programas\Java\jdk-xx,
le damos a aceptar y seleccionamos el JDK como JRE por defecto.
g) Ya nos aparece en la vista Servers nuestro Tomcat. Para iniciarlo abrimos el menú
contextual sobre él y pulsamos Start.

7- Instalación del plagin JBoss en eclipse. Para ello descomprimimos el fichero. Nos aparecen dos carpetas: plugins y features. El contenido de plugins lo copiamos al directorio plugins de eclipse y el contenido de featrues lo copiamos dentro del directorio features de eclipse. Arrancamos eclipse y comprobamos en Window->Show View->Other que nos aparece JBoss.

8- Crear el proyecto holaMundo en eclipse y desplegarlo en Tomcat. Para ello:
a) Pulsamos sobre File->New->Dynamic Web Project.
b) En el diálogo le damos el nombre holaMundo y en la sección Target Runtime
seleccionamos Apache v6.0 Tomcat. Pulsamos siguiente.
c) En el siguiente diálogo dejamos los valores por defecto y pulsamos sobre finalizar
d) En la vista Project Explorer de la ventana principal desplegamos el árbol de directorios de
nuestro proyecto y sobre la carpeta WebContent abrimos el menú contextual y elegimos
New->JSP. En el cuadro de diálogo le damos el nombre index y aceptamos.
e) Se nos abre el fichero e introducimos el código JSP.


f) Para desplegar nuestro proyecto abrimos el menú contextual sobre el servidor Tomcat y
seleccionamos Add and Remove Projects. En el nuevo diálogo elegimos el proyecto que
hemos creado lo añadimos y aceptamos.
g) Para ver el proyecto abrimos el explorador he introducimos la ruta siguiente:
http://localhost:8080/holaMundo/index.jsp?nombre=loquesea.