viernes, 27 de febrero de 2009

Día 32: Proyectos con maven e implementaciones

Proyectos maven desde eclipse
Hoy probamos a crear e instalar un proyecto maven desde eclipse.
Después de esta introducción hicimos una serie de ejercicios.
En cada ejercicio lo que nos tiene que quedar claro es:
  • Crear un proyecto Maven (Maven project) desde eclipse.
    • Marcarlo como un proyecto simple.
    • Indicar el "Group id" (Que le ponemos el mismo nombre que los paquetes, pej: es.cea)
    • Indicar el "Artifact id" (Que es el nombre del proyecto)
    • Indicarle la versión.
    • El modo de empaquetado, que lo dejaremos en ".jar"
    • Y un nombre y una descripción, aunque ésto es opcional.
  • Crear una interfaz poniendo un método que tenga que recibir algo y devolver otra cosa.
  • "Instalar" el proyecto, incluyendolo en el repositorio para despues usarlo como librería.
  • Crear otro proyecto y añadir una dependencia desde el maven indicandole el proyecto que "instalamos"
  • Crear una clase que implemente la interfaz que creamos e implementar el método.


Ejercicios
Creamos una aplicación web "web01" que va a llamar a servicioCalculadora y a servicioTraduccion (los ejercicios que hemos hecho antes)
Lo marcaremos como webapp
Crearemos un servlet que escuchará por el web01/home y llamará a la vista home.jsp
Desde el build path crearemos la carpeta "java" dentro del "main"
En el proyecto seleccionamos "Run As" y marcamos "Maven build..." y en "Goals" pondremos "clean tomcat:run-war" Para que borre lo que se haya podido guardar y arranque la aplicación desde el tomcat y ya podremos acceder a el: http://localhost:8080/web01/
Advertencia! Si dejamos un proyecto abierto que sea importado y estemos utilizando en otro proyecto, debemos cerrarlo, sino no funcionará!!

jueves, 26 de febrero de 2009

Día 31: Proyecto MySQL, MAVEN

Proyecto
Hoy continuamos con la implementación de MySQL en el proyecto de la biblioteca.

Volvemos a recordar los comandos del maven:
Para comprobar que funciona abrimos la consola del windows y tecleamos: "mvn -version" y si sale la versión del MAVEN, es que nos funciona.
Seguimos en la consola y tecleamos la siguiente secuencia de comandos: "mvn archetype:create -DgroupId=es.cea -DartifactId=EjemploMaven"
Hacemos "cd EjemploMaven" y escribimos "mvn compile"
Si queremos realizar algun test usaremos "mvn test"
Si queremos hacer un paquete: "mvn package" que lo que hace es primeramente compila, despues testea y despues hace el paquete.
"mvn install" > Compila, pasa prubas, hace jar y lo añade al repositorio.
Comandos básicos:

mvn clean
mvn compile
mvn package
Se pueden hacer varios comandos de golpe, por ejemplo: "mvn clean compile package"

Creamos un nuevo proyecto, EjemploMaven2
Modificamos el pom.xml y le añadimos una nueva dependencia que dependa del EjemploMaven.
Lo instalamos y no debería dar error.
Ahora desde el maven escribimos "mvn eclipse:eclipse" y creará los archivos necesarios para que lo abra el eclipse.
Una vez que hemos creado un proyecto con el mismo nombre y lo rescata, lo "mavenizamos" y desde la opcion de maven podemos hacer lo mismo que por consola.

Como crear una aplicacion web.
Desde el workspace: "mvn archetype:create -DgroupId=es.cea -DartifactId=web00 -DarchetypeArtifactId=maven-archetype-webapp"

miércoles, 25 de febrero de 2009

Día 30: Proyecto MySQL

Proyecto
Hoy continuamos con la implementación del dao en MySQL
Request
Creamos un listener de tipo ServletRequest.
Un Mapa devuelve un Collection, todas las colecciones siempre devuelven un Collection.

martes, 24 de febrero de 2009

Día 29: Expansión del proyecto

Implementación en grupo de DaoBibliotecaMySQL
Cambios en proyecto original
  • Dao se crea y se guarda en sesión [y se accede...]
  • Se crea listener evento que realice.
    • La conexión al inicializar Request.
    • Cierre la conexión al destruir Request.

lunes, 23 de febrero de 2009

Día 28: MAVEN y MySQL

DESARROLLO DE APLICACIONES J2EE
Hoy comenzamos con un nuevo módulo pero continuando la misma temática.

Wink
El wink es un programa que es capaz de crear "vídeos" hechos en flash que nos vendrá bien si queremos realizar alguna documentación.
Instalamos el wink y creamos un nuevo archivo.
Seleccionamos opciones.
Exportar como html.

MySQL - Instalación
Primero descargamos el tutorial hecho en flash y seguimos sus pasos.
Usuario root y la contraseña ya la imaginamos.
Para conectarnos al mysql desde la consola debemos usar los siguientes comandos: "mysql --user=root -p"
En todo comando que introduzcamos en la consola (a excepción del login) siempre debe de terminar con puto y coma ";"
Despues de probar unos comandos instalamos el MySQL Tools.
Arrancamos el MySQL Administrator, ponemos que arranque en el localhost y ponemos el nombre y el usuario.
En el Administrador le damos al catálogo y creamos un nuevo esquema y lo llamamos CEA.
Dentro de la base de datos CEA creamos una nueva tabla y seleccionaremos el Engine MylSAM (En la pestaña Table Options) y le ponemos un nombre a la tabla nueva.
A la hora de crear campos en las tablas tenemos un conjunto de variables.
Para texto:
  • CHAR
  • VARCHAR() -> Debemos introducir el número de caracteres que necesitará.
  • TEXT

Abrimos el MySQL query Browser.
Insertarremos un nuevo alumno. (mirar comandos)
Borramos un alumno según el nombre.
(mirar comandos)

Ahora crearemos una tabla nueva llamada "Profesores" y relacionaremos la tabla alumnos con la de profesores.
Para ello necesitaremos de una clave ajena con el nombre que queramos pero tiene que ser con la variable exactamente igual que la tabla de origen.
La relación será de tipo N-1, un profesor tendrá muchos alumnos y un alumno tendrá un profesor (en realidad sería N-N, pero para empezar está bien)
Como el MySQL nos da problemas, lo reconfiguraremos y siempre estará marcada la primera opción.
Ahora si nos dajará poner como clave ajena.

MAVEN
Antes de hacer nada recordar que era el maven, veamoslo aquí
Primeramente copiamos la carpeta entera de "apache-maven-2.0.9
" y la copiamos en la raíz de C:
Para meter el subdirectorio bin en el path de ejecutables, le doy con el botón derecho del ratón sobre el icono de "Mi PC" y elijo "Propiedades", "Avanzado" y "Variables de Entorno". Busco "Path" y le doy a "Editar". Añado al final ";C:\
apache-maven-2.0.9\bin" (con punto y coma delante, para separarlo de lo que ya haya escrito)
Para comprobar que funciona abrimos la consola del windows y tecleamos: "mvn -version" y si sale la versión del MAVEN, es que nos funciona.
Seguimos en la consola y tecleamos la siguiente secuencia de comandos: "mvn archetype:create -DgroupId=es.cea -DartifactId=EjemploMaven"
Hacemos "cd EjemploMaven" y escribimos "mvn compile"
Si queremos realizar algun test usaremos "mvn test"
Si queremos hacer un paquete: "mvn package" que lo que hace es primeramente compila, despues testea y despues hace el paquete.
"mvn install" > Compila, pasa prubas, hace jar y lo añade al repositorio.

Instalar el plugin de Eclipse
Vamos a "Help", software updates y añadimos un sitio nuevo: "http://m2eclipse.sonatype.org/update/" y de las casillas que apaceren, marcaremos "maven integration"

Una vez instalado el plugin y reiniciado el Eclipse copiamos el proyecto "mysqlmaven" en el workspace y hacemos un proyecto con ese nombre.
Despues configuramos el maven: Window, Preferences, Installations y le decimos la siguiente ruta: C:\apache-maven-2.0.9\conf\settings.xml

Proyecto "mysqlcea"
Para comenzar abrimos el MySQL Administrator, pulsamos en "restore" y le decimos que restaure una base de datos a partir del archivo: mysqlcea\src\test\resources\mysqlcea.sql
Con eso ya podremos usar el maven.
Ejecutamos los archivos .sql que tiene el proyecto en resoruces.
Con eso ya hemos creado las tablas de la base de datos para realizar las pruebas del proyecto.

A la hora de recojer datos haciendo una consulta en la base de datos a través de java tenemos que crear un objeto de tipo "ResultSet", inicializandolo así: connection.createStatement().executeQuery("consulta");
Para recojer los datos sería usando el objeto de tipo ResultSet y llamando a sus métodos.. "getString("campo")" para recojer el dato del campo que hayamos introducido. (Existe casi un método para cada tipo de dato)
Si en vez de hacer una consulta, queremos borrar algo en la base de datos, no usaremos el executeQuery, sino que usaremos el: connection.createStatement().executeUpdate("delete from autores where nombre='autor'");

Como ejercicio editamos el proyecto:
Creamos una tabla llamada "generos"
Creamos una fila de generos
Hacemos un test con los siguientes métodos: crearGeneros, modificarGeneros, borrarGeneros.



Comandos MySQL
Para cambiar de base de datos usamos el comando "use [nombreBD]", nombreBd: El nombre de la base de datos.
Para ver las tablas de la base de datos usamos "show tables".
Para ver los campos de las tablas usaremos "decribe [nombreTb]"
, nombreTb: El nombre de la tabla.

Insertar:
Insert into alumnos(nombre,edad) values('Alumno1',25); ,Lo que sea numérico no lleva comillas.
Borrar:
delete from alumnos where nombre='Alumno1';

viernes, 20 de febrero de 2009

Día 27: Proyecto MVC, Finalización

Término.
Hoy, por fin, damos por concluido el proyecto de la bibliotecaMvc. (aunque no se recoje hasta el lunes, así que tenemos "prórroga" este fin de semana)

jueves, 19 de febrero de 2009

Día 26: Proyecto MVC, continuación 5

Continuación, ...
Continuamos con el proyecto con algo de prisa porque mañana ya termina el plazo.
Consejo sobre la validación
Servlet
...doGet()..{
try{
compruebaNoNulos(req,"mail","clave");
}catch(){
req.setAtribute("error",...);
}
...
}

Método
public void compruebaNoNulos(HttpRequest req,String ... parametros){
foreach(String para:parametros)
if(request.getParameter(par)==null) throw new (par);
}

miércoles, 18 de febrero de 2009

Día 25: Proyecto MVC, continuación 4

Continuando, ...
Hoy continuamos con el proyecto de la biblioteca usando el modelo vista controlador.

MAVEN
Se hizo una pequeña introducción de lo que es capaz de hacer el MAVEN.

Es una herramienta de consola.
Puede crear proyectos java, creando también la estructura básica.
También puede compilar: "mvn compile"
Puede crear paquetes: "mvn package" (un jar)

martes, 17 de febrero de 2009

Día 24: Proyecto MVC, continuación 3

Continuando, ...
Hoy continuamos con el proyecto.

MAVEN
Tenemos que mirar el maven, este enlace: MAVEN

lunes, 16 de febrero de 2009

Día 23: Proyecto MVC, continuación 2

Continuando, ...
Hoy continuamos haciendo el proyecto de la biblioteca usando el modelo vista controlador.

viernes, 13 de febrero de 2009

Día 22: Proyecto MVC, continuación

Continuando, ...
Hoy continuamos con la nueva versión del proyecto de la biblioteca.

jueves, 12 de febrero de 2009

Día 21: DAO / Iniciar Proyecto MVC

Clase DAO
Un ejemplo de una clase DAO: VER.
Ese es un ejemplo de una clase DAO sin usar una base de datos, pero si la usáramos solo tendríamos que sustituir las listas por consultas SQL.

Los datos del ejemplo se usarían por las variables de aplicación usando el servletContext como tantas veces hemos hecho.

El DAO es una capa de acceso a datos y cada capa pueden lanzar excepciones.


Proyecto MVC: Biblioteca
Una vez terminado esta pequeña explicación comenzamos a organizar la continuación del proyecto de la biblioteca adaptándolo al Modelo-Vista-Controlador.

miércoles, 11 de febrero de 2009

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.


martes, 10 de febrero de 2009

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

lunes, 9 de febrero de 2009

Día 18: JSTL

JSTL
Primeramente un poco de siglas:

Tag = Etiqueta = Referencia a una clase java
JSP = Java Server Pages
JSTL = Java Standard Tag Library
TLD = Tag Library Descriptor
EL = Expression Lenguaje

En las vistas se intenta eliminar el código java o al menos la menor cantidad posible y con JSTL se usan etiquetas parecidas a HTML.

En vez de usar el request.getParameter("x"); ahora se usa el Param.x
Las variables empiezan como en php, con el $

Un recuerdo de una de las etiquetas que usaremos para que funcionen nuestras aplicaciones usando JSTL:

Directivas - <%@... ...%> - Son importantes, por ejemplo
<%@page import=”java.util.*”%> - Para importar una librería

<%@taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>
Donde referencia los tag que voy a utilizar. Con esta librería podremos hacer un if, un for, un for each, y más.

Cuando vayamos a incluir alguna librería de este tipo:
En algún lugar debemos tener los archivos descriptores de tags
Y añadir la librería que usaremos en el web.xml.

Cómo crear una etiqueta personalizada
Una etiqueta es una clase java que extiende de la clase TagSupport
Para ello debemos sobreescribir los métodos: doStartTag y doEndTag

Ahora hacemos una nueva etiqueta, copiandonos de una ya hecha y después tendremos que hacer una etiqueta que formatee monedas.

Otro ejercicio es crear una etiqueta que liste un mapa.

Servlet --> getServletContext().getAttribute("");
JSP --> application.getAttribute("");
JSTL+EL -->

Objetos Implícitos
El lenguaje de expresion JSTL define un conjunto de obletos implícitos:
pageContext - the PageContext object
pageScope - a Map that maps page-scoped attribute names to their values
requestScope - a Map that maps request-scoped attribute names to their values
sessionScope - a Map that maps session-scoped attribute names to their values
applicationScope - a Map that maps application-scoped attribute names to their values
param - a Map that maps parameter names to a single String parameter value (obtained by calling ServletRequest.getParameter(String))
paramValues - a Map that maps parameter names to a String[ ] of all values for that parameter (obtained by calling ServletRequest.getParameterValues(String))
header - a Map that maps header names to a single String header value (obtained by calling ServletRequest.getheader(String))
headerValues - a Map that maps header names to a String[ ] of all values for that parameter (obtained by calling ServletRequest.getHeaders(String))
cookie - a Map that maps cookie names to a single Cookie (obtained by calling HttpServletRequest.getCookie(String))
initParam - a Map that maps a parameter names to a single String parameter value (obtained by calling ServletRequest.getInitParameter(String))

Por ahora empezaremos a usar el "
applicationScope"


Consejos
1- Si tenemos que modificar el web.xml a mano (= no se haya instalado bien el pluggin en el Eclipse para hacerlo visualmente) cada librería de tags que queramos usar tendremos que introducirlos dentro del mismo jsp-config, y cada librería en su respectivo taglib
2- Si una aplicación web de las que hagamos da un error antes de arrancar la aplicación, lo más probable es que el error será del web.xml.

viernes, 6 de febrero de 2009

Día 17: Test a Colecciones e introducción a Capas

Repaso a Objetos

Al empezar la clase comenzamos importando un nuevo proyecto que copiamos en el workspace.
Repasamos también la idea básica de los objetos y es que a la hora de introducirlo a una lista, de "sacarlo" a una variable, modificarlo y demás, en realidad siempre estamos trabajando con un mismo objeto, porque siempre estamos haciendo referencia al mismo objeto, no lo estamos copiando constantemente (para eso ya hay un método específico: clone()).

Colecciones
Si tenemos una lista de elementos y queremos ordenarlas tenemos dos maneras:

Sin pasarle el criterio del orden:
Collections.sort(clase)
Se da por hecho que la lista es de un tipo de objeto tiene que implementar Comparable. Si no se implementa no puedo utilizar el método.
Solamente funciona para clases que implementan
Comparable.
public class Alumno implements Comparable{ ...

Y cuando decimos que nuestra clase implementa
Comparable estamos obligados a implementar el método CompareTo() y ahí es donde decimos la comparación.
public int compareTo(Alumno o){
return this.dni.compareTo(o.dni);
}

Al pasarle el criterio del orden
Collections.sort(clase,ObjetoDeCriterio)
La clase no tiene porque implementar la clase Comparable.
El criterio es una clase que tenemos que crear implementando el Comparator.
public class AlumnoNombreComparator implements Comparator {
public int compare(Alumno alumno1, Alumno alumno2) {
return alumno1.nombre.compareTo(alumno2.nombre);
}
}
Se puede invertir el orden, si "alumno1" es mayor que "alumno2", devuelve 1 y si es menor -1 y si son iguales 0.

Diseño de un programa en capas
Es un patrón de desarrollo.
Las responsabilidades de las clases son las capas.

Capa DAO: son clases que acceden a datos.
Las capas no ven entre capas. Por ejemplo, los controladores no pueden ver a la capa DAOs, sólo a la capa Servicios.
Si se realiza un cambio en una capa DAO no se debe de "enterar" la capa Controladores. A eso se le llama un programa robusto, porque si se cambia la capa DAO y se entera todo el mundo, entonces es frágil, no compila.

Los servicios no se relacionan con las clases, sino con las interfaces.

jueves, 5 de febrero de 2009

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.

miércoles, 4 de febrero de 2009

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.

martes, 3 de febrero de 2009

Día 14: Terminando proyecto

Hoy continuamos con el proyecto y también se nos explicó dos atajos de teclado interesantes en eclipse:
Control + mayuscula + T: Para buscar el nombre de una clase o tipo (type)
Control + mayuscula + R: Para buscar algún recurso (resource)

También vimos que podríamos ahorrar líneas de código usando un método de las listas, en vez de recorrerlas con bucles para buscar coincidencias:

Ahorrarnos:
List usuarios;
for(Usuario u:usuarios){
if(u.equals...)
}

Método:
boolean existe = usuarios.contains(o);
Comprueba si el objeto "o" esta en la lista.

Por último vimos de nuevo el uso de los test aplicando lo anteriormente mencionado sobre la comparación de objetos en una lista.

Y para terminar.. continuamos con el proyecto.

lunes, 2 de febrero de 2009

Día 13: TestNG

TestNG
Programación orientada a pruebas.
T.D.D. -> Development Directed Test

La idea es la de primero hacer la prueba y luego programar, pero nosotros empezaremos al revés para entenderlo pero está mal.
Nuestro código principal está en la carpeta "src" y la de pruebas está en "test" y dentro de ésta "src" y se le llama estructura simétrica.
Con esto se puede poner en práctica las propiedades de protected de las clases, que aún estando en carpetas diferentes están en el mismo paquete y puede accederse mutuamente.

Instalar pluggin TestNG a Eclipse
Primeramente vamos a la siguiente dirección que nos dirá cómo instalar el pluggin: http://testng.org/doc/eclipse.html

Añadimos un sitio más de actualización al eclipse y copiamos la siguiente dirección: "http://beust.com/eclipse"

Haciendo test
Para crear un programa test, lo que haremos será poner una anotación de tipo test "@test"
El código siguiente es un ejemplo de un programa test:

public class ServicioGoogleTest{
@test
public void conexion(){
ServicioGoogle servicio = new ServicioGoogle();
boolean estado= servicio.conecta("usuario","password");
assert(estado==true);
}
}

También necesitaríamos la librería del TestNG

Empezamos haciendo un proyecto nuevo de tipo Java (proyecto normal) y creamos 2 source folders nuevos: "java/src" y "java/test" y añadimos la librería TestNG.

El método "assert" sirve para hacer un test a los métodos u objetos que queremos probar y si sale algo mal nos saldrá el error blanco, pero si queremos que nos muestre un mensaje lo haremos del siguiente modo:
assert(estado==true):" se esperaba conectar con admin";

Una vez terminado esta visión sobre los test volvemos con nuestro proyecto de la biblioteca.

Wink
Mientras estamos coordinando los proyectos hicimos un paréntesis sobre una aplicación que graba nuestros movimientos y crea un vídeo flash, el Wink, que es de código abierto.
De primera obtuvimos un vídeo de cómo instalar el MySQL.