Ormlite: Motor Java de mapeo objeto-relacional muy ligero

Alguno se preguntará si con JPA, MyBatis, Hibernate,… (ver post Comparando IBatis, Hibernate y JPA) tiene sentido un motor de este estilo.

En su momento ya intentamos responder a esta pregunta con este post: Persistencia KISS: Persistencia sin JPA, ni Hibernate ni IBatis en el que hablábamos de Persist, Siena y SequaLite.

En este caso hablaremos de ormlite que ofrece funcionalidades muy similares y aún sigue en desarrollo (por desgracia no puede decirse lo mismo de Persist o Siena :)).

Otro punto interesante de ormlite es que tiene una versión para Android y que es muy ligero, por lo que en algunos escenarios puede ser más apropiado que un Hibernate.

Las funcionalidades principales de ormlite son:

· Muy ligero: se compone de 2 jars:

ormlite-jdbc-4.47.jar

ormlite-core-4.47.jar

· Configuración de clases con anotaciones Java simples

· Soporte de DAO

· QueryBuilder para queries simples y complejas

· Soporte bases de datos: MySQL, Postgres, Microsoft SQL Server, H2, Derby, HSQLDB, y Sqlite

· Soporte provisional para DB2, Oracle, ODBC yNetezza.

· Soporte básico para transacciones

· Autoconfiguración

· Soporte configuración sobre Spring

  • Soporte nativo Android SQLite API

La forma de usarlo es:

· Anoto las clases que representan tablas y campos:

Podemos ver como se mapean campos y tablas, ids,…

· Y a usarlo:

Aunque su documentación no es muy extensa es más que suficiente: http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite.html y además incluye un gran número de ejemplos.

CodeMirror: Un editor de código fuente en Javascript

(Espero llegar a tiempo Pedro :D)

CodeMirror es un editor Javascript de código fuente open-source (licencia MIT).

Aunque hay algunos más completos (como ACE), CodeMirror ofrece características más que suficientes para la mayoría y es muy sencillo de usar.

Y cuando digo sencillo es que es muy sencillo (sólo un js J):

Para haceros una idea muy rápidamente podéis jugar con los ejemplos embebidos que trae:

Entre sus principales características:

· Soporte out-of-the-box de más de 60 lenguajes (entre ellos Java, Groovy, Javascript,…)

· Autocompletado

· Sistema para componer languajes

· Temas

· Split Views

· Mezclado de fuentes

· Addons

· API

Su documentación es correcta y más que suficiente para usar con sus ejemplos.

Si no os convence en estas páginas podéis encontrar una comparativa de diferentes editores de código fuente:

http://en.wikipedia.org/wiki/Comparison_of_JavaScript-based_source_code_editors

Podéis descargar su última versión (3.2.0) desde este link o incluso generar un JS minimizado online:

Publicado Spring Reactor 1.0 GA

Spring acaba de publicar la primera versión estable (GA) de Spring Reactor que es la propuesta de Spring para desarrollar aplicaciones reactivas a eventos con baja latencia y alto throughput sobre la JVM (capaces de soportar cientos de miles de eventos por segundo o millones según sus creadores).

Reactor se basa en el patrón Reactor y también en el modelo de Actores (el que usa Akka) además de en la programación tradicional event-callback.

Reactor forma parte de Spring pero no tiene dependencias de este, ya que sólo depende de SLF4J y de la librería LMAX Disruptor.

Reactor puede programarse en Java o Groovy y está pensada para ser extensible.

Además está pensada para usarse sobre Java 8. Veamos un ejemplo con funcionalidades Lambda:

Que en Java 6/7 quedaría:

Y en Groovy:

En este post podéis leer algo más sobre Reactor.

Aquí podéis encontrar unos ejemplos: https://github.com/reactor/reactor-samples y un Quick Start: https://github.com/reactor/reactor-quickstart

Aparte de Spring Reactor podéis echarle un ojo a la solución de Netflix (los mismos de Hystrix :D) a esta problemática: RxJava

¿Qué es OpenCV?

OpenCV (Open Source Computer Vision) es una librería software open-source de visión artificial y machine learning.

OpenCV provee una infraestructura para aplicaciones de visión artificial.

OpenCV tiene una licencia BSD, lo que permite utilizar y modificar el código, tiene una comunidad de más de 47000 personas y más de 7 millones de descargadas. Es una librería muy usada a nivel comercial, desde Google, Yahoo, Microsoft, Intel, IBM, Sony, Honda, Toyota, Applied Minds, VideoSurf, Zeitera…

La librería tiene más de 2500 algoritmos, que incluye algoritmos de machine learning y de visión artificial para usar.

Estos algoritmos permiten identificar objetos, caras, clasificar acciones humanas en vídeo, hacer tracking de movimientos de objetos, extraer modelos 3D, encontrar imágenes similares, eliminar ojos rojos, seguir el movimiento de los ojos, reconocer escenarios,…

Se usa en aplicaciones como la detección de intrusos en vídeos, monitorización de equipamientos, ayuda a navegación de robots, inspeccionar etiquetas en productos,…

OpenCV está escrito en C++, tiene interfaces en C++, C, Python, Java y MATLAB interfaces y funciona en Windows, Linux, Android y Mac OS. O

Los Javeros podéis empezar por aquí: http://docs.opencv.org/2.4.4-beta/doc/tutorials/introduction/desktop_java/java_dev_intro.html

En ejemplo sencillo:

Si os animáis podéis comenzar por su User Guide en la documentación

Viskit.js: Librería Javascript para Charts

Viskit.jses una librería Javascript de Charting con licencia Apache 2 y mantenida por WSO2 (la usan en sus productos), además de para crear los charts (DataProviders) integra la parte de filtrado (DataFilters) y la persistencia en local para datos temporales.

Viskit realmente no es un motor, si no que usa diferentes librería y ofrece un mecanismo de plugins: actualmente usa: Raphael – http://g.raphaeljs.com/, Protovis – http://mbostock.github.com/protovis/, JQPlot – http://www.jqplot.com/, InfoVis – http://thejit.org/ y Sencha Touch Charts – http://www.sencha.com/products/touch/charts

Usar Viskit es muy sencillo:

Incluir librería y

<script type="text/javascript" language="javascript" src="/Viskit/js/Viskit.js"></script>

Crear el chart:

Los ejemplos os pueden dar una visión más clara de lo que ofrece: http://www.nuwanbando.com/Viskit/examples/

Podéis leer más sobre Viskit.js en su página y ver cómo configurar las propiedades, crear conversores, extender Viskit.js, usar persistencia local, establecer pull, filtros,…

PI4J, control del GPIO de Raspberry Pi con Java

PI4J es un proyecto que provee un puente entre librerías nativas y Java para ganar acceso a los pines de comunicación GPIO del Raspberry PI.

Los autores de las librerias nos recuerdan que es un proyecto joven, en constante cambio, y nos alentan a probar las versiones snapshot, cosa que haremos.
 

Que es GPIO


El conector GPIO del PI es un interfaz en forma de serie de pines al cual enchufar hardware externo:

Las funciones de estos pines son las siguientes:

  • GPIO Real (General Purpose Input Output) pines para controlar leds, etc
  • El interfaz I2C permite conectar módulos controlados con tan solo dos pines
  • Interfaz SPI un estándar alternativo al I2C
  • Pines Rx and Tx comunicación con dispositivos en serie
  • PWM control de dispositivos como pueden motores y servos

 

Preparativos


Partimos de una instalación básica de Raspberry Pi

https://unpocodejava.wordpress.com/2013/07/05/java-en-un-raspberry-pi-desde-cero-2/

Incluyendo la instalación de la versión 1.8.0 de Java, que vendrá muy bien.

Aunque Java 1.7 dice no ser compatible sobre el sistema operativo Raspbian “wheezy” (se sugiere la alternativa “wheezy” soft-float), parece que a versión Java 1.8 no ha dado ningún tipo de problemas con el Wheezy. De modo que nos mantenemos en esta versión.

Pi4J implementa un envoltorio JNI de la librería WiringPI https://projects.drogon.net/raspberry-pi/wiringpi/

image032 image033

Y utiliza esta numeración de pines (que abstrae la numeración hardware, para mantenerla constante en caso de cambios)
 

Preparar Java

Para completar la instalación JDK del post anterior, le indicaremos al sistema donde está localizada la JVM.
>sudo update-alternatives –install “/usr/bin/java” “java” “/opt/jdk1.8.0/bin/java” 1

Indicamos al sistema cual es la JDK por defecto.
>sudo update-alternatives –set java /opt/jdk1.8.0/bin/java

Configuramos la variable de entorno JAVA_HOME en el entorno
>sudo nano /etc/environment

y añadimos

JAVA_HOME="/opt/jdk1.8.0"

Despues editar
>sudo nano ~/.bashrc
y añadir

export JAVA_HOME="/opt/jdk1.8.0"
export PATH=$PATH:$JAVA_HOME/bin

>sudo reboot

 

Configuración


En el PI descargamos una copia del último paquete de instalación
>wget http://pi4j.googlecode.com/files/pi4j-0.0.5.deb

Lo descomprimimos e instalamos
>sudo dpkg -i pi4j-0.0.5.deb

Los paquetes instalados irán a las rutas

/opt/pi4j/lib
/opt/pi4j/examples

Es necesario incluir el directorio lib en el classpath de java, como veremos más adelante. Los ejemplos se pueden compilar con
>cd /opt/pi4j/examples
>./build

 

Instalación


Aparte del PI necesitaremos:

Y lo conectamos todo de este modo:

image0041

image005

 

Ejemplo de Salida


Aquí hay un ejemplo para controlar el led mediante la salida GPIO_01

>sudo nano ControlGpioExample

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;
/**
 * Ejemplo encendido/apagado de un led
 */
public class ControlGpioExample {

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

 System.out.println("<--Pi4J--> GPIO Control Example ... started.");

  // crear controlador gpio
 final GpioController gpio = GpioFactory.getInstance();

 // provisionar pin #01 como output y encenderlo como estado inicial
 final GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.HIGH);
 System.out.println("--> GPIO state: ON");

 Thread.sleep(5000);

 // apagarlo gpio pin #01
 pin.low();
 System.out.println("--> GPIO stat: OFF");
 Thread.sleep(5000);
 // cambiar al estado contrario (should turn on)
 pin.toggle();
 System.out.println("--> GPIO state: ON");
 Thread.sleep(5000);
 // toggle (should turn off)
 pin.toggle();
 System.out.println("--> GPIO state: OFF");

 Thread.sleep(5000);
 // encender gpio pin #01 1 segundo y apagar
 System.out.println("--> GPIO state: ON 1 second");
 pin.pulse(1000, true); // set second argument to 'true' use a blocking call

 // acabar con todos los hilos del controlador gpio
 gpio.shutdown();
 }
}


Salvamos y compilamos con la orden
>javac -classpath .:classes:/opt/pi4j/lib/'*' -d . ./ControlGpioExample.java

aparecerá el .class

y ejecutamos
>sudo java -classpath .:classes:/opt/pi4j/lib/'*' ControlGpioExample

Si todo ha ido bien el led se encenderá y apagará 3 veces

 

Desarrollo en PC


Aunque podemos compilar en el raspberry pi
>javac -classpath .:classes:/opt/pi4j/lib/'*' ...

Es mejor optar por la ventaja multiplataforma de java y desarrollar y compilar en un PC de desarrollo con eclipse.

Para ello podemos importar las librerías

O montar un proyecto maven con el repositorio en el POM.XML

<repositories>
 <repository>
 <id>oss-snapshots-repo</id>
 <name>Sonatype OSS Maven Repository</name>
 <url>https://oss.sonatype.org/content/groups/public</url>
 <snapshots>
 <enabled>true</enabled>
 <updatePolicy>always</updatePolicy>
 </snapshots>
 </repository>
</repositories>

Y las dependencias

<dependency>
 <groupId>com.pi4j</groupId>
 <artifactId>pi4j-core</artifactId>
 <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
 <groupId>com.pi4j</groupId>
 <artifactId>pi4j-gpio-extension</artifactId>
 <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
 <groupId>com.pi4j</groupId>
 <artifactId>pi4j-device</artifactId>
 <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
 <groupId>com.pi4j</groupId>
 <artifactId>pi4j-example</artifactId>
 <version>1.0-SNAPSHOT</version>
</dependency>

 

Otros Ejemplos


Con Pi4J podemos realizar lectura asíncrona de señales

// provision gpio pin #02 as an input pin with its internal pull down resistor enabled
 final GpioPinDigitalInput myButton = gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN);
 // create and register gpio pin listener
 myButton.addListener(new GpioPinListenerDigital() {
 @Override
 public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
 // display pin state on console
 System.out.println(" --> GPIO PIN STATE CHANGE: " + event.getPin() + " = " + event.getState());
 }

 });

Crear triggers que realizan callbacks y redirección de señales entre pines

// provision gpio pin #02 as an input pin with its internal pull down resistor enabled
 final GpioPinDigitalInput myButton = gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN);
 // create and register gpio pin listener
 myButton.addListener(new GpioPinListenerDigital() {
 @Override
 public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
 // display pin state on console
 System.out.println(" --> GPIO PIN STATE CHANGE: " + event.getPin() + " = " + event.getState());
 }

 });

Lectura y escritura del puerto serie

// create an instance of the serial communications class
 final Serial serial = SerialFactory.createInstance();
 // create and register the serial data listener
 serial.addListener(new SerialDataListener() {
 @Override
 public void dataReceived(SerialDataEvent event) {
 // print out the data received to the console
 System.out.print(event.getData());
 } 
 });

 // open the default serial port provided on the GPIO header
 serial.open(Serial.DEFAULT_COM_PORT, 38400);

 // write a formatted string to the serial transmit buffer
 serial.write("CURRENT TIME: %s", new Date().toString());

En el javadoc y los ejemplos podemos encontrar más operaciones, como definición de estados en caso de shutdown, obtener información de la placa, creación de pulsos de amplitud modulada (PWM) , etc.

 

Referencias


http://pi4j.com
https://projects.drogon.net/raspberry-pi/wiringpi/

Cuando pensábamos que nunca llegaría: Log4J 2

Cuando muchos pensábamos que nunca llegaría…..

Apache Log4j 2 es una actualización de Log4J con mejoras significativas sobre Log4J 1.X, incluye muchas de las mejoras que se implementaron en LogBack y solucionando algunos de los problemas de este.

Algunas de las características de Log4J 2 (podía haber llegado algo antes, que muchas de estas nos tocó implementarlas a medida!) son:

· Separación de API

· Configuración más sencilla:

Incluso se puede configurar en JSON:

· Mejora de rendimiento con Loggers asíncronos basados en la librería LMAX Disruptor

· Recarga de configuración automática

· Filtering avanzado

· Arquitectura de Plugins

· Soporte de properties: como lo he echado de menos!!!

Otras consideraciones:

· Log4J 2 requiere Java 6.

· El API de Log4J 2 no es compatible con Log4J 1.X aunque existe una adaptador que permite usar el API de Log4J 1.X

· Existen adaptadores para commons-logging y para SLF4J.

PrimeUI: una gran suite de componentes Javascript sobre JQuery

PrimeUI es una colección de widgets Javascript basados en JQuery UI con licencia Apache, diseñados para ser muy fáciles de usar, trabajar con JSON y renderizado progresivo en el cliente.

PrimeUI usa jQuery UI WidgetFactory APIs de modo que los widgets se proven como jQuery Plugins.

PrimeUI surge como un spin-off de la suite de components JSF PrimeFaces que pudieran usarse desde otros frameworks.

En su web podéis probar toda la suite de componentes que ofrecen, como:

Galería:

Rastro:

Dropdown:

Growl: para mostrar mensajes en un overlay

Menús:

Rating,

Y muchos más.

Diría que PrimeUI es una librería muy interesante para todos los usuarios de JQuery ya que ofrece una completa suite de componentes, ya integrada, usable, documentada, con ejemplos,…

La última versión es la 0.9 que podéis descargar desde aquí: http://www.primefaces.org/downloads.html#primeui

JSR 353 – Java API for JSON Processing (JSON-P)

En Java EE 7 se publicarán un conjunto de APIs para procesar JSON.

Este estándar se denomina JSR 353 – Java API for JSON Processing (JSON-P).

Estando donde estamos, con librerías ya establecidas como GSON, JSON-Simple, Jackson no parece que el enfoque seguido sea el mejor (o al menos el más usable), y si no veamos,

Como generar JSON:

Leer más

Publicado en Java, Librerías. 1 Comment »

¿Qué es Jubatus?

Jubatus es un framework/librería open source para machine learning, aún en fase temprana pero muy prometedora:

Ofrece:

· Librería Machine Learning Online: Classification, Regression, Recommendation, Graph Mining, Anomaly Detection

· Conversor: preproceso de datos y extracción de features

· Framework Machine Learning distribuido online con tolerencia a fallos

Surge para dar soporte a análisis de datos en tiempo real, por ejemplo detección de anomalías en sensores M2M o demanda de energía:

En estos escenarios no encajan las soluciones actuales basadas en Hadoop (mahout), ya que ofrecen un aprendizaje Batch donde se escanean todos los datos antes de construir el modelo y estos datos se almacenan:

Jubatus ofrece aprendizaje online, donde el modelo se actualiza con cada dato:

Las ventajas del aprendizaje online son:

· Baja latencia

· Alto rendimiento

· No necesita almacenar grandes datasets

Comparando escenarios de uso tendríamos:

Jubatus ofrece librerías cliente para C++, Python, Ruby o Java. En el caso de Java añadiríamos a nuestro proyecto de Eclipse:

Dentro de Jubatus se ofrecen una serie de ejemplos de algoritmos en diferentes lenguajes:

Leer más

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 407 seguidores

%d personas les gusta esto: