27 July, 2008

Contabilidad casera con HomeBank

HomeBank

Pues si, para eso que mi abuela hacía solo con su cabeza, administrar sus dineros, yo voy a intentar hacerlo con HomeBank.

¿Porque utilizar HomeBank si mi abuela era capaz de hacerlo de memoria?, puff pues principalmente porque la abuela todavía tiene un coco tremendo y yo no le llego ni a la suela de los zapatos. Después, porque cuando uno comienza a tener varias entradas/salidas (y eso que no tengo hipoteca) puede resultar fácil perderse si no administra bien sus cuentas.

HomeBank tiene una interfaz muy intuitiva y amigable, también probé GNUCash pero este me parece demasiado complejo/liante y yo necesitaba algo muy sencillo, que no tenga que estructurar demasiado mis cuentas y no deba dedicarle demasiado tiempo, de lo contrario a la primera de cambio lo dejaría de lado. Simplemente quiero registrar gastos/ingresos mas importantes, operaciones automáticas (sueldo, letras, etc.) y una previsión futura del saldo de mi cuenta. Ahora ya sé cuando podré comprarme mi nuevo portatil por ejemplo ;-), creo que falta poco, lo siguiente será decidirse mac vs pc (ubuntu jugará un papel decisivo en la lucha).

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>

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