Aprendiendo SOA

Dejo algunos links que vienen bien leer:

http://blogs.tecsisa.com/articulos-tecnicos/¿por-que-soa/
http://blogs.tecsisa.com/articulos-tecnicos/¿por-que-un-enterprise-service-bus

Además les aconsejo un blog, Espacio SOA y además el mio jeje.

http://www.espaciosoa.net

Apache Ivy

Ivy es una herramienta para la gestión (registro, seguimiento, resolución y notificación) dependencias del proyecto. Se caracteriza por lo siguiente:

• Flexibilidad y configurabilidad - Ivy es esencialmente independiente del proceso y no está vinculado a cualquier metodología o estructura. En su lugar, proporciona la necesaria flexibilidad y configurabilidad de adaptarse a una amplia gama de gestión de la dependencia y construir procesos.
• Estrecha integración con Apache Ant. Ivy funciona particularmente bien con Apache Ant proporcionando un número de poderosos tareas Ant desde la resolución de dependencias para la presentación de informes y publicación de dependencia.

Si la pregunta es porque no usar Apache maven y la respuesta es simple: no siempre se puede usar maven. En un proyecto que ya usa Ant y ya fue construido. Un proyecto particular que no encuadra con la estructura propuesta por maven, en estos casos usar Ivy para resolver las dependencias es la mejor idea que se te puede ocurrir.

Ivy es de código abierto y liberado bajo una licencia Apache.

Dejo el link: http://ant.apache.org/ivy/index.html

Apache Harmony - Open Source Java SE.

Apache Harmony es una open JDK si si ya se no esta certificada pero es interesante para comenzar. Esta jdk es para la gente que no confía demasiado en Oracle, por lo menos yo no confió.

Es interesante que Open Jdk sea más famosa (open jdk era una implementación impulsada por Sun) y más inmadura. Apache Harmony es una jdk que no certifica como Jdk, según las malas lenguas solo cuestión de política.

Y yo personalmente uso muchos productos de Apache y la verdad es que siempre tuve buenos resultados. Vamos a probar esta Jdk

Dejo el link: http://harmony.apache.org/index.html

Configurar una cache con Spring con ehcache

Saben como viene la mano? Yo no tengo ganas de ir a buscar a la base todas las veces los datos que me piden; por qué? Porque es más lento. Lo que nos conviene es usar una cache de datos. Como funciona esto? Fácil cada vez que yo deseo consultar un objeto lo guardo en un lugar, cuando alguien hace la misma consulta no vuelvo a ir a la base sino que lo busco de donde lo guarde “la cache” y si alguien guarda o modifica un objeto limpio la cache para que no traiga datos viejos.

Spring modules es nuestro mejor amigo para configurar cache en spring. Vamos a ver como podemos configurar la cache con anotaciones. Uso anotaciones porque me parece más descriptivo pero podría usar aop (va en gusto)

Primero en mi creo los siguientes beans:

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:ehcache="http://www.springmodules.org/schema/ehcache"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">

<ehcache:config configLocation="classpath:ehcache.xml" />

<ehcache:annotations>

<!—- para metodos cacheables -->

<ehcache:caching id="cache" cacheName="defaultCache" />

<!—- para metodos que borran la cache -->

<ehcache:flushing id="flushCache" cacheNames="defaultCache" when="before" />

</ehcache:annotations>

</beans>

Ahora bien debemos crear el archivo: ehcache.xml

<ehcache >

<defaultCache

maxElementsInMemory="10000"

eternal="false"

timeToIdleSeconds="300"

timeToLiveSeconds="600"

overflowToDisk="false"

memoryStoreEvictionPolicy="LRU"

/>

<cache name="defaultCache"

maxElementsInMemory="10000"

eternal="false"

overflowToDisk="false"

memoryStoreEvictionPolicy="LRU"

/>

</ehcache>

Ahora con anotaciones indicamos que cacheamos y que borra la cache

@Cacheable(modelId="cache")

public List<T> buscarTodos() {

return this.getHibernateTemplate().find("from " +persistentClass.getName());

}

@Cacheable(modelId="cache")

public T buscarPor(Serializable id) {

return (T) this.getHibernateTemplate().get(persistentClass, id);

}

@Cacheable(modelId="cache")

public List<T> buscarPor(T ejemplo) {

return this.getHibernateTemplate().findByExample(ejemplo);

}

@Cacheable(modelId="cache")

public Long contarTodos() {

Query query = this.getSession().createQuery("select count(*) from "+persistentClass.getName());

return (Long) query.uniqueResult();

}

@CacheFlush(modelId="flushCache")

public void guardar(T entidadPersistible) {

this.getHibernateTemplate().save(entidadPersistible);

}

@CacheFlush(modelId="flushCache")

public void actualizar(T entidadPersistible) {

this.getHibernateTemplate().update(entidadPersistible);

}

@CacheFlush(modelId="flushCache")

public void guardarOActualizar(T entidadPersistible) {

this.getHibernateTemplate().saveOrUpdate(entidadPersistible);

}

@CacheFlush(modelId="flushCache")

public void borrar(T entidadPersistible) {

this.getHibernateTemplate().delete(entidadPersistible);

}

@CacheFlush(modelId="flushCache")

public void borrarPor(Serializable id) {

T entidadPersistible = this.buscarPor(id);

this.getHibernateTemplate().delete(entidadPersistible);

}

Si todo salió bien la aplicación va a usar la cache para estos métodos

Dejo las dependencias de maven:

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>net.sf.ehcache</groupId>

<artifactId>ehcache</artifactId>

<version>1.6.2</version>

</dependency>

<dependency>

<groupId>org.springmodules</groupId>

<artifactId>spring-modules-cache</artifactId>

<version>0.8</version>

<exclusions>

<exclusion>

<artifactId>gigaspaces-ce</artifactId>

<groupId>gigaspaces</groupId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>jsk-lib</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>jsk-platform</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>mahalo</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>reggie</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>start</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>boot</artifactId>

</exclusion>

<exclusion>

<groupId>jini</groupId>

<artifactId>webster</artifactId>

</exclusion>

<exclusion>

<groupId>jboss</groupId>

<artifactId>jboss-cache</artifactId>

</exclusion>

<exclusion>

<groupId>jboss</groupId>

<artifactId>jboss-common</artifactId>

</exclusion>

<exclusion>

<groupId>jboss</groupId>

<artifactId>jboss-jmx</artifactId>

</exclusion>

<exclusion>

<groupId>jboss</groupId>

<artifactId>jboss-minimal</artifactId>

</exclusion>

<exclusion>

<groupId>jboss</groupId>

<artifactId>jboss-system</artifactId>

</exclusion>

<exclusion>

<groupId>jcs</groupId>

<artifactId>jcs</artifactId>

</exclusion>

<exclusion>

<groupId>xpp3</groupId>

<artifactId>xpp3_min</artifactId>

</exclusion>

<exclusion>

<groupId>ehcache</groupId>

<artifactId>ehcache</artifactId>

</exclusion>

<exclusion>

<groupId>org.springframework</groupId>

<artifactId>spring</artifactId>

</exclusion>

</exclusions>

</dependency>

Apache Tuscany y Spring

Sigo experimentando con Apache Tuscany, hoy el objetivo es hacer un ejemplo con integración con spring. Mismo ejemplo que hicimos en : http://emanuelpeg.blogspot.com/2010/05/desarrollar-un-ejemplo-con-apache.html

Comenzamos escribiendo la interfaz:

@Remotable
public interface ExampleService {

String sayHello();

}

Su implementación :

@Service(ExampleService.class)
public class ExampleServiceImpl implements
ExampleService {

private String hello = "Holasss !!! \n";

public void setHello(String hello) {
this.hello = hello;
}

/**
* @see org.assembly.nornas.ExampleService#sayHello()
*/
@Override
public String sayHello() {
System.out.print("llamaron a Say");
return hello;
}

@Init
public void init() {
System.out.println("Starting with "+ExampleServiceImpl.class + " \n");
}

}

Ahora tenemos que configurar el beans de spring, en un archivo que llamaremos: appcontext-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:sca="http://www.springframework.org/schema/sca"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/sca http://www.osoa.org/xmlns/sca/1.0/spring-sca.xsd ">


<bean id="service.example" class="com.elpaquete.ExampleServiceImpl">
<property name="hello" value="Hola desde Spring!!" ></property>
</bean>


<sca:service name="ExampleService"
type="org.assembly.nornas.sandbox.service.example.ExampleService" target="service.example" />


</beans>

Notaron que además de declarar el bean le indicamos a Apache Tuscany cual es la interfaz de nuestro bean que va a ser un componente de Apache Tuscany.

Ahora escribimos el archivo ExampleSpring.composite:

<?xml version="1.0" encoding="UTF-8" ?>

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
xmlns:t="http://tuscany.apache.org/xmlns/sca/1.0"
targetNamespace="http://nornas"
xmlns:nornas="http://nornas"
name="Example" >

<component name="ExampleServiceComponent">
<implementation.spring location="spring-sandbox.xml" />

<service name="ExampleService">
<interface.java interface="org.assembly.nornas.sandbox.service.example.ExampleService"/>
<binding.ws uri="http://localhost:8080/nornas/ws" />
<t:binding.atom uri="http://localhost:8080/nornas/atom" />
<t:binding.jsonrpc uri="http://localhost:8080/nornas/jsonrpc" />
<t:binding.rss uri = "http://localhost:8080/nornas/rss"/>
<binding.sca />
</service>

</component>


</composite>

Notaron que la implementación del componente no se indica clase si no el archivo appcontext-spring.xml, Apache tuscany va a leer y buscar de ahí la implementación.

Ya lo tenemos, ahora vamos a hacer la clase main:

public class MainSpring {

public static void main(String[] args) throws IOException {

System.out.println("Starting ...");
SCADomain scaDomain = SCADomain.newInstance("ExampleSpring.composite");
System.out.println("Example in "+scaDomain.getURI());
System.in.read();
System.out.println("Stopping ...");
scaDomain.close();
System.out.println();

}

}

Si todo salio bien, en http://localhost:8080/nornas/ws?wsdl va a estar wsdl de su web service soap.

Por ultimo las dependencias de maven:

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6.SEC01</version>
</dependency>


<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-sca-api</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-core-spi</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-policy-security</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-embedded</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-data-api</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.ws.security</groupId>
<artifactId>wss4j</artifactId>
<version>1.5.3</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-java-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-atom-abdera</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-rss-rome</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-ws-axis2</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-jsonrpc-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-rmi-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-resource-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-http-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-jetty</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-spring</artifactId>
<version>1.6</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-spring-runtime</artifactId>
<version>1.6</version>
<scope>runtime</scope>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
</dependency>

Desarrollar un ejemplo con Apache Tuscany

Como ven no estoy escribiendo mucho dado que estoy dedicando tiempo a mi tesis. Por esta razón rápidamente vamos a desarrollar un ejemplo con Apache Tuscany.
En otro post les prometo dar más detalles de mi tesis.
Si no leyeron estos posts, sería bueno que lo hagan :
http://emanuelpeg.blogspot.com/2010/02/apache-tuscany_4551.html
http://emanuelpeg.blogspot.com/2010/02/sca.html

La idea es desarrollar un ejemplo facil usando maven.
Veamos la descripción del componente:

import org.osoa.sca.annotations.Remotable;

@Remotable
public interface ExampleService {

String sayHello();

}

Veamos la implementación:

import org.assembly.nornas.service.example.ExampleService;
import org.osoa.sca.annotations.Init;
import org.osoa.sca.annotations.Service;


@Service(ExampleService.class)
public class ExampleServiceImpl implements
ExampleService {

@Override
public String sayHello() {
System.out.print("llamaron a Say");
return "Holasss !!! \n";
}

@Init
public void init() {
System.out.println("Starting with "+ExampleServiceImpl.class + " \n");
}

}

Ahora hay que hacer un archivo composite que describe el componente:
Example.composite

<?xml version="1.0" encoding="UTF-8" ?>

<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
xmlns:t="http://tuscany.apache.org/xmlns/sca/1.0"
targetNamespace="http://nornas"
xmlns:nornas="http://nornas"
name="Example" >

<component name="ExampleServiceComponent">
<implementation.java class="org.assembly.nornas.serviceImpl.example.ExampleServiceImpl" />

<service name="ExampleService">
<interface.java interface="org.assembly.nornas.service.example.ExampleService"/>
<binding.ws uri="http://localhost:8080/nornas/ws" />
<t:binding.atom uri="http://localhost:8080/nornas/atom" />
<t:binding.jsonrpc uri="http://localhost:8080/nornas/jsonrpc" />
<t:binding.rss uri = "http://localhost:8080/nornas/rss"/>
<binding.sca />
</service>

</component>


</composite>

Ahora vamos a correr todo esto, para lo cual vamos a tener que hacer una clase que tenga el método main:

import java.io.IOException;

import org.apache.tuscany.sca.host.embedded.SCADomain;

public class Main {

public static void main(String[] args) throws IOException {
System.out.println("Starting ...");
SCADomain scaDomain = SCADomain.newInstance("Example.composite");
scaDomain.getURI();
System.out.println("store.composite ready for big business !!!");
System.in.read();
System.out.println("Stopping ...");
scaDomain.close();
System.out.println();
}

}

Ojo hago esto porque no tengo servidor, para otro ejemplo probamos con tomcat o jetty. Internamente Apache tuscany levanta un jetty.

Y Listo!!

Si vamos a esta url: http://localhost:8080/nornas/ws?wsdl deberíamos tener en wsdl de nuestro web server SOAP.
Si fueron observadores vieron que use varios bildings (solo lo hice para probarlos)

Les dejo las dependencias del pom para correr el ejemplo:

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-core-spi</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-policy-security</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-embedded</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-data-api</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.ws.security</groupId>
<artifactId>wss4j</artifactId>
<version>1.5.3</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-java-runtime</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-atom-abdera</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-rss-rome</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-ws-axis2</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-jsonrpc-runtime</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-rmi-runtime</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-implementation-resource-runtime</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-binding-http-runtime</artifactId>
<version>1.6</version>
</dependency>

<dependency>
<groupId>org.apache.tuscany.sca</groupId>
<artifactId>tuscany-host-jetty</artifactId>
<version>1.6</version>
</dependency>

Acabamos de hacer un servicio SOA con Apache Tuscany, muy fácil no?

Manual de Osgi

Gente en java hispano publicaron un manual de Osgi dejo el link:

http://www.javahispano.org/contenidos/archivo/14922/OSGI_Roberto_Montero.pdf

W3C

Yo no sabia la W3C tiene una serie de manueles basicos, cosas que hay que saber, css, seguridad, i18n, etc...

Les dejo el link: http://www.w3c.es/Divulgacion/

xForm

Buscando otra cosa por la pagina de la w3c, me encontré con esto:

¿Qué es XForms?

Es un nuevo lenguaje de etiquetado para formularios Web, diseñado para ser el sustituto de los formularios tradicionales HTML , y que va a permitir a los desarrolladores de formularios Web distinguir entre el propósito del formulario y su presentación. Esta separación clara entre contenido y presentación ofrece grandes ventajas en términos de:

• Reutilización: ya que los módulos XForms pueden reutilizarse independientemente de los datos que recogen
• Independencia de Dispositivo: gracias a que los controles de la interfaz de usuario son abstractos y sólo se indican sus características genéricas, lo que permite su representación en diferentes dispositivos
• Accesibilidad: al separar presentación y contenido la información está disponible de forma más sencilla para los usuarios que precisen de ayudas técnicas para la navegación en la Web.

¿Para qué sirve?

XForms puede hacer todo lo que hacen los formularios HTML, pero además permite:

• Comprobar automáticamente los valores de los datos mientras el usuario los introduce.
• Indicar que ciertos campos son obligatorios y que el formulario no podrá ser enviado sin esta información.
• Enviar formularios de datos como XML , ya que XForms es XML.
• La integración con Servicios Web, por ejemplo, usando SOAP y XML RPC.
• Enviar el mismo formulario a diferentes servidores (por ejemplo, la búsqueda de una palabra se envía a diferentes motores de búsqueda).
• Guardar y restaurar valores en y desde un archivo.
• Utilizar el resultado de un envío como entrada para un formulario posterior.
• Obtener los datos iniciales para un formulario a partir de un documento externo.
• Deducir valores desde otros valores presentes en el formulario, por ejemplo que el campo "cantidad total" contenga la suma de todas la compras individuales.
• Forzar valores para que aparezcan de determinada forma, por ejemplo obligando a que los valores estén comprendidos en un rango determinado.
• Construir formularios al estilo de "cesta de la compra" y "asistentes" sin necesidad de programar.
• Utilizar nuevos métodos de envío en comparación con los formularios HTML. Todos ellos son métodos HTTP estándar para enviar datos a través de la red.
• Mejorar la experiencia de los usuarios.
• Combinar tecnologías XML existentes.
• Lograr la Independencia de Dispositivo.
• Facilitar la creación de formularios complejos.

Me parecio una idea genial, nunca lo utilice pero va a solucionarme varios problemas.

Si quieren leer más : http://www.w3c.es/Divulgacion/GuiasBreves/XForms

HSQLDB, HyperSQL 2.0

 

HSQLDB (HyperSQL base de datos) es el principal motor de base de datos relacional SQL escrito en Java. Dispone de un controlador JDBC y apoya ANSI casi completa de SQL-92(formato de árbol BNF), además de muchos de SQL: 2008 las mejoras. Ofrece un pequeño motor de base de datos rápido que ofrece en memoria y un disco basado en tablas y tiene soporte incorporado y los modos de servidor. Además, incluye herramientas como una herramienta de línea de comandos SQL y herramientas de consulta GUI.

 

El producto está siendo utilizado como una base de datos y motor de persistencia en muchos proyectos Open Source Software y en proyectos comerciales y productos. En su versión actual es muy estable y fiable. Es mejor conocida por su pequeño tamaño, la capacidad de ejecutar completamente en la memoria, su flexibilidad y velocidad.

 

Versión 2.0 es compatible con la más amplia gama de características estándar SQL visto en ningún otro motor de fuente abierta de bases de datos. Hemos llegado a la conformidad con SQL estándar SQL casi lleno-1992 de nivel avanzado y SQL: 2008 las características de lenguaje básico más una extensa lista de SQL: 2008 y las características opcionales muchas extensiones. El motor es totalmente compatible con múltiples subprocesos y 2PL y modelos de control MVCC transacción.

 

Es totalmente gratuito para uso y distribución con licencia BSD estándar. Completamente libre de costo o restricciones y totalmente compatible con todas las principales licencias de código abierto. Código fuente de Java y una extensa documentación incluida.

 

Yo uso esta base para correr test que interactúan con base de datos. Si usamos maven agregamos la siguiente dependencia en el pom:

<dependency>

<groupId>hsqldb</groupId>

<artifactId>hsqldb</artifactId>

<version>1.8.0.10</version>

</dependency>

Y la configuramos con spring el dataSource:

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName" value="org.hsqldb.jdbcDriver" />

<property name="url" value="jdbc:hsqldb:mem:testDB" />

<property name="username" value="sa"/>

<property name="password" value=""/>

 

<property name="defaultAutoCommit">

<value>false</value>

</property>

 

<property name="poolPreparedStatements">

<value>true</value>

</property>

 

<property name="initialSize">

<value>1</value>

</property>

 

<property name="maxActive">

<value>90</value>

</property>

 

<property name="maxIdle">

<value>50</value>

</property>

</bean>

 

Y listo!!

Mapeos de Enums en Hibernate

Esta información fue provista por un amigo mío y del blog, Lucas Acosta

Cuando usamos Enum y tenemos que guardar con hibérnate podemos hacer lo que sugiere la documentación de hibérnate:

http://community.jboss.org/wiki/UserTypeforpersistinganEnumwithaVARCHARcolumn

Podemos guardar nuestro Enum en una columna como varchar:

import java.io.Serializable;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Types;

import org.hibernate.HibernateException;

import org.hibernate.usertype.UserType;

public class EnumUserType<E extends Enum<E>> implements UserType {

private Class<E> clazz = null;

protected EnumUserType(Class<E> c) {

this.clazz = c;

}

private static final int[] SQL_TYPES = {Types.VARCHAR};

public int[] sqlTypes() {

return SQL_TYPES;

}

public Class returnedClass() {

return clazz;

}

public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException, SQLException {

String name = resultSet.getString(names[0]);

E result = null;

if (!resultSet.wasNull()) {

result = Enum.valueOf(clazz, name);

}

return result;

}

public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index) throws HibernateException, SQLException {

if (null == value) {

preparedStatement.setNull(index, Types.VARCHAR);

} else {

preparedStatement.setString(index, ((Enum)value).name());

}

}

public Object deepCopy(Object value) throws HibernateException{

return value;

}

public boolean isMutable() {

return false;

}

public Object assemble(Serializable cached, Object owner) throws HibernateException

return cached;

}

public Serializable disassemble(Object value) throws HibernateException {

return (Serializable)value;

}

public Object replace(Object original, Object target, Object owner) throws HibernateException {

return original;

}

public int hashCode(Object x) throws HibernateException {

return x.hashCode();

}

public boolean equals(Object x, Object y) throws HibernateException {

if (x == y)

return true;

if (null == x || null == y) return false;

return x.equals(y);

}

}

Supongamos que tenemos este Enum:

public enum MyEnum {

ENUM_A, ENUM_B;

}

Hacemos el userType :

public class MyEnumUserType extends EnumUserType<MyEnum> {

  public MyEnumUserType() {
   super(MyEnum.class);
}

  
}

Y Por ultimo mapeamos:

<property name="sample" type="mypackage.MyEnumUserType" not-null="true"/>
   

Borrar base de datos en test!!

Cuando hacemos test de DAOs, servicios o que tenga que interactuar con una base de datos es bueno usar una base de datos en memoria como HSQLDB.

El problema está en que cada test inserta datos en la base, lo que hace que el resultado de un test dependa de la ejecución de otro test; esto no es bueno.

Si trabajamos con base de datos en memoria y Spring lo que podríamos hacer es bajarla y volverla a subir usando: @DirtiesContext en cada uno de los test. @DirtiesContext es una anotación de spring que baja y sube el contexto. Esto es una solución, pero no la más optima los test van a demorar más dado que por cada test se baja y sube el contexto. La solución más óptima es borrar la base en cada test de este modo:

@After
public void tearDown() {
this.restoreEmptyDatabase();
}

private void restoreEmptyDatabase() {
LocalSessionFactoryBean sessionFactory = (LocalSessionFactoryBean) this.applicationContext
.getBean("&sessionFactory");
sessionFactory.dropDatabaseSchema();
sessionFactory.createDatabaseSchema();
}

Podríamos ponerlo en el After o Before es indistindo este método borrara la base por test.

Reflexiones sobre los problemas del desarrollo orientado a pruebas

Muy recomendable que lean el siguiente post:

http://agilizar.es/blog/11/03/2010/reflexiones-sobre-los-problemas-del-desarrollo-orientado-a-pruebas/

Publico este enlace dado que comparto en todo la opinión TDD no llego para solucionarnos TODOS nuestros problemas. Solo es una herramienta para mejorar nuestro código.

Apache ActiveMQ

Antes de comenzar a hablar de ActiveMQ debemos entender JMS. JMS trata sobre la comunicación de aplicaciones de forma asíncrona. Funciona de forma similar que un mail, JMS envía el mensaje a la aplicación sin esperar que la reciba la otra aplicación.

La vía indirecta es la clave de JMS. Cuando una aplicación envía información a otra mediante JMS, no hay vínculo directo entre ambas aplicaciones. En su lugar, la aplicación emisora coloca el mensaje en manos de un servicio que garantiza su entrega a la aplicación receptora. Hay dos conceptos principales en JMS: corredor de mensajes (message brokers) y destinos (destinations)

Apache ActiveMQ es un estupendo message brokers de código abierto y una maravillosa opción para la mensajería asíncrona con JMS. Aunque ActiveMQ comenzó como un proyecto de CodeHaus, se traslado a Apache.

Apache ActiveMQ es rápido, soporta varios lenguajes Java, C, C++, C#, Ruby, Perl, Python, PHP, soporte a Enterprise Integration Patterns, integración con spring, y se distribuye bajo licencia Apache 2.0 License

Dejo links:

http://java.sun.com/products/jms/

http://activemq.apache.org/index.html

El sector de la construcción y la informática