005 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Datos importantes antes de crear formularios.

Agregar bibliotecas.

Img. 1

Para el caso hacemos clic derecho sobre la carpeta “Bibliotecas” dentro del proyecto, y “Agregar biblioteca…”. Paso siguiente solo seleccionamos la que necesitemos y clic en “Añadir biblioteca”.


Img. 2

A lo que corresponde a Hibernate, la misma biblioteca se agrega al crear el archivo “hibernate.cfg”. El “mysql-connector-java-5.1.13-bin.jar” en mi caso se agrega también al crear la conexión con el DB, en casos especiales solamente debemos agregar el “jar” desde la carpeta de instalación del Netbeans.

Crear nuevas bibliotecas.

Para esto debemos dirigirnos a menú superior, clic en “Herramientas” y en “Bibliotecas”.


Img. 3

Se nos abre la ventana de “Administrador de bibliotecas”. Hacemos clic en “Nueva biblioteca…”. En la venta “Nueva biblioteca” establecemos “Nombre de Biblioteca”, normalmente el nombre debería ser una que describa a la perfección su función o procedencia. “Tipo de biblioteca” queda sin cambios. Clic en “Aceptar”.


Img. 4

Ahora debemos agregar los “jar”, para eso seleccionamos nuestra Biblioteca desde la lista “Bibliotecas”, clic en “Agregar archivo JAR/Carpeta…”, seleccionamos las que correspondan y las agregamos. Todo se ira mostrando dentro de la lista “Ruta de clases de la biblioteca”. Por último clic en “Aceptar”. Desde ahora podremos utilizar y también podremos dado el caso agregar o eliminar “jar” de la biblioteca creada.


Img. 5

En cualquier proyecto, dado la extensión de la misma podremos agregar gran cantidad de bibliotecas. En la imagen las que corresponden a nuestro proyecto. Las cuales iremos agregando según necesitemos.


Img. 6

Obs.: Resulta difícil explicar todo el proceso y función de cada línea de código por tanto pueden realizar un comentario con sus dudas.


004 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando clases persistentes.

En la siguiente imagen pueden ver el modelo de datos que utilizaremos para nuestra aplicación. Este modelo los traduciremos en clases persistentes que utilizaremos para manejar todo tipo de transacciones. (Mod. 1)
Modelo DER Base de Datos
Empezamos por lo fácil, creando la clase persistente “Tipo”. Este representa la tabla “tipo” del modelo de datos, cada registro de esta representa un grupo de artículos filtrados por; como su nombre índica “tipo” de artículos. La relación entre “Tipo” y “Articulo” es de “Uno a Muchos bidireccional”. Con esto podemos navegar de ambas tabla viendo esto desde la perspectiva de MySQL, ej., podemos obtener un registro “Tipo” y a través de esta utilizando listas de todos los “Articulos” relacionadas a la misma. Las clases las crearemos de a uno, por tanto mientras no estén todas Java indicaré ciertos errores, esto por la relación que hay entre las clases persistentes. Empecemos.
Pasos previos. Estas serán iguales para crea cada una de las clases persistentes.
Debemos hacer clic derecho sobre el paquete “com.entidades” que hemos creado con anterioridad, clic en “Nuevo” y en “Clase Java…” (Img. 01).
Creando Clases
En la pantalla siguiente indicamos el “Nombre de Clase”; si creamos la clase como se indica, en “Paquete” no mostrará el nombre “com.entidades”. Por último clic en “Terminar” (Img. 02).
Creando Clases
Esta nos crea una plantilla con el paquete a la que pertenece la clase y nombre de esta. (Img. 03) Esta plantilla es la que modificaremos para que funcione como clase persistente.
Plantilla de Clase
Clase persistente “Tipo.java”.

Código Java
package com.entidades;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

/**
 *
 * @author ariel
 */
@Entity
public class Tipo implements Serializable {
    private List<Articulo> articulos = new ArrayList<Articulo>();
    private int id;
    private String des;
    
    @Column(length=50)
    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }
    
    @Id
    @GeneratedValue(strategy= GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @OneToMany(mappedBy = "tipo",cascade= CascadeType.ALL)
    public List<Articulo> getArticulos() {
        return articulos;
    }

    public void setArticulos(List<Articulo> articulos) {
        this.articulos = articulos;
    }
    
}



Explicación de algunos detalles.
Imports
Imagen(04)

  • (1) Nos indica el paquete a la que pertenece la clase.
  • (2) Muestra la lista de importaciones que requiere la clase para que funcione.
    Clase Tipo
    Imagen(05)
    Antes que nada debemos saber que cada variable privada de la clase debe tener un par de “Setters y Getters” para tener acceso a ellas. Todas las anotaciones JPA se realizan sobre las líneas de los “Getters”.
  • (1) “@Entity” es una anotación con JPA, la cual indica que la clase representa una entidad.
  • (2) Toda clase que sea persistente debe implementar la interfaz “Serializable”. Es lo que indicamos en esta línea.
  • (3) En esta línea indicamos una variables de tipo “List”, ya que la clase “Tipo” como tiene relación con la clase “Articulo” (que la crearemos) de “Uno-a-Mucho” bidireccional debe crea una variable de tipo “java.util.List” lo cual nos indica que una clase “Tipo” puede relacionarse con una lista de clases “Articulo”.
  • (4) “@Column(length=50)” con esta anotación indicamos que la columna “des” que esta debajo posee una extensión de 50 caracteres.
  • (5) “@Id” anotación que indica que la columna, en este caso “id” es la que será la llave primaria dentro de la tabla.
  • (6) “@GeneratedValue(strategy= GenerationType.IDENTITY)” estamos indicando con esta anotación que el “Id” se va ha generar de forma automática o mejor dicho de tipo autoincremental. Con esto no tendremos que preocuparnos del valor que pueda tomar la llave primaria. Es importante ya que los valores se generan de forma secuencial por tanto no hay posibilidad que se repitan. Como sabemos las llaves primarias deben ser únicas.
  • (7) “@OneToMany(mappedBy = "tipo",cascade= CascadeType.ALL)” en esta línea estamos indicando expresamente el tipo de relación que va tener la clase “Tipo” con la clase “Artículo” y que variable del otro lado (Articulo) va representar a la clase “Tipo” (mappedBy = "tipo"). También indicamos el tipo de actualización de la relación con la línea (cascade= CascadeType.ALL), esto quiere decir que si eliminamos un registro del lado de “Tipo” también se eliminan todos los registro del lado de “Artículo” que estén relacionado con esta. Es importante para no dejar registros huérfanos o similares.


    Clase persistente “Articulo.java”.


  • Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    
    /**
     *
     * @author Toshiba
     */
    @Entity
    public class Articulo implements Serializable {
        private int id;
        private String des;
        private int pco;
        private int por;
        private int pve;
        private int can;
        private Tipo tipo;
    
        public int getCan() {
            return can;
        }
    
        public void setCan(int can) {
            this.can = can;
        }
    
        public String getDes() {
            return des;
        }
    
        public void setDes(String des) {
            this.des = des;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public int getPco() {
            return pco;
        }
    
        public void setPco(int pco) {
            this.pco = pco;
        }
    
        public int getPor() {
            return por;
        }
    
        public void setPor(int por) {
            this.por = por;
        }
    
        public int getPve() {
            return pve;
        }
    
        public void setPve(int pve) {
            this.pve = pve;
        }
    
        @ManyToOne
        public Tipo getTipo() {
            return tipo;
        }
    
        public void setTipo(Tipo tipo) {
            this.tipo = tipo;
        }
        
           
        
    }
    


    Explicación de algunos detalles.
    Solo explicaremos algunas de las anotaciones que sean diferentes a las anotaciones de la anterior “Clase” que ya hemos explicado o que puedan ser de interés especial.
    Clase Articulo
    Imagen(06)

  • (1) Declaramos una variable privada de “Tipo” con nombre “tipo” la cual representa a la clase “Tipo” con la cual esta clase “Articulo” posee una relación. Como del lado de “Articulo” varios registros pueden relacionarse con un solo registro “Tipo” esta no se representa como una lista, como se hizo en la clase anterior.
    Clase Articulo
    Imagen(07)
  • (1) “@ManyToOne” con esta anotación indicamos que del lado la Clase “Articulo” serán muchos registros relacionados con una del lado de la Clase “Tipo”. Como vemos no se ha indicado la anotación ((mappedBy = "tipo",cascade= CascadeType.ALL) que teníamos en la clase “Tipo”. Esto es porque siempre del lado del (OneToMany) se toma el control de la relación, quedando el (ManyToOne) como dependiente.

    Clase persistente “Cliente.java”.
    Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class Cliente implements Serializable {
        private List<VentaCab> ventaCabs = new ArrayList<VentaCab>();
        private int id;
        private String des;
        private String dir;
        private String tel;
        private String ruc;
    
        public String getDes() {
            return des;
        }
    
        public void setDes(String des) {
            this.des = des;
        }
    
        public String getDir() {
            return dir;
        }
    
        public void setDir(String dir) {
            this.dir = dir;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getRuc() {
            return ruc;
        }
    
        public void setRuc(String ruc) {
            this.ruc = ruc;
        }
    
        public String getTel() {
            return tel;
        }
    
        public void setTel(String tel) {
            this.tel = tel;
        }
    
        @OneToMany(mappedBy = "cliente")
        public List<VentaCab> getVentaCabs() {
            return ventaCabs;
        }
    
        public void setVentaCabs(List<VentaCab> ventaCabs) {
            this.ventaCabs = ventaCabs;
        }
        
    }
    

    Como podemos ver esta clase posee una única relación de tipo (OneToMany), que ya se ha explicado con anterioridad. La diferencia sería que no posee la anotación (cascade= CascadeType.ALL) ya que la relación es con la Clase que representa “Venta”, cuyos registro no deberían eliminarse.


    Clase persistente “Funcionario.java”.


  • Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class Funcionario implements Serializable {
        private List<CompraCab> compraCabs = new ArrayList<CompraCab>();
        private List<VentaCab> ventaCabs = new ArrayList<VentaCab>();
        private int id;
        private String nombres;
        private String apellidos;
        private String dir;
        private String tel;
        private String cargo;
    
        public String getApellidos() {
            return apellidos;
        }
    
        public void setApellidos(String apellidos) {
            this.apellidos = apellidos;
        }
    
        public String getCargo() {
            return cargo;
        }
    
        public void setCargo(String cargo) {
            this.cargo = cargo;
        }
    
        public String getDir() {
            return dir;
        }
    
        public void setDir(String dir) {
            this.dir = dir;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getNombres() {
            return nombres;
        }
    
        public void setNombres(String nombres) {
            this.nombres = nombres;
        }
    
        public String getTel() {
            return tel;
        }
    
        public void setTel(String tel) {
            this.tel = tel;
        }
    
        @OneToMany(mappedBy = "funcionario")
        public List<VentaCab> getVentaCabs() {
            return ventaCabs;
        }
    
        public void setVentaCabs(List<VentaCab> ventaCabs) {
            this.ventaCabs = ventaCabs;
        }
    
        @OneToMany(mappedBy = "funcionario")
        public List<CompraCab> getCompraCabs() {
            return compraCabs;
        }
    
        public void setCompraCabs(List<CompraCab> compraCabs) {
            this.compraCabs = compraCabs;
        }
        
        
    }
    


    Esta clase a diferencia de “Cliente” posee relación de tipo (OneToMany), con dos Clases que son las que representan “Compra” y “Venta”.


    Clase persistente “Proveedor.java”.

    Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class Proveedor implements Serializable {
        private List<CompraCab> compraCabs = new ArrayList<CompraCab>();
        private int id;
        private String des;
        private String dir;
        private String tel;
    
        public String getDes() {
            return des;
        }
    
        public void setDes(String des) {
            this.des = des;
        }
    
        public String getDir() {
            return dir;
        }
    
        public void setDir(String dir) {
            this.dir = dir;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getTel() {
            return tel;
        }
    
        public void setTel(String tel) {
            this.tel = tel;
        }
    
        @OneToMany(mappedBy = "proveedor")
        public List<CompraCab> getCompraCabs() {
            return compraCabs;
        }
    
        public void setCompraCabs(List<CompraCab> compraCabs) {
            this.compraCabs = compraCabs;
        }
        
    }
    


    Esta clase posee una relación de tipo (OneToMany) con la Clase que representa “Compra”. Tipo de relación que ya explicamos.


    Clase persistente “VentaCab.java”.

    Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.List;
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    import javax.persistence.OneToMany;
    import javax.persistence.Temporal;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class VentaCab implements Serializable {
        private List<VentaDet> ventaDets = new ArrayList<VentaDet>();
        private int num;
        private Cliente cliente;
        private Funcionario funcionario;
        private Calendar fecha;
        private String hora;
        private long total;
    
        public long getTotal() {
            return total;
        }
    
        public void setTotal(long total) {
            this.total = total;
        }    
        
        @ManyToOne
        public Cliente getCliente() {
            return cliente;
        }
    
        public void setCliente(Cliente cliente) {
            this.cliente = cliente;
        }
    
        @Temporal(javax.persistence.TemporalType.DATE)
        public Calendar getFecha() {
            return fecha;
        }
    
        public void setFecha(Calendar fecha) {
            this.fecha = fecha;
        }
    
        @ManyToOne
        public Funcionario getFuncionario() {
            return funcionario;
        }
    
        public void setFuncionario(Funcionario funcionario) {
            this.funcionario = funcionario;
        }
    
        public String getHora() {
            return hora;
        }
    
        public void setHora(String hora) {
            this.hora = hora;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getNum() {
            return num;
        }
    
        public void setNum(int num) {
            this.num = num;
        }
    
        @OneToMany(mappedBy = "ventaCab",cascade= CascadeType.ALL)
        public List<VentaDet> getVentaDets() {
            return ventaDets;
        }
    
        public void setVentaDets(List<VentaDet> ventaDets) {
            this.ventaDets = ventaDets;
        }
        
        
    }
    


    Explicación de algunos detalles.
    Clase que representa la cabecera de la Clase “Venta”. Como sabemos una transacción normalmente posee una tabla de tipo cabecera y otra de tipo detalle. En este caso la diferencia es que estas son clases y nada más. Algo importante de mencionar es la línea que incluye el objeto tipo Calendar que declaramos (private Calendar fecha;). La anotación para Calendar si utilizamos de ella fecha es como se indica (@Temporal(javax.persistence.TemporalType.DATE)). Si no indicamos como esta, podría dar pie a errores.
    Clase VentaCab
    Imagen(08)

  • (1) “private List ventaDets = new ArrayList();” estamos indicando una relación a través de una variable de tipo “List” con una Clase que se llama “VentaDet”. Esta relación es de tipo (OneToMany), con lo cual queremos decir que una venta cabecera puede contener varios detalles; las cuales almacenaremos en una lista.
  • (2) Indicamos que hay una relación con la clase “Cliente”. Dicho de otra forma, cada venta se debe realizar a un cliente y nada más.
  • (3) Indicamos que hay una relación con la clase “Funcionario”. Lo que vemos es que un funcionario debe ser responsable de realizar la venta.

    Clase persistente “VentaDet.java”.


  • Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class VentaDet implements Serializable {
        private int num;
        private Articulo articulo;
        private int cant;
        private int importe;
        private VentaCab ventaCab;
    
        @ManyToOne
        public Articulo getArticulo() {
            return articulo;
        }
    
        public void setArticulo(Articulo articulo) {
            this.articulo = articulo;
        }
    
        public int getImporte() {
            return importe;
        }
    
        public void setImporte(int importe) {
            this.importe = importe;
        }
        
        public int getCant() {
            return cant;
        }
    
        public void setCant(int cant) {
            this.cant = cant;
        }
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getNum() {
            return num;
        }
        
        public void setNum(int num) {
            this.num = num;
        }
    
        @ManyToOne
        public VentaCab getVentaCab() {
            return ventaCab;
        }
    
        public void setVentaCab(VentaCab ventaCab) {
            this.ventaCab = ventaCab;
        }   
        
    }
    


    Explicación de algunos detalles.
    En la Clase “VentaDet” vemos que hay una relación de tipo (ManyToOne) unidireccional con la clase “Articulo”. Con esto indicamos que un artículo puede relacionarse como muchas clases “VentaDet”, pero que no hace falta indicar una relación desde la Clase “Articulo”. También vemos que hay una relación de tipo (ManyToOne) bidireccional con la Clase “VentaCab”. Como indicamos más arriba una clase “VentaCab” puede contener varias Clases de tipo “VentaDet” y esta última puede relacionarse con una sola Clase “VentaCab”. Como vemos hay una relación de dependencia.


    Clase persistente “CompraCab.java”.

    Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.List;
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    import javax.persistence.OneToMany;
    import javax.persistence.Temporal;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class CompraCab implements Serializable {
        private List<CompraDet> compraDets = new ArrayList<CompraDet>();
        private int id;
        private int num;
        private Proveedor proveedor;
        private Funcionario funcionario;
        private Calendar fecha;
        private String hora;
        private long total;
    
        public int getNum() {
            return num;
        }
    
        public void setNum(int num) {
            this.num = num;
        }
            
        @Temporal(javax.persistence.TemporalType.DATE)
        public Calendar getFecha() {
            return fecha;
        }
    
        public void setFecha(Calendar fecha) {
            this.fecha = fecha;
        }
    
        
        @ManyToOne
        public Funcionario getFuncionario() {
            return funcionario;
        }
    
        public void setFuncionario(Funcionario funcionario) {
            this.funcionario = funcionario;
        }
    
        public String getHora() {
            return hora;
        }
    
        public void setHora(String hora) {
            this.hora = hora;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
        
        
        public void setId(int id) {
            this.id = id;
        }
    
       
        @ManyToOne
        public Proveedor getProveedor() {
            return proveedor;
        }
    
        public void setProveedor(Proveedor proveedor) {
            this.proveedor = proveedor;
        }
    
        public long getTotal() {
            return total;
        }
    
        public void setTotal(long total) {
            this.total = total;
        }
    
        @OneToMany(mappedBy = "cabecera",cascade= CascadeType.ALL)
        public List<CompraDet> getCompraDets() {
            return compraDets;
        }
    
        public void setCompraDets(List<CompraDet> compraDets) {
            this.compraDets = compraDets;
        }
            
    }
    


    Explicación de algunos detalles.
    Al igual que “VentaCab” la clase “CompraCab” representa la cabecera que corresponde a la transacción “Venta”. La Clase como se ve se relaciona con las Clases “Funcionario” (ManyToOne), “Proveedor” también (ManyToOne) y con “VentaDet” que es de tipo (OneToMany). Al igual que en “VentaCab” para la fecha se utiliza el objeto Calendar.


    Clase persistente “CompraDet.java”.

    Código Java
    package com.entidades;
    
    import java.io.Serializable;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    
    /**
     *
     * @author Ariel
     */
    @Entity
    public class CompraDet implements Serializable {
        private int id;
        private CompraCab cabecera;
        private Articulo articulo;
        private int cantidad;
        private long importe;
    
        @ManyToOne
        public Articulo getArticulo() {
            return articulo;
        }
    
        public void setArticulo(Articulo articulo) {
            this.articulo = articulo;
        }
    
        @ManyToOne
        public CompraCab getCabecera() {
            return cabecera;
        }
    
        public void setCabecera(CompraCab cabecera) {
            this.cabecera = cabecera;
        }
    
        public int getCantidad() {
            return cantidad;
        }
    
        public void setCantidad(int cantidad) {
            this.cantidad = cantidad;
        }
        
        @Id
        @GeneratedValue(strategy= GenerationType.IDENTITY)
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public long getImporte() {
            return importe;
        }
    
        public void setImporte(long importe) {
            this.importe = importe;
        }   
        
        
    }
    


    Explicación de algunos detalles.
    La estructura de esta clase es prácticamente igual que la de “VentaDet”, la diferencia es que “CompraDet” tiene que realizar una actualización positiva del stock, dicho de otra forma, se suman las cantidades a diferencia de la anterior.
    Con esto último terminamos la creación de las clases persistentes. Lo siguiente será empezar a crear formularios y almacenar datos.

    Al terminar de elaborar nuestras clases persistentes, tendremos que modificar el “hibernate.cfg” desde “Vista XML”, agregando las clases persistentes que hemos creado. El “hibernate.cfg” deberá quedar de la siguiente forma. Imagen(09).


    Imagen(09)

    003 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando paquetes, Base de Datos, realizando la conexión y configuración de HibernateUtil e hibernate.cfg.

    Creando paquetes.

    (Paquetes: Un Paquete en Java es un contenedor de clases que permite agrupar las distintas partes de un programa cuya funcionalidad tienen elementos comunes. Wikipedia…)

    Para crear un paquete hacemos clic derecho sobre “Paquetes de fuentes” que esta dentro del proyecto desplegado. Clic en “Nuevo” y seleccionando “Paquete Java…” le especificamos el nombre. Abajo la lista de paquetes a utilizar. (Img. 1)

  • com.app
    Para almacenar los formularios y clases ejecutables y de apoyo.
  • com.entidades
    Para almacenar las clases persistentes.
  • com.img
    Para almacenar las imágenes que utilizaremos para el proyecto.
  • com.informe
    Para almacenar los informes.
  • ultil
    Para almacenar la clase HibernateUtil. (Img. 2)

    Creando la Base de Datos, realizando la conexión y configuración de HibernateUtil e hibernate.cfg.

    Creando Base de Datos.

    Abrimos nuestro MySQL Workbench, que ya tendríamos de tener instalado junto con el MySQL y la instancia ya creada. Accedemos a “Local MySQL” como “root” indicando contraseña si tenemos configurado de esa forma.

    Ya dentro de la sesión hacemos clic sobre el icono de “Create a New Shema”, damos un nombre a la Base de Datos, en este caso “proyecto”, clic en “Apply”, nuevamente “Apply” y listo, ya tenemos nuestra Base de Datos. Las tablas las creará el Hibernate. (Img. db 1).


    Realizando la conexión y configuración de hibernate.cfg.

    Al configurar el hibernate.cfg también configuramos la conexión con la Base de Datos. Lo cual quiere decir que la misma queda a cargo del Hibernate. Desplegamos el proyecto, hacemos clic sobre “Paquetes de fuentes – Nuevo – Otros”. Dentro de categorías seleccionamos “Hibernar”, en “Tipos de Archivos” indicamos “Asistente de configuración de Hibernate” y clic en “Siguiente” (Img. 3).

    En la pantalla que aparece dejamos todo como está “Nombre de archivo: hibernate.cfg” “Carpeta: src”, este último indica que se guarda dentro del paquete predeterminado y no dentro de las que hemos creado. (Img. 4)

    Pantalla siguiente “Selecciones Data Source”. Dentro de “Conexión con base de datos” indicamos “Nueva Conexión de Base de Datos…” y se despliega la ventana “New Connection Wizard”. En este apartado indicamos “MySQL (Connector/J driver)” y clic en siguiente. (Img. 5)

    Pantalla siguiente “Customize Connection” rellenamos como indica la imagen, “Base de Datos: proyecto” “Nombre de Usuario: root” “Contraseña:“ la que hayamos establecido al crear la instancia de MySQL. Hacemos clic en “Test Connection” y si todo ha ido bien el mensaje será “Connection Succeeded”. Clic en “Siguiente” y a la pantalla siguiente “Terminar”. (Img. 6)

    Todo este proceso nos crea el archivo “hibernate.cfg” la cual iremos modificando según las necesidades.

    Por último hacemos una pequeña edición al “hibernate.cfg” que nos agrega dos líneas de código más. Quedando como se muestra en la imagen. Esto lo hacemos dentro de “Propiedades varias” y clic en “Agregar”. (Img. 7)

    Creando la clase HibernateUtil.java.

    Esta clase es la que nos crea sesiones a la nuestra fuente de datos, en este caso MySQL. Para esto utiliza el “hibernate.cfg” que creamos con anterioridad.

    Pasos: Hacemos clic derecho sobre “Paquetes de fuentes – Nuevo – Otros”. Dentro de categorías seleccionamos “Hibernar”, en “Tipos de Archivos” indicamos “HibernateUtil.java” y clic en “Siguiente” (Img. 8).

    Siguiente paso configuramos “Nombre y Ubicación”, “Nombre de Clase: HibernateUtil”, “Paquete: util” que creamos anteriormente (Img. 9).

    Clic en “Terminar”, nos abre la clase con los códigos prestablecidos, no hay nada para modificar: ej.


    Código Java
    package util;

    import org.hibernate.cfg.AnnotationConfiguration;
    import org.hibernate.SessionFactory;

    /**
    * Hibernate Utility class with a convenient method to get Session Factory object.
    *
    * @author Ariel
    */

    public class HibernateUtil {

    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;
    }
    }


  • 002 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando nuevo proyecto.

    Empezamos creando nuevo proyecto.

    Abrimos nuestro NetBeans IDE, que ya tendríamos que tener instalado.

    Vamos en el menú Archivo – Proyecto Nuevo. En “Categorías” seleccionamos “Java”, en “Proyectos” indicamos “Aplicación Java” y clic en siguiente. (Img. 1)

    Nombre de proyecto indicamos el que mejor nos parezca, “proyectoJava” en este caso para el tutorial.

    Podemos desmarcar “Crear clase principal” y “Configurar proyecto como principal”. (Img. 2)

    Paso siguiente crear paquetes, realizar la conexión y configurar HibernateUtil e hibernate.cfg.


    001 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Introducción.

    Conceptos previos.


    Hibernate.
    Es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma 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.
    Java Persistence API
    Java Persistence API, más conocida por sus siglas JPA, es la API de persistencia desarrollada para la plataforma Java EE. Es un framework del lenguaje de programación Java que maneja datos relacionales en aplicaciones usando la Plataforma Java en sus ediciones Standard y Enterprise.
    MySQL
    MySQL es un sistema de gestión de bases de datos relacional, multihilo y multiusuario con más de seis millones de instalaciones.
    JasperReports con iReport.
    JasperReports es una herramienta de creación de informes que tiene la habilidad de entregar contenido enriquecido al monitor, a la impresora o a ficheros PDF, HTML, XLS, CSV y XML. Está escrito completamente en Java y puede ser usado en gran variedad de aplicaciones de Java, incluyendo J2EE o aplicaciones web, para generar contenido dinámico. Su propósito principal es ayudar a crear documentos de tipo páginas, preparados para imprimir en una forma simple y flexible. JasperReports se usa comúnmente con iReport, un front-end gráfico de código abierto para la edición de informes. Se encuentra bajo licencia libre GNU, por lo que es Software libre. Forma parte de la iniciativa apilada open source Lisog. (Wikipedia)

    Herramientas necesarias para el desarrollo.


  • JDK.: Java Development Kit o (JDK), es un software que provee herramientas de desarrollo para la creación de programas en Java.
  • NetBeans IDE. Es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programación Java.
  • MySQL.
  • MySQL Workbench (GUI Tool).
  • iReport. -- Descarga: Instalador-Librerias iReport-4.7.0.zip
  • Hibernate: Utilizaremos el que se incluye con el Netbeans.