sábado, 28 de noviembre de 2009

Spring Roo

Spring Roo viene a ser la alternativa Spring a Ruby on Rails o Grails. Es decir, un framework creado bajo los principios de convención frente a configuración y que aprovecha al máximo Java y Spring.

Ni que decir tiene que el framework está totalmente centrado en torno a Spring, Maven, JPA, muchas anotaciones, el soporte de REST de Spring 3.0 y AspectJ, siendo este último lo que se utiliza para introducir el llamemos "dinamismo" en la aplicación. La verdad es que me parece muy interesante.

Si leemos las características en http://www.springsource.org/roo, nos llama la atención que por ejemplo:
  • Se puede construir aplicaciones en 10 minutos.
  • 100% programado en java, no es necesario cambiar de lenguaje.
  • Eficiencia
  • Implementación de las mejores prácticas de spring 3
  • Basado en maven 2, jpa (hibérnate) ,
  • Incluye soporte para configuración de base de datos
  • Incluye test automáticos de jUnit y test web con Selenium
  • Aplicación backend basada en RESTfull
  • Integración con Spring security
  • URL amigables, url RESTfull
  • Soporte para Scripting

Spring Integration

Spring Integration es una nueva extensión de Spring Framework, el popular framework Java de aplicaciones. Spring Integration brinda una extensión a Spring para soportar los Patrones de Integración Corporativos (Enterprise Integration Patterns), ampliamente conocidos en el desarrollo de aplicaciones JEE.

El sitio web dos ideas publico un tutorial de este framework.

sábado, 21 de noviembre de 2009

Inyección de dependencia


Lo prometido es deuda, vamos a hacer un ejemplo de inyección de dependencia bastante simple usando como framework spring. Spring no es el único framework de Inyección de Dependencia, pero es sin duda el más usado.
Vamos a los bifes!!! Vamos a hacer un servicio que salude. Antes de empezar a escribir el servicio vamos a hacer una interfaz que lo describa.

package com.ejemplo;

public interface SaludadorService {

String saludar();
}

Esto, por que lo hacemos? Cuando nosotros queramos usar nuestro servicio vamos a usar esta interfaz, de esta forma si cambia la implementación, no vamos a necesitar cambiar el código.
Implementemos la interfaz!!!

package com.ejemplo;

/**
* Implementación de SaludadorService
*
* @author Emanuel
*/
public class SaludadorServiceImpl implements SaludadorService {

private String saludo;

public void setSaludo(String saludo) {
this.saludo = saludo;
}

public SaludadorServiceImpl() { }

public SaludadorServiceImpl(String saludo) {
this.saludo = saludo;
}
@Override
public String saludar() {
return saludo;
}
}


Bastante simple, ahora debemos hacer a configurar el xml para que spring sepa que inyectar.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<bean id="saludador" class="com.ejemplo.SaludadorServiceImpl" >
<property name="saludo" value="Holasss !! " />
</bean>
</beans>


Ahí inyectamos el valor “Holasss !!” a la propiedad saludo por medio del set, es decir spring va a hacer lo siguiente:

SaludadorServiceImpl saludador = new SaludadorServiceImpl();
saludador.setSaludo("Holasss !! ");

Podriamos haberlo hecho por constructor de la siguiente forma:

<bean id="saludador" class="com.ejemplo.SaludadorServiceImpl" >
<constructor-arg index="0" value=" Holasss !! " />
</bean>

Podemos discutir todo un día cual es mejor si inyectar por set o constructor. Yo personalmente uso por set. Ustedes usen el que le parezca.
Ahora vamos a usar nuestro bean:

/**
* @author Emanuel
*
*/
public class Principal {

public static void main(String[] args) {
BeanFactory fabrica = new XmlBeanFactory(new FileSystemResource("bean.xml"));
SaludadorService saludador = (SaludadorService)fabrica.getBean("saludador");
System.out.println(saludador.saludar());
}
}

Y Listo!!

Si fueron observadores yo construyo una fabrica con un archivo xml donde declare el bean. Además uso la interfaz de esta forma el día de mañana quiero cambiar la implementación , lo pueda hacer sin problema, sin modificar código solo tocando el xml.

Además use spring solo como fabrica de beans, no como contenedor, como contenedor es más potente. Pero esto es otra historia...




domingo, 15 de noviembre de 2009

JNA

JNA es un framework que nos facilita las tareas con dll; es decir nos hace más fácil jni.
Alguien que leyo, vio, trabajo o se pregunto que es jni; debe haberse dado cuenta que es complejo. Esta complijida se ve disminuida casi a 0 con JNA.

Parece publicidad barata pero es verdad. Si te digo que con una interfaz podes usar funciones que se encuentran en una dll?

Mira, tengo la siguiente dll:

// dllParaPruba.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"


extern "C"
{
//---------------------------------------------------------------------------
double __declspec(dllexport) multiplicar(double a, double b)
{
return a * b;
}
//---------------------------------------------------------------------------
double __declspec(dllexport) sumar(double a, double b)
{
return a + b;
}

//---------------------------------------------------------------------------

double __declspec(dllexport) potencia(double a, double n)
{
double acumulador = 1;
for (int i = 0; i <>
acumulador*=a;
}

return acumulador;
}
}

Y yo desde java quiero leerla y usarla, bueno tengo que escribir la siguiente interfaz:

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;

/**
*
* @author Emanuel
*/
public interface EjemploJNA extends Library {

EjemploJNA INSTANCE = (EjemploJNA)
Native.loadLibrary("dllParaPruba",
EjemploJNA.class);

double multiplicar(double a, double b);

double sumar(double a, double b);

double potencia(double a, double b);
}

Bueno ahora vamos hacer un test:

import org.junit.Test;
import static org.junit.Assert.*;
/**
*
* @author Emanuel
*/
public class EjemploJNATest {

static {
System.load("pathDondeSeEncuentraMiDll\dllParaPruba.dll");
}

@Test
public void sumar(){
double resultado = EjemploJNA.INSTANCE.sumar(2.3, 4.5);
assertEquals(new Double(resultado), new Double(6.8));
}

@Test
public void multiplicar(){
double resultado = EjemploJNA.INSTANCE.multiplicar(2.3, 4.5);

assertEquals(new Double(resultado), new Double(10.35));
}

@Test
public void potencia(){
double resultado = EjemploJNA.INSTANCE.potencia(2, 4);

assertEquals(new Double(resultado), new Double(16));
}

}

Listo!!

Que lo pario dijo mendieta!!

Una cosa me queda por aclarar es que compile la dll con el compilador de borland y no me fue muy bien, explotaba (no se bien por que) use el de microsoft y no hubo problema.

El que quiera más info dejo el link: https://jna.dev.java.net/

Y para toda la gente linda que usa maven la entrada en el pom:

<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>3.2.2</version>
</dependency>

Saludos!!!

domingo, 8 de noviembre de 2009

¿Quién necesita un arquitecto?

Como ya dije antes dos ideas es una pagina web muy buena, mezcla lo técnico con lo metodológico de una forma muy buena. Hoy quiero aconsejarles que lean este articulo :


Describe el rol de un arquitecto de software.

sábado, 7 de noviembre de 2009

Apache Solr

Solr es un servidor de búsquedas basado en Lucene, contiene Apis de comunicación xml/http y JSON. Entre otras características: es liviano, tiene cache, replicable y trae una interfaz web para administrarlo.


El modo de distribución es un war el cual nosotros deployeamos en nuestro web conteiner (jetty, tomcat o otro) y listo!


Vamos al browser y ponemos por ejemplo http://localhost:8080/solr (si lo deployearon como solr) y hay va aparecer la interfaz web para configurarlo.


Solr provee diferentes clientes para casi todas las plataformas:

· Ruby - SolRuby

· PHP - SolPHP

· Java - SolJava

· Python - SolPython

· JSON - SolJSON

· .Net - solrnet

  • C#

o SolrSharp

o Deveel Solr Client

  • Perl

o SolPerl

o Solr.pm

· JavaScript

o AJAX Solr.


Dejo links:

http://lucene.apache.org/solr/

http://wiki.apache.org/solr/

domingo, 1 de noviembre de 2009

RESTEasy

Es un proyecto de jboss que provee una implementación a jsr 311. Este proyecto contiene un conjunto de frameworks que nos facilitan el desarrollo con web services rest.

Jsr 311 nos permite desarrollar y publicar web services rest con anotaciones, vean que fácil es:

@Path("/library")

public class Library {

@GET

@Path("/books")

public String getBooks() {...}

@GET

@Path("/book/{isbn}")

public String getBook(@PathParam("isbn") String id) {

// search my database and get a string representation and return it

}

@PUT

@Path("/book/{isbn}")

public void addBook(@PathParam("isbn") String id, @QueryParam("name") String name) {...}

@DELETE

@Path("/book/{id}")

public void removeBook(@PathParam("id") String id {...}

}

Recuerden que los web services rest no tienen un descriptor wsdl como los soap, sino que lo que describe a los servicios rest en la url y el método por donde se aceden.

@PUT, @DELETE, @GET, etc decimos el método y con @Path indicamos el path donde esta publicado.

RESTeasy puede ejecutarse sobre cualquier contenedor web.