23 July, 2008

De vuelta y a la carga

Personal

Aunque todavía estoy apurando mis últimos días de vacaciones, ya hemos vuelto del viaje a Cantabria y a estas horas intento cerrar algunos proyectos personales que tengo pendientes.

El viaje fue de lo mas agradable y de lo mas agotador: 2 rutas de senderismo (la ruta del cares y fuente dé-aliva espinama), un día por Santander ciudad y Santillana, un día por las maravillosas playas de oyambre, visita a la cueva del soplao, visitas varias a Comillas y San Vicente, y un poco de vagancia que para eso estábamos de vacaciones ;-). Para vuestro deleite ahí quedan esas fotos, creo que queda alguna mas en mi flickr por si a alguno le interesa.

Ruta del caresRuta del caresRuta del caresRuta del caresRuta del caresRuta del caresFuente déFuente deFuente dé EspinamaFuente dé Espinama

13 July, 2008

Curso J2EE - Fin

Hemos terminado el curso.

El temario prometía y entre otras razones era el principal motivo por el que me animé a asistir, pero a estas alturas ya sabemos que el temario nunca es garantía de nada. El nivel de cualquier curso siempre lo acaba marcando en primera instancia los docentes y a continuación el grupo de alumnos.

Y bien, este curso ha sido de los pocos que ha cumplido con creces las expectativas iniciales. Ha sido uno de los cursos mas provechosos a los que he asistido. Y creo que principalmente porque quien enseñaba no solo era profesor, trabajaba diariamente como programador, como nosotros. Por esto nos entendía, entendía nuestras necesidades, nuestros problemas, entendía como funcionan las empresas, entendía que no siempre podemos trabajar con la última VM o el último framework y aportaba su punto de vista al respecto. Mostrando siempre una base teórica de cada uno de los puntos lo provechoso principalmente ha sido una importante base práctica y marcando bien los puntos conflictivos en base a sus experiencias. Y es que como bien se expone en la fábula que contiene este buen artículo que os animo a leer, no se puede enseñar a cazar dragones sin haber cazado ningún dragón, evidente no?.

Y ahora toca descansar :-), 1 semanita por Santander playa-sol-montaña y otra por mi querida tierra gallega.

Un saludo y hasta la vuelta.

Curso J2EE (15ª,16ª semana) JSF

Después de varias semanas con spring cambiamos de tercio y nos adentramos en otro framework java, jsf (java server faces). Mi experiencia con jsf se había reducido ya hace tiempo al trabajo con jbpm pero había profundizado muy poco.

Jsf es el estándar propuesto por sun para el desarrollo de aplicaciones web en j2ee, sus especificaciones se definen en los siguientes jsr JSR 127, JSR 252, JSR 276.
Como toda especificación definida por sun encontraremos diversos proyectos que la implementan: MyFaces, backbase, ice-faces, adf-faces , richfaces, jsf-extensions, etc...

La mayor novedad en jsf respecto a otros frameworks es el concepto de componente/evento, así emulando al desarrollo bajo swing por ejemplo tendremos componentes para crear menús, listas, arboles, componentes que nos aportan funcionalidades bajo ajax y tendremos la posibilidad de crear nuestros propios componentes en caso de ser necesario.

Para comenzar a utilizar jsf necesitaremos modificar nuestro web.xml indicando el servlet que gestionará todas nuestras peticiones jsf:

  1. <servlet>
  2.         <servlet-name>Faces Servlet</servlet-name>
  3.         <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
  4.         <load-on-startup>1</load-on-startup>
  5.     </servlet>
  6.     <servlet-mapping>
  7.         <servlet-name>Faces Servlet</servlet-name>
  8.         <url-pattern>*.jsf</url-pattern>
  9.     </servlet-mapping>

Por supuesto no nos libraremos de los ficheros de configuración xml, en jsf este fichero será faces-config.xml, en el declaramos por ejemplo todas las reglas de navegación, y los beans de nuestro modelo.

  1. <faces-config>
  2.   <managed-bean>
  3.     <managed-bean-name>facturaBean</managed-bean-name>
  4.     <managed-bean-class>net.jsanroman.beans.FacturaBean</managed-bean-class>
  5.     <managed-bean-scope>request</managed-bean-scope>
  6.   </managed-bean>
  7.  
  8.   <navigation-rule>
  9.     <from-view-id>/factura.jsp</from-view-id>
  10.     <navigation-case>
  11.       <from-outcome>error</from-outcome>
  12.       <to-view-id>/WEB-INF/factura.jsp</to-view-id>
  13.     </navigation-case>
  14.     <navigation-case>
  15.       <from-outcome>success</from-outcome>
  16.       <to-view-id>/WEB-INF/facturas.jsp</to-view-id>
  17.     </navigation-case>
  18.   </navigation-rule>

En jsf los controles de la vista lanzarán eventos listener y estos serán implementados por los métodos de los respectivos beans:

  1. ...
  2.   <h:selectBooleanCheckbox
  3.            valueChangeListener="#{facturaBean.aplicaDescuento}"
  4.            onclick="submit()"
  5.            immediate="true"/>
  6.  
  7.   <h:commandButton
  8.     value="Guardar"
  9.     actionListener="#{facturaBean.save}"
  10.     immediate="true"/>
  11. ...

Crear nuestros propios componentes jsf puede resultar al principio un poco complejo pero una vez sabemos la mecánica será siempre igual, la complejidad entonces vendrá dada por el componente que necesitemos crear:
- Crear la clase que represente a nuestro componente, que extenderá de UIComponentBase.
- Crear la clase que represente a los tags necesarios para incluir nuestro componente en la vista y que extenderá de UIComponentTag.
- Creamos el tld que defina nuestro componente.
- Y lo incluimos en faces-config.xml de la forma:

  1. <component>
  2.      <component-type>net.jsanroman.JsfHolaMundo</component-type>
  3.      <component-class>net.jsanroman.component.HolaMundoUIComp</component-class>
  4. </component>

Para finalizar estas 2 semanas hemos probado varios componentes de myfaces que integran funcionalidades ajax, y como no!, hemos integrado spring con jsf.

Una buena comparativa entre struts y jsf.

11 July, 2008

Curso J2EE (13ª semana) spring:webflow

Semana 13ª continuamos con spring, esta vez probamos spring webflow, el modulo de spring para definir e implementar flujos de trabajo (workflow).

Atrás quedan aquellos días con jbpm, en mi opinión creo que lo habíamos comenzado a utilizar demasiado pronto (recién salida del horno la primera stable) y la documentación era muy escasa por lo que los comienzos fueron muy pero que muy difíciles. A esto (y otra vez en mi opinión) le sumamos un equipo de trabajo falto de muchos conocimientos y conceptos en los que se basa jbpm y como tantas otras veces el poco tiempo disponible para asimilarlos. Por todo esto mi anterior experiencia con jbpm no fué del todo satisfactoria, pero quien sabe, quizás un día de estos tontos lo retome y me lleve una grata sorpresa, ganas no me faltan pero tiempo todo el del mundo como a la mayoría.

En general spring webflow no me resultó complejo, lo principal es tener claro como trabaja spring.

Puedes declarar tu flujo tanto en un fichero xml como en una clase java y como en todo workflow tendrás diferentes estados y tipos de estado por los que pasará el proceso. Así por ejemplo tendremos: view-state (estados que renderizan una vista), action-state (estados de lógica de negocio), start-state (estado de comienzo), end-state (estado de fin). Podrán tener n transiciones que especificaremos por ejemplo en el fichero xml de la forma:

  1. <action-state>
  2.    <action bean="loginAction"/>
  3.    <transition on="ok" to="listadoFacturas"/>
  4.    <transition on="nok" to="login"/>
  5. </action-state>

En este caso hemos declarado un action state que por ejemplo comprobaría los datos insertados por un usuario y le mostraría un listado de facturas si son correctos o lo devolvería a la página de login.

Podríamos definir subflujos con la etiqueta subflow-state.

Debemos declarar los beans utilizados en el flujo indicado anteriormente:

  1. <bean id="loginAction" class="net.jsanroman.webflow.action.LoginAction"/>

A los enlaces html que inicien el flujo debemos pasarle el parámetro _flowId=id_del_start_state.

Una de las diferencias significativas que en un primer momento he encontrado respecto a jbpm es que spring webflow no guarda la información entre los diferentes estados de forma automática, cosa que si hace jbpm, pero bueno dependiendo de lo que necesitemos siempre podemos hacerlo a mano.

9 July, 2008

Curso J2EE (12ª semana) integración spring+struts, quartz y appfuse

Semana 12ª y continuamos integrando librerías con spring, como veis tenemos un montón y cada vez mas spring es nuestro punto de unión entre todas ellas.

Tenemos 3 formas de integrar struts y spring:

Extendiendo la clase ActionSupport:
Creamos nuestro action que extenderá de ActionSupport, dentro cargaremos el contexto de spring manualmente y obtendremos los bean necesarios y definidos en el fichero de configuración de spring:

  1. public class ObtenerFacturaAction extends ActionSupport {
  2.       public ActionForward execute(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response)
  3.             throws IOException, ServletException {
  4.             ApplicationContext ctx = getWebApplicationContext();
  5.             FacturaManager facturaManager = (FacturaManager) ctx.getBean("facturaManager");
  6. ...

Definimos nuestras acciones en struts-config.xml

  1. <action path="/obtenerFactura"
  2.         type="net.jsanroman.spring.struts.actions.ObtenerFacturaAction">
  3.           <forward name="success" path="/WEB-INF/facturas/fichaFactura.jsp"/>
  4. </action>
  5. ...

y a spring en este caso le toca proporcionar los beans que dispondremos en las clases actions:

  1. ...
  2. <bean id="facturaManager"
  3.    class="net.jsanroman.spring.struts.manager.FacturaManagerImpl"/>
  4. ...

Un gran acoplamiento entre spring y struts.

Empleando DelegatingRequestProcessor:
Debemos añadir a struts-config.xml

  1. <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor"/>

además de definir las acciones en struts deberemos definirlas también como beans en spring:

  1. <bean name="/obtenerFactura" class="net.jsanroman.spring.struts.actions.ObtenerFacturaAction">
  2.    <property name="facturaManager">
  3.       <ref bean="facturaManager"/>
  4.    </property>
  5. </bean>

Empleando DelegatingActionProxy:
En cada acción definida en struts-config.xml debemos añadir type = “org.springframework.web.struts.DelegatingActionProxy”. En este caso la ventaja es que podemos aprovechar las capacidades de spring, por ejemplo aop.

Pero en definitiva, un autentico coñazo cualquiera de las formas y una opción que solo deberemos utilizar en casos excepcionales.

Terminamos esta semana con un par de ejemplos primero con la libreria quartz para configurar "tareas programadas". Y el segundo con appfuse librería que nos crea todo el codigo para una completa aplicación web de gestión de una BD dada, basandose en struts (y en la última versión en struts2) tengo pendiente jugar mas con ella pues me dejó muy buen sabor.

Curso J2EE (11ª semana) spring+(aop, velocity), aspectj

Continuamos con spring y hemos aprovechado su módulo aop para introducirnos en la programación orientada a aspectos además también hemos hecho algún ejemplo con aspectj (otra implementación de este paradigma) mas potente que el módulo aop de spring. Por supuesto también tenemos implementaciones de programación orientada a aspectos para otros lenguajes (aspect#, aspect .net, aspectc, phpAspect, etc).

Esta semana también nos ha dado para conocer otra de las librerías que podemos integrar con spring, el motor de plantillas velocity, integrarlo es tan sencillo como declarar los beans de configuración:

  1. <bean id="velocityConfig" class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
  2.       <property name="resourceLoaderPath" value="/WEB-INF/velocity/"/>
  3. </bean>
  4. <bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
  5.       <property name="cache" value="true"/>
  6.       <property name="prefix" value=""/>
  7.       <property name="suffix" value=".vm"/>
  8. </bean>

8 July, 2008

Nautilus svn, el tortoise linuxero

Cuando me pasé a ubuntu busqué y rebusqué algo parecido a tortoisesvn, estaba muy acostumbrado a trabajar con el. Al final no encontré nada parecido y me quedé con los clientes de eclipse y netbeans (que están muy bien por cierto), con kdesvn y con la línea de comandos claro.

Pero estos días he descubierto nautilussvn. Un cliente subversion que se integra bastante bien con nautilus el explorador de ficheros de gnome. Le faltan muchas opciones, pero para echar un vistazo a los ficheros modificados y no commiteados o para subir ciertos cambios de una forma ágil esta muy pero que muy bien.

Nautilus svn

Su creador Jason Field ha publicado el proyecto en el repositorio de código de google para todo el que quiera participar, ¡ánimo!.

PD: Acabo de recibir 2 sms de la uoc, he aprobado las 2 asignaturas a las que me presenté, esto merece una gran celebración!! :-).

Powered by WordPress
Bajo licencia Creative Commons
Contacto sanroman.javier at gmail.com