Usar Java LinQ nos puede parecer extraño ya que es una tecnología que nace con .NET framework . .NET nos permite usar programación funcional con los frameworks y soluciones de persistencia realizando una validación de las consultas en tiempo de compilación. ¿Existe alguna solución similar en Java? . La respuesta a esta pregunta es peculiar. Java 8 es posterior a JPA 2.0. Por lo tanto aunque Java soporta programación funcional , JPA en estos momentos no tiene integración con ella.
Existen dos opciones, esperar a Java 9 o usar una librería adicional que nos aporte la funcionalidad. En este caso vamos a usar JinQ como librería para añadir programación funcional a JPA y sus consultas. El primer paso es configurar las dependencias de Maven e incluir JPA y JlinQ.
<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.arquitecturajava</groupId> <artifactId>linqjava</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <dependency> <groupId>org.jinq</groupId> <artifactId>jinq-jpa</artifactId> <version>1.8.19</version> </dependency> <dependency> <groupId>org.jinq</groupId> <artifactId>api</artifactId> <version>1.8.19</version> </dependency> <dependency> <groupId>org.hibernate.javax.persistence</groupId> <artifactId>hibernate-jpa-2.1-api</artifactId> <version>1.0.0.Final</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.2.10.Final</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.6</version> </dependency> </dependencies> </project>
El siguiente paso es definir el fichero de persistence.xml :
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0"> <persistence-unit name="arquitecturajava"> <properties> <property name = "hibernate.show_sql" value = "true" /> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" /> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="mysql" /> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/pruebas" /> </properties> </persistence-unit> </persistence>
Es momento de construir el código Java :
package com.arquitecturajava; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class Persona { @Id private String nombre; private String apellidos; private int edad; public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public String getApellidos() { return apellidos; } public void setApellidos(String apellidos) { this.apellidos = apellidos; } public int getEdad() { return edad; } public void setEdad(int edad) { this.edad = edad; } }
Por último diseñamos el programa principal que se conecta a la base de datos y nos selecciona los apellidos de “pepe”.
package com.arquitecturajava; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; import javax.persistence.TypedQuery; public class Principal { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("arquitecturajava"); EntityManager em = emf.createEntityManager(); TypedQuery<Persona> consulta=em.createQuery("select p from Persona p where p.nombre='pepe'",Persona.class); List<Persona> lista=consulta.getResultList(); for(Persona p: lista) { System.out.println(p.getApellidos()); } } }
Todo funciona correctamente y vemos el apellido de pepe imprimirse en la consola.
Java LinQ con la libreria JinQ
Sin embargo sería mucho más cómodo trabajar con una tecnología tipo LinQ que diseñe las consultas apoyándose en programación funcional. El compilador nos avisara de cualquier error de sintaxis .Es momento de ver el mismo ejemplo pero usando Java LinQ con JinQ como librería de apoyo.
import java.util.List; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; import org.jinq.jpa.JinqJPAStreamProvider; import org.jinq.orm.stream.JinqStream; public class Principal2 { public static void main(String[] args) { EntityManagerFactory emf = Persistence.createEntityManagerFactory("arquitecturajava"); EntityManager em = emf.createEntityManager(); JinqJPAStreamProvider streams = new JinqJPAStreamProvider(emf); JinqStream<Persona> personas = streams.streamAll(em, Persona.class); List<String> lista=personas.where(p->p.getNombre().equals("pepe")).select(p->p.getApellidos()).toList(); for(String apellidos:lista) { System.out.println(apellidos); } } }
Acabamos de diseñar al consulta con programación funcional utilizando las claúsulas Select y Where de JinQ .
El resultado es muy similar.
Java comprobará en tiempo de compilación que la sintaxis es correcta y diseñara la consulta SQL más apropiada.
Otros artículos relacionados:
De grande quiero ser como tú!!! Llevo tres horas en tu blog y he aprendido más que en los 4 años de universidad y 2 años de experiencia de trabajo en la consultoría. Ayer salieron temas de mejora en los desarrollos que hacemos en Spring Web MVC, Hibernate, Envers, las observaciones las hizo un colega con más experiencia, pero… Lamentablemente no nos da luz, ejemplo y prueba de la teoría. Estoy sumamente agradecido por tus aportes!
gracias 🙂
Buen aporte estimado.
gracias 🙂
Muy interesante. Gracias!
buen aporte.
gracias
Me alegro que te fuera util