Mostrando entradas con la etiqueta Eclipse. Mostrar todas las entradas
Mostrando entradas con la etiqueta Eclipse. Mostrar todas las entradas

viernes, 17 de abril de 2009

Día 54: EJB y JSF (12ªP) / JBoss-Seam (5ºP)


Ejercicio1
El objetivo del ejercicio de ahora es, que modificando el ejercicio de ayer, que el enlace de edición vaya a una acción de un ejb y que esa acción rellene un objeto de tipo Disco gracias a un componente, una clase, que hemos creado que se enlaza a la lista, y que nos rediriga a la página de edición simplemente llamando a su url, sin ninguna acción más ya que el disco ya lo tiene.
  • Duplicamos los bean (y sus interfaces): ListaDiscoBean y EditaDiscoBean y en los xhtml igualmente pero en el de lista de disco quitamos el parametro al s:link, o mejor dicho... quitamos el s:link completo y usamos mejor un h:commandButton o un h:commandLink con la acción redirigiendola a "EditaDiscoBean2"
  • Creamos una clase java, que se llame "MiComponente" con una anotación anteponiendo la clase: "@Name("miComp")".
    Le añadimos como atributo: "HtmlDataTable tabla" con sus métodos getter y setter y creamos su método principal:
    public String selecciona(){
    Object o = tabla.getRowData();
    Disco d =(Disco) o;
    return null;
    }
  • Creamos ahora el ejb con la acción que estaba enlazada la lista con el "editar"
    Lo nuevo en esta clase es que hay un objeto del tipo componente que hemos creado antes y con una anotación que lo hace dependiente:
    @In(value="miComp",create=true)
    MiComponente miComponente;

    Y su método principal:
    public String selecciona(){
    disco=(Disco) miComponente.getTabla().getRowData();
    System.out.println(">>>>>>>>>Nombre del disco: "+disco.getNombre()+"!!!!!!!!!!!!!!!!!!");
    return "/editaDisco2.xhtml";
    }

    El return puede devolver directamente la url o podria devolver un valor y poner una regla de navegación en el "pages.xml"
  • Para que a la hora de probar los enlaces la consola no se nos vaya disparada por las consultas sql que se nos muestra editaremos el archivo "persistence.xml" usando el buscador de archivos del eclipse y editamos la propiedad "hibernate.show_sql" a false

Ejercicio2
El objetivo de este segundo ejercicio es el de hacer lo mismo pero con las clases que creamos hace unos dias, específicamente con la clase "Cliente"
Hacer una lista de clientes, que haya un enlace y que se pueda editar.
Como "novedad" usaremos el mismo componente, así que simplemente duplicamos los métodos que nos hagan falta pero para la clase Cliente

Pseudo-Ejercicio3
Bueno, esto es ya a modo personal, no me enteré bien en su día y no lo llegé a hacer pero hoy si me he enterado y lo he hecho.
El objetivo del ejercicio es que a la hora de editar un disco también aparezca un menú desplegable para cambiarle su autor y que se guarde.
Podemos cojer el ejercicio 1 de hoy y mejorarlo con esto.
  • La clase "ListaDiscosBean2":
    • Añadir un nuevo Query en el método de carga que seleccione todos los cantantes.
    • Añadir también una lista de cantantes y su método getter y "subirlo" a la interfaz.
  • La página "listaDiscos2.xhtml":
    • Añadir a la tabla una columna nueva para ver el nombre del cantante (para comprobar que se ha guardado): #{d.cantante.nombre}
  • La página "editaDisco2.xhtml"
    • Añadir el select teniendo cuidado al nombre de la variable que le pongamos para mostrar la lista.
    • Primer nivel// h:selectOneMenu value="#{editaDisco2.disco.cantante}" required="true"
    • Segundo nivel// s:selectItems value="#{listaDiscos2.listaCant} var="_cantante" label="#{_cantante.nombre}" noselectionlabel="#{Selecciona cantante}" \\ cierre
    • Segundo nivel// s:convertEntity \\ cierre
    • \\cierre del primer nivel
  • En la clase persistente "Cantante" añadir el Hashcode y el equals


Consejo:
No nos olvidemos del atajo de eclipse: Control+Shift+R para buscar un archivo que no sepamos donde está!!!

jueves, 16 de abril de 2009

Día 53: EJB y JSF (11ªP) / JBoss-Seam (4ºP)

Cambio de JBoss 5.0 Server a JBoss 4.2 Server

Al comenzar el día lo primero que hicimos fue cambiar la versión del servidor JBoss ya que la versión 5 que hemos estado utilizando presenta muchos fallos y mucho coñazo a la hora de los errores y de intentar arreglarlos.
Para cambiarnos de servidor con el proyecto que estamos usando ("seamcea") lo copiamos a JAVA/servers (que lo pusimos en el escritorio) y en el eclipse creamos un nuevo servidor desde la pestaña de servidores, se selecciona el directorio y lo reconocerá, también habrá que añadirle el proyecto y lo más importante el archivo .xml que es el datasource.
Con el servidor bien puesto ya solo hace falta configurar el proyecto al servidor para ello botón secundario encima del proyecto principal, propiedades y "Targeted Runtime" y marcaremos la versión del nuevo jboss.

Un modelo se carga a traves de acciones.
Una acción la llamamos de 2 maneras, desde el pages.xml que se llamara la accion cada vez que recargemos la pagina y a traves de un s:link que es solo 1 vez.
En el pages.xml podemos tener una condicion para limitar la carga.
La vida (SCOPE) de un modelo:
  • Por ahora usamos la vida de sesion.
  • Tambien existe de por conversacion o tarea del usuario.
    Si por ejemplo pulsamos en un enlace para editar algo es una tarea y se guarda ahi. La ventaja seria tener varias ventanas y cada ventana una tarea y varias tareas a la vez. Otra ventaja es la limpieza, que una vez terminemos con nuestra "conversacion", nuestra tarea, llamamos al método con la anotación @End y todo lo que conlleve la conversación se limpiará, se quedará a nulo.
    Tampoco hay que olvidarse de poner una etiqueta (Anotacion) nueva @Begin en el/los método/s principal/es (el de cargar o buscar algo), solo funcionara si es de tipo conversación. Después del @Begin hay que añadir un "join=false" si no queremos que las conversaciones se pisen (que abramos una segunda ventana para editar un segundo disco y cuando editamos el primero, éste pise al segundo.)
    La etiqueta @End se pondran en el/los metodo/s que termine/n la conversación/es.


Ejercicio:
Cambiar el scope del ejercicio de ayer de sesion a conversación y probar si funciona y añadir el @Begin con el join.

Para validar un calendario
rich:calendar value=... validator="#{bean.valida}"

@Name("bean")
public class MiBean{
public void valida(FacesContext fc, UIComponent ucom,Object o) throws exception{
Date fechaSel=(Date) o;
if(fechaSel) throw Excetion();
}
}


Para validar un input text cerramos la etiqueta a parte y como cuerpo le ponemos una etiqueta del tipo f:validate


lunes, 30 de marzo de 2009

Día 45: EJB (4ª Parte) y JSF (3ª parte)


Hoy comenzamos cambiando el puerto en la que abre las aplicaciones. Para ello modificamos las propiedades de configuración del pluggin jetty de maven del proyecto que queremos arrancar (modificar el archivo "pom.xml").
Después añadimos todas las librerías que están en: "jboss-5.0.1.GA\client" a las librerías del proyecto "jsf1"

Creamos un nuevo servicio, ServicioCadenas que lo que hace es recibir una cadena de caracteres y devolver el número de su longitud.
El método para hacerlo es como lo hemos hecho anteriormente.




Consejos
Atajo del eclipse: (Alt+T) Botón secundario, Refactor y "Pull up" y marcamos los métodos que queramos "subir" de una implementación a una interfaz.
Problemas con proyectos remotos EJB: Las soluciones son varias al igual que los problemas, pero lo más común es:
  • Reponer la librería del proyecto: Run As, Maven Clean (Eliminará la librería del proyecto en el servidor JBoss) y después Run As, Maven Package (volverá a poner la librería)
  • Si se nos ha olvidado instalar el proyecto: Run As, Maven Install (Añadirá una librería del proyecto en el repositorio del maven) y después: Run As, Maven package (lo de antes, ...)
  • Lo que casi todo en la informática, reiniciar:
    > Cerrar y volver a encender el servidor jetty (Control+c y después S)
    > Cerrar y volver a encender el JBoss
    > Combinar orden de encendidos y apagados, ...
  • Se admiten más consejos

miércoles, 4 de marzo de 2009

Día 35: Struts, continuación

Servidores web java
Pueden ejecutar Servlets y Jsps

Dos servidores web java conocidos son el tomcat y el jetty
El jetty en un servidor web más moderno que tomcat y más liviano.
Una gran ventaja del jetty es que se autoactualiza si realizamos algún cambio, por ejemplo, en algún jsp.
Para arrancar el jetty desde el maven por consola es: "mvn jetty:run" si le indicamos "-war" después del comando descrito antes, creará un archivo ".war" y lo ejecutará pero no se autoactualizará ante los cambios.
Un comando interesante del maven es el "source:jar install" que instala en el repositorio también los archivos source.
El servidor jetty suele dar un error de tipo "PerGem Space" de vez en cuando y para solucionarlo... como todo en la informática, reiniciarlo.

En el Eclipse nos vamos a las preferencias, escribimos "maven" y marcamos las opciones "Download Artifacts Sources" y "Download Artifact JavaDoc"


Ejercicio
El ejercicio de hoy consiste en que la aplicación pueda añadir, modificar o borrar calquier elemento.


Plugin
Es un complemento, una clase java, que se crea al arrancar la aplicación.

Sitemesh
Es una herramienta para embellecer la vista.
Es una librería, una dependencia, hay que implementarlo en el xml.
También se tiene un .xml que se llama "decorators.xml" que se encarga de redistribuir la información de nuestras páginas según una plantilla llamada "layout.jsp", aunque claro, todo se puede personalizar y cambiar.

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á!!

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';

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

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.

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.

martes, 27 de enero de 2009

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.

miércoles, 14 de enero de 2009

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.