Proyecto Java Hibernate Maven Flex
- Detalles
- Publicado el Lunes, 12 Junio 2017 18:35
- Escrito por Agustín Muñoz
Proyecto MySql->Hibernate->Maven->Java->BlazeDS->Flex
En esta ocasión vamos a realizar un proyecto bastante completo
Vamos a crear un proyecto con Backend en Java y como FrontEnd utilizaremos Flex. Para conectarlos utilizaremos Remote Object con BlazeDS.
Como IDE de Java utilizaremos Eclipse y para trabajar con AS3 utilizaremos Flash Buider. Yo utilizo Eclipse Neón y Flash Builder 4.7 Premium, pero podemos utilizar cualquier versión.
Para el manejo de Base de Datos desde Java utilizaremos Hibernate. Hibernate es un ORM, Mapeo Objeto-Relacional (Object-Relational Mapping).
Por un lado tenemos la base de Datos, y por otro lado las Entidades ("Entity").
Las entidades son "pojos" (Plain Old Java Object) con anotaciones JPA o ducumentos XML para persitir los datos en nuestra base de datos relacional.
Tabla Base de Datos -> Entity (Clase Java con Anotaciones JPA)
¿Qué significa esto que parece tan complicado?
Una instancia de mi clase "Entity" se relaciona directamente con la base de datos. Es decir, una instancia de la clase "Entity" es una n-tupla de la tabla de la base de datos relacional a que esté ligada.
Veamos un ejemplo:
Vamos a utilizar MySql como Base de Datos, aunque no importa que tipo de DDBB sea porque uno de los beneficios de la utilización de Hibernate es la posibilidad de migrar las bases de datos cambiando una línea de código, siempre que se respete la estructura de la base de datos, claro está
Arrancamos MySql Server, -normalmente en el puerto 3306-, accediendo en local, localhost, 127.0.0.1. Si el Servidor está en otro equipo de nuestra red, accederemos directamente a traves de la ip, del equipo que contenga el Server. (Toca pelearse con el router y hacer un forwarding de la ip del equipo con el puerto 3306. Es posible, dependiendo de lo puñetero que sea, que tengas que configurar tu Firewall y el Antivirus)...Por eso, para pruebas, no nos complicamos y lo hacemos en localhost.
Creamos la BBDD “prueba”, y una tabla “person” con la siguiente estructura:
|
Bueno, ahora abrimos nuestro Eclipse
y creamos un Dinamic Web Proyect
como nombre le he puesto “JavaProyect” y como server Java utilizo Tomcat7
El Tomcat, -en concreto tenemos el Tomcat 7- también está instalado en local y accedemos a través del puerto 8080. Aunque de momento, para el backend, no utilizaremos todavía el server Java. Lo usaremos para comunicar el front-end con el backend a través de remote objects de BlazeDs. Para ello debemos desplegar el proyecto en nuestro Tomcat....pero eso lo veremos mucho más tarde.
Pero para ir adelantando trabajo, le decimos que nos cree el archivo web.xml, que necesitaremos más tarde para esta cuestión y que veremos más adelante.
Marcamos la opción para que nos cree el archivo web.xml.
Maven:
Vamos a configurar nuestro proyecto para trabajar con Maven. Para ello convertimos nuestro Web Project en un MavenProject.
Maven nos va a ayudar a configurar la estructura de nuestro proyecto, descargandose los .jar externos que necesitemos directamente desde internet, y luego al desplegar el proyecto los exportará directamente a:
WebContent->WEB-INF->lib
perfectamente preparados para su utilización.
¿Cómo se hace esto?
Al convertir el proyecto en un MavenProject, se genera el archivo pom.xml
Editaremos este archivo para indicarle al proyecto que librerías externas son las necesarias.
Abrimos el archivo pom.xml.
Como vemos, eclipse nos ofrece varias vistas para editar correctamente el archivo, ofreciendonos así mismo asistentes en la parte inferior: Overview, Dependencies, etc... Nosotros vamos a editar directamente el código. Por ello nos vamos directamente a la última pestaña (pom.xml).
En el nodo <dependencies></dependencies> especificaremos las librerias externas que necesitamos
En nuestro caso las dependencias de nuestro pom.xml quedarían así:
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.8.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.8.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.10</version>
</dependency>
<!-- for JPA, use hibernate-entitymanager instead of hibernate-core -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>javax.persistence</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-commons-annotations</artifactId>
<version>3.2.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.4.1.Final</version>
</dependency>
<!-- <dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>6.1.0.jre8</version>
</dependency> -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.25</version>
</dependency>
</dependencies>
En el archivo pom.xml, borraremos todo el nodo <dependencies></dependencies> y pegaremos el anterior. Si el archivo pom.xml original no tenía <dependencies></dependencies>, pega el código anterior después de la etiqueta </packaging>
Cada dependencia (“<dependency>”), le dice a maven que se descargue los archivos necesarios y los prepare para utilizarlos en nuestro proyecto.
Como vemos, necesitamos las librerías de Hibernate, de conexión a base de datos Mysql, (la dependencia de SQLServer está comentada por si quieres usar esta BBDD).
Los common y slf4j, tienen relación con los log
y javax.persistence es necesario para las anotaciones que haran comunicar nuestra “entities” con las tablas de la BBDD.
En realidad, esto es una idea general para que no sea gratuito ni dogma de fe el pegar un trozo de código sin saber para que sirve. Pero ahora no es necesario comprenderlo todo. Lo iremos viendo poco a poco conforme desarrollemos el proyecto.
Ahora haremos una actualización Maven para que se descarguen y actualicen las nuevas dependencias que hemos especificado
Maven->Update Project
Vale. Tenemos configurado nuestro proyecto Maven con las librerias necesarias. Podemos empezar a trabajar para conectar Java y BBDD mediante Hibernate.
Lo hacemos “a pelo” con código ?
Utilizamos un asistente (JBoss Tools)?
Desde luego ya podemos ponernos a teclear código y conectar con BBDD mediante Hibernate sin más. Todo está dispuesto. Y además es la forma de hacerlo para comprenderlo bien.
Vamos a hacer primeramente el proyecto a “pelo” y luego explicaremos el uso de Jboss Tools para principiantes
1.- Sin asistente ("A pelo")
Vale, ahora un poco de teoría.
Las transacciones de datos entre java y la BBDD, las maneja un objeto de hibernate llamado Session
Pues bien, el sesionManager busca un archivo xml denominado hibernate.cfg.xml.
Este archivo hibernate.cfg.xml contiene los datos de configuración y acceso a la BBDD:
- Host de Conexión
- Puerto
- Driver Conexión
- Dialecto de Base de Datos (MySql5 en este caso)
-Usuario
-Contraseña
Con estos datos nos podemos fabricar nuestro hibernate.cfg.xml, que tiene una estructura como esta
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings --> <propertyname="connection.driver_class">org.gjt.mm.mysql.Driver</property> <propertyname="connection.url">jdbc:mysql://localhost:3306/prueba</property> <propertyname="connection.username">root</property>
<propertyname="connection.password"></property> <propertyname="dialect">org.hibernate.dialect.MySQL5Dialect</property>
</session-factory>
</hibernate-configuration>
Creamos el archivo hibernate.cfg.xml y lo colocamos en la raíz src del Proyecto (fuera de los paquetes).
La interface entre la Aplicación Java e Hibernate es org.hibernate.Session (Session). La principal función de Session es establecer comunicación entre las instancias de las entidades “Entity” mapeadas con las bases de datos para persistirlas (grabarlas en la base de datos y operar con ellas. Save(), persist(), saveOrUpdate(), etc...).
Ahora vamos a crear la configuración de “Session”
Configuration.configuration= new Configuraction();
configuration.configure();
Carga el contenido del archivo hibernate.cfg.xml en la instancia de Clase Configuration
Creamos un servicio
ServiceRegistry servicRegistry=new StandardServiceRegistry().applySettings(configuration.getProperties()).build();
y ahora creamos una factoria de sesiones, donde cada instancia será una Session a utilizar en nuestro proyecto
SessionFactory sessionFactory=configuration.configure().buildSessionFactory(serviceRegistry);
Y ahora obtenemos una session de la sessionFactory
Session session=sessionFactory.openSession();
Con lo cual nuestro código completo de acceso a las funcionalidades de Hibernate queda de la siguiente manera:
Configuration.configuration= new Configuraction();
configuration.configure();
ServiceRegistry servicRegistry=new StandardServiceRegistry().applySettings(configuration.getProperties()).build();
SessionFactory sessionFactory=configuration.configure().buildSessionFactory(serviceRegistry);
Session session=sessionFactory.openSession();
Todo lo anterior lo vamos a incluir en una clase "HibernateUtil", que nos hará todo el trabajo de llamar a la "session". Esta clase "HibernateUtil" quedará así definitivamente (la hemos incluido en el paquete com.agustin.munoz.vo):
Cuidado!!!
Esta forma acceder a una session de Hibernate es propia de Hibernate 4.3 o superiores. En versiones anteriores varía un poco. Si recordamos los .jar externos que descargamos mediante maven en las <dependency></dependency> corresponden a la version 4.3 de Hibernate en nuestro proyecto.
Y ahora, el meollo de la cuestión. Pero fácil , eh!!!
Recordemos la estructura de nuestra tabla person en la BBDD
Tabla "person":
Una n-upla de nuestra tabla (una fila, vamos):
id nombre ape1 ape2 nif provincia ciudad municipio sexo
Pues bien, vamos a crear nuestra primera “Entity”, ¡Ya era hora.......!
Creamos una clase Java, a la que llamaremos “Person”. ¡Nuestra apreciada “entity” Person!!!!!!
Yo voy a meter las “entities” en un paquete llamado com.agustin.munoz.vo,
con lo que nuestra clase seria:
package com.agustin.munoz.vo;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.Table;
public class Person implements Serializable {
private Integer id;
private String nombre;
private String ape1;
private String ape2;
private String nif;
private String pais;
private String provincia;
private String municipio;
private String sexo;
public Person() {
}
public Person(String nombre, String ape1, String ape2, String nif, String pais, String provincia, String municipio,
String sexo) {
this.nombre = nombre;
this.ape1 = ape1;
this.ape2 = ape2;
this.nif = nif;
this.pais = pais;
this.provincia = provincia;
this.municipio = municipio;
this.sexo = sexo;
}
Y ahora los getters y setters, con lo que nuestro código de la clase "Entity" Person quedaría así:
package com.agustin.munoz.vo;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Id;
import javax.persistence.Table;
public class Person {
private Integer id;
private String nombre;
private String ape1;
private String ape2;
private String nif;
private String pais;
private String provincia;
private String municipio;
private String sexo;
public Person() {
}
public Person(String nombre, String ape1, String ape2, String nif, String pais, String provincia, String municipio,
String sexo) {
this.nombre = nombre;
this.ape1 = ape1;
this.ape2 = ape2;
this.nif = nif;
this.pais = pais;
this.provincia = provincia;
this.municipio = municipio;
this.sexo = sexo;
}
public Integer getId() {
return this.id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNombre() {
return this.nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApe1() {
return this.ape1;
}
public void setApe1(String ape1) {
this.ape1 = ape1;
}
public String getApe2() {
return this.ape2;
}
public void setApe2(String ape2) {
this.ape2 = ape2;
}
public String getNif() {
return this.nif;
}
public void setNif(String nif) {
this.nif = nif;
}
public String getPais() {
return this.pais;
}
public void setPais(String pais) {
this.pais = pais;
}
public String getProvincia() {
return this.provincia;
}
public void setProvincia(String provincia) {
this.provincia = provincia;
}
public String getMunicipio() {
return this.municipio;
}
public void setMunicipio(String municipio) {
this.municipio = municipio;
}
public String getSexo() {
return this.sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
}
Y diremos, pues muy bien: Apreciamos ciertas características especiales entre esta simple clase Java con su correspondiente tabla. Ambas son "Person", y las propiedades de la clase java coinciden con los nombres de los campos de la tabla "person". ¿Ya está? ¿Esta clase es ya una "Entity"?....Casi....
Para covertir nuestra clase en una Entity debemos utilizar las anotaciones JPA (Java Persistence API). Estas anotaciones le indican al proyecto que una determinada clase en una Entity y que debe utilizarse para persistir los datos.
Existen numerosas anotaciones, para lo cual remitimos a la documentación de las JPA.
En nuestro proyecto vamos a utilizar las siguientes:
@Entity: Indica que la clase debe actuar como una entidad
@Table: Datos de la tabla de la BBDD con la que está relacionada la entidad
@Column: Indica a los getters la columna con que se relaciona
@Id: Indica cual es la clave primaria
@GeneratedValue
Todas estas anotaciones se incluyen en javax.persistence.*, por lo que habrá que importar las clases necesarias en nuestro proyecto
Aunque hay muchas más y cada una de ellas tiene numerosas propiedades, de momento, en nuestro proyecto vamos a usar las anteriores
Vamos directamente a completar nuestra clase Person con las anotaciones en nuestro ejemplo, que quedaría definitivamente así:
2.- Con Asistente (JBoss Tools)
Eclipse nos brinda la oportunidad de utilizar una herramienta, para crear las Entities, el archivo hibernate.cftg.xml, los Dao, etc...
Vale, volvemos al inicio del proyecto a la parte en que está configurada la estructura del proyecto. (Donde comienza, 1.- Sin Asistente "a pelo").
A partir de aquí tienes 2 opciones:
a) Borrar la Entity Person y y el hibernate.cfg.xml (los generaremos de nuevo automáticamente)
b) Crear un proyecto nuevo para tener ambos
Aunque al final será exactamente igual
No tienes instaladas las JBoss Tools? No pasa nada. Vamos a instalarlas.
Help->Eclipse Marketplace
Y en el cuadro de búsqueda tecleamos JBoss Tools (¿Qué si no?)
Una vez instalada se nos crea una nueva vista con el logo de Hibernate
Vamos a la vista de Hibernate y vamos a crear una consola de configuración de Hibernate.
Pulsamos sobre el icono de [+] para crear una nueva configuración
Hemos llamado a la consola de Hibernate "JavaProjectHibernate"
Seleccionamos el Proyecto Java al que queremos asociar la Consola de Hibernate y pulsamos sobre el botón "Setup" para crear nuestro archivo de configuración. El ya famoso hibernate.cfg.xml
y lo situamos en la raiz de nuestra carpeta src. (Si lo creaste anteriormente "a pelo" te saldrá un error que indica que el archivo ya existe. Tendrás que borrarlo previamente)
Le indicamos los parámetros necesarios para la configuración y ya está
En la vista Hibernate, comprobamos que se ha creado una consola donde podemos desplegar a la izquierda el menú Database y comprobar como ya se ha realizado la conexión conla BBDD y tenemos acceso a las tablas y a sus campos.
La ingeniería Inversa (Reverse Engineer)
¿Qué es la Ingeniería Inversa?
Parece cosa de la NASA. No. En realidad el concepto es fácil.
Una vez establecida la conexión con la base de datos y con acceso a la tabla prueba, hibernate nos va a crear la entity Person automáticamente rastreando la tabla person y generando los métodos, propiedades (tomándolas de la tabla que le indiquemos) y las anotaciones necesarias en función de la estructura de la tabla person
En la vista Hibernate seleccionamos la consola "ProjectJavaHibernate"
Cuidado, en la foto está mal, -pero me ha dado pereza cambiarla.
Seleccionamos:
Run->HibernateCodeGenerator->Hibernate Code GenerationConfiguration
Seleccionamos el Projecto con el que está relacionada.
Como vemos está activada la casilla Reveng Enginer.
Pulsamos sobre el setup del reveng.xml e indicamos un paquete. Le decimos que queremos crear un archivo reveng.xml nuevo
Si no nos sale la conexión con la base de datos y la tabla, pulsamos sobre "Refresh"
Vale. Ya tenemos nuestras tablas en la consola.
Seleccionamos la tabla "person" y pulsamos en el include. Le estamos indicando que queremos una "Ingeniería Inversa" de esta tabla. La tabla alumnos no la vamos a utilizar.
Pulsamos sobre la pestaña Exporter. Nos ofrece la generación automática de varios archivos.
Nosotros vamos a pulsar solo sobre la creación de las Entities (Domain code .java).
Podríamos crear directamente desde aquí el hibernate.cfg.xml, si hubiésemos accedido a la generación de código como primera opción -lo hemos hecho anteriormente porque creemos que es más lógico-, y por eso ya lo tenemos creado. Podríamos crear los DAO directamente desde aquí automáticamente, pero nos crea un código un poco más complejo para los principiantes. Por eso los DAO los crearemos próximamente "a pelo" para que se entiendan mejor
Podemos comprobar que se ha generado automáticamente la Clase "Person" (nuestra Entity). Ya tenemos de nuevo nuestro proyecto listo para continuar, pero lo hemos construido ahora con la herramienta que nos proporciona las JBoss Tools...tú eliges.
Podemos continuar con nuestro proyecto. Continuará