Monday, February 13, 2017

Migrar documentos de MongoDB a Couchbase con jmoordb

Migrar documentos de MongoDB a Couchbase con jmoordb

Los pasos son:

  • Definir el Entity
  • Definir el Facade MongoDB
  • Definir el Facade Couchbase
  • Definir el Provider para MongoDB
  • Definir el Provider para Couchbase




Definimos el Entity
@Getter
@Setter
public class Planetas {

    @Id
    private String idplaneta;
    private String planeta;
    @Ignore
    private Date fecha;

    public Planetas() {
    }

    public Planetas(String idplaneta, String planeta, Date fecha) {
        this.idplaneta = idplaneta;
        this.planeta = planeta;
        this.fecha = fecha;
    }

 

}


Definir el facade MongoDB

public class PlanetasFacade extends AbstractFacade<Planetas> {
 MongoClientProvider mongoclientProvider = new MongoClientProvider();
    public PlanetasFacade() {
        super(Planetas.class, "fantasy", "planetas");
    }

    @Override
    protected MongoClient getMongoClient() {
       return mongoclientProvider.getMongoClient();
    }

   @Override
    public Object findById(String key, String value) {
       return search(key,value);
    }

    @Override
    public Object findById(String key, Integer value) {
        return search(key,value);
    }

}


Definir el Facade Couchbase

public class PlanetasFacade extends CouchbaseAbstractFacade<Planetas> {
 CouchbaseClientProvider couchbseclientProvider = new  CouchbaseClientProvider();
    public PlanetasFacade() {
        super(Planetas.class, "planetas", "planetas");
    }

    @Override
    protected Cluster getCluster() {
    return  couchbseclientProvider.getCluster();
    }

     @Override
    public Object findById(String key, String value) {
        return search(key, value);
    }

    @Override
    public Object findById(String key, Integer value) {
        return search(key, value);
    }


}


Definir la clase MongoClientProvider

public class MongoClientProvider {

    private MongoClient mongoClient = null;

    public MongoClient getMongoClient() {
        mongoClient = new MongoClient();
        try {
       
        } catch (Exception e) {
            System.out.println("getMongoClient() " + e.getLocalizedMessage());
        }
        return mongoClient;
    }

}

Definir la clase CouchbaseClientProvider

public class CouchbaseClientProvider {
private Cluster cluster;


    public Cluster getCluster() {
           CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()
                    .connectTimeout(10000) //10000ms = 10s, default is 5s
                    .build();
            cluster = CouchbaseCluster.create("localhost");
        return cluster;
    }


}


Código para ejecutar la migración


  com.migrador.couchbase.ejb.PlanetasFacade planetascouchbaseFacade = new PlanetasFacade() ;
            com.migrador.mongodb.ejb.PlanetasFacade planetasmongodbFacade = new com.migrador.mongodb.ejb.PlanetasFacade() ;
            
            List<Planetas> list = planetasmongodbFacade.findAll();
            if(!list.isEmpty()){
                list.forEach((p) -> {
                    planetascouchbaseFacade.save(p,false);
                });
            }

Base de datos en MongoDB



Couchbase después de la migración:






Friday, February 03, 2017

jmoordb 0.1.9.2


jmoordb

Libro:
https://avbravo.gitbooks.io/jmoordb/content/

Jmoordb es un Object Document Mapper para Java que soporta bases de datos NoSQL (MongoDB ,OrientDB,Couchbase).

Es un Framework orientado a desarrolladores Java, ya que pueden interactuar con bases de datos NoSQL desde su código Java, para los expertos en NoSQL permite interactuar desde Java con la sintaxis de NoSQL de la base de datos que utiliza, para los expertos que vienen del mundo relacional permite ejecutar instrucciones SQL que son convertidas a instrucciones NoSQL.


  • Ofrece una sintaxis similar a JPA
  • Permite el uso de Objetos java para operaciones CRUD
  • Permite el uso de Document para operaciones con las colecciones de documentos
  • Ofrece un soporte para SQL
  • Soporta Java 8
  • Soporta Anotaciones
  • Soporta Beans Validation (JSR 349)
  • Soporta documentos embebidos
  • Soporta documentos referenciados
  • Definición sencilla de Entitys
  • Métodos para operaciones de creación, eliminación, actualización , búsquedas avanzadas.

Esta basado en: Driver Java para MongoDB, Couchbase, OrientDB
Forma de uso muy sencillo:
Definir un Entity:
@Getter
@Setter
public class Planetas {
  @Id
  private String idplaneta;
  private String planeta;
  @Ignore
  private Date fecha;
  public Planetas() {
  }
}
En el controller invocar los métodos del facade:

planetasFacade.save(planetas);
Con esto generados el documento que es almacenado en la base de datos NoSQL
Planetas{ "_id" : ObjectId("587cf876a6cca92842bf2ea9"),
"idplaneta" : "tr",
"planeta" : "Tierra"
}

Tuesday, January 31, 2017

Dos interesantes Articulos sobre Java Script

En Toptal podemos encontrar dos excelentes artículos:
Gulp: A Web Developer's Secret Weapon for Maximizing Site Speed
En donde se muestra el proceso de automatización y optimización con Gulp.js

Este otro articulo

Immutability in JavaScript using Redux

Muestra el proceso de crear Actions, usar inmutables librerías.
Ambos son excelentes articulos para analizar.



Tuesday, January 24, 2017

Why You Need to Upgrade to Java 8 Already

Why You Need to Upgrade to Java 8 Already, enlace https://www.toptal.com/java/why-you-need-to-upgrade-to-java-8-already

Los amigos de Toptal han publicado un interesante articulo sobre Java 8,  se tratan temas interesantes:


  • Lambda expressions.
  • Stream API for working with Collections.
  • Asynchronous task chaining with CompletableFuture.
  • Brand new Time API.

Ejemplo de implementación de  funciones 

(Integer i1, Integer i2) -> i1 % 2 - i2 % 

Descripción de métodos referenciados, Stream APi

books.stream()
       .filter(book -> book.year > 2005)  // filter out books published in or before 2005
       .map(Book::getAuthor)              // get the list of authors for the remaining books
       .filter(Objects::nonNull)          // remove null authors from the list
       .map(Author::getName)              // get the list of names for the remaining authors
       .forEach(System.out::println);     // print the value of each remaining element



Sin duda un excelente articulo de referencia que muestra las principales características de Java8.




Friday, January 13, 2017

Definir un Entity Simple en JGMongo

Definir un Entity Simple en JGMongo

Un Entity representa el documento en MongoDB, por lo que debemos describir su estructura en Java.
Reglas

  •  La clase debe extender de GenericsBeans
  •  Implementar @Getter /@Setter
  •  El atributo  @SerializedName("") es opcional, lo usamos cuando los nombres de campo (key) en el documento son diferentes a los nombres de propiedades
  • @Id idenficar el PrimaryKey
  •  Crear método toDocument() para convertir de Java o Document
  •  Crear método toPojo()

Contamos con un documento llamado Pais:
{
  "_id" : ObjectId("57bc789da6cca9237822eafb"),
  "Siglas" : "1",
  "Pais" : "Name1",
  "Logo" : "--"
}
Representación visual:

Si observa el nombre de campos (key) inician con la primera letra en mayúsculas,  y nuestros Entity deben iniciar con la primera letra en minúsculas.
MongoDB("Siglas"
Java(siglas)
Por lo tanto debemos indicar cual es el nombre del campo en el documento en este caso usamos la anotación : @SerializedName( colocar el nombre del documento), si este campo inicia en minúsculas o es el mismo que el atributo en nuestra clase en java no es necesario especificarlo.
     @SerializedName("Siglas")
       private String siglas;

Llave Primaria @Id
Si es el campo que usamos como llave primaria agregamos la anotación @Id.

Crear el método toDocument() que devolverá un Documento en base al objeto Java.

 public Document toDocument(Paises paises) {
       return toDoc(paises);
 }


Crear el método toPojo que recibe un Documento y lo convierte a objeto Java

public Paises toPojo(Document doc) {
        return (Paises) toJava(doc, new Paises().getClass());
    }


Ejemplo 1: 
Nombres de campo en MongoDB diferentes a nombres de atributos de clases en Java.

import com.google.gson.annotations.SerializedName;
import com.jgmongo.anotaciones.Id;
import com.jgmongo.services.GenericBeans;
import lombok.Getter;
import lombok.Setter;
import org.bson.Document;

/**
 *
 * @author avbravo
 */
@Getter
@Setter
public class Paises extends GenericBeans {

    @Id
    @SerializedName("Siglas")
    private String siglas;
    @SerializedName("Pais")
    private String pais;
    @SerializedName("Logo")
    private String logo;

    public Document toDocument(Paises paises) {
          return toDoc(paises);
    }

    public Paises toPojo(Document doc) {
       return (Paises) toJava(doc, new Paises().getClass());
    }

    @Override
    public String toString() {
        return "Paises{" + "siglas=" + siglas + ", pais=" + pais + '}';
    }
}


Ejemplo 2: 
Nombres de campo en MongoDB iguales a nombres de atributos de clases en Java. No es necesario utilizar la anotación  @SerializedName("")
Paises:
{
  "_id" : ObjectId("57bc789da6cca9237822eafe"),
  "siglas" : "2",
  "pais" : "Name2",
  "logo" : "--"

}

Representación visual

import com.google.gson.annotations.SerializedName;
import com.jgmongo.anotaciones.Id;
import com.jgmongo.services.GenericBeans;
import lombok.Getter;
import lombok.Setter;
import org.bson.Document;

/**
 *
 * @author avbravo
 */
@Getter
@Setter
public class Paises extends GenericBeans {

    @Id
    private String siglas;
    private String pais;
    private String logo;

    public Document toDocument(Paises paises) {
        return toDoc(paises);
    }

    public Paises toPojo(Document doc) {
          return (Paises) toJava(doc, new Paises().getClass());
    }

    @Override
    public String toString() {
        return "Paises{" + "siglas=" + siglas + ", pais=" + pais + '}';
    }
}