En nuestro caso, usaremos Spring 2.5 y Hibernate 3.3 y MySQL, donde es necesario ya tengas armado los beans de conexión a la base de datos. El siguiente código es un array de cadenas, si en nuestro caso tenemos segmentado los xml de spring, los añadiremos de la siguiente manera.

// array de string para agregar todos tus archivos de configuración de spring
private static final String[] SPRING_CONFIG_FILES =
new String[]{"source/spring/config/xxxxxx-db-context.xml", "source/spring/config/xxxxxxx-param-context.xml"};

A continuación, el código necesario para generar nuestra base de datos, el FileSystemXmlApplicationContext carga el Contexto de la Aplicación, y una vez teniendo el contexto obtenemos el SessionFactory, que en nuestro caso usamos Anotaciones, creamos el bean en base a la clase AnnotationSessionFactoryBean , esto es importante pues en base a esta clase usaremos los metodos dropDatabaseSchema(); para borrar el actual schema (tablas, relaciones , etc) y luego ejecutamos createDatabaseSchema(); para crear el nuevo schema.

// carga el application context de Spring
 FileSystemXmlApplicationContext appContext = new FileSystemXmlApplicationContext(SPRING_CONFIG_FILES);
// Obtiene el bean del session factory
 AnnotationSessionFactoryBean annotationSF = (AnnotationSessionFactoryBean)  appContext.getBean("&sessionFactory");
// si quieres eliminar el schema de la base de datos
 annotationSF.dropDatabaseSchema();
// para crear nuevamente el schema de la base de datos
 annotationSF.createDatabaseSchema();

Los archivos de configuración de Spring, deben lucir de la siguiente manera, hay que destacar el hibernate.dialect donde indicamos el dialecto que usaremos para crear el schema, en el caso de MySQL puede ser MySAM o InnoDB, luego el parametro hibernate.hbm2ddl.delimiter que también indicamos el tipo de tablas que usaremos en mi caso usaré type=InnoDB.

<bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${datasource.classname}" />
        <property name="url" value="${datasource.urldb}" />
        <property name="username" value="${datasource.userbd}" />
        <property name="password" value="${datasource.pass}" />
    </bean>
 
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="annotatedClasses">
          <list>
              <value>Clase1</value>
              <value>Clase2</value>
          </list>
        </property>
        <property name="hibernateProperties">
           <props>
                <!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                <prop key="hibernate.dialect">${datasource.dialect}
                </prop>
                <prop key="hibernate.show_sql">${datasource.showsql}</prop>
                <prop key="hibernate.hbm2ddl.delimiter">${datasource.delimited}</prop>
            </props>
        </property>
      </bean>

Me quedado algo sorprendido  de la noticia que encontramos en JavaHispano y InfoQ, donde nos cuentan Sun eliminó completamente de Java 7 el conocido Swing, para aplicaciones de escritorio desarrolladas en Java.

Se comenta que también “han surgido dos fork diferentes basados en el código del proyecto original (Beter Swing Application Framework y Swing application framework fork) , donde la intención es seguir un “Swing Application Framework” al margen del JDK 7 y sin la intervención de Sun”.

http://www.infoq.com/news/2009/09/java7_m5

Algunos aspectos interesantes de la entrevista, habla sobre el nuevo logo de RichFaces, del cual ya hablamos en este blog meses atras, también toca el tema sobre que va pasar con las versiones anteriores a RichFaces 4, donde dijo que a partir de septiembre empieza el modo mantenimiento en el branch 3.3.x, asi obligando, a la mayoria a mudarse a RichFaces 4.0

Nos da unos tips a los que desean colaborar con el desarrollo en RichFaces, empezando por ayudar en los foros, probando las Alfas y aportando nuevas ideas.

Entrevista completa

Hace poco el equipo de Spring Source liberó Spring 3.0 RC1 y viene con muchas nuevas características interesantes, para mi una de las mas interesantes es que ya viene con soporte para Java 6 y completamente basado en Java 5, ya era hora !. Me tomado el permiso de pegar la traducción que hizo Dos Ideas.

• Completamente basado en Java 5. Esta la primer versión de Spring que necesita Java 5 o superior para funcionar, y que utiliza la sintáxis de Java 5 en todo el API de Spring, y también en su implementación. Por ejemplo, el API del BeanFactory retorna instancias tipadas con generics cuando es posible, y un ApplicationListener puede declarar tipos de eventos específicos con generics. En comparación, Spring 2.5 (la versión actual de Spring) todavía es compatible con el JDK 1.4, aunque mucha funcionalidad de alto nivel se construía en Java 5.
• Lenguaje de expresiones de Spring (SpEL – Spring Expression Language). Un parser de expresiones para usar en la definición de los beans, que permite referenciar a estructuras anidadas (por ejemplo, propiedades de otros beans), y también a estructuras del sistema (por ejemplo, variables de entorno) usando la sintáxis común #{…} en el valor de las propiedaes de un bean. Esto también sirve como base para otras características basadas en expresiones en otros proyectos de Spring.
• Soporte extendido para componentes basados en anotaciones. Se incluye el concepto de clases de configuración y métodos de factory anotados – ¡las características fundamentales del proyecto Spring JavaConfig finalmente están disponibles en Spring!. Sprint también permite inyectar valores de configuración a través de expresiones @Value, y referirse a valores de la configuración usando expresiones dinámicas #{…} o estáticas ${…}.
• Modelo de estereotipos. Permite crear anotaciones “de atajo” a través del uso de meta-anotaciones. Por ejemplo, para determinar scopes predeterminados o características de transacción predeterminadas en estereotipos propios. Imaginen una anotación propia @MiServicio que indica @Service, @Scope(“request”) y @Transactional(readOnly=true) usando una única anotación. Este es el principio de No Repetirse aplicado al uso de anotaciones de componentes.
• Anotaciones de inyección de dependencias estándar. Spring 3.0 provee un soporte inicial para el JSR-330 specification for Dependency Injection in Java- inyección a través de anotaciones usando javax.inject.Inject y sus calificadores asociados y modelo de proveedores, como una forma alternativa a la anotación @Autowired propia de Spring. Tengan en cuenta que el JSR-330 todavía no está terminado; el soporte para javax.inject en Spring se irá completando a medida que madure la especificación.
• Modelo de validaciones declarativo basado en anotaciones de restricciones. Configuración al estilo de Spring de un proveedor de JSR-303 Bean Validation (como ser, Hibernate Validator 4.0). Spring 3.0 viene con una opción para hacer validaciones basadas en anotaciones en Spring MVC, exponiendo una vista unificada cuando no se cumplen las restricciones. Tengan en cuenta que el JSR-303 está próximo a terminarse, aunque todavía puede tener modificaciones.
• Soporte para REST extendido. Soporte nativo para REST en Spring MVC, como ser mapeos de peticiones REST, extracción de variables URI a través de parámetros @PathVariable, y resolución de vistas guiadas por la negociación del contenido. Imaginen Spring MVC 2.5 con soporte de primera clase para REST – y manteniendo en enfoque de MVC. Hay soporte para el lado del cliente de REST a través de la clase RestTemplate.
• Mapeo Objeto/XML (OXM). Tal como se usaba en Spring Web Services, ahora dentro del núcleo de Spring Framework. Abstracciones para el marshalling y unmarshalling con soporte directo para JAXB 2, Castor, etc. Se provee opciones de integración para soporte de contenidos XML en Spring MVC y Spring JMS.
• Soporte para Portlet 2.0. Spring MVC soporta completamente los entorno de Portlet 2.0 y el nuevo modelo de recursos y eventos de Portlet 2.0. Se incluyen facilidades de mapeo para peticiones de portlet típicas: @ActionMapping, @RenderMapping, @ResourceMapping, @EventMapping.
• Nuevo sistema de scheduling. Nuevos mecanismos de TaskScheduler y Trigger con soporte estilo cron, alineados con el mecanismo de Spring TaskExecutor. Spring 3.0 provee un namespace que soporta anotaciones @Async y @Scheduled. Esto se puede ejecutar sobre pooles nativos de hilos o en pooles manejados por Servidores de Aplicaciones, incluyendo soporte para los servidores de aplicaciones Java EE más populares.
• Y por último, soporte inicial para Java EE 6. Spring 3.0 soporte el uso de JSF 2.0 y JPA 2.0 dentro de Spring, junto al soporte de JSR-303 y JSR-330. Se irá incluyendo soporte para otras tecnologías de Java EE 6 (como Servlet 3.0) a medida que se vayan concretando los productos.

Hace unos dias Exadel, libero el primer alfa de RichFaces 4.0, con integración completa a JSF2 , estas son las actualizaciones y nuevas características (lo dejo en ingles, porque pierde en la traducción ).

• Simplified Component Development Kit with annotations, faces-config extensions, advanced templates support and more..
• Ajax framework improvements extending the JSF 2 specification.
• Component review for consistency, usability, and redesign following semantic HTML principles where possible.
• Both server-side and client-side performance optimization.
• Strict code clean-up and review.

Parece que tuvieron algunos problemitas con el primer alfa, pero ya lo dejaron bien explicado aqui si tienes problemas para correr el war.

http://download.jboss.com/jboss-richfaces/richfaces-demo-4.0.0.ALPHA1-tomcat6.war

]]> http://blog.jotadeveloper.com/2009/09/09/richfaces-4-0-alpha1-ya-disponible/feed/ 0 http://blog.jotadeveloper.com/2009/09/08/jboss-world-2009/ http://blog.jotadeveloper.com/2009/09/08/jboss-world-2009/#comments Wed, 09 Sep 2009 03:56:52 +0000 Jota http://blog.jotadeveloper.com/?p=2803

La semana pasada se celebró la cumbrede Red Hat JBOSS WORLD 2009 , se reunieron desarrolladores de Red Hat, usuarios y clientes. Se mostró cómo se está utilizando su tecnología, noticias de Red Hat acerca de la tecnología que vendrá. La cumbre era para personas interesadas en Red Hat y las soluciones de código abierto. Se ejecutaron varias presentaciones, talleres y laboratorios de prácticas en donde se mostraron nuevas formas de hacer negocio.

Si no tuviste la suerte de ir, como yo, pues tenemos que conformarnos con todo lo que quedó colgado en el sitio de Jboss

• Videos de Presentación
• Las Presentaciones en PDF
• La Agenda del Evento

Les dejo una presentación de Marck Little, sobre el Proyecto OVERLOD de Jboss.

Pero a los que a veces, tenemos malos hábitos de programación (me incluyo) , existen herramientas interesantes, para diferentes metodologias de desarrollo que siempre nos son útiles y completamente integrables como con Maven2, Ant y Eclipse.

Es importante que nuestro código sea de buena calidad, o lo mas cercano posible, eso va hacer que la mantenibilidad del código y ponerle los cámbios más fáciles a otros futuros programadores que les toque lidiar con nuestro código. Estoy consciente que existen más, si puedes aportar para mejorar este post, se agradece.

Cobertura

Cobertura (http://cobertura.sourceforge.net/) es una herramienta libre (GPL) escrita en Java, que nos permite comprobar el porcentaje de código al que accedemos desde los test. Es decir, Cobertura nos permite saber cuanto código estamos realmente probando con nuestros test.

De esta forma Cobertura se convierte en una potente herramienta de trabajo, ya que lo podemos usar como medida de calidad (mientras más código tengamos probado, más garantías tenemos de que podemos hacer refactorizaciones sin peligro).

Además Cobertura también nos indica la complejidad ciclomática de McCabe (http://en.wikipedia.org/wiki/Cyclomatic_complexity). Esto nos dice como de “complejo” es un método. Esto nos puede servir para orientar nuestros test y probar primero las piezas más complejas, o incluso nos puede hacer plantearnos una refactorización para bajar la complejidad del código.

FindBugs

FindBugs es una herramienta opensource desarrollada por la Universidad de Maryland. Desarrollada en Java, tiene una interfaz simple pero efectiva. Gracias a esta herramienta se puede incrementar el rendimiento de una aplicación además de eliminar bugs potenciales.

http://findbugs.sourceforge.net/

Checkstyle

Esta herramienta que inicialmente fue desarrollada para  validar que nuestro código Java se ajustaba a unas conveciones de códificación, se ha ido ampliando con nuevas funcionalidades que la convierten en una estupenda herramienta para realizar el analisis estático de nuestro código Java. Una de las principales aportaciones de esta nueva versión es que añade soporte para Java 1.5.

http://checkstyle.sourceforge.net/

Fuentes

FindBugs, Cobertura, Checkstyle

• Strings en switch, para evitarte tantos if anidados al comparar cadenas.
• Bloques de recursos automatizados
• Expresiones de bloque, la idea es que la expresión delimitada dentro de un paréntesis devuelva un valor,
• Mejoras al manejo de excepciones
• Mejoras al manejo del Tipo en Generics

Actualmente, estan por el Mileston 3, se tiene pensado que se libere finalmente para Febrero del 2010, aquí el plan http://java.dzone.com/articles/plan-jdk-7 , también les dejo un interesante video que habla sobre las novedades.

Aquí una interesante presentación

Fuente

Estoy aprendiendo JavaFX, es una tecnologia practicamente nueva para la creación de Rich Internet Applications (RIAs) , se pretende competir contra Flash de Adobe y Silverligth de Microsoft.

Esto que podemos ver, es un hola mundo, el primer trozo de código que debemos aprender.

import javafx.ui.*;
Frame {
title: "JavaFX Hello World"
content: Label {
text: "Hello World"
}
visible: true
}

Para no llenar el post con aburridas explicaciones, es mejor ver una presentación como introducción a esta interesante tecnologia, el proximo post, trataré de programar algo pequeño.