jueves, 7 de septiembre de 2017

Tutorial: comunicación entre Java y una base de datos H2 (con ejemplos): Parte 3 - Hibernate con Anotaciones

Hibernate, a pesar de sus ventajas, era bastante aparatoso. Todos estos ficheros XML de mapping, los DAO, la realización de DAO...Se te quitan hasta las ganas de escribir código. En la última parte hemos creado un proyecto con Hibernate y hemos visto todo el jaleo q se lleva Hibernate.

Los creadores de Hibernate tb se han dado cuenta de lo aparatoso q era y han venido con una idea fantástica: para que crear los ficheros especiales de mapping elos DAO, donde "mapeamos" nuestra BD (y básicamente duplicamos la información sobre nuestra BD), si podemos simplemente escribir los nombres de las columnas encima los campos en los ficheros de entity:


La información que estaba en DAO y los ficheros Mapping viene metida cómodamente en los ficheros "entity" en forma de las anotaciones:

martes, 22 de agosto de 2017

Tutorial: comunicación entre Java y una base de datos H2 (con ejemplos): Parte 2 - Hibernate con XML

El tiempo pasaba y JDBC, con lo simple que era, tenía sus desventajas:

- El cambio de la BD? De Oracle a SQL Server ?


Venga - a parar el servidor, recompilar todo el proyecto y reiniciar el servidor. A un banco de parar su servidor de la producción por, digamos, una media hora, puede ser un problema....

- Fiabilidad

Si haces un pequeño programa para tu universidad o una pequeña empresa - no lo vas a notar. Pero que pasa, si tu aplicacion Java va ser ejecutada por miles de usuarios cada segundo? Imagina que 2 usuarios quieren a la vez actualizar la misma línea de BD, quien gana?

Por este motivo varios chavales han empezado a crear unas herramientas que se llamaban ORM (Object-Relational Mapping), donde las tablas y las relaciones entre las tablas en la BD están "mapeadas" en el código Java a traverso de los ficheros mapping XML (y mas tarde con el código Java usando las anotaciones).  Al mismo tiempo la manera, en que una aplicación Java guarda los datos en una BD ha tambien evolucionado y así apareció la capa de Persistance, donde los datos primero estaban guardados en los objetos simples de Java (POJO) que tenían los setters y getters y luego una sesión les guardaba en la base de datos a traverso de una transacción.

Los primeros eran los de JBoss que han creado Hibernate en 2001. En verdad hay un montón de frameworks ORM - IBATIS, EclipseLink y no solo en Java, pero tb en C#, PHP, etc. Pero Hibernate sigue siendo una de mas simples y mas populares.

Hoy vamos modificar nuestro proyecto que hemos creado un la parte 1 y en vez de utilizar la conexión a traverso de un driver JDBC, utilizamos Hibernate. Voy pegar otra vez la esquema de la BD:


Aquí en vez de abrir y cerrar la conexión manualmente, utilizamos una sesión Hibernate que actualiza las tablas a traverso de un mapping XML. El mapping XML refleja le estructura de una tabla SQL en un file XML.



miércoles, 26 de julio de 2017

Sobre Stream API en Java 8

Stream API en Java8 se utiliza para trabajar con las colecciones, escribiendo el código en el estilo funcional. Gracias a su simplicidad se ha hecho muy popular entre los programadores. Segun la descripcion oficial, la bilioteca «Java.util.stream» - nos permite hacer varias operaciones de estilo funcional con las colecciones de elementos, tales como transformaciones mapReduce, etc. Contiene las operaciones "intermedias", como Stream.map o Stream.filter, pero también las operaciones "finales" como Stream.forEach o Stream.reduce . Las operaciones "intermedias" no serán ejecutadas hasta q una operacion "final" sera llamada (Stream.map no sera ejecutado hasta Stream.reduce, tb si lo metes antes en el código). Ese comportamiento se llama LAZY.
Otra gran característica de Stream API es la paralelización de las fuentes parallelStream (). Se utiliza para mejorar el rendimiento cuando tienes q procesar grandes cantidades de datos. Las corrientes paralelas pueden acelerar la ejecución para ciertos tipos de transacciones. Yo las uso, cuando sé que la colección es demasiado grande para manejarla con «ForkJoin». Más información sobre la biblioteca ForkJoin puedes leer aqui: http://www.baeldung.com/java-fork-join.
Volvemos a nuestras ovejas y vamos a considerar un ejemplo práctico. Un ejemplo para buscar máximos y mínimos en una colección.

ArrayList testValues = new ArrayList();
testValues.add(0,15);
testValues.add(1,1);
testValues.add(2,2);
testValues.add(3,100);
testValues.add(4,50);
Optional
maxValue = testValues.stream().max(Integer::compareTo);
System.out.println("MaxValue="+maxValue);
Optional
minValue = testValues.stream().min(Integer::compareTo);
System.out.println("MinValue="+minValue); 



jueves, 13 de julio de 2017

Tutorial: servicio Spring REST y cliente AngularJS (parte 1: versión básica)

Casi todos los tutoriales que he visto en internet te hacen crear el servicio y el cliente juntos en una aplicación. Pero dime cuando lo has visto en la vida real? En una empresa normal las aplicaciones y la infraestructura de back-end están claramente separados de los de front-end. Osea q las 2 cosas casi nunca van juntas. Los clientes front-end normalmente desarrollan programadores JavaScript juntos con diseñadores Web que a veces no están ni en el mismo edificio con los de back-end.
Por eso vamos a crear el servicio y el cliente por separado:

Servicio:

Paso 1:

Abre Eclipse y crea New->Dynamic Web Project o mejor con maven (New->Maven Project). Selecciona el arquetipo maven-archetype-webapp:


Lo llamamos app-test-greeting-service y va tener una estructura siguiente:


Paso 2:

Dentro src crea un paquete hello y tres classes Java:


La clase Application será una cosa mas tonta del mundo:
package hello;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
Luego creamos nuestra clase de entidad para los mensajes que tendrán una id y un contenido:
package hello;

public class Greeting {

    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId() {
        return id;
    }

    public String getContent() {
        return content;
    }
}
Bueno, y nuestro controlador REST de toda la vida:
package hello;

import java.util.concurrent.atomic.AtomicLong;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();


    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(required=false, defaultValue="World") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }
}
- Ponle @RestController y no solamente @Controller, sino no va funcionar
- el counter va aumentar cada vez que clicas en "actualizar" de tu navegador web.
- el mensaje "Greeting" de la vuelta sera en formato JSON con el nombre que tu pasas como el parámetro (@RequestParam) El pom de tu proyecto será pequeño:

    4.0.0

    org.springframework
    app-rest-greeting
    0.1.0

    
        org.springframework.boot
        spring-boot-starter-parent
        1.3.0.RELEASE
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        
    

    
        1.8
    


    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    


Lanzalo clicando derecho en tu proyecto y seleccionando "Run As->Java Application" y vas a ver lo siguiente:

Cliente:

Paso 1:

- En el Eclipse haz copiar y pegar de tu proyecto anterior y cambiale el nombre a app-test-greeting-client.
- Puedes eliminar todo el código Java del proyecto anterior de src/main

Paso 2:

- Crea una carpeta public para meter tu pagina web con el código Angular/HTML dentro:


- Creamos nuestra pagina web index.html que nos va mostrar el mensaje:

 
  Hello AngularJS
  
      
 
 
  
Your name: The ID is {{greeting.id}} The content is {{greeting.content}}

Si aun no sabes que es AngularJS, te explico rapidito que es lo que esta escrito:
- La pagina web de arriba es para Angular una aplicación (ng-app)
- Los bloques de la pagina que envían o reciben algo son controladores (ng-controller)
- Dale al controlador un nombre que asi lo puedes referenciar en el código Angular (ng-controller="Hello")
- Los campos para meter cosas son modeles(ng-model) y saben actualizarse (update()) cuando le das "click" (ng-click="update()") o presionas "enter" (ng-click="enter()")
- Los campos para recibir cosas se maraca con {{}} - Crea un file hello.js y pega este codigo:

function Hello($scope, $http) {
    $http.get('greeting', {data: {name: name}}).
        success(function(data) {
            $scope.greeting = data;
        });

    $scope.update = function() {
        $http.get('greeting', {params: {name: $scope.name}}).
         success(function(data) {
             $scope.greeting = data;
         });
    }
}

- La función $http.get viene ejecutado cada vez que visitamos nuestra pagina index.html
- Esta función va a la dirección (http://localhost:8080/greeting?name=Juan) y así enviando al servidor el parámetro name
- La vuelta el servidor (el mensaje Greeting en la forma JSON) metemos en una variable greeting ($scope.greeting = data)
- La pagina web HTML de arriba recibe esta variable y extracta 2 parámetros: id y content
The ID is {{greeting.id}} 
The content is {{greeting.content}} 
Lanzaremos el cliente y iremos a http://localhost:8080/index.html:


Clicamos varias veces en el botón y veremos como aumenta nuestro id. En la segunda parte haremos una aplicación mas complicada que va obtenir información desde la base datos.

lunes, 10 de julio de 2017

Como desplegar el JAR de Spring Boot en otro servidor (JBoss, Tomcat, WebSphere)

Sabemos que el lanzamiento de una aplicacion Spring Boot as muy fácil y se hace con el método main():
@SpringBootApplication
public class RestServiceDemoApplication {
   public static void main(String[] args) throws Exception 
   {
       SpringApplication.run(TuNuevaAplicacion.class, args);
   }
}
Para probar rapidito, si tu aplicación va bien - eso es mejor método: lanzas y la Spring Boot se te lanza una instancia de Tomcat automáticamente. Pero q pasa, si lo tienes q desplegarla en otro servidor? Spring Boot te genera un JAR, pero otro servidor acepta solo un WAR para las aplicaciones web. Q hacemos? Convertir JAR de Spring Boot en WAR es muy facil y asi lo puedes copiar y meter en la carpeta /webapps del servidor. - Paso 1: tienes que añadir a tu clase principal la extensión de la clase SpringBootServletInitializer
@SpringBootApplication
public class RestServiceDemoApplication extends SpringBootServletInitializer
- Paso 2: tienes que añadir una implementación de un método de la clase SpringBootServletInitializer
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
   return application.sources(RestServiceDemoApplication.class);
}
Codigo completo:
@SpringBootApplication
public class RestServiceDemoApplication extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(RestServiceDemoApplication.class);
   }
   public static void main(String[] args) throws Exception {
      SpringApplication.run(RestServiceDemoApplication.class, args);
   }
}
- Paso 3: anadir a pom.xml el packaging
war
y la clase principal en los "properties"
com.example.restservicedemo.RestServiceDemoApplication
ahora puedes crear el package o desde Eclipse, o desde la linea de comandos: - mvn package Maven te dira, donde el WAR sera creado: normalmente hay una carpeta target en la carpeta de tu proyecto. Toma este WAR para desplegarlo en tu servidor:

lunes, 3 de julio de 2017

Tutorial: comunicación entre Java y una base de datos H2 (con ejemplos): Parte 1 - JDBC

La problemática de comunicación entre las aplicaciones Java y las bases de datos ha sido actual desde el primer año de la existencia del lenguaje Java. Hoy vamos a mirar, cómo con años ha evolucionado el método de esta comunicación haciendo una aplicación "enterprise" simple.

Principio
Tenemos una empresa que tiene unos empleadores (tabla Employee). Cadauno tiene su dirección (tabla Address). Y cadauno tiene sus proyectos en cuyos está trabajando (tabla Projects). Visto que cada proyecto puede tener varios empleadores y cada empleador puede trabajar en varios proyectos - tenemos una relación del tipo ManyToMany y eso lógicamente nos hace crear una tabla intermedia - una tabla con asociaciones entre empleadores y proyectos - la llamamos EmplProj:

EmployeeID ProjectID
1                    1
1                    2
2                    2
3                    3
4                    4

Se ve que el empleador #1 trabaja con los proyectos #1 y #2, al mismo tiempo con el proyecto #2 están trabajando el empleador #1 y el empleador #2.
El esquema relacional de nuestra base de datos:




viernes, 30 de junio de 2017

Consejos: connection Pool en Java: es q vale realmente la pena el rollo?

Hoy voy a escribir un pequeno articulo sobre el "Connection Pool" - el tema q siempre veo en los forums. Normalmente el código crea una nueva conexión cada vez que ejecutamos un SQL -> no es optimal para la performance. Entonces porque no intentamos a re-utilizar una conexión, si existe ya?
El problema es q no es tan fácil y la realización depende del vendedor de la BD: Oracle tiene su manera de gestionarlo, WebSphere - la suya, Tomcat - la suya etc.

Es q vale realmente la pena el rollo?

Yo consejería 2 posibilidades. Para pequeños proyectos y para probar algo rapidito - no nos enrollamos y hacemos a la manera fácil:

- con BasicDataSource:

BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("oracle.jdbc.driver.OracleDriver");
ds.setUsername("scott");
ds.setPassword("tiger");
ds.setUrl(URL);
ds.getConnection();

o con DriverManager:


Class.forName(DRIVER);
java.sql.Connection con = DriverManager.getConnection(URL, USERNAME, PASSWORD);



miércoles, 21 de junio de 2017

Tutorial: servicio REST con Kotlin y Spring Boot para "dummies"

Hoy haremos un pequeño servicio REST "Greeter" muy simple, así que al final de este tutorial cada uno de vosotros puede saltar de alegría "yo se hacer servicios REST!".
El codigo esta en el GitHub:
https://github.com/cyberglad/kotlindemo

Este servicio simplemente nos va decir "Hola, <tu nombre>". Al inicio no necesitamos mas. Pero solo al inicio. No vas a poner en tu currículum un servicio "Hola mundo!", entonces enseguida lo vamos a hacer mas inteligente y redirigir las respuestas según que parametro le pasas.

Kotlin - un lenguaje de la familla Java, pero mas "pragmático", breve y conciso y se parece un poco a Groovy. Que por supuesto también utiliza la JVM.
IntelliJ IDEA - hace poco que descubierto esta IDE y estoy encantado, especialmente me encanta la integration con Kotlin (normal, visto que las 2 cosas pertenecen a la misma sociedad - JetBrains). Os recomiendo mucho: tiene muy buen "texto predictivo" (por fin he encontrado uno que tiene sentido) casi como MS Visual Studio y mucho mejor que Eclipse. También el entorno es muy claro, los "pom.xml" de Maven por fin se ven bien estructurados.
Spring Boot - pa alegrarnos la vida y no enrollarnos con el Tomcat.
Spring Initializer (https://start.spring.io): para tener lista la estructura del proyecto Maven con el pom.xml

Kotlin + IntelliJ + Spring Boot = crea un entorno rápido y eficaz sin perder el tiempo en chorradas tipo "como crear mi proyecto Maven y importar todas las bibliotecas necesarias".

jueves, 8 de junio de 2017

50 sombras de Play

Hoy vamos a hablar sobre el Play, el famoso framework Java para el frontend que se ha hecho muy popular hace pocos años y que ha prometido de hacernos maravillas por los fácil y eficaz que era. Por que se hecho tan famoso? Porque combinaba la facilidad de Ruby on Rails con la eficacidad de Java ( por fin podemos desarrollar en Java sin tener que compilar/re-deployar/linkear/etc cada vez que cambiamos una letra en el código!).

Originalmente escrito en Scala, hoyendía Play tiene también las bibliotecas Java y utiliza tambien el concepto MVC (utilizado en otros frameworks, como p.e. Struts).

Ventajas:

Los ventajas de Play:
  •          No Redeploy! Cambios en el código no hace falta re-deployar
  •          Ligero: no hace falta ni DAO, ni XML
  •          Fácil para empezar, tutoriales son de maravilla
  •          Proyectos tienen una estructura muy lógica
  •          Routing es muy simple: no hace falta ni registrar ni configurar nada (controller/method)

viernes, 2 de junio de 2017

Anatomía de la máquina virtual Java (JVM)

En muchas entrevistas que se hacen, cuando se buscan los programadores Java en nivel “senior”, se espera que ellos sepan un poco cómo JVM funciona. Sin entrar en muchos detalles, pero en general. La mayoría de gente empieza por el famoso recolector de basura (Garbage Collector). Asombrosamente muy poca gente sepa que es lo que realmente está pasando dentro la JVM cuando su código viene ejecutado. Aquí intentamos a presentar una pequeña excursión en la anatomía de la JVM.
Vamos a cubrir los temas siguientes (dibujados en el diagrama de arriba):
- Código binario (byte code) en la JVM y sus especificaciones
- Java Runtime y para que sirve
- Como la JVM carga las clases
Como la JVM verifica las clases
Como la JVM ejecuta las clases (JIT)
- Sincronización de los hilos de ejecución (Multi-Thread)
- Recolección de la basura (Garbage Collection)
- Monitoring
- Realizaciones de la JVM (HotSpot, IBM J9, etc)


lunes, 22 de mayo de 2017

Introducción a Spring Security

Hoy vamos a considerar los siguientes aspectos de Spring Security:
· Objetos principales.
· El proceso de autenticación.
· Integración con el proyecto Spring Security.

Spring Security es una framework de tipo Springt para Java Enterprise, que propone un mecanismo de autenticación y autorización, y otras características de seguridad para las aplicaciones empresariales construidas utilizando Spring. El proyecto fue iniciado por Ben Alex a finales de 2003 con el nombre de "Acegi Security" primera versión fue lanzada en 2004. Posteriormente, el proyecto fue retomado por Spring y se convirtió en su proyecto oficial afiliado. Por primera vez se presenta en público con su nuevo nombre "Spring Security" en abril de 2008.

viernes, 19 de mayo de 2017

Porque el mapping ORM viola los principios de la programación orientada a objetos (POO)

El tema de este artículo - porqué la aplicación del mapping ORM en Java (se habla de cualquier tipo de ORM: JPA, Hibernate, etc) no es un buen ejemplo de la programación orientada a objetos y que podemos hacer para mejorar esta situación.
Sabemos que cuando se habla del mapping ORM, hablamos de varios frameworks JPA que permiten acceder a una base de datos (BD) relacional. Los frameworks JPA nos permiten de ser más productivos en el entorno de Java, donde trabajamos con los objetos.
Como ejemplo, consideramos una típica clase de unidad en Hibernate:


@Entity
@table (name = "Users")
public class User {
   @id @GeneratedValue
   @Column (name = "id")
   Identificación del private int;

   @Column (name = "name")
   private String nombre;

   Usuario público () {}
   public int getId () {
      Identificación del retorno;
   }
   setId pública vacío (int id) {
      this.id = id;
   }
   Public String getName () {
      Nombre del retorno;
   }
   pública setName void (String nombre) {
      esto. name = nombre;
   }
}

Angular JS + SQL (versión simple)

Hoy vamos a ver una forma moderna y sencilla para crear los aplicaciones Web - utilizando la framework Angulars JS.  Por fin JavaScript se puede comunicar con una base de datos, que antes no era posible. Obviamente no comunica solo, sino a través de una página web con contenido dinámico escrito en cualquier lenguaje (Java, .NET, PHP).
Hace 15 años, cuando las paginas se cargaban lentamente y eso era normal, las paginas dinámicas se comunicaban directamente con una BD y el usuario tenía que utilizar toda su paciencia para esperar la respuesta. Hoy la página se recarga por partes a la manera que el usuario ni se da cuenta. Y en una de estas partes puede haber el código que recupera información desde la BD, que puede ser, por ejemplo, una lista de algo, o un formulario, o otra cosa.
Sin embargo, técnicamente un código Javascript sigue siendo incapaz de comunicarse con una BD o hacer otras operaciones que se llaman “server-side”. En este ejemplo nos ayuda una página dinámica ASP.NET escrita en C# y será esta página que se va comunicar con la BD. La misma cosa puede ser hecha en JSP o PHP. El código Javascript (en la forma de Angular JS) va llamar a esta página que se ocupa de recuperar la información (o actualizar la información) desde la BD.

jueves, 18 de mayo de 2017

Servicios REST con Jersey (Versión 1.x.x)

Hoy vamos a mirar una tecnología un poco vieja, pero que aún viene utilizada en muchas empresas y entonces todavía debe ser mantenida. Ya tenemos Jersey 2.0 que simplifica muchas tareas y hace el desarrollo de los servicios REST mas fácil. Pero hoy vamos a seguir la versión 1.xxx.
Vamos a crear un pequeño servicio que convierte los grados Celsius en los grados Fahrenheit.