En esta parte necesito aclarar algo muy importante , en la Parte I y Parte II vimos como configurar el «PLUGIN» de Hibernate para Eclipse Helios.
Lo que significa que si piensas que con el plugin instalado ya puedes ponerte a programar , lamento decirte que aún no.
Bueno los últimos pasos de configuración son:
1.-
Debemos bajar la ultima distro de Hibernate la puedes conseguir aquí.
2.- Ahora debemos preparar el distro para ser agregado a eclipse.
Nos creamos una carpeta llamada Hibernate aparte la idea es que en esa carpeta vallamos copiando las librerias que necesitamos.
Debemos de descomprimir el zip que hemos descargado y adentro de ella veremos todo el distro de hibernate de ahi copiaremos el archivo hibernate3.jar .
También debemos entrar a lib->Required y seleccionar todos los archivos y los copiamos a nuestra carpeta hibernate.
Por ultimo debemos meternos a lib>jpa y copiar los archivos y también pegarlos en nuestra carpeta hibernate
Con esto debemos tener la carpeta con estos archivos.
Por alguna extraña razon que desconozco en lo personal si agregamos estas librerias deberia funcionar sin problemas hibernate pero no es asi.
Falta agregar una libreria extra que la podemos encontrar en slf4j.org
descarga la ultima version que es la 1.6.1 de aquí
Ahora bien, descomprimimos el zip de slf4j y buscamos el jar llamado slf4-simple-1.6.1.jar y lo copiamos a nuestra carpeta de hibernate.
Ahora si ya tenemos todo listo! Abrimos nuestro eclipse y le damos boton derecho del mouse a nuestro proyecto y nos dirigimos a Build Path –> Add Libreries
Nos va aparecer una ventana como esta:
Seleccionamos User Library ahora le damos en siguiente y nos llevara a la siguiente ventana donde presionaremos el boton User Library y le damos en el Boton New y nos pedirá el nombre de la librería personalizada que queremos agregar bueno aquí yo le puse HibernateLib pero puedes nombrarla como quieras.
Ahora solo le damos en Add JARs y seleccionamos todos los jars de nuestra carpeta hibernate que contiene todas las librerías que vamos a ocupar.
nos quedaría algo asi:
Le damos en OK y listo si todo salió bien ya podremos trabajar con Hibernate.
Como ya sabrán hibernate trabaja por sesiones para no manejar tecnicismos simplemente crea una instancia a la base de datos para que podamos trabajar en ella , un error muy común es que por cada clase iniciamos una sesión esto en muchos casos puede generar errores y consumo incensario de memoria . Lo recomendable es crear una única instancia que se utilice para toda nuestra aplicación , para lograr esto necesitamos crear un singleton.
Para los que no saben que es un singleton dejo aquí un articulo que puede aclarar la duda.
Creamos una clase llamada SessionFactoryUtil.java en el paquete modelos de nuestro proyecto de ejemplo y escribimos el siguiente codigo:
package modelos;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class SessionFactoryUtil {
private static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from standard (hibernate.cfg.xml)
// config file.
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Log the exception.
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
Con esta clase nosotros podemos obtener la sesión actual de cualquier parte de nuestra aplicación!
Ahora en el default package nos creamos una clase llamada Main.Java de aquí correremos nuestro proyecto aquí dejo el código:
import modelos.SessionFactoryUtil;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SessionFactory sesion= SessionFactoryUtil.getSessionFactory();
}
}
Con una sola línea de código podemos obtener la sesión creada por el singleton este es el mismo mecanismo para nuestras n clases en las que deseemos realizar operaciones con nuestra base de datos.
Corremos nuestro proyecto desde el Main.java y si todo sale bien no nos marcara ningún error.
Con esto sabemos que nuestro esta listo para desarrollar nuestras aplicaciones con Hibernate!.
Adjunto el proyecto completo en mi SkyDrive es llamado HibernateExample.rar
Espero esto sea de utilidad para quien quiera trabajar con hibernate y eclipse Helios!
Saludos!.
WPF es una tecnología fascinante no solo porque te permite hacer grandiosas cosas con las interfaces si no que ofrece mecanismos para poder facilitar el desarrollo de nuestras aplicaciones.
Una breve introducción sobre que es el patrón MVVM:
Una breve explicación fuera de tecnicismos (que la mayoría de ocasiones confunde en vez de ayudar) es que ofrece la posibilidad de separar prácticamente en su totalidad el código fuente de la interface en otras palabras que uno puede borrar, rediseñar parcial o totalmente las interfaces que se presentan al usuario final.
El patrón MVVM se divide en 3 principales conceptos que hay que entender antes de implementarlo.
Model(Modelo):
El modelo no es mas que simplemente los datos, por ejemplo los datos de una persona:Nombre ,Apellidos,Ocupación etc.…
ModelView (Vista-Modelo) :
El ModelView es el encargado de en términos vincular los datos de nuestro modelo a la interface, además de reflejar los cambios hechos en la interface hacia el modelo. Yo lo entiendo en términos generales es como el intermediario entre los datos y la interface esto permite que el código fuente y la interface vivan independientes.
View(Vista):
Como su nombre lo indica son las interfaces no hay mas que decir solo que los controles o componentes de la interface se enlazaran al ViewModel para que este se encargue de efectuar los cambios al modelo.
Claro este es un concepto muy general porque MVVM abarca mas que eso. No estaría mal que investigaran un poco mas sobre ello a mi en lo personal me ha costado mucho tiempo y trabajo entenderlo por eso trato que este artículo sea lo mas sencillo posible.
Vamos a realizar un ejemplo sencillo sobre como trabaja este patrón:
Para esto vamos a crear un simple proyecto de WPF yo en lo personal me gusta mas VB.NET así que este artículo se basara en este lenguaje.
Para empezar ha que crear el modelo:
Como? simplemente una nueva clase que llamaremos Game
Esta clase contiene algunas propiedades de un videojuego:
Public Class Game
Public Property Name As String
Public Property Description As String
Public Property Platform As String
End Class
Ahora el siguiente paso es crear el ViewModel que no es mas que otra clase
pero a diferencia de la otra esta implementa la interface INotifyPropertyChanged
Esta interface se usa para notificar que alguna de nuestras propiedades ha cambiado es muy útil en este patrón.
Aquí esta la clase:
Imports System.ComponentModel
Imports System.Collections.Generic
Public Class GameViewModel
Implements INotifyPropertyChanged
Public Sub New()
Dim Game1 As New Game
Dim Game2 As New Game
Dim Game3 As New Game
Game1.Name = "Halo Reach" : Game1.Description = "Shotter" : Game1.Platform = "Xbox 360"
Game2.Name = "BioShock" : Game2.Description = "Shotter" : Game2.Platform = "Xbox 360"
Game3.Name = "Devil May Cry" : Game3.Description = "Shotter" : Game3.Platform = "Xbox 360,PS3"
Games = New List(Of Game)
Games.Add(Game1)
Games.Add(Game2)
Games.Add(Game3)
End Sub
Private _Games As List(Of Game)
Public Property Games As List(Of Game)
Get
Return _Games
End Get
Set(value As List(Of Game))
_Games = value
NotifyPropertyChanged("Games")
End Set
End Property
Public Event PropertyChanged(sender As Object, e As System.ComponentModel.PropertyChangedEventArgs) _
Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
Private Sub NotifyPropertyChanged(ByVal info As String)
RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(info))
End Sub
End Class
En esta clase he creado una lista del tipo Game en ella tendremos nuestra colección de video juegos.
Además cabe decir que la parte mas interesante de esta clase es la manera en que que notificamos algún cambio en las propiedades estas pueden ser cambiadas ya sea por código o por medio de la interface.
Private Sub NotifyPropertyChanged(ByVal info As String)
RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(info))
End Sub
Esta rutina es la encargada disparar el evento que notifica cuando una propiedad ha cambiado y para lograr esto simplemente debemos mandarla a llamar en el set de cada propiedad que deseemos actualizar.
Private _Games As List(Of Game)
Public Property Games As List(Of Game)
Get
Return _Games
End Get
Set(value As List(Of Game))
_Games = value
NotifyPropertyChanged("Games")
End Set
End Property
Por ultimo ahora solo queda enlazar nuestro ViewModel con nuestra interface(View)
Esto se hace en el constructor de la clase del MainWindow.xaml
Public Sub New()
' This call is required by the designer.
InitializeComponent()
'Enlazamos el ViewModel con la interface.
Me.DataContext = New GameViewModel
' Add any initialization after the InitializeComponent() call.
End Sub
Creamos nuestra pequeña interfaz que solo se compone de un DataGrid la parte interesante es como le indicamos al DataGrid que llene la colección de videojuegos esto se logra mediante su propiedad ItemsSource y para que genera automaticamente las columnas solo basta como poner en True la propiedad AutoGenerateColumns
El código XAML luce así:
<DataGrid AutoGenerateColumns="True" Height="270" HorizontalAlignment="Left"
Margin="12,29,0,0" Name="DataGrid1"
VerticalAlignment="Top" Width="479"
ItemsSource="{Binding Games}"/>
y si le damos F5 a nuestro proyecto se debería ver algo así:
Como verán al principio debe ser algo confuso porque tanto para solo agregar una colección de datos , la ventaja principal es que nos brinda la posibilidad de cambiar de controles, o de interfaces hasta reutilizar el código en otras interfaces además utilizando las características de WPF en una aplicación real este patrón brinda una escalabilidad enorme y fácil de mantener.
Por ahora a sido todo espero le haya sido útil este pequeño artículo.
Saludos.!
Nota: Esta desarrollado este ejemplo en VS2010 SP1
Trabajando con Hibernate y Eclipse Helios:
Parte II:
Bueno en la entrega anterior vimos como instalar el plugin de hibernate en nuestro Eclipse, para poder seguir con el tutorial se supone que ya debes tener la base de datos llamada Ejemplo en MySQL.
Para esta entrega veremos como configurar hibernate para que se comunique con MySQL y nos cree las clases correspondientes de cada tabla de la base de datos Ejemplo.
Bueno Creamos un nuevo proyecto en Eclipse :
File-> New –>Java Project
Ahora bien nuestro proyecto nos quedara algo asi:
Ahora lo que falta es agregar el driver de MySQL (http://dev.mysql.com/downloads/connector/j/)
Seleccionamos nuestro proyecto y presionamos boton derecho y nos vamos a Buil Paths-> Add Libreries se desplegara una ventana parecida a esta:
Seleccionamos Connectivity Driver Definition y presionamos Next ahora nos saldra una ventana dando las opciones abiables para conectarnos a una fuente de datos en este caso es JDBC MySQL Driver lo seleccionamos y presionamos el trinagulito que viene aun lado.
ahora bien nos saldra otra ventana con la configuracion del driver he de aclarar que Eclipse no tiene el driver por eso vamos a editar la configuracion para decirle cual es jar que se va a usar para la conexion , En este punto es donde nos vamos a la pestaña Jar List y presionaremos el boton Add Jar/Zip y seleccionamos el driver que bajamos anteriormente .
Nota: Cuando se descarguen el driver de la pagina descomprimanlo antes y ahi esta un archivo llamado mysql-connector-java-5.1.13-bin este es el que deben seleccionar.
Una vez terminado le damos en finish y en nuestro proyecto debe aparecer algo asi.
Si se dan cuenta se ha agregado la referencia a MySQL.
Configuración de Hibernate:
Seleccionamos nuestro proyecto y presionamos boton derecho del mouse y vamos a:
New-> Other->Hibernate->Hibernate Configuration File(cfg.xml)
Este archivo no es mas que un xml que contiene todo lo necesario para realizar la conexion a la base de datos .
Presionamos Next y nos pedira donde crear el archivo para este ejmplo usaremos el folder default “src” presionamos Next y a continuacion nos pedira los datos para poder realizar nuestra conexion a la base de datos:
Explico rapidamente los campos mas importantes:
Bueno Aqui en la imagen dejo los datos para conectarse a MySQL sin en dado caso en driver class no te aparece com.mysql.jdbc.Driver significa que no instalaste bien el JDBC de MySQL.
Ahora sigue crear el xml Hibernate Console Configuration.
Le presionamos siguiente y nos saldra otra ventana:
En el apartado: Configuration file ya viene seleccionado nuestro archido de configuracion si no lo seleccionamos. este ya lo creamos antes, en el campo Name: le ponemos un nombre a nuestra configuracion yo lo llame “ConfiguracionHb” y presionamos Finish.
Por ultimo falta crear el Hibernate Reverse Engineering(reveng.xml)
Este archivo es el encargado de crear las clases de nuestras tablas de MySQL.
Presionamos Next y nos pedira que indiquemos donde se va a guardar Importante!! se debe guardar en el mismo paquete que el cfg.xml este esta en src asi que ahi guardaremos el reveng.xml, presionamos next y nos aparecera una ventana si todo va bien aqui es donde diremos que tablas queremos mapear presionamos refresh y so todo salio bien se mostrara nuestra base de datos y sus tablas.
Seleccionamos ya sea una por una o todas las tablas y presionamos el boton include y presionamos finish.
Aquí el código fuente generado automáticamente de el Reveng.xml
<?xml version="1.0" encoding="UTF-8"?>
<hibernate-reverse-engineering>
<table-filter match-catalog="Ejemplo" match-name="alumno"/>
<table-filter match-catalog="Ejemplo" match-name="grupo"/>
</hibernate-reverse-engineering>
Solo falta generar las clases de nuestra base de datos Ejemplo, para lograr esto debemos presionar un botón parecido al de Run –>Hibernate Code Generation Configurations (tiene una especie de candado)
Aparecerá una ventana de configuración, en esta especificaremos:
Pestaña Main:
Console Configuration: ConfiguracionHB
Output directory: debe ser el mismo source folder que es “src”
Package:modelos
revenge.xml: nuestro archivo revenge.xml ya creado con anterioridad.Muestro como quedaría configurada esta pestaña.
En la pestaña exporters debemos indicar que archivos quiero que se generen :
Una vez seleccionado daremos en Apply y posteriormente en Run.
Si todo sale bien nos generara un paquete llamado modelos y con las clases de nuestras tablas!.
Si se dan cuenta nos genera un total de 6 archivos 3 clases y 3 archivos xml. Estos xml contienen la informacion del mapeado de su respectiva tabla y las clases sus set y gets de cada campo de la tabla.
Para comprobar que hemos realizado correctamente nos vamos a la perspectiva de Hibernate y seleccionamos nuestra configuracion en la pestaña hibernate configurations y le damos click derecho en Database-> HQL Editor
y pondremos un sencillo codigo HQL de prueba .
from Alumno
y nos aparecera algo como esto:
en el panel HQL Result veremos dos registros si seleccionamos uno veremos en el panel Properties los el contenido del registro para esto me tome la molestia de agregar dos alumnos desde MySQL.
Esto significa que ya esta configurado Hibernate para poder trabajar .
En la proxima entrega veremos como agregar nuevos registros, modificarlos y eliminarlos hasta la proxima.
Antes de empezar este pequeño tutorial vamos a explicar algunos conceptos.
Que es Hibernate?
Hibernate es una herramienta de Mapeo objeto-relacional para la plataforma Java (y disponible también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre una base de datos relacional tradicional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los beans de las entidades que permiten establecer estas relaciones.
Hibernate es software libre, distribuido bajo los términos de la licencia GNU LGPL.
Como todas las herramientas de su tipo, Hibernate busca solucionar el problema de la diferencia entre los dos modelos de datos coexistentes en una aplicación: el usado en la memoria de la computadora (orientación a objetos) y el usado en las bases de datos (modelo relacional). Para lograr esto permite al desarrollador detallar cómo es su modelo de datos, qué relaciones existen y qué forma tienen. Con esta información Hibernate le permite a la aplicación manipular los datos de la base operando sobre objetos, con todas las características de la POO. Hibernate convertirá los datos entre los tipos utilizados por Java y los definidos por SQL. Hibernate genera las sentencias SQL y libera al desarrollador del manejo manual de los datos que resultan de la ejecución de dichas sentencias, manteniendo la portabilidad entre todos los motores de bases de datos con un ligero incremento en el tiempo de ejecución.
Hibernate está diseñado para ser flexible en cuanto al esquema de tablas utilizado, para poder adaptarse a su uso sobre una base de datos ya existente. También tiene la funcionalidad de crear la base de datos a partir de la información disponible.
Hibernate ofrece también un lenguaje de consulta de datos llamado HQL (Hibernate Query Language), al mismo tiempo que una API para construir las consultas programáticamente (conocida como "criteria").
Hibernate para Java puede ser utilizado en aplicaciones Java independientes o en aplicaciones Java EE, mediante el componente Hibernate Annotations que implementa el estándar JPA, que es parte de esta plataforma.
Fuente: http://es.wikipedia.org/wiki/Hibernate
Bueno ya aclarado vamos a empezar para este tutorial vamos a usar el IDE Eclipse Helios por si aun no lo tienen aqui dejo el enlace. http://www.eclipse.org/downloads/ recomiendo bajar la version de java EE Developers bueno es cuestion de gustos.
Recomiendo bastante el IDE Eclipse ya que es muy versatil y tiene bastantes plugins que ofrecen gran poder al desarrollar aplicaciones ya sea de escritorio o web.
Una vez descargado he instalado eclipse( en este tutorial no abarcaremos como hacerlo) ahora lo que viene es preparar nuestro eclipse para usar hibernate para esto necesitamos instalar el plugin de hibernate para Eclipse.
Para esto nos vamos al menu de Eclipse Help-> Install New Software
en donde dice Work With escribimos:
http://download.jboss.org/jbosstools/updates/development/
Nos vamos a donde dice Data Services-> Hibernate Tools lo seleccionamos y le damos al boton Next de ahi nos dara la licencia y lo instalara , nos pedira reiniciar Eclipse y listo.
Para darnos cuenta de que ha quedado instalado el plugin de Hibernate solo basta con ir las perspectivas y veremos que tenemos la perspectiva de Hibernate.
Ya que tenemos configurado Eclipse necesitamos tener nuestra base de datos ya lista.
Para este ejemplo voy a ocupar MySQL aqui dejo el diagrama de como quedaria la base de datos llamada Ejemplo.
A continuacion les dejo el Script para generarlo:
SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0;
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL';
CREATE SCHEMA IF NOT EXISTS `Ejemplo` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci ;
USE `Ejemplo` ;
-- -----------------------------------------------------
-- Table `Ejemplo`.`Grupo`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `Ejemplo`.`Grupo` (
`Id_Grupo` INT NOT NULL AUTO_INCREMENT ,
`Nombre` VARCHAR(50) NULL ,
PRIMARY KEY (`Id_Grupo`) )
ENGINE = InnoDB;
-- -----------------------------------------------------
-- Table `Ejemplo`.`Alumno`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `Ejemplo`.`Alumno` (
`Id_Alumno` INT NOT NULL AUTO_INCREMENT ,
`Nombre` VARCHAR(50) NULL ,
`Escuela` VARCHAR(50) NULL ,
`Grupo_Id_Grupo` INT NOT NULL ,
PRIMARY KEY (`Id_Alumno`, `Grupo_Id_Grupo`) ,
INDEX `fk_Alumno_Grupo` (`Grupo_Id_Grupo` ASC) ,
CONSTRAINT `fk_Alumno_Grupo`
FOREIGN KEY (`Grupo_Id_Grupo` )
REFERENCES `Ejemplo`.`Grupo` (`Id_Grupo` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
SET SQL_MODE=@OLD_SQL_MODE;
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;
-- -----------------------------------------------------
-- Data for table `Ejemplo`.`Grupo`
-- -----------------------------------------------------
SET AUTOCOMMIT=0;
USE `Ejemplo`;
INSERT INTO `Ejemplo`.`Grupo` (`Id_Grupo`, `Nombre`) VALUES ('1', 'S302');
INSERT INTO `Ejemplo`.`Grupo` (`Id_Grupo`, `Nombre`) VALUES ('2', 'S401');
INSERT INTO `Ejemplo`.`Grupo` (`Id_Grupo`, `Nombre`) VALUES ('3', 'S501');
INSERT INTO `Ejemplo`.`Grupo` (`Id_Grupo`, `Nombre`) VALUES ('4', 'S602');
INSERT INTO `Ejemplo`.`Grupo` (`Id_Grupo`, `Nombre`) VALUES ('5', 'S702');
COMMIT;
Para generar la base de datos se puede crear desde la consola de MySQL o usar MySQL WorkBench en lo personal el mejor manejador de MySQL. aqui les dejo el link http://wb.mysql.com/
Bueno hasta aqui la primera parte de este tutorial.
En la siguiente entregar veremos como configurar Hibernate.
Bueno en esta ocasión les traigo una manera tal vez no es tan eficiente pero si la complementan con un instalador es una manera muy útil de como instalar postgreSQL de manera desatendida en artículos posteriores iré publicando como también crear la base de datos igualmente de manera desatendida , además como poder realizar un instalador que ejecute estas tareas he instalar nuestra aplicación y el usuario final solo tenga que hacer el típico siguiente, siguiente etc…
Bueno a lo que vamos para poder realizar esta operación necesitamos crear un archivo.BAT yo lo llame InstalarPost.BAT con un Bloc de Notas.
aqui el codigo fuente:
@echo off
set _SCRIPT_DRIVE=%~d0
set _SCRIPT_PATH=%~p0
set R=%_SCRIPT_DRIVE%%_SCRIPT_PATH%
cd %R%
%R%%postgresplus-8.4.1-2-windows.exe –mode unattended –superpassword postgres –unattendedmodeui none
Si analizan el código del BAT busca la ruta de donde se ejecuta el bat y ahí mismo busca el installer del PostgreSQL (eso significa que peguen el instalador de PostgreSQL donde tienen el BAT) después solo le damos los parámetros que se explican a continuación.
–mode unattend :Significa que es en modo silencioso o desatendido
–superpassword : Se entiende el password que se le da al usuario postgres que PostgreSQL genera.(puede ser el pass que ustedes quieran
–unattendedmodeui : Le decimos que queremos que el usuario no tenga ninguna intervencion en la instalacion de PostgreSQL.
Nota: Este método al parecer no es compatible con versiones anteriores de PostgreSQL pues antes se instalaba mediante un .msi asi solo es de cuidar que versión se quiere instalar.