Download Generación Entity Classes desde Database

Conceptualización
Diferencias con los beans de sesión y
de Entidad
Los beans de entidad se diferencian de los beans de
sesión, principalmente, en que son persistentes,
permiten el acceso compartido, tienen clave primaria
y pueden participar en relaciones con otros beans de
entidad
Diferencias con los beans de sesión y de
Entidad
Persistencia
Debido a que un bean de entidad se guarda en un mecanismo
de almacenamiento se dice que es persistente. Persistente
significa que el estado del bean de entidad existe más tiempo
que la duración de la aplicación o del proceso del servidor J2EE.
Un ejemplo de datos persistentes son los datos que se
almacenan en una base de datos.
Diferencias con los beans de sesión y de
Entidad
Persistencia
Los beans de entidad tienen dos tipos de persistencia:
a) Persistencia Gestionada por el Bean (BMP, Bean-Managed Persistence):
el bean de entidad contiene el código que accede a la base de datos
b) Persistencia Gestionada por el Contenedor (CMP, Container-Managed
Persistence): la relación entre las columnas de la base de datos y el bean
se describe en el fichero de propiedades del bean, y el contenedor EJB se
ocupa de la implementación.
Diferencias con los beans de sesión y de
Entidad
Acceso compartido
Los clientes pueden compartir beans de entidad, con lo que el
contenedor EJB debe gestionar el acceso concurrente a los
mismos y por ello debe usar transacciones.
La forma de hacerlo dependerá de la política que se especifique
en los descriptores del bean.
Diferencias con los beans de sesión y de
Entidad
Clave primaria
Cada bean de entidad tiene un identificador único.
Un bean de entidad alumno, por ejemplo, puede identificarse
por su número de expediente.
Este identificador único, o clave primaria, permite al cliente
localizar a un bean de entidad particular.
Diferencias con los beans de sesión y de
Entidad
Relaciones
De la misma forma que una tabla en una base de datos
relacional, un bean de entidad puede estar relacionado con otros
EJB.
Por ejemplo, en una aplicación de gestión administrativa de una
universidad, el bean alumnoEjb y el bean actaEjb estarían
relacionados porque un alumno aparece en un acta con una
calificación determinada.
Diferencias con los beans de sesión y de
Entidad
Relaciones
Las relaciones se implementan de forma distinta según se esté usando la
persistencia manejada por el bean o por el contenedor.
• En el primer caso, al igual que la persistencia, el desarrollador debe
programar y gestionar las relaciones.
• En el segundo caso es el contenedor el que se hace cargo de la gestión de
las relaciones. Por ello, estas últimas se denominan a veces relaciones
gestionadas por el contenedor.
Evolución del Framework
Capa empresarial
Los beans de sesión se utilizan para
envolver
componentes
de
lógica
empresarial, proporcionándoles servicios
transaccionales, distribuidos, remotos y
de seguridad.
Suelen implementar un patrón de fachada
para reducir el tráfico de red entre el
cliente y el proveedor de servicios.
Los clientes locales (residen en la misma
JVM) o los clientes remotos pueden
acceder a los beans de sesión.
Las capas permite características básicas
como la separación de obligaciones y
habilidades, agrupación en clústeres y
reutilización de componentes.
Capa de persistencia
Es el conjunto de servicios y
componentes que permiten que los
datos de la aplicación sean persistentes
en una base de datos relacional.
La capa de persistencia puede
implementarse de estas maneras:
a) Beans
de
entidad
(beans
gestionados por contenedor y beans
gestionados por beans)
b) Objetos de
JDBC(DAO)
acceso
de
datos
c) Infraestructuras de correlaciones
relacionales de objeto (ORM)
Modelo simplificado en EJB 3.0
La arquitectura global de Java EE y EJB 3.0 refleja la simplificación del modelo EJB 3.0:
EJB 3.0 se centra en un modelo de
programación POJO (antiguo objeto
Java simple) que utiliza anotaciones
Java para capturar la información
que los descriptores de despliegue
solían contener.
Los descriptores de despliegue
ahora son opcionales en la mayoría
de los casos.
La utilización liberal de los valores
predeterminados significa también
que es necesario escribir y mantener
menos código de soporte.
Las características principales de este
modelo son
a)Los EJB ahora son objetos POJO que
exponen interfaces de empresa normales
(POJI) y no hay ningún requisito para
interfaces de inicio.
b)Utilización de anotaciones de metadatos:
una infraestructura ampliable, gestionada
por metadatos, orientada a atributos, que
se emplea para generar código Java o
descriptores de despliegue XML.
c) Eliminación del requisito de interfaces y
descriptores
de
despliegue
(la
información de descriptor de despliegue
se puede sustituir por anotaciones)
específicos.
d) El recurso interceptor para invocar
métodos de usuario en la invocación
de métodos empresariales o eventos
de ciclo de vida.
e)Los valores predeterminados se
utilizan siempre que sea posible
(enfoque
“configuración
por
excepción”).
f) La reducción en los requisitos para la
utilización de la excepción marcada.
g)Un nuevo modelo de persistencia
completo (basado en el estándar JPA),
que reemplaza beans de entidad EJB
2.x.
JPA Vs Hibernate
JPA (Java Persistence API): es una parte de la
especificación de EJB 3 ( JSR 220) . Por lo tanto no
existe realmente como framework, sino que es
simplemente un documento. Un documento en el
cual se especifica los principios básicos de gestión de
la capa de persistencia en el mundo de Java EE.
Hibernate como frameworks de persistencia. Si es
algo real y se trata de un framework que gestiona la
capa de persistencia a través de ficheros xml o
anotaciones.
Relación entre JPA e Hibernate
Hibernate implementa como parte de su código la especificación de JPA. Es
decir, se puede usar Hibernate para construir una capa de persistencia
apoyándose en las definiciones y reglas que la especificación de JPA, aunque
no es obligatorio.
Esto no quiere decir que Hibernate simplemente
implemente el standard de JPA.
Hibernate es mucho más grande que la especificación
de JPA y añade más funcionalidad.
Discordancias entre los modelos
relacionales y objeto
Los objetos relacionales están representados en un
formato tabular, mientras que modelos de objetos son
representados en un gráfico de interconexión formato
de objeto.
Discordancias entre los modelos relacionales y objeto
Al almacenar y recuperar un modelo de objetos a partir de una base de
datos relacional, se producen incongruencias debido a razones:
• Granularidad: el modelo de objetos tiene mayor nivel de detalle del
modelo relacional.
• Los subtipos: (significa herencia) no es compatible con todos los tipos de
bases de datos relacionales.
• Identidad: El modelo de objetos no es idéntico al modelo relacional.
• Asociaciones: Los modelos relacionales no puede determinar relaciones
múltiples como lo hace el modelo de dominio de los objetos.
• Navegación de datos: Los datos de navegación entre objetos en un objeto
red es diferente en ambos modelos.
¿Qué es JPA?
Java Persistence API: conjunto de clases y
métodos que almacenan gran cantidad de datos
a una base de datos.
¿Dónde usar JPA?
Se usa para reducir la carga de escribir código para gestión de
objetos relacionales, permitiendo la fácil interacción con
instancias de la base de datos.
Arquitectura JPA
Unidades
Arquitectura JPA
Descripción
EntityMana Clase de fábrica de EntityManager.
gerFactory Crea
y
gestiona
múltiples
instancias EntityManager.
EntityMana Interfaz,
que
gestiona
la
ger.
persistencia de objetos. Funciona
como instancia de consulta.
Entidad
Las entidades son los objetos de
persistencia, almacenados como
registros en la base de datos.
EntityTrans Tiene una relación de uno a uno
action
con EntityManager. Para cada
método
EntityManager,
las
operaciones son mantenidas por
la calse EntityTransaction.
Persistencia Esta clase contiene
estáticos
para
EntityManagerFactory.
Consulta
métodos
obtener
Esta interfaz es implementada por
cada proveedor JPA relacional para
obtener objetos que cumplan los
criterios.
Las relaciones entre las clases JPA.
En la arquitectura, las relaciones entre las clases e interfaces se
gestionan en el paquete javax.persistence.
Las relaciones entre las clases JPA.
• La relación entre EntityManagerFactory
EntityManager es de uno a varios. Se trata
de una clase de fábrica a instancias
EntityManager.
• La relación entre EntityManager y
EntityTransaction es uno a uno. para cada
operación EntityManager, hay una instancia
EntityTransaction.
• La relación entre EntityManager y Query es
de uno a varios. Muchas consultas puede
ejecutar
mediante
una
instancia
EntityManager.
• La relación entre Entity y EntityManager
es uno de muchos. Una instancia
EntityManager puede administrar varias
entidades
Object Relational Mapping (ORM)
ORM es una capacidad de programación para convertir los datos de
tipo de objeto a tipo relacional y viceversa.
La principal característica de ORM es de mapear o enlazar un
objeto a sus datos en la base de datos. El mapeo tiene que tener en
cuenta los datos, el tipo de datos, y sus relaciones con la entidad o
entidades en cualquier otra tabla.
Funciones avanzadas
• Persistencia idiomáticas: permite escribir clases persistentes
utilizando las clases orientadas a objetos.
• Fiable: es muy estable y utilizado por muchos programadores
profesionales.
Arquitectura ORM
Como almacenar un Objeto en una Tabla
Fase1
Denominada fase de datos del objeto, contiene los POJO, interfaces
y clases. Es la capa principal del negocio, que tiene las operaciones de
lógica de negocios y atributos.
Por ejemplo, al tener una base de datos de empleados como
esquema.
• La clase POJO Empleado contiene atributos como ID, nombre,
salario, y designación. También contiene métodos setter y getter
de esos atributos.
• Empleado DAO contienen métodos de servicio tales como crear
empleado, encontrar los empleados y eliminar empleado.
Como almacenar un Objeto en una Tabla
Fase2
Denominada fase de mapeo o persistencia, contiene el JPA provider,
archivo de mapas (ORM.xml), JPA Loader y Object Grid.
• JPA Provider: es el proveedor del producto que contiene el JPA
(javax.persistence). Por ejemplo Eclipselink, Toplink, hibernate, etc.
• Archivo de Mapeo: (ORM.xml) contiene la configuración de mapeo entre
los datos de un POJO y los datos en una base de datos relacional.
• JPA Loader: funciona como una memoria caché. Puede cargar los datos
relacionales en una grid. Funciona como una copia de base de datos para
interactuar con los servicios del POJO (atributos de clase).
• Object Grid: es una ubicación temporal que puede almacenar una copia
de los datos relacionales, como una memoria caché. Todas las consultas
en la base de datos se efectuará, primero en los datos del grid. Sólo
después de que se ha commited, se afecta la base de datos principal.
Como almacenar un Objeto en una Tabla
Fase 3
Fase de datos relacionales. Contiene los datos relacionales que
son lógicamente conectados al componente de negocio. Sólo
cuando el componente de negocio commit los datos, se
almacenan en la base de datos físicamente.
Hasta entonces, los datos modificados se almacenan en una
memoria caché como una grid. El proceso de obtención de los
datos es idéntico al de almacenar los datos.
Este mecanismo de interacción
denomina mapeo objeto-relacional.
de
tres
fases
se
Como hacer el Mapeo de una Clase
El archivo mapping.xml le indica al proveedor como
mapear una entidad a una tabla.
Ejemplo
Entidad Empleado: contiene cuatro atributos. El
POJO Employee.java es la siguiente:
Como hacer el Mapeo de una Clase: El POJO
public class Employee {
private int eid;
private String ename;
private double salary;
private String deg;
public Employee(int eid, String ename,
double salary, String deg) {
super( );
this.eid = eid;
this.ename = ename;
this.salary = salary;
this.deg = deg;
}
public Employee( ) {
super(); }
public int getEid( ) {
return eid; }
public void setEid(int eid) {
this.eid = eid; }
public String getEname( ) {
return ename; }
public void setEname(String ename) {
public double getSalary( ) {
return salary; }
public void setSalary(double salary) {
public String getDeg( ) {
this.salary = salary; }
return deg; }
public void setDeg(String deg) {
}
this.ename = ename; }
this.deg = deg; }
Como hacer el Mapeo de una Clase: mapping.xml
<? xml version="1.0" encoding="UTF-8" ?>
<entity-mappings
xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
http://java.sun.com/xml/ns/persistence/orm_1_0.xsd"
version="1.0">
<description> XML Mapping file</description>
<entity class="Employee">
<table name="EMPLOYEETABLE"/>
<attributes>
<id name="eid">
<generated-value strategy="TABLE"/>
</id>
<basic name="ename">
<column name="EMP_NAME" length="100"/>
</basic>
<basic name="salary">
</basic>
<basic name="deg">
</basic>
</attributes>
</entity>
</entity-mappings>
El script para el mapeo de la clase a la tabla usa:
• <entity-mappings> definición de esquema para
permitir los tags de entidad en archivo xml.
• <description> : ofrece una descripción acerca
de la aplicación.
• <entity> : define la clase que desea convertir
en una tabla en una base de datos. Define el
nombre de la clase de entidad.
• <table> : define el nombre de la tabla. Si desea
tener nombres idénticos tanto para la clase, así
como la tabla, este tag no es necesario.
• <attributes> : define los atributos (campos de
una tabla).
• <id> : define la clave principal de la tabla. El tag
<generated-value> define cómo asignar el valor
de la clave principal; automática, manual o
de secuencia.
• <basic> : se utiliza para definir los atributos de
la tabla.
• <column-name> : se usa para definir nombres
de tablas definidas por el usuario.
Las Anotaciones
Generalmente los archivos XML son utilizados para configurar
componentes específicos, o mapear dos especificaciones diferentes
de componentes.
Al escribir un archivo de asignación xml, se debe comparar los
atributos de la clase POJO con las etiquetas de la entidad en el
archivo mapping.xml.
En la definición de la clase, se describe la configuración con
anotaciones. Las anotaciones se utilizan para las clases, propiedades
y métodos. Las anotaciones comienzan con el símbolo " @".
Las anotaciones son declarados antes de una clase, propiedad o
método. Todas las anotaciones de JPA se definen en el
paquete javax.persistence
Las anotaciones
Anotación
@Entity
@Table
@Basic
@Embedded
@Id
@GeneratedValue
Descripción
Declara la clase como una entidad o una tabla.
Declara nombre de la tabla.
Especifica restricción explícita.
Especifica las propiedades de la clase o de una entidad cuyo valor es una instancia de una clase
embebida.
Especifica la propiedad, usada por la identidad (la clave principal) de una clase.
@AccessType
Especifica el modo en que la identidad puede inicializar un atributo como automática, manual o
valor tomado de secuencias.
Especifica la propiedad que no es constante, es decir, el valor nunca se almacena en la base de
datos.
Especifica el atributo para la propiedad persistence.
Especifica el valor de la propiedad que se especifica en la anotación @GeneratedValue. Crea una
secuencia.
Especifica el generador de valor para la propiedad especificada en la anotación @GeneratedValue.
Crea una tabla de generación de valor.
Este tipo de anotación se utiliza para establecer el tipo de acceso.
@JoinColumn
Especifica la entidad asociación. Esto se utiliza en asociaciones muchos-a-uno y uno-a-muchas.
@UniqueConstraint
@ColumnResult
Especifica los campos y las restricciones unique para la tabla primaria o la secundaria.
Hace referencia al nombre de una columna de la consulta SQL que utiliza cláusula select.
@ManyToMany
@ManyToOne
@OneToMany
@OneToOne
@NamedQueries
@NamedQuery
Define una relación many-to-many entre tablas.
Define una relación de many-to-one entre tablas.
Define una relación one-to-many entre tablas.
Define una relación one-to-one entre tablas.
Especifica la lista de consultas.
Especifica una consulta con nombre estático.
@Transient
@Column
@SequenceGenerator
@TableGenerator
Como hacer un primer
Mapeo en NetBeans
1. Cree en NetBeans, una base de datos “RegistroJPA”
2. Cree una tabla “Estudiantes”, con los campos Código (Varchar
10), Nombre (Varchar 25), Apellido (Varchar 25)
3. Inserte unos registros
Generación Entity Classes desde Database
JPA requiere que identifique las clases que almacenara en la base
de datos. El API usa el termino entity para definir las clases que
mapeara a la base de datos relacional.
Identifique las entidades persistentes y defina sus relaciones
usando anotaciones.
Una entidad representa una tabla en una base de datos
relacional. Cada instancia de entidad corresponde a una fila en la
tabla.
Una entidad es codificada como un POJO.
Generación Entity Classes desde Database
1. Cree un proyecto Java Application (sin main), denominado
“ PersistenciaDemo.”
Generación Entity Classes desde Database
Dentro del proyecto cree un nuevo “ Entity Classes From
Database”
Generación Entity Classes desde Database
Para este “ Entity Classes From Database” ingrese la siguiente
información y oprima NEXT:
Generación Entity Classes desde Database
En la siguiente ventana, ingrese el “Package Name” como “demo”
y oprima NEXT:
Generación Entity Classes desde Database
En la ventana de Mappings seleccione “Finish” con los valores
por defecto:
Generación Entity Classes desde Database
Inmediatamente se crea una clase con las respectivas
anotaciones:
Generación Entity Classes desde Database
La entidad creada se denomina “persistence unit”. Las
Persistence units son configuradas en un archivo XML
ubicado en la carpeta META-INF.
Se usa para especificarle al proveedor de persistencia los
nombres de las entidades y sus atributos, y las
propiedades de la base de datos como connection URL,
driver, user, password.
Generación Entity Classes desde Database
Implementado el CRUD usando JPA
Los objetos Entity son instancias en memoria de las clases entity,
las cuales representan objetos físicos de la base de datos.
En JPA se pueden usar entity objects para muchas operaciones,
incluyendo Crear , Consultar, Actualizar y Borrar objetos de la
base de datos.
Se necesitan tres artefactos para implementar las operaciones
CRUD usando JPA:
1. Una clase Entity
2. Un archivo persistence.xml
3. Una clase (o cliente) a través de la cual se realicen las
respectivas operaciones.
Implementado la Inserción usando JPA
Para crear el cliente que realizara dicha operaciones, se desarrollan los siguientes pasos:
1.
2.
En el Proyecto PersistenciaDemo cree una nueva clase “InsertarEstudiante” y guárdela en
el paquete Demo.
Abra la clase e importe las siguientes clases:
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
3. Cree el metodo main en esta clase y adicione las siguientes líneas:
public static void main(String[] args) {
EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersistenciaDemoPU");
EntityManager em = emf.createEntityManager();
}
Implementado la Inserción usando JPA
Implementado la Inserción usando JPA
Este código muestra la creación de una instancia de EntityManager. De persistir una nueva entidad,
se necesita una instancia de EntityManager.
EntityManagerFactory es una fábrica para la creación de un EntityManager. EntityManager
gestiona entidades y es responsable de su adición, actualización y eliminación. La instancia
EntityManager representa una unidad de persistencia, y debe proporcionar el nombre de la unidad
de persistencia. En este ejemplo PersistenceDemoPU es el nombre de la unidad de persistencia
que se declara en el archivo persistencia.xml junto con otras propiedades.
Implementado la Inserción usando JPA
Adicione el siguiente código al main
Estudiantes p1 = new Estudiantes();
p1.setCodigo("201020");
p1.setNombre("Juan");
p1.setApellido("Perez");
em.persist(p1);
Estudiantes p2 = new Estudiantes();
p2.setCodigo("2009020");
p2.setNombre("Maria");
p2.setApellido("Alvarez");
em.persist(p2);
em.getTransaction().commit();
em.close();
emf.close();
Este código crea una transacción, 2 objetos de la clase Estudiantes, que se mantuvo
como 2 filas de la tabla del Estudiantes.
Implementado la Inserción usando JPA
Implementado la Inserción usando JPA
Adicione el jar del cliente de Derby, al proyecto
Implementado la Inserción usando JPA
a) En la ventana Proyectos, haga clic derecho a la clase InsertarEstudiante.java y
seleccione “Ejecutar”.
b) Verifique la salida. Examine el contenido de la base de datos.
Bibliografía
https://jcp.org/aboutJava/communityprocess/final/jsr220/index.html
http://docs.oracle.com/javaee/6/tutorial/doc/