Consulta en SQL que te muestre un campo por defecto

Necesitaba una consulta que me mostrara un campo de un registro por defecto y luego el resto de los registros. En principio probé con UNION pero me estuve liando poco y era engorroso.

Al final es más fácil de lo que parecía.

SELECT campo FROM tabla ORDER BY campo=condicion DESC campo ASC

en mi caso era tal que:

select nombre from poblacion order by nombre='SEVILLA' desc,nombre asc

Esto me mostraba como primera opcion al registro cuya población sea Sevilla, y posteiormente el resto de registros ordenador.

Si por el contrario queremos que Sevilla sea la ultima opción debemos cambiar 'desc' por 'asc', nos kedaría:

select nombre from poblacion order by nombre='SEVILLA' desc,nombre asc

PD:

Debo agradecer a Noelia la ayuda mostrada para conseguir esta magnidica consulta, puesto que sin ella todavía estaría dandome chocazos contra la pared ^_^.

Cambio de nombre de dirección

Puesto que este blog empezó siendo un blog para un curso que poco a poco he ido... digamos que de vez en cuando le echaba un rato para copiar pegar cosas de otros sitios... he decidido cambiarle el nombre de la dirección para que sea 1 poco más personal.

Antiguamente se llamaba:

http://cea-victorortega.blogspot.com/

Ahora lo he cambiado por:

http://victorort.blogspot.com/

Supongo que nadie habrá puesto un enlace de mi humilde página pero si es así que cambie la dirección para evitar problemas de redirección.

Un saludo.

PD: Sois libres de comentar todas mis entradas, tanto rectificamer, como agradecermelo si ha alguien le ha servido. Puesto que eso me hará seguir adelante.

Añadir código PHP al blog

Si deseas aportar una ayuda a los demás visitantes y quieres comentar algo de código (PHP, ASP, JSP, etc) y tienes problemas al mostrarlo porque tu navegador reconoce esa parte de código como código propio usa la siguiente tabla para escribir símbolos como '<','>'.

Enlace.

Formulario que adjunte ficheros y controle tldes, eñes (ñ) y simbolos extraños

Buenas, yo estuve pegándome con un problema que tenía a la hora de elaborar un formulario dinámico que también adjuntara ficheros; el problema erea que cuando ponía a elegir entre el turno de "mañana" o el de "tarde", si se seleccionaba el de "mañana" recibía "ma#na", un símbolo extraño como 'ñ' (y a veces se comia la siguiente letra), asímismo hacia lo mismo con las tildes, º y demás simbolos extraños.

El problema me lo daba el atributo 'enctype="multipart/form-data"' del FORM que nos permite adjuntar ficheros, por lo tanto si lo quitamos nos traducirá bien los caracteres "extraños" pero no me dejaría adjuntar ficheros o por el contrario añadir el atributo enctype pero no tener controlado las tildes, eñes, etc.

Después de buscar entre varias páginas vi que en la mayoría llegaban a la misma conclusión, la codificicación.

En un foro resuelven el tema de la codificación comprobando que tipo de codificación se hace mediante una función, pero a mi no me solucionaba nada puesto que mi formulario no es estático y no dispongo de campos fijos que verificar.

Acto seguido encuentro otro en el que lo solucionan añadiendo en la cabecera (HEAD) lo siguiente:

<meta equiv="Content-Type" content="text/html;charset=UTF-8">

Pero no me dió resultados.

Buscando por el amplio mundo de internet descubrí un atributo llamado "accept-charset" del formulario (FORM) que permite cambiar la codificación.

Tan solo hay que añadir a nuestro FORM el atributo 'accept-charset="utf-8"'

<form id="formUserData" name="formUserData" action="/usuarios/guardar/" method="post" accept-charset="utf-8">

A mi me funcionó, quizás alguna de las tres opciones propuestas te puedan servir a la hora de realizar un formulario que permita adjuntar ficheros.

Vuelta al mundo...

Pues después de mi estancia en París y tras haber estado en la World Wide Invitational 2008 de Blizzard y haber disfrutado con todo lo que había montado, ahora me toca posar los pies en la tierra y empezar otra vez con el trabajo.

A ver si tengo tiempo y pongo algo nuevo que tengo esto 1 poco abandonado.

Saludos.

Plantillas en Groovy

Las plantillas se harán en dos partes, una que se hará en la parte del Groovy, que es donde cargaremos todos los datos y donde generaremos nuestra plantilla y otra parte será la plantilla en si, que en este caso lo haremos con OpenOffice.

En la parte del Groovy necesitamos que nos manden un mapa del tipo [clave,valor], por ejemplo ["Nombre","Juan"](Recordad que en el mapa podeis meter varia claves asi como nombre, apellidos, etc.), y una vez recibido el mapa y sabiendo donde esta la plantilla que vamos a usar solo nos faltaría generar el código:

def mapa=asociaNombresCampo(datos);//CREA UN MAPA DEL TIPO mapa[clave:valor];
DocumentTemplateFactory templateFactory = new DocumentTemplateFactory();
File templateFile=getTestFile("plantilla.odt");
try{
File openDocumentFile = grabarFichero();
DocumentTemplate template= templateFactory.getTemplate(templateFile);
templateFile.deleteOnExit();
template.createDocument(mapa, new FileOutputStream(openDocumentFile));
}catch (Exception e){}



protected File grabarFichero() throws IOException {
String rutaDestino= "rutadestino";
File tempFile = new File(rutaDestino+"nombrePlantilla.odt");
return tempFile;
}

En el apartado de la plantilla, sólo nos faltaría definir cómo queremos que sea nuestra apariencia y decirle que asocie los datos que hemos mandado en el mapa a valores en nuestra plantilla. Para eso pulsaremos CTRL+F2 y en la pestaña de Functions, seleccionar Text Field. Poned un nombre que sea recibido, por ejemplo 'Nombre!', (el signo '!' sirve para decirle que este parametro puede venir vacio, si no lo haces dara un error). Ahora solo faltaría darle un nombre representativo para que asocies ese campo y te acuerdes a que parametro está asociado.

En este ejemplo vamos a hacer una plantilla de un carnet, por lo tanto sólo nos vendra un mapa del tipo clave valor de una persona.

Usaremos algo así:

Titular: Nombre* Apellido1* Apellido2*
Teléfono de contacto: Telefono*

*: Campos asociados al mapa.

Para la plantilla usaremos OpenOffice.
Para hace que se rellene con datos que le hemos mandados debemos pulsar CTR+F2 y nos momstrará una venta como la siguiente:

Pulsaremos en la pestaña FUNCTIONS, y seleccionamos el Input Field. Ahora pondremos uno de las claves que recibimos, en este caso recibimos un nombre, por lo tanto escribiremos 'nombre!' (la ! sirve para que no de fallos si viene vacio o nulo).


Ahora ya sabe que recibe un valor llamado nombre, al pulsar en insert nos pedirá que le pongamos un nombre para hacerle referencia, ponedle 'Nombre' para saber que recibiremos el nombre.


Una vez que aceptemos ya tendremos asignado a nuestra plantilla un nombre que será introducido por nuestra aplicación.
Cerramos esta ventana y nos marcará a nuestro campo 'Nombre' con un fondo más oscuro.


Bueno, ya sabemos introducir un campo, tan solo hace falta repetir esta operación tantas veces como necesitemos cojer datos de nuestro mapa. Por ejemplo pondremo los Apellidos para poner el nombre completo en este ejemplo. Y también añadiremos un telefono de contacto, por lo tanto nuestra aplicación quedará:



Ya sólo nos faltaría el diseño de nuestra plantilla, es decir si vamos ha hacer un carnet deberíamos recortar un poco para que quede más ancho que largo y ponerle una imagen de fondo.

Esto último os lo dejo a ustedes, que va a gusto del consumidor.

Converter

Las clases destinadas a realizar conversiones deberán implementar la interfaz Converter, que tiene dos métodos:

▪ Object getAsObject(FacesContext context, UIComponent component, String newValue)
▪ String getAsString(FacesContext context, UIComponent component, Object value)

En el primero de ellos convierte una cadena de texto a un objeto, y en la segunda al contrario, de un objeto a una cadena de texto.

Por lo tanto podemos ahcer que recibiendo un idUsuario podramos mostrar los datos de Nombre + Apellidos, por ejemplo.

Para ello debemos agregar en nuestro fichero de configuracion face-config:


Y para usarlo debemos añadir en nuestro jsp:


Otros recursos:

· Adictos al trabajo.

Seam 2

Aunque aún no hay anuncio oficial de JBoss, ya puedes descargarte la segunda versión de este framework para creación de aplicaciones web en java. Para los que no lo conozcan, Seam es un producto creado por Gavin King el creador de Hibernate y que busca la creación rápida de aplicaciones web java. Para ello utiliza una herramienta llamada seam-gen que te genera a partir de tablas en una base de datos una aplicación CRUD (create, read, update, delete) totalmente funcional con tecnologías estándar de JEE como JSF para la vista, EJB3 para la lógica del negocio y JPA para la persistencia y tecnologías de JBoss como Hibernate Validation o JBoss jBPM para definir el flujo de tu aplicación.

En esta nueva versión encontrarás las siguientes características:

• Seam WS que permite que un componente Seam sea un servicio web
• Creación de componetes Seam con Groovy
• Independencia de JSF, por lo que en teoría puedes usar cualquier otro framework web para tu capa de vista
• Soporte para Google Web Toolkit
• Integración con Hibernate Search
• Soporte para transacciones no JTA
• Integración de Ajax4JSF

Esta sacado de javaHispano

Guia JBoss Seam

Descargas necesarias:

Eclipse for Java EE Developers (segunda entrada)
http://www.eclipse.org/downloads/

Intenta descarga las ultimas GAs en la pagina de JBoss.

JBoss Seam 2.0.X
http://labs.jboss.com/jbossseam/download/index.html

And the JBoss Application Server 4.2.X
http://labs.jboss.com/jbossas/downloads/

Necesitarás una Base de Datos(BD), uaremos MySQL. Descargate los JDBC Driver.
http://dev.mysql.com/downloads/connector/j/5.0.html

Extrae estos archivos donde quieras pero ten en cuenta no usar espacios " " u otros carateres especiales “áä”.

En este ejemplo se usara la ruta “C:\Development”. Crea una nueva carpeta de WorkSpace (WS) aquí.

Ahora los ficheros quedaran tal que así:

Descarga e instalación de la BD.

Descargate la MySQL Database de esta página:

http://dev.mysql.com/downloads/mysql/5.0.html

Ahora necesitamos echar a andar nuestra BD.

Ejecuta el setup y usa la instalación "typical". Al final de la configuración del setup de MySQL server, elije "Standard Configuration". No cambies nada en las próximas ventanas. Ahora ponle un nombre al roor y su contraseña para esta BD. En este ejemplo se usará "mysql". Pasa a la siguiente ventana y termina el proceso.

Setup de JBoss Seam y crear un nuevo proyecto.

Necesitarás crear un nuevo proyecto Seam. Para ello:

Introduce en el símbolo del sistema (Tecla de Windows +R-> introduce "cmd"):
Diríjete a “C:” y muevete hasta el directorio del JBoss Seam
“cd C:\Development\jboss-seam-2.0.X.GA”. (recuerda comprobar al version y la ruta donde lo tienes guardado)

Ahora es tiempo de ejecutar el setup.

Tipo: “seam setup”

Seam nos da la bienvenida pero quiere saber algunas cosas sobre nuetro proyecto.

Introduce la ruta de tu WorkSpace. En este caso usaremos el siguiente:
“C:\Development\workspace”

Introduce el directorio donde esta el JBoss Application Server
“C:\Development\jboss-4.2.2.GA”

Dale un nombre al proyecto:
“MyFirstSeamProj”

RichFaces estan bien. Pulsa intro.

El BlueSky también esta bien. Pulsa intro.

EAR, tambiém. Pulsa intro.

Introduce el nombre del paquete de tu sesion de Beans.

“com.mydomain.MyFirstSeamProj.session”

Introduce el nombre del paquete de las "entities" de los Beans.

“com.mydomain.MyFirstSeamProj.entity”

El paquete de test está bien. Intro.

Este caso usaremos como BD MySQL, así que introduciremos “mysql”.

Los Dialect están bien. Intro.

Ruta del JDBC driver. En este caso son:

“C:\Development\mysql-connector-java-5.0.8\mysql-connector-java-5.0.8-bin.jar”

Estos son las clases de los drivers, Pulsa intro.

Introduce la conexión URL de la BD.

En este caso usaremos el test en la BD MySQL.

“jdbc:mysql://localhost:3306/test”

El nombre de usuario “root” y la contraseña “mysql”.

No hay catalogo de DBen este caso. Intro.

No hay tablas hechas. Intro.

Deseo mantener las tablas. Enter.

El setup ha terminado. Fue mucho trabaho, así que.. donde está el proyecto?
Aun no hay proyecto. Introduce en la consola del sistema:

Enter “seam create-project”

Aquí lo tienes!

Suficiente consola por el momento....


Empezar con Eclipse

Empezamos con Eclipse y elegimos nuestro WS “C:\Development\workspace”.

Cierra la pantaña de bienvenida (si aún no lo has hecho)

Crea un nuevo proyecto java. File => New => Project.. => Java => Java Project

Elije “Create project from existing source” e introduce la ruta de tu proyecto Seam “C:\Development\workspace\MyFirstSeamProj”.

Introduce el mismo nombre “MyFirstSeamProj” y pulsa “Finish”.

Añadiremos la pestaña de servidores, para ellos pulsamos en Windows-> Show View -> Other y escribimos server y seleccionamos la que se llama "servers"

Ahora selecciona la pestalla de “Servers”. Botón derecho y seleccionamos "new".

Eleji JBoss v4.2. Introduce el directorio donde tienes guardado tu JBoss “C:\Development\jboss-4.2.2.GA”, luego “Finish”.

Arranca el servidor pulsando “Start”.

Abre el proyecto, boton derecho en el archivo build.xml y pulsa "Run as" -> "ant build".

Un error a ocurrido! Porqué? La ventana de archivos del sistema no quiere un fichero y un directorio con el mismo nombre.

Paramos el server.

Abrimos el explorador y vamos a :“C:\Development\jboss-4.2.2.GA\server\default\deploy” y borramos nuestro ear MyFirstSeamProj.ear.

Lo intentamos otra ver. Encendemos el server. Esto va mejor.

Ahora es tiempo de abrir una página de nuestro proyecto Seam.

Abre el navegador e introduce: http://localhost:8080/MyFirstSeamProj/

Aquí lo tienes nuestro primer proyecto Seam.

Tener el ejemplo corriendo

Ahora es tiempo de probar un ejemplo del Seam. Vamos a usar el ejemplo de registrar.

Ve a “C:\Development\jboss-seam-2.0.1.GA\examples\registration”
Loa archivos están en “\src\org\jboss\seam\example\registration”

Copia Register.java, RegisterAction.java e insertalos en tu proyecto Eclipse src/action en el paquete “com.mydomain.MyFirstSeamProj.session”.

Otro error ocurrió! Bueno, es el mismo que antes, pero ahora nosotros tenemos una ventana adicional.

Es la ventana de sistema de windows otra vez.

Ve a “C:\Development\jboss-4.2.2.GA\server\default\deploy” vuelve a borrar el archivo ear “MyFirstSeamProj.ear”. El error se debe de haber solventado.

Vuelve al Eclipse y haz nuevos paquetes en “src/model” y nombralos “com.mydomain.MyFirstSeamProj.entity”. Copia “User.java” desde el ejemplo a este paquete.

Ahora debemos corregir la entrada del paquete en los ficheros fuente del proyecto de eclipse a “com.mydomain.My…”. En “RegisterAction.java” tienes que importar User desde “com.mydomain.MyFirstSeamProj.entity.User”. Guarda todos los ficheros.

Vuelve a la raíz del directorio del ejemplo de Registration y copia todos los archivos desde el view folder de tu proyecto eclipse y sobrescribe los que ya existan.

Usa el metodo deploy.

Abre tu navegador otra vez http://localhost:8080/MyFirstSeamProj/ .

El ejemplo de registrar esta ya funcionando.

Pero esta seguro que nada hay ido mal, para y enciende el servidor en eclipse otra vez.

Ahora puedes registrar usuarios ene el navegador y mira en tu BD con el query browser.

Esta guia a sido sacada de:
http://techieexchange.wordpress.com/2008/02/01/how-to-make-jboss-seam-work-with-eclipse-for-windows/ (inglés).

SPRING - HIBERNATE - Ejemplo

(Tengo que editar 1 par de cosas, como problema al mostrar el código del jsp)

Partiendo de una petición hecha por un usuario a través de una petición web, vamos a obtener una lista de editoriales.



Teniendo en cuesta que ya existe una peticón de 'getUsers', simplemente haremos lo mismo pero con las editoriales.



Partiremos de la clase UserController (myapp/src/main/java/org.appfuse.web), aquí nuestra clase controlador es quien recibira la petición hecha y controlará a donde se redireccionará y que datos debemos cargar.

Por lo tanto, debemos pedir los datos a cargar, que para ellos y sabiendo que pedimos las editoriales, debemos hacer una consulta a nuestra base de datos para pedir las editoriales.

Mediante el diagrama que hemos mostrado, nuestra clase UserController se comunicarña con la clase EditorialManager (que es un Servicio). Ésta a su vez se comunicara con un DAO y ésta a su vez hara la consulta pertinente.

Empezaremos creando un EditorialManager y se la añadiremos a la clase UserController. Por lo tanto nos quedaría:

@Autowired
private EditorialManager editorialManager;

Ahora debemos crear una interfaz EditorialManager. La interfaz la crearemos en: myapp/src/main/java/org.appfuse.service.

Esta interfaz sólo tendrá el método getEditoriales. Por lo tanto nos quedará:

public interface EditorialManager {
public List
getEditorial();
}

Puesto que es una interfaz, debemos implemetar sus métodos con una clase que crearemos en myapp/src/main/java/org.appfuse.service.impl. La clase la llamaremos EditorialManagerImp.

Puesto que nuestro Manager (servicio) se comunica con el Dao, crearemos un dao con el nombre editorialDao de la clase EditorialDao que crearemos posteriormente. Y ahora implementaremos los métodos de la implementación y los getters & setter del editorialDao.
(Recuerda que si al editorialDao le pones otro Nombre cómo dao, hacer un método setEditorialDao)

Al final obtendremos:

public class EditorialManagerImpl implements EditorialManager
{
public EditorialDao editorialDao;

@Override
public List getEditorial() {
return editorialDao.getEditorial();
}
public getEditorialDao()
{
return this.editorialDao;
}
public setEditorialDao(EditorialDao editorialdao)
{
this.editorialDao=editorialDao;
}
}

En estos momentos nos dirá que no existe la clase EditorialDao y por lo tanto no reconoce la variable editorialDao. Crearemos el interfaz EditorialDao en el paquete org.appfuse.dao, y le añadiremos el método getEditorial.

Una vez creada la interfaz vamos retocar un archivo de configuración para decirle que siempre que se quiera acceder a la interfaz EditorialManager, se debe ir a su implementación EditorialmanagerImpl. Para ello accdemos al applicationContext.xml (myapp/src/main/webapp/WEB-INF) y añadiremos:

Añadimos el Bean de editorialManager. (buscad por el id)

Aquí podeis ver el applicationContect.xml.

Una vez modificado el application-context, insertaremos el método getEditoriales a la interfaz.

public interface EditorialDao {
public List
getEditorial();
}

Pueto que es una interfaz, ahora debemos implementarla. Para ello nos crearemos una clase EditorialDaoImp y la guardaremos en el paquete org.appfuse.dao.impl. Y le diremos que extienda de HibernateDaoSupport para que se pueda conectar a la base de datos e implemente de la interfaz EditorialDao.

En el método getEditoriales, haremos una consulta a la base de datos a traves de la siguiente linea de código:

getHibernateTemplate().find("from Editorial")

Ésto nos devolvería una lista de Editoriales, qué es lo que deseamos, por lo tanto esto lo iremos devolviendo hasta llegar al UserControler.

Al final nos quedará:

public class EditorialDaoImpl extends HibernateDaoSupport implements
EditorialDao {
@Override
public
List getEditorial() {
return
getHibernateTemplate().find("from Editorial");
}
}

Al igual que antes modificamos el applicationContext, ahora debemos modificar el applicationContext-hibernate para decirle que siempre que se llame a la interfaz donde debe buscar su implementación. Y a parte para decirle que donde debe ir a buscar la tabla cuando haga la consulta y que estructura seguirá.






Con ello le decimos que siempre que se acceda a la interfaz editorialDao su clase de implementación es EditorialDaoHibernate

Añadiremos esta línea dentro del List:

org/appfuse/model/Editorial.hbm.xml

Aqí le decimos que existirá una tabla basado en la estructura encontrada en Editorial-hbm.xml.

Ahora necesitamos crear el xml Editorial-hbm.xml (paquete: org/appfuse/model). Cuyo cuerpo será:




Con la etiqueta 'table', creará una tabla con el nombre que le pongamos, en este caso 'app_editorial'. Nuestra tabla sólo tendrá dos parámetros, una id y un nombre, cuyo id será una clave.

Sólo faltaría decirle al UserController que siempre que se llame a la página Editoriales.html nos carge una lista de editoriales, y para ellos usaremos el model.

@RequestMapping("/editoriales.html")
public String executeEditorial(ModelMap
model){

model.addAttribute("listaEditoriales",userManager.getEditoriales());

return "editorialList";
}

Tan sólo faltaría modificar nuestro jsp y decirle que nos muestre la tabla que hemos denominado "listaEditoriales".

El jsp lo crearemos en myapp/src/main/webapp, y le pondremos el nombre de 'editorialList', que le hemos dicho en el UserController.

Aquí podeis ver el código.

Instalar Maven

Esta guia está sacada de http://maven.apache.org/guides/getting-started/maven-in-five-minutes.html.

Lo primero que debemos hacer es bajarnoslo. Para ello podemos hacerlo desde aqui.

Pasos a seguir para instalarlo en win 2000/xp.

· Descomprimir la carpeta en: C:\Program Files\Apache Software Foundation\ (está basado en una página inglesa, yo lo instalaría en C:\, teniendo en cuenta que siempre que debas hacer referencia al maven debes modificar la ruta, sino dejala por defecto). Se creará un subdirectorio llamado apache-maven-2.0.8

· Añadir una variable de entorno (para ello usaremos tecla de windows + pause, ir a la pestaña de opciones avanzadas pulsaremos 'Variables de entorno'). Añadiremos una variable de entorno con el nombre M2_HOME y cuyo valor de variable será C:\Program Files\Apache Software Foundation\apache-maven-2.0.8 en las variables del usuario (la zona de arriba).
Nota: Para las versiones inferiores a 2.0.9 aseguraos que no terminamos el valor con un \

· Añadir otra variable de entorno con el nombre M2 y cuyo valor será %M2_HOME%\bin.

· Opcional: Añadir otra variable más con el nombre MAVEN_OPTS que nos servirá para especificar las propiedades de la JVM, p.ej. el valor -Xms256m -Xmx512m. Ésta variable puede ser usada como opciones adicionales para Maven.

· En el mismo diálogo (varables del usuario), añadiremos/modificaremos la variable Path con el valor %M2%;%Path%, que nos permitirá darle permiso para usar la consola de comandos.

· En el mismo diálogo aseguraos que existe un JAVA_HOME en las variables del usuario o en las del sistema y asignadle la ruta donde teneis el JDK, por ejemplo C:\Program Files\Java\jdk1.5.0_02, y que está añadido el valor %JAVA_HOME%\bin al Path.

· Por último verificar que que está correctamente instaldo, para ello abrid la consola de comando (tecla de window + R y escribid cmd). Escribid mvn --version

Creación de un archivo JSP

Antes de empezar debemos tener en cuenta:

· Todos los archivos JSP los guardaremos en la carpera 'src/main/webapp'.
· El servicio lo guardaremos en el paquete org.appfuse.service de la ruta 'src/main/java'. Al igual guardaremos la implementación en el paquete 'org.appfuse.service.imp'.
· Y por ultimo guardaremos todos los controladores en el paquete 'org.appfuse.web', de la ruta 'src/main/web'.

Necesitaremos una clase controlador con el cual sabiendo la página a la que han hecho referencia podemos devolver una vista con lo necesario. Para ello accederemos al 'model' y le iremos añadiendo atributos al modelo, para que en él podamos obtener lod datos necesarios que deseamos mostrar. (éste modelo se llama MVC)

Ejemplo:

Crearemos una página en JSP la cual la llamaremos en nuestro navegador "editoriales.html".

Nuestro controlador posee una método tal que:

@RequestMapping("/editoriales.html")
public String executeEditorial(ModelMap model){
logger.info("Cargando editoriales...");
model.addAttribute("listaEditoriales",userManager.getEditoriales());
return "editorialList";
}

Podemos observar que, @RequestMapping lo usamos para saber el nombre de la página y que debemos hacer.

(el logger sirve para más información, cosa que no es necesaria a la hora de crear un JSP).

Sabiendo que actue cuando llamen en el navegador a 'editoriales.html', ahora necesitamos cargar el modelo con la información que queremos mostrar. Para ellos usaremos 'model.addAttribute(...)', en este caso añadiremos una lista de editoriales. Esta lista de editorial la obtendremos gracias a la clase userManager, una interfaz que la implementaremos para que disponga del método getEditoriales().

Una vez creado el controlador y cargador los datos al modelo sólo nos quedaría retocar la vista de la página JSP. Para ello entramos en el jsp de editorialesList. Éste debe coincider con el return del controlador.

Una vez dentro podemos escribir mediante código HTML y acceder al model

Nuestro jsp sólo dispondrá de una tabla.



Otras referencias:

Mensajes en jsp
Logger
Tablas en jsp

Interceptores

Se puede llamar a los interceptores antes de llamar a la acción, después de llamarla o antes y después. Tienen acceso total a la clase Action y al entorno de ejecución permitiendote llamar a los métodos de la clase Action o trabajar con su entorno
Otra característica de los interceptores es la facilidad con la que podemos configurar la pila de interceptores.

POJO

Es un acrónimo de Plain Old Java Object y es utilizado por los programadores en Java para enfatizar el uso de clases simples y que no dependen de un framework en especial.

Simplemente tendrán métodos getters & setters.

Reutilización

Cualidad que nos indica que partes del programa ( en este caso objetos) pueden ser reutilizados en la confección de otros programas. Ello implica que los objetos definidos en un programa pueden ser extraídos del mismo e implantados en otro sin tener que realizar modificaciones importantes en el código del objeto.

Refactorización

La refactorización consta en el cambio del nombre de una variable, clase u otro tipo de objeto y su correspondiente cambio en todos las clases y metodos que se use, para así dar un código más limpio.
Por ejemplo en un principio podemos crear la clase Usuario, pero tras un transcurso del programa vemos que el nombre no se claro, así qie se prefiere llamar Cliente, pues cambiaremos el nombre de Usuario por Cliente y en todas las clases y metodos donde se utilice.

Refactorización de código:

Es crear sub-procesos para dejar el código principal más limpio y que no sea tan largo.

Referencias:

Modularidad

Encapsulación

Podemos imaginarla encapsulación como introducir el objeto dentro de una caja negra donde existen dos ranuras denominadas entrada y salida. Si introducimos datos por la entrada automáticamente obtendrá un resultado en la salida. No necesita conocer ningún detalle del funcionamiento interno de la caja.

El término encapsulación indica la capacidad que tienen los objetos de construir una cápsula a su alrededor, ocultando la información que contienen a las otras clases que componen la aplicación.

Los lenguajes OOP incorporan la posibilidad de encapsular también las estructuras de datos que sirven como base a las funciones. Aportan por tanto un nivel superior en cuanto a protección de información.

Polimorfismo

Esta propiedad indica la posibilidad de definir varias operaciones con el mismo nombre, diferenciándolas únicamente en los parámetros de entrada. Dependiendo del objeto que se introduzca como parámetro de entrada, se elegirá automáticamente cual de las operaciones se va a realizar.

Modularidad

La modularidad se basa en la descomposición de un problema en una serie de sub problemas; dividiéndolo en módulos que resultan de segmentar el problema en funciones.

Herencia

Es una relación entre clases por la cual existe un 'herencia' de padre a hija denominando padre a la sucesora y la hija a la que va a 'heredar' los comportamientos de su padre, así cómo sus métodos.

Por lo tanto podemos decir que la herencia está gerarquizada ya que una padre puede tener varias clases hijas:

Dicha jerarquía facilita el poliformismo y el encapsulamiento.

A la hora de crear una clase hija debemos poner:

public class Hija extends Padre {
}

Así mismo debemos implementar sus métodos y atributos.

POO

Programación Orientada a Objetos.- También denominada OOP o POO dependiendo de la traducción de inglés o español. Está basado en objetos. Está basado en:

Herencia
Modularidad
Poliformismo
Simplificación
Independencia
Reutilización
Encapsulación
Refactorizacioón

La POO expresa un programa como un conjunto de estos objetos, que colaboran entre ellos para realizar tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener y reutilizar.

Los objetos se componen de atributos (estado) y métodos (comportamientos). Y usan los métodos para relacionarse entre objetos.

POA

Programación Orientada a Aspecto crea un contenedor que sirve entre relación entre clases y asi darle más libertad a dichas clases.

EJB3

Framework dentro de j2ee, se pueden hacer pruebas muy faciles, ya que son POJO.

Caja Blanca y Caja Negra

Ambos sirven para realizar pruebas y se diferencian en:

Caja Blanca.- Es cuando conocemos en todo momento todos los pasos y el seguimiento de la traza y por lo tanto conocemos tanto el resultado de un método como su comportamiento interno.

Caja Negra.- A diferencia de la caja blanca, no conocemos todos los pasos, simplemente sabemos que el método a usar nos devolverá un valor concreto sin saber el comportamiento interno del método.

Nuevo proyecto con SEAM-GEN

Jboss- /seam-gen/built ->ant

Dentro de ant:

->Reset

->Setup

· Introducir workspace

· Introducir dirección del servidor

· Introducir nombre del proyecto

· Color de la paleta

· EAR WAR (usare EAR pork uso EJB)

· Nombre del paquete del proyexto

· Nombre del paquete del UI

· Nombre del paquete de los test

· Nombre de la Base de Datos

· Nombre del directorio de la base de datos

· Ruta de los drivers (dejar por defecto)

· Conectar con la base de datos (defecto)

· Ruta URL donde se conecte la Base de Datos

· Nombre del root

· Contraseña del root

· Nombre de la Base de Datos

· Existen las tablas creadas

· Cada vez que arranque la BD cree que los datos que teniamos cargados.

· Implementación (dejar en blanco)

->New Project (Creará un nuevo proyecto en el workspace)

Desde Eclipse:

Seleccionar el nuevo proyecto en java y seleccionar desde uno ya creado, seleccionamos el que ha creado el Seam-gen y le pondremos el mismo nombre.

Servicios que proporciona un contenedor EJB

* Statefull

* Stateless

* MDB – message driven bean

* Entities (ofrece otros servicios)

Messaging * (Transacciones y persistencia)

Inyeccion Dependencias * * (Testeable)

Pooling * * (Alto Rendimiento)

Thread- Safety * * * (Seguridad)

Mantenimiento estado * (Gestión Estado)

AOP-Interceptores * * * (Interceptores )

RMI * (APP. Distribuida y multiusuario)

Web Services * (APP. Distribuida y multiusuario)

Transacciones * * *

Seguridad * *

Ciclo de vida

Podemos distinguir 2 tipos:

Stateless

Si alguien quiere crear un Bean y no existe, se crea. Y en el momento que no se use se destruye.

Si alguien quiere un Bean y existe no es necesario crearlo.

Cuando estamos en preparado se lanza un evento, y otro antes de eliminarse.

Statefull

Durante un tiempo el objeto esta vivo en el contenedor. Mantener un objeto con estado es muy dificl de mantener, en J2EE han conseguido crear la vida de un objeto si usar una base de datos.

El cliente entre estado y estado, en vez de estar en estado “preparado”, pasa al estado de Pasivo, que hace que se guarda en el disco duro la información del usuario. Cuando el usuario vuelva e interactue de nuevo, vuelve a pasar al estado “preparado”. Para hacer esto debemos implementar la interfaz implement Serializable.

Para que un objeto pueda ser guardada en disco debe de implementar Serializable.

Los statefull tienen dos metodos, “post construct” y “pre destroy”, pero el Statefull además inclye “pre passive” y “post activate”.

TestNG

TestNG es un framework para pruebas y testing que trabaja con Java y está basado en un sistema de pruebas de caja blanca.
Este si tiene bastantes diferencias con respecto a JUnit, podemos oabservar el hecho que podemos usar anotaciones para introducir informacion sobre las clases y metodos que vamos a testear.

EASY MOCK

Easymock es un framework que sirve para hacer pruebas (Caja Negra) creando clases que no disponemos y simular su comportamiento.


El código sigue este argumento:

Controlador controlador=new Controlador(); //Nos crearemos un controlador
crear datos; //Datos necesarios

INTERFAZ mock=EasyMock.creatMock(INTERFAZ.class); //La interfaz a simular
EasyMock.reset(mock); //Reiniciamos el easymock
EasyMock.expect(mock.funcion(datos)).andReturn(devolver Valor de la funcion); //Esperamos el comportamiento
EasyMock.replay(mock); //Accionamos el mock

controlador.atributo=mock //Asignamos el mock
controlador.funcion(datos); //Probamos la funcion

EasyMock.verify(mock); //Verificamos el comportamiento



EJEMPLO


Cliente cli = new Cliente(); Creamos la clase
Controlador cont = new Controlador(); Creamos el controlador

ServicioContacto servicioContactoMock= EasyMock.createMock(ServicioContacto.class); //Creamos el Mock diciendole k clase es

EasyMock.reset(servicioContactoMock); //Reset
EasyMock.expect(servicioContactoMock.enviaMail(cli)).andReturn(true); //Expect
EasyMock.replay(servicioContactoMock); //Estado alerta //Replay

cont.servicioContacto=servicioContactoMock; //Asiganmos el mock
cont.enviaMail(cli);
EasyMock.verify(servicioContactoMock); //Verificamos comportamiento