Creando la primera aplicación con Quarkus

Empecemos por el principio, necesitamos graalvm 11 o superior (en realidad cualquier Jdk 11 o superior pero yo voy a utilizar graalvm para sacar todo el jugo) , maven o gradle (yo voy a usar intellij que viene con gradle y listo) y un ide. 

Pueden usar maven o gradle para crear el proyecto o intellij (tambien) pero yo utilice la pagina https://code.quarkus.io/ y luego lo abrí con intellij. Pero eso lo hice porque quise, pueden hacerlo como quieran. 

Más allá de si eligieron maven o gradle o como hiciero para crear el proyecto, deberían tener esta dependencia : 

implementation 'io.quarkus:quarkus-resteasy'

Ahora veamos el código que genero, es un hola mundo común en un servicio REST : 

import javax.ws.rs.GET;

import javax.ws.rs.Path;

import javax.ws.rs.Produces;

import javax.ws.rs.core.MediaType;

@Path("/hello")

public class GreetingResource {

    @GET

    @Produces(MediaType.TEXT_PLAIN)

    public String hello() {

        return "Hello RESTEasy";

    }

}

Si ejecutamos esto con : 

gradle :quarkusDev 

Va a demorar un rato pero luego si vamos a http://localhost:8080/hello vemos : 

Hello RESTEasy

Y como primer acercamiento, bien, en proximos post vamos a seguir desarrollando este ejemplo. 

Libros de Java code geeks

 

Download IT Guides!   Groovy Programming Cookbook Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to...     Gradle Build Automation Handbook Gradle was designed for multi-project builds which can grow to be quite large, and supports incremental builds by intelligently determining which parts of the build tree are up-to-date,...     Apache Solr Cookbook Providing distributed search and index replication, Solr is designed for scalability and fault tolerance. Solr is the second-most popular enterprise search engine after Elasticsearch. ...     Apache Maven Cookbook An XML file describes the software project being built, its dependencies on other external modules and components, the build order, directories, and required plug-ins. It comes with...

Libros Gratuitos de Java Code Geeks

 

Download IT Guides!   Apache Maven Cookbook An XML file describes the software project being built, its dependencies on other external modules and components, the build order, directories, and required plug-ins. It comes with...     Apache Hadoop Tutorial Hadoop has become the de-facto tool used for Distributed computing. For this reason we have provided an abundance of tutorials here at Java Code Geeks.     JBoss Drools Cookbook Drools supports the JSR-94 standard for its business rule engine and enterprise framework for the construction, maintenance, and enforcement of business policies in an organization,...     Java Interview Questions In the following sections we will discuss about object-oriented programming and its characteristics, general questions regarding Java and its functionality, collections in Java, garbage...

Ejemplo con Java y Spark

Vamos hacer un pequeño ejemplo, una aplicación Java que utilice Spark para contar palabras. La aplicación calculara cuantas veces aparece una palabra en un archivo de texto.

Para hacer esto vamos a utilizar eclipse y maven.

Primero creamos un proyecto simple de maven, para lo cual podemos utilizar la consola, con el siguiente comando:

mvn archetype:generate
-DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-quickstart
-DarchetypeVersion=RELEASE
-DgroupId=org.miOrganizacion
-DartifactId=nombreDelProyecto

o con eclipse, vamos a File -> New -> Project -> Maven -> Maven Project y luego elegimos es arquetipo "maven-archetype-quickstart" y luego completamos los campos groupId y artifactId. Y listo!

Ahora vamos agregar spark en las dependencias en el pom.xml :

  <dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>

Y vamos a indicarle que utilizaremos java 8 con la siguiente lineas :

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

El pom.xml queda de la siguiente manera:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.hexacta</groupId>
<artifactId>testSpark</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>testSpark</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

<dependencies>

<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.11</artifactId>
<version>2.2.1</version>
</dependency>


<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>


</dependencies>
</project>

Y ahora, a programa!!.

Vamos hacer el ejemplo de contar palabras de un archivo de texto. Para lo cual haremos un objeto llamado "App.java" : 

package com.hexacta.testSpark;

import java.util.Arrays;

import org.apache.spark.api.java.JavaPairRDD;

import org.apache.spark.api.java.JavaSparkContext;

import org.apache.spark.api.java.JavaRDD;

import org.apache.spark.SparkConf;

import scala.Tuple2;

public class App {

public static void main(String[] args) {

// Create a SparkContext to initialize

SparkConf conf = new SparkConf().setMaster("local").setAppName("Word Count");

// Create a Java version of the Spark Context

JavaSparkContext sc = new JavaSparkContext(conf);

// Load the text into a Spark RDD, which is a distributed representation of each

// line of text

JavaRDD<String> textFile = sc.textFile("/java/spark/artists.csv");

JavaPairRDD<String, Integer> counts = textFile

                                .flatMap(s -> Arrays.asList(s.split("[ ,]")).iterator())

.mapToPair(word -> new Tuple2<>(word, 1)).reduceByKey((a, b) -> a + b);

counts.foreach(p -> System.out.println(p));

System.out.println("Total words: " + counts.count());

counts.saveAsTextFile("/java/spark/artistsCount.txt");

}

}

Dejo el repo git :
https://github.com/emanuelpeg/client-java-spark

Maven Central + Google Cloud Storage

Maven Central es el repositorio central donde muchas bibliotecas Java de código abierto publican sus artefactos. Muchas aplicaciones utilizan estos artefactos.

A la vez Google Cloud Storage permite a los usuarios almacenar datos ilimitados en la infraestructura de Google en recipientes llamados cubos, reclamando un mayor rendimiento, la fiabilidad y la disponibilidad de los casos de uso como alojamiento web, archivo y recuperación de desastres

Imagínense estos 2 juntos.

Google nos ofrece un mirror con la central de maven agregando el siguiente mirror a   ~/.m2/settings.xml.

<settings>
  <mirrors>
    <mirror>
      <id>google-maven-central</id>
      <name>Google Maven Central</name>
      <url>https://maven-central.storage.googleapis.com</url>
      <mirrorOf>central</mirrorOf>
    </mirror>
  </mirrors>
</settings>

A disfrutar!!

Gradle una herramienta para construir aplicaciones con la potencia y flexibilidad de Ant y con la gestión de dependencia de Maven

Ya escribí anteriormente a Gradle, es una herramienta que permite crear proyectos en Java o Groovy. Similar a Maven, es más utiliza los repositorio de Maven.

Si vemos la pagina web nos dice más o menos lo siguiente:

"Gradle es un sistema de automatización de compilación de código abierto. Gradle puede automatizar la creación, prueba, publicación, distribución y más de paquetes de software u otro tipo de proyectos, tales como sitios web generados estáticos, documentación generada o de hecho cualquier otra cosa.

Gradle combina la potencia y flexibilidad de Ant con la gestión de dependencias como Maven"

Pero, como utilizamos esta herramienta? Si utilizaron Maven anteriormente, instalar Gradle es muy similar. Se debe bajar esta herramienta y luego se debe agregar la carpeta a la variable PATH, en linux tenemos el archivo .profile y podemos hacer algo así:

export GRADLE_HOME=/java/gradle-2.2.1
export PATH=$GRADLE_HOME/bin:$PATH

Y luego hacemos que tome estos cambios con source

source .profile

Luego podemos probar esto de la siguiente manera:

$ gradle -v

------------------------------------------------------------

Gradle 2.2.1

------------------------------------------------------------

Build time:   2014-11-24 09:45:35 UTC

Build number: none

Revision:     6fcb59c06f43a4e6b1bcb401f7686a8601a1fb4a

Groovy:       2.3.6

Ant:          Apache Ant(TM) version 1.9.3 compiled on December 23 2013

JVM:          1.8.0_11 (Oracle Corporation 25.11-b03)

OS:           Linux 3.11.0-12-generic amd64

Por hoy estamos, en siguientes post vamos a crear proyectos y ejecutar tareas. 

Dejo link: http://gradle.org/

Spring Boot

Es raro que no haya escrito antes de Spring Boot dado que es un subproyecto de Spring muy útil. Este proyecto nos ayuda a comenzar un proyecto rápidamente.

Como saben crear un proyecto Spring con todo configurado no es fácil y conlleva tiempo. Con Spring Boot podemos crear diferentes proyectos rápidamente. Ojo luego debemos trabajar un poco para personalizar nuestro proyecto pero el trabajo más grueso ya esta hecho.

Algo que me falto decir es que Spring Boot utiliza maven o Gradle, se pueden crear proyectos como arquetipos.

Entre las características podemos nombrar:

• Podemos utilizar jetty o tomcat embebido. 
• No necesitamos tocar configuraciones de Maven
• Tenemos un proyecto listo para ejecutar, con mínimas configuraciones. 

Dejo link:

http://projects.spring.io/spring-boot

Hacer un proyecto con cxf, rest o soap con maven

Si recuerdan el post anterior, sabrán que ahora vamos a hacer un proyecto rest con cxf, pero vamos a usar m2e y jetty con el plugin "run jetty run".

Esto va a ser muy facil, vamos a nuestra queriada IDE eclipse, con los plugines m2e y run jetty run instalados. Y vamos a crear un nuevo proyecto maven:

Y luego clean install:

Y luego a correr el servicio:

Y ahora si ponemos en el browser http://localhost:8080/rest/hello/echo/HolaBlog veremos lo siguiente:

HolaBlog

Y Listo!!

Hacer un proyecto con cxf, rest o soap con maven

Hace muy poco tuve que hacer un proyecto rest con maven y decidí utilizar Apache CXF y la verdad es que quede sorprendido por la facilidad. Y para que vean que no miento, les dejo la receta:

Ingredientes:

• Abundante maven
• IDE a gusto (yo voy a utilizar eclipse) 
• Servidor web Jetty o tomcat, pueden utilizar el plugin de eclipse “run jetty run” si usa jetty. 

Para hacerlo más divertido vamos a hacer el proyecto soap con maven solamente y luego para el proyecto rest vamos a utilizar el plugin m2e de eclipse.

Vamos a hacer un proyecto soap con Apache CXF, para esto nos posicionamos en la carpeta que queremos crear el proyecto y luego ejecutamos:

 $ mvn archetype:generate
[INFO] Scanning for projects...
[INFO]                                                                        
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
 …

Ahora debemos elegir el archetype en nuestro caso es :
368: remote -> org.apache.cxf.archetype:cxf-jaxws-javafirst (Creates a project for developing a Web service starting from Java code)

Y luego elegimos la versión (hacer enter si quieren la ultima)
Y luego ingresar el nombre del proyecto, paquete y número de versión:

Define value for property 'groupId': : com.prueba
Define value for property 'artifactId': : soap
Define value for property 'version':  1.0-SNAPSHOT: :
Define value for property 'package':  com.prueba: :
Confirm properties configuration:
groupId: com.prueba
artifactId: soap
version: 1.0-SNAPSHOT
package: com.prueba
Confirm properties configuration:
groupId: com.prueba
artifactId: soap
version: 1.0-SNAPSHOT
package: com.prueba
 Y: : y
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: cxf-jaxws-javafirst:3.0.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.prueba
[INFO] Parameter: artifactId, Value: soap
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.prueba
[INFO] Parameter: packageInPathFormat, Value: com/prueba
[INFO] Parameter: package, Value: com.prueba
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: groupId, Value: com.prueba
[INFO] Parameter: artifactId, Value: soap
[INFO] project created from Archetype in dir: /home/emanuel/Projects/restVsSoap/soap
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5:05:03.940s
[INFO] Finished at: Sun Jun 15 18:17:02 ART 2014
[INFO] Final Memory: 14M/207M
[INFO] ------------------------------------------------------------------------
$ cd soap
$ mvn clean install
Al finalizar puedes importarlo a eclipse o cualquier IDE es recomendable utilizar m2e.
Ahora bien el reto era no utilizar IDE, por lo tanto vamos a levantar el tomcat desde maven:
$ mvn tomcat:run

Y Listo!!
Vamos a un browser e ingresamos a http://localhost:8080/soap
Y verán lo siguiente:

Available SOAP services:

HelloWorld sayHi

Endpoint address: http://localhost:8080/soap/HelloWorld WSDL : {http://prueba.com/}HelloWorldImplService Target namespace: http://prueba.com/

Available RESTful services:


En el próximo post vamos con REST.

SBT, haciendo fácil la construcción de proyectos en scala

SBT es Simple Build Tool, una herramienta que permite crear proyectos Scala o java. Seria como el querido Maven. Es necesario para utilizarlo java 1.6 o superior entre sus características podemos destacar:

• Creación fácil de proyectos simples
•  .sbt que es como el pom.xml de maven, es el archivo de definición del proyecto y esta basado en DSL
• Compilación continua y testing con triggered execution
• Genera documentación con scaladoc
• Genera y publica jars
• Soporta proyectos que mezclan java y scala
• Soporta subproyectos
• Soporta correr tareas en diferentes hilos al mismo tiempo. Esto es genial!
• Soporta diferentes administradores de librerías, se puede configurar con Apache Ivy o maven, etc.

Si hicieron el curso de programación funcional en scala seguro lo utilizaron. Y se puede ver que es muy fácil de usar.

Dejo link:
http://www.scala-sbt.org/#features

http://typesafe.com/technology/sbt

Spring Scala, Facilitando el uso de Spring en Scala

El objetivo de Spring Scala es facilitar el uso de Spring framework en proyectos Scala. Como sabrán la adopción de Scala está creciendo cada vez más; pero los que venimos del mundo Spring; no podemos utilizar el conocimiento que tenemos? Claro que si, podemos utilizar Scala con Spring. Hoy podemos utilizar Spring en proyectos Scala sin utilizar Spring Scala pero al igual que cualquier lenguaje Scala tiene su propia forma de hacer las cosas y si usamos Spring haremos las cosas muy al estilo Java. Por lo tanto el proyecto Spring Scala arregla esto.


Que provee Spring Scala?

• Facilidad para utilizar inyección de dependencia
• Configuración de beans de forma funcional
• Utilizar Template de Spring a la manera de Scala

Si quieren utilizarlo utilizando maven deben agregar el siguiente repositorio y la dependencia:

    
        milestone.repo.springsource.org
        repo.springsource.org-milestone
        https://repo.springsource.org/libs-milestone
    


    org.springframework.scala
    spring-scala
    1.0.0.M1

Spring Scala está en progreso por lo tanto se esperan muchos cambios y puede tener algunos bugs.

Dejo links:
http://blog.springsource.org/2012/12/10/introducing-spring-scala/

http://www.infoq.com/articles/scala_and_spring
https://github.com/SpringSource/spring-scala

Crear un proyecto Apache Wicket con Apache Maven

La idea es hacer un proyecto maven de prueba que utilice Wicket, por ejemplo para los que comienzan a programar. 

Instalación de JDK

Bueno tenemos que bajar la JDK de java de aquí: http://www.oracle.com/technetwork/java/javase/downloads/index.html para este tutorial vamos a instalar la JDK 6. Luego de instalarlo tenemos que crear una variable de entorno JAVA_HOME y además agregar en la variable PATH, el path de la JDK.

En linux debemos hacer

export JAVA_HOME=/opt/java

si instalamos java en  /opt/java y luego seteamos esta variable en PATH

export PATH=$PATH:$JAVA_HOME/bin

En Windows sería así:

set JAVA_HOME=C:\java

set PATH=%PATH%;%JAVA_HOME%\bin

Instalacion de maven.

Vamos a bajar Maven de http://apache.xfree.com.ar/maven/binaries/apache-maven-3.0.4-bin.zip

Luego lo guardamos en una carpeta por ejemplo en linux /opt/maven y en Windows c:\maven ahora descomprimimos el zip y nos va quedar una carpeta con el siguiente nombre: apache-maven-3.0.4

Ahora tenemos que configurar la variable MAVEN_HOME esta forma:

En linux :
export MAVEN_HOME=/opt/java
export PATH=$PATH:$MAVEN_HOME/bin

En windows sería así:
set MAVEN_HOME=c:\maven
set PATH=%PATH%:%MAVEN_HOME%\bin

Si todo sali bien al hacer en una consola

mvn -version

Y debe tirar algo parecido se:
Apache Maven 3.0.4 (r1232337; 2012-01-17 05:44:56-0300)
Maven home: /java/apache-maven-3.0.4
Java version: 1.6.0_25, vendor: Sun Microsystems Inc.
Java home: /java/sdk/jdk1.6.0_25/jre
Default locale: es_ES, platform encoding: UTF-8
OS name: "linux", version: "3.2.0-26-generic", arch: "i386", family: "unix"

vamos ahora a hacer nuestro proyecto wicket :
mvn archetype:generate
Ahora nos preguntara un numero, deben escribir el de wicket, en mi caso es el 308; de igual forma busquenlo.

308: remote -> org.apache.wicket:wicket-archetype-quickstart (-)

Y nos va a preguntar el groupId y el archetypeId puede ir lo que quieran por ejemplo: com.ejemplo, prueba.

y listo tenemos nuestro proyecto; ahora a entrar a la carpeta y hacer:

 cd miproyecto
 mvn clean install y luego mvn eclipse:eclipse

Con esto tenemos todo listo para importar nuestro proyecto a Eclipse; abrimos eclipse y vamos al workshop donde en el panel de Package Explore hacer menu contextual y poner import...
En la ventana que aparece elegimos "General -> Existen Projects into Workspace" y luego ponemos la carpeta del proyecto y listo!


Ahora a configurar la variable de entorno M2_REPO en eclipse, tenemos que ir a "Windows-Preference" y hay ir a "Java -> Build Path -> Classpath variables" y agregar una variable llamada M2_REPO que apunte a la carpeta .m2/repository normalmente se encuentra en la carpeta home del usuario; en windows sería la carpeta del usuario; ojo que esta oculta. 


Con todo esto tenemos el proyecto compilando, ahora a instalar Jetty para esto ir a help -> eclipse marketplace buscar jetty y instalar run-jetty-run y luego que se instale se puede correr jetty desde el debug y por defecto va a levantar en localhost:8080.


Espero que puedan hacer todo esto, sino escucho dudas. 

Utilizar maven en proyectos Android!

Maven provee soporte para una amplia gama de tecnologías en la que Android esta incluida. Cuando hacemos mvn archetype:generate de forma interactiva podemos elegir el arquetipo:  de.akquinet.android.archetypes:android-quickstart el cual es una aplicación android. Luego de generar nuestro proyecto y de hacer mvn install podemos ejecutar:

mvn android:deploy

Con este comando nos muestra la aplicación en el avd de android.

Para que funcione este plugin necesitamos solamente el sdk de android y confugurada una variable de entorno ANDROID_HOME que contenga el path al sdk de android.

Para integrarlo con eclipse se debe instalar un connector de m2e y luego importar el proyecto así:

El plugin lo pueden buscar del Marketplace como Android Configurator for M2E

Jasper en jsf

Antes que nada hagamos nuestro reporte con el ireport y lo guardamos por hay...

  Tienen que poner como lenguaje Java; por defecto trae Groovy.

Primero crear el proyecto con maven:
mvn archetype:generate

Yo voy a usar un archetype que se llama:
194: remote -> org.apache.myfaces.buildtools:myfaces-archetype-helloworld20 (Archetype to create a new webapp based on MyFaces 2.0) Ojo pueden usar cualquier implementación de jsf.
Bueno luego importamos el proyecto a eclipse, como siempre...

Agregamos la siguiente dependencia al pom

 net.sf.jasperreports
 jasperreports
 4.5.1

            

 javax.servlet
 servlet-api
 2.4
 provided




        mysql
        mysql-connector-java
        5.1.6

Ahora a integrar jasper a nuestra aplicación jsf.

Vamos a escribir el siguiente controller:

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.HashMap;

import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperRunManager;

public class ReportGeneratorController {
 
 public void generateReport(ActionEvent actionEvent)
   throws ClassNotFoundException, SQLException, IOException,
   JRException {
  Connection connection;
  
  //Buscamos el contexto de jsf
  FacesContext facesContext = FacesContext.getCurrentInstance();
  HttpServletResponse response = (HttpServletResponse) facesContext
    .getExternalContext().getResponse();
  //Con el contexto buscamos el jasper
  // Ojo / es webapp
  InputStream reportStream = facesContext.getExternalContext()
    .getResourceAsStream("/reports/DbReport.jasper");
  ServletOutputStream servletOutputStream = response.getOutputStream();
  
  //Nos conectamos a la base de datos (creamos una coneccion)
  Class.forName("com.mysql.jdbc.Driver");
  //Ojo mybase es el nombre de la base, user y password.
  connection = DriverManager
    .getConnection("jdbc:mysql://localhost:3306/mybase?"
      + "user=user&password=secret");
  facesContext.responseComplete();
  //seteamos el contentType
  response.setContentType("application/pdf");
  
  //ejecutamos el reporte
  JasperRunManager.runReportToPdfStream(reportStream,
    servletOutputStream, new HashMap(), connection);
  // Cerramos la coneccion a la Base
  connection.close();
  // flush y close del reporte
  servletOutputStream.flush();
  servletOutputStream.close();
 }
}

Ojo copien el reporte al proyecto yo lo copie en /webapp/resources
Ahora escribimos un link en una pagina para acceder.

Tenemos que registrar nuestro controller en el face-config.xml:

  
  reportGenerator
  org.assembly.tyr.reports.ReportGeneratorController
  request
 

A probarlo!

Dejo el código:

http://code.google.com/p/jaspertyr/source/browse/

Para bajarlo pueden hacer:

git clone https://code.google.com/p/jaspertyr/

Spring Data Neo4j

Neo4j es una base de datos basada en grafos. De la cual ya hablamos:

http://emanuelpeg.blogspot.com/2009/09/neo4j.html

Neo4j permite acceder a un nodo mediante una clave la cual contiene un valor. También tenemos una API para acceder a los datos y un lenguaje de consulta llamado Cypher.

Una de las características de Neo4j es que es una base transaccional y por lo tanto soporta ACID. Esto es bastante inusual para una base de datos NoSQL.

Podemos agregar a un estro proyecto Neo4j (si utilizamos maven) con la siguiente entrada en el pom:

  
   org.neo4j
   neo4j
   1.5
  

Trabajar con la Api de Neo4j puede ser un trabajo duro por lo tanto Spring framework nos provee un modulo que nos permite trabajar con Neo4j de forma más fácil y elegante.

Primero agregamos la siguiente entrada al pom:

 
org.springframework.data 
spring-data-neo4j 
2.0.0.RC1 
 

Y ahora vamos a agregar la siguiente entrada al applicationContext.xml :

 
... 
 
... 
 

La idea es hacer una aplicación que mantenga la relación de amistad entre personas. Primero creamos el proyecto con maven:

mvn archetype:generate

Luego configuramos como un proyecto normalito de maven.

Y el pom debería tener las siguientes dependencias:

 4.0.0

 org.assembly
 friend
 1.0-SNAPSHOT
 jar

 friend
 http://maven.apache.org

 
  UTF-8
  3.0.6.RELEASE
 

 
  
   
    maven-compiler-plugin
    
     1.6
     1.6
    
   
   
    org.apache.maven.plugins
    maven-eclipse-plugin
    2.7
    
     2.0
     true
    
   
   
    org.apache.maven.plugins
    maven-javadoc-plugin
   
   
    org.apache.maven.plugins
    maven-project-info-reports-plugin
   
  
 

 
  
   spring-snapshot
   Spring Maven SNAPSHOT Repository
   http://s3.amazonaws.com/maven.springframework.org/snapshot
  
 

 

  
   org.springframework.data
   spring-data-neo4j
   2.0.0.BUILD-SNAPSHOT
  

  
   org.springframework
   spring-core
   ${spring.version}
  

  
   org.springframework
   spring-context
   ${spring.version}
  

  
   org.springframework
   spring-aop
   ${spring.version}
  

  
   org.springframework
   spring-aspects
   ${spring.version}
  

  
   org.springframework
   spring-tx
   ${spring.version}
  

  
   org.neo4j
   neo4j
   1.5
  

  
   junit
   junit
   4.10
   test
  

  
   org.springframework
   spring-test
   ${spring.version}
   test
  


 

Luego hacen mvn clean install y luego eclipse:eclipse.

Luego importamos el proyecto a eclipse, ahora veamos la clase persona:

/**
 * 
 */
package org.assembly.model;

import java.util.HashSet;
import java.util.Set;

import org.springframework.data.neo4j.annotation.GraphId;
import org.springframework.data.neo4j.annotation.Indexed;
import org.springframework.data.neo4j.annotation.NodeEntity;

/**
 * @author emanuel
 *
 */
@NodeEntity
public class Person {
 
 @GraphId
 private Long id;
 
 @Indexed //nos permite buscar por ejemplo por nombre. 2 personas no deberian llamarse igual
 private String name;
 
 private String lastName;
 
 private Set friends = new HashSet();

 public Person() { }
 
 public Person(String name, String lastName) {
  super();
  this.name = name;
  this.lastName = lastName;
 }

 public Person(String name, String lastName, HashSet friends) {
  super();
  this.name = name;
  this.lastName = lastName;
  this.friends = friends;
 }

 public void makeAFriend(Person friend) {
  this.getFriends().add(friend);
  friend.getFriends().add(this);
 }
 
//geters , seters, hashcode and equal
 

}

Con esas anotaciones le decimos a spring cual es el id de nuestro nodo y que puede usar como indice para buscar. Ahora hagamos un dao:

package org.assembly.dao;
//La interfaz
import org.assembly.model.Person;

public interface PersonDAO {
 
 void save(Person person);

 Person get(Long id);
 
 Person findByName(String name);
 
}

package org.assembly.dao;

import java.util.List;

import org.assembly.model.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.neo4j.repository.GraphRepository;
import org.springframework.data.neo4j.support.Neo4jTemplate;
//La implementacion
public class PersonDAOImpl implements PersonDAO {
 
 @Autowired
 private Neo4jTemplate template;
 
 public void setTemplate(Neo4jTemplate template) {
  this.template = template;
 }

 @Override
 public void save(Person person) {
  this.template.save(person);
 }

 @Override
 public Person get(Long id) {
  return this.template.findOne(id, Person.class);
 }

 @Override
 public Person findByName(String name) {
  GraphRepository movieRepository =
    template.repositoryFor(Person.class);
  
  return movieRepository.findByPropertyValue("name", name);
 }


}

Vamos a configurar el applicationContext.xml:

Vamos a probar todo con un test:

package org.assembly.dao;

import static org.junit.Assert.assertEquals;

import javax.annotation.Resource;

import org.assembly.model.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class PersonDAOTest {

 @Resource
 private PersonDAO dao;
 
 public void setDao(PersonDAO dao) {
  this.dao = dao;
 }
 
 @Test 
 @Transactional
 public void save() {
  Person person = new Person("Pablo", "Goette");
  
  dao.save(person);
  
  Person personSaved = dao.get(person.getId());
  
  assertEquals(person, personSaved);
 }
 
 @Test 
 @Transactional
 public void saveFriendly() {
  Person person = new Person("Pablo", "Goette");
  
  person.getFriends().add(new Person("Mercedez","Benz"));
  person.getFriends().add(new Person("Al","Colico"));
  person.getFriends().add(new Person("Barry","Gota"));
  person.getFriends().add(new Person("Mercedez","Benz"));
  dao.save(person);
  
  Person personSaved = dao.get(person.getId());
  
  assertEquals(person, personSaved);
 }

 @Test 
 @Transactional
 public void findByName() {
  Person person = new Person("Aquiles", "Canto");
  
  dao.save(person);
  
  Person personSaved = dao.findByName("Aquiles");
  
  assertEquals(person, personSaved);
 }
}

Y listo, verán por ahí la carpeta data con la base de neo4j.

Si todo salio bien los test terminaron exitosos.

Dejo el repositorio subversion:
svn checkout http://spring-neo4j.googlecode.com/svn/trunk/ spring-neo4j-read-only

Dejo links:

http://www.springsource.org/spring-data/neo4j
http://neo4j.org/
http://video.neo4j.org/YbYN/webinar-introduction-to-spring-data-neo4j/
http://youtu.be/9qVs9vxx8lk
http://www.infoq.com/presentations/Introduction-to-Spring-Data-Neo4j

Y dejo un video:

EJB 3 + Maven 2 + JBoss 6 + Eclipse

Vamos a crear un proyecto Jee con maven y que use como servidor Jboss con la siguiente estructura:

pom parent _
                     |__ ejb
                     |__ war

Bueno creamos el proyecto parent:

mvn archetype:create -DgroupId=com.ejemplos -DartifactId=EjemploJEE

Y modificamos el pom para que quede de la siguiente manera:

  4.0.0

  org.assembly
  ExampleJEE
  1.0-SNAPSHOT
  pom

  ExampleJEE
  http://maven.apache.org

  
    UTF-8
  

   
  
   
   maven-compiler-plugin 
    
    1.6 
    1.6 
    
   
   
   org.apache.maven.plugins 
   maven-eclipse-plugin 
   2.7      
    
    2.0 
    true 
    
   
   
   org.apache.maven.plugins   
      maven-javadoc-plugin    
   
   
   org.apache.maven.plugins   
       maven-project-info-reports-plugin    
   
  
  

  
        
            jboss-repository
            JBoss Repository
            https://repository.jboss.org/nexus/content/groups/public/
            default
        
    


  
     
    
      jboss
      jboss-ejb-api
      4.2.0.GA
      provided
    

    
      junit
      junit
      4.10
      test
    

  

Creamos el proyecto ejb:

cd ExampleJEE
mvn archetype:create -DgroupId=org.assembly -DartifactId=ExampleEJB

Y cambiamos el pom de la siguiente manera:

  4.0.0

  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  

  org.assembly

  ExampleEJB

  1.0-SNAPSHOT

  ejb

  ExampleEAR

  http://maven.apache.org

  
   
       
            javax.persistence
            persistence-api
            1.0
            provided
           
        
  
  
  
    UTF-8
  

 
    
    
      
        org.apache.maven.plugins
        maven-ejb-plugin
        2.1
        
          3.0
        
      

    
  

Ahora vamos a generar el proyecto war siempre dentro de ExampleJEE:

mvn archetype:create -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=org.assembly -DartifactId=ExampleWAR

Y cambiamos el pom de la siguiente manera:

  
  4.0.0
  
  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  
  
  org.assembly
  
  ExampleWAR

  1.0-SNAPSHOT

  war

  ExampleWAR Maven Webapp

  http://maven.apache.org

  
    ExampleWAR
  

  
 
   
            org.assembly
            ExampleEJB
            1.0-SNAPSHOT
            provided
        
 
     
            javax.servlet
            servlet-api
            2.5
            provided
        

  

Pongo la dependencia a ExampleEJB como provided dado que no quiero que maven agregue el jar dentro del war después hago deploy del proyecto EJB y del WAR.

Ahora mvn clean install parados en el proyecto parent (ExampleJEE) y mvn eclipse:eclipse (si usan eclipse).

Bueno ahora importamos el proyecto a eclipse: file-> import-> Existing Projects into Workspace … Elegimos el path donde se encuentra el proyecto ExampleJEE y importamos.

Vamos a crear las siguientes clases en ExampleEJB:

La interfaz del servicio:

package org.assembly.service.api;

import javax.ejb.Remote;

@Remote
public interface HolaMundo {
 
 String decirHola();

}

La implementación :

package org.assembly.service.impl;

import javax.ejb.Stateless;

import org.assembly.service.api.HolaMundo;

@Stateless
public class HolaMundoImpl implements HolaMundo {

 /* (non-Javadoc)
  * @see org.assembly.service.api.HolaMundo#decirHola()
  */
 @Override
 public String decirHola() {
  return "Hola";

 }

}

Además agregamos este archivo en src/main/resources (si no existe la carpeta la crean) y lo nombramos jndi.properties

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost:1099

Y en el Proyecto web agregamos este servlet:

package org.assembly.web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.assembly.service.api.HolaMundo;

public class HolaMundoServlet extends HttpServlet {

 private static final long serialVersionUID = 7819040755879233852L;

 private HolaMundo holaMundo = null;

 
 public HolaMundoServlet() {
  final Context context;
  try {
   context = new InitialContext();
   holaMundo = (HolaMundo) context.lookup("HolaMundoImpl/remote");

  } catch (NamingException e) {
   e.printStackTrace();
  }
 }


 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
   throws ServletException, IOException {
  final PrintWriter out = resp.getWriter();

  try {
   out.println(holaMundo.decirHola());
  } catch (Exception e) {
   out.println(e.getStackTrace().toString());
  }

 }

}

Por ultimo modificamos el web.xml para que escuche el servlet:

  Archetype Created Web Application
  
  
    
        hola
        org.assembly.web.HolaMundoServlet
    

    
        hola
        /hola.html
    
  
  

Ahora lo que hacemos es instalar el plugin Jboss Tools en eclipse lo podemos hacer desde el Marketplace de eclipse.

Ahora bajar Jboss 6 desde http://download.jboss.org/jbossas/6.1/jboss-as-distribution-6.1.0.Final.zip

Instalar el Jboss desde el panel de Servers menú contextual new. Luego importamos nuestros proyectos. Si todo fue bien debería verse el entorno así:

Corremos Jboss y en http://localhost:8080/ExampleWAR/hola.html deberíamos ver un “hola”