JPA - Guía rápida

Cualquier aplicación empresarial realiza operaciones de base de datos almacenando y recuperando grandes cantidades de datos. A pesar de todas las tecnologías disponibles para la gestión del almacenamiento, los desarrolladores de aplicaciones normalmente luchan por realizar las operaciones de la base de datos de manera eficiente.

Generalmente, los desarrolladores de Java usan mucho código, o usan el marco propietario para interactuar con la base de datos, mientras que al usar JPA, la carga de interactuar con la base de datos se reduce significativamente. Forma un puente entre los modelos de objetos (programa Java) y los modelos relacionales (programa de base de datos).

Discordancias entre modelos relacionales y de objetos

Los objetos relacionales se representan en formato tabular, mientras que los modelos de objetos se representan en un gráfico interconectado de formato de objeto. Al almacenar y recuperar un modelo de objetos de una base de datos relacional, se producen algunas discrepancias debido a las siguientes razones:

  • Granularity : El modelo de objetos tiene más granularidad que el modelo relacional.

  • Subtypes : Los subtipos (significa herencia) no son compatibles con todos los tipos de bases de datos relacionales.

  • Identity : Al igual que el modelo de objetos, el modelo relacional no expone la identidad al escribir igualdad.

  • Associations : Los modelos relacionales no pueden determinar múltiples relaciones mientras miran el modelo de dominio de objetos.

  • Data navigation : La navegación de datos entre objetos en una red de objetos es diferente en ambos modelos.

¿Qué es JPA?

La API de persistencia de Java es una colección de clases y métodos para almacenar de forma persistente grandes cantidades de datos en una base de datos proporcionada por Oracle Corporation.

¿Dónde usar JPA?

Para reducir la carga de escribir códigos para la gestión de objetos relacionales, un programador sigue el marco 'JPA Provider', que permite una fácil interacción con la instancia de la base de datos. Aquí, el marco requerido es asumido por JPA.

Historia de JPA

Versiones anteriores de EJB, capa de persistencia definida combinada con capa de lógica empresarial usando la interfaz javax.ejb.EntityBean.

  • Al presentar EJB 3.0, la capa de persistencia se separó y se especificó como JPA 1.0 (API de persistencia de Java). Las especificaciones de esta API se publicaron junto con las especificaciones de JAVA EE5 el 11 de mayo de 2006 utilizando JSR 220.

  • JPA 2.0 se lanzó con las especificaciones de JAVA EE6 el 10 de diciembre de 2009 como parte de Java Community Process JSR 317.

  • JPA 2.1 se lanzó con la especificación de JAVA EE7 el 22 de abril de 2013 utilizando JSR 338.

Proveedores de JPA

JPA es una API de código abierto, por lo tanto, varios proveedores empresariales como Oracle, Redhat, Eclipse, etc. proporcionan nuevos productos al agregarles el sabor de persistencia JPA. Algunos de estos productos incluyen:

Hibernate, Eclipselink, Toplink, Spring Data JPA, etc.

La API de persistencia de Java es una fuente para almacenar entidades comerciales como entidades relacionales. Muestra cómo definir un OBJETO JAVA ANTIGUO PLANO (POJO) como una entidad y cómo gestionar entidades con relaciones.

Arquitectura de nivel de clase

La siguiente imagen muestra la arquitectura de nivel de clase de JPA. Muestra las clases principales e interfaces de JPA.

La siguiente tabla describe cada una de las unidades que se muestran en la arquitectura anterior.

Unidades Descripción
EntityManagerFactory Esta es una clase de fábrica de EntityManager. Crea y administra múltiples instancias de EntityManager.
EntityManager Es una interfaz, gestiona las operaciones de persistencia en los objetos. Funciona como fábrica para la instancia de consulta.
Entity Las entidades son los objetos de persistencia que se almacenan como registros en la base de datos.
EntityTransaction Tiene una relación de uno a uno con EntityManager. Para cada EntityManager, las operaciones se mantienen mediante la clase EntityTransaction.
Persistence Esta clase contiene métodos estáticos para obtener la instancia de EntityManagerFactory.
Query Cada proveedor de JPA implementa esta interfaz para obtener objetos relacionales que cumplan con los criterios.

Las clases e interfaces anteriores se utilizan para almacenar entidades en una base de datos como un registro. Ayudan a los programadores reduciendo sus esfuerzos para escribir códigos para almacenar datos en una base de datos para que puedan concentrarse en actividades más importantes, como escribir códigos para mapear las clases con tablas de la base de datos.

Relaciones de clase JPA

En la arquitectura anterior, las relaciones entre las clases y las interfaces pertenecen al paquete javax.persistence. El siguiente diagrama muestra la relación entre ellos.

  • La relación entre EntityManagerFactory y EntityManager es one-to-many. Es una clase de fábrica para las instancias de EntityManager.

  • La relación entre EntityManager y EntityTransaction es one-to-one. Para cada operación de EntityManager, hay una instancia de EntityTransaction.

  • La relación entre EntityManager y Query es one-to-many. Se pueden ejecutar muchas consultas utilizando una instancia de EntityManager.

  • La relación entre EntityManager y Entity es one-to-many. Una instancia de EntityManager puede administrar varias Entidades.

La mayoría de las aplicaciones contemporáneas utilizan bases de datos relacionales para almacenar datos. Recientemente, muchos proveedores cambiaron a la base de datos de objetos para reducir su carga de mantenimiento de datos. Significa que la base de datos de objetos o las tecnologías relacionales de objetos se encargan de almacenar, recuperar, actualizar y mantener los datos. La parte central de esta tecnología relacional de objetos es el mapeo de archivos orm.xml. Como xml no requiere compilación, podemos realizar cambios fácilmente en múltiples fuentes de datos con menos administración.

Mapeo relacional de objetos

El mapeo relacional de objetos (ORM) le informa brevemente sobre qué es ORM y cómo funciona. ORM es una capacidad de programación para convertir datos del tipo de objeto al tipo relacional y viceversa.

La característica principal de ORM es mapear o vincular un objeto a sus datos en la base de datos. Al mapear, tenemos que considerar los datos, el tipo de datos y sus relaciones con la propia entidad o entidades en cualquier otra tabla.

Características avanzadas

  • Idiomatic persistence : Le permite escribir las clases de persistencia utilizando clases orientadas a objetos.

  • High Performance : Tiene muchas técnicas de búsqueda y técnicas de bloqueo esperanzadoras.

  • Reliable : Es muy estable y lo utilizan muchos programadores profesionales.

Arquitectura ORM

La arquitectura ORM se ve de la siguiente manera.

La arquitectura anterior explica cómo se almacenan los datos del objeto en una base de datos relacional en tres fases.

Fase 1

La primera fase, denominada como object data phase, contiene clases de POJO, interfaces de servicio y clases. Es la capa principal del componente empresarial, que tiene operaciones y atributos de lógica empresarial.

Por ejemplo, tomemos una base de datos de empleados como esquema.

  • La clase POJO de empleado contiene atributos como ID, nombre, salario y designación. También contiene métodos como setter y getter de esos atributos.

  • Las clases de servicio / DAO de empleado contienen métodos de servicio como crear empleado, encontrar empleado y eliminar empleado.

Fase 2

La segunda fase, nombrada como mapping o persistence phase, contiene el proveedor JPA, el archivo de mapeo (ORM.xml), el cargador JPA y la cuadrícula de objetos.

  • JPA Provider: Es el producto del proveedor que contiene el sabor JPA (javax.persistence). Por ejemplo, Eclipselink, Toplink, Hibernate, etc.

  • Mapping file : El archivo de mapeo (ORM.xml) contiene la configuración de mapeo entre los datos en una clase POJO y los datos en una base de datos relacional.

  • JPA Loader: El cargador JPA funciona como una memoria caché. Puede cargar los datos de la red relacional. Funciona como una copia de la base de datos para interactuar con las clases de servicio para los datos POJO (atributos de la clase POJO).

  • Object Grid: Es una ubicación temporal que puede almacenar una copia de datos relacionales, como una memoria caché. Todas las consultas a la base de datos se efectúan primero en los datos de la cuadrícula de objetos. Solo después de que se confirma, afecta a la base de datos principal.

Fase 3

La tercera fase es la relational data phase. Contiene los datos relacionales que están conectados lógicamente al componente empresarial. Como se mencionó anteriormente, solo cuando el componente empresarial confirma los datos, se almacenan físicamente en la base de datos. Hasta entonces, los datos modificados se almacenan en una memoria caché en formato de cuadrícula. El proceso de obtención de datos es idéntico al de almacenamiento de datos.

El mecanismo de la interacción programática de las tres fases anteriores se denomina como object relational mapping.

Mapping.xml

El archivo mapping.xml es para indicarle al proveedor de JPA que mapee las clases de entidad con las tablas de la base de datos.

Tomemos un ejemplo de entidad Empleado que contiene cuatro atributos. La clase POJO de entidad de empleado denominadaEmployee.java es como sigue:

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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
}

El código anterior es la clase POJO de entidad de empleado. Contiene cuatro atributoseid, ename, salaryy deg. Considere estos atributos como los campos de la tabla en una tabla yeidcomo la clave principal de esta tabla. Ahora tenemos que diseñar el archivo de mapeo de hibernación para él. El archivo de mapeo llamadomapping.xml es como sigue:

<? 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 anterior se utiliza para mapear la clase de entidad con la tabla de la base de datos. En este archivo

  • <entity-mappings> : etiqueta define la definición de esquema para permitir etiquetas de entidad en un archivo xml.

  • <description> : etiqueta proporciona una descripción sobre la aplicación.

  • <entity>: tag define la clase de entidad que desea convertir en tabla en una base de datos. La clase de atributo define el nombre de la clase de entidad POJO.

  • <table>: etiqueta define el nombre de la tabla. Si desea tener nombres idénticos tanto para la clase como para la tabla, esta etiqueta no es necesaria.

  • <attributes> : etiqueta define los atributos (campos en una tabla).

  • <id>: etiqueta define la clave principal de la tabla. los<generated-value> La etiqueta define cómo asignar el valor de la clave principal, como Automatic, Manual, o tomado de Sequence.

  • <basic> : la etiqueta se utiliza para definir los atributos restantes de la tabla.

  • <column-name> : la etiqueta se utiliza para definir nombres de campo de tabla definidos por el usuario en la tabla.

Anotaciones

Generalmente, los archivos xml se utilizan para configurar componentes específicos o mapear dos especificaciones diferentes de componentes. En nuestro caso, tenemos que mantener los archivos xml por separado en un marco. Eso significa que mientras escribimos un archivo xml de mapeo, necesitamos comparar los atributos de la clase POJO con las etiquetas de entidad en el archivo mapeo.xml.

Aqui esta la solucion. En la definición de clase, podemos escribir la parte de configuración usando anotaciones. Las anotaciones se utilizan para clases, propiedades y métodos. Las anotaciones comienzan con el símbolo '@'. Las anotaciones se declaran antes que una clase, propiedad o método. Todas las anotaciones de JPA se definen en eljavax.persistence paquete.

A continuación, se incluye una lista de anotaciones utilizadas en nuestros ejemplos.

Anotación Descripción
@Entidad Declara la clase como entidad o tabla.
@Mesa Declara el nombre de la tabla.
@Básico Especifica campos sin restricciones de forma explícita.
@Incrustado Especifica las propiedades de la clase o una entidad cuyo valor es una instancia de una clase incrustable.
@Carné de identidad Especifica la propiedad, uso para la identidad (clave principal de una tabla) de la clase.
@GeneratedValue Especifica cómo se puede inicializar el atributo de identidad, como automático, manual o valor tomado de una tabla de secuencia.
@Transitorio Especifica la propiedad que no es persistente, es decir, el valor nunca se almacena en la base de datos.
@Columna Especifica el atributo de columna para la propiedad de persistencia.
@SequenceGenerator Especifica el valor de la propiedad que se especifica en la anotación @GeneratedValue. Crea una secuencia.
@TableGenerator Especifica el generador de valor para la propiedad especificada en la anotación @GeneratedValue. Crea una tabla para la generación de valor.
@Tipo de acceso Este tipo de anotación se utiliza para establecer el tipo de acceso. Si establece @AccessType (FIELD), el acceso se produce en el campo. Si establece @AccessType (PROPERTY), el acceso se produce según la propiedad.
@UnirseColumna Especifica una asociación de entidades o una colección de entidades. Esto se usa en asociaciones de varios a uno y de uno a varios.
@UniqueConstraint Especifica los campos y las restricciones exclusivas para la tabla primaria o secundaria.
@ColumnResult Hace referencia al nombre de una columna en la consulta SQL mediante la cláusula select.
@Muchos a muchos Define una relación de varios a varios entre las tablas de unión.
@ManyToOne Define una relación de varios a uno entre las tablas de unión.
@Uno a muchos Define una relación de uno a varios entre las tablas de unión.
@Doce y cincuenta y nueve de la noche Define una relación de uno a uno entre las tablas de unión.
@NamedQueries especifica la lista de consultas con nombre.
@NamedQuery Especifica una consulta con un nombre estático.

Estándar de Java Bean

La clase Java encapsula los valores de la instancia y sus comportamientos en una sola unidad llamada objeto. Java Bean es un componente o un objeto de almacenamiento temporal y reutilizable. Es una clase serializable que tiene un constructor predeterminado y métodos getter y setter para inicializar los atributos de la instancia individualmente.

Convenciones de frijoles

  • Bean contiene su constructor predeterminado o un archivo que contiene una instancia serializada. Por lo tanto, un bean puede instanciar otro bean.

  • Las propiedades de un frijol se pueden segregar en propiedades booleanas o propiedades no booleanas.

  • La propiedad no booleana contiene getter y setter métodos.

  • La propiedad booleana contiene setter y is método.

  • Getter El método de cualquier propiedad debe comenzar con letras pequeñas. get(convención del método java) y continúa con un nombre de campo que comienza con mayúscula. Por ejemplo, el nombre del campo essalary por lo tanto, el método getter de este campo es getSalary ().

  • Setter El método de cualquier propiedad debe comenzar con letras pequeñas. set (convención del método java), continuó con un nombre de campo que comienza con mayúscula y la argument valuepara establecer en el campo. Por ejemplo, el nombre del campo essalary por lo tanto, el método de establecimiento de este campo es setSalary ( double sal ).

  • Para la propiedad booleana, ismétodo para comprobar si es verdadero o falso. Por ejemplo, la propiedad booleanaempty, la is El método de este campo es isEmpty ().

Este capítulo lo lleva a través del proceso de configuración de JPA en sistemas basados ​​en Windows y Linux. JPA puede instalarse e integrarse fácilmente con su entorno Java actual siguiendo unos sencillos pasos sin ningún procedimiento de configuración complejo. Se requiere la administración de usuarios durante la instalación.

Requisitos del sistema

JDK Java SE 2 JDK 1.5 o superior
Memoria 1 GB de RAM (recomendado)
Espacio del disco Sin requisito mínimo
Versión del sistema operativo Windows XP o superior, Linux

Procedamos ahora con los pasos para instalar JPA.

Paso 1: Verifique su instalación de Java

En primer lugar, debe tener instalado el kit de desarrollo de software (SDK) de Java en su sistema. Para verificar esto, ejecute cualquiera de los siguientes dos comandos dependiendo de la plataforma en la que esté trabajando.

Si la instalación de Java se ha realizado correctamente, mostrará la versión actual y la especificación de su instalación de Java. En la siguiente tabla se proporciona un resultado de muestra.

Plataforma Mando Salida de muestra
Ventanas

Abra la consola de comandos y escriba:

\>java –version

Versión de Java "1.7.0_60"

Entorno de tiempo de ejecución Java (TM) SE (compilación 1.7.0_60-b19)

VM de servidor Java Hotspot (TM) de 64 bits (compilación 24.60-b09, modo mixto)
Linux

Abra el terminal de comando y escriba:

$java –version

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución abierto de JDK (rhel-2.3.10.4.el6_4-x86_64)

Abra la máquina virtual del servidor JDK de 64 bits (compilación 23.7-b01, modo mixto)

Paso 2: configura tu entorno Java

Configure la variable de entorno JAVA_HOME para que apunte a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,

Plataforma Descripción
Ventanas Establezca JAVA_HOME en C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux Exportar JAVA_HOME = / usr / local / java-current

Agregue la ruta completa de la ubicación del compilador Java a la ruta del sistema.

Plataforma Descripción
Ventanas Agregue la cadena "C: \ Archivos de programa \ Java \ jdk1.7.0_60 \ bin" al final de la variable de sistema PATH.
Linux Exportar RUTA = $ RUTA: $ JAVA_HOME / bin /

Ejecuta el comando java -version desde el símbolo del sistema como se explicó anteriormente.

Paso 3: instalación de JPA

Puede realizar la instalación de JPA utilizando cualquiera de los proveedores de JPA de este tutorial, por ejemplo, Eclipselink, Hibernate. Sigamos la instalación de JPA usando Eclipselink. Para la programación JPA, necesitamos seguir el marco de carpetas específico, por lo tanto, es mejor usar IDE.

Descargue el formulario Eclipse IDE siguiendo el enlace https://www.eclipse.org/downloads/ Elija el desarrollador EclipseIDE para JavaEE que sea Eclipse indigo.

Descomprima el archivo zip de Eclipse en la unidad C. Abra Eclipse IDE.

Instalación de JPA usando Eclipselink

Eclipselink es una biblioteca, por lo tanto, no podemos agregarla directamente a Eclipse IDE. Para instalar JPA usando Eclipselink, debe seguir los pasos que se indican a continuación.

  • Cree un nuevo proyecto JPA seleccionando File->New->JPA Project en el IDE de Eclipse de la siguiente manera:

  • Obtendrá un cuadro de diálogo llamado New JPA Project. Ingrese el nombre del proyectotutorialspoint_JPA_Eclipselink, comprobar el jre versión y haga clic en siguiente:

  • Haga clic en descargar biblioteca (si no tiene la biblioteca) en la sección de biblioteca de usuario.

  • Seleccione la última versión de la biblioteca Eclipselink en el cuadro de diálogo Descargar biblioteca y haga clic en Siguiente de la siguiente manera:

  • Acepte los términos de la licencia y haga clic en finalizar para descargar la biblioteca.

  • 6. La descarga comienza como se muestra en la siguiente captura de pantalla.

  • Después de la descarga, seleccione la biblioteca descargada en la sección de la biblioteca del usuario y haga clic en finalizar.

  • Finalmente obtienes el archivo del proyecto en el Package Exploreren Eclipse IDE. Extraiga todos los archivos, obtendrá la jerarquía de carpetas y archivos de la siguiente manera:

Agregar conector MySQL al proyecto

Cualquier ejemplo que analicemos aquí requiere conectividad de base de datos. Consideremos la base de datos MySQL para operaciones de bases de datos. Requiere jar mysql-connector para interactuar con un programa Java.

Siga los pasos para configurar el jar de la base de datos en su proyecto.

  • Ir a propiedades del proyecto ->Java Build Path haciendo clic derecho sobre él. Obtendrá un cuadro de diálogo como se muestra en la siguiente captura de pantalla. Haga clic en Agregar jarras externas.

  • Vaya a la ubicación del jar en la memoria del sistema, seleccione el archivo y haga clic en abrir.

  • Haga clic en Aceptar en el diálogo de propiedades. Obtendrá el Jar del conector MySQL en su proyecto. Ahora puede realizar operaciones de base de datos utilizando MySQL.

Este capítulo utiliza un ejemplo sencillo para demostrar cómo funciona JPA. Consideremos la gestión de empleados como ejemplo. Suponga que la administración de empleados crea, actualiza, encuentra y elimina los registros de un empleado. Como se mencionó, estamos usando la base de datos MySQL para operaciones de base de datos.

Los módulos principales de este ejemplo son los siguientes:

  • Model or POJO

    Employee.java

  • Persistence

    Persistence.xml

  • Service

    CreatingEmployee.java

    UpdatingEmployee.java

    FindingEmployee.java

    DeletingEmployee.java

Tomemos la jerarquía de paquetes que hemos utilizado en la instalación de JPA con Eclipselink. Siga la jerarquía de este ejemplo como se muestra a continuación:

Creando Entidades

Las entidades no son más que frijoles o modelos. En este ejemplo, usaremosEmployee como entidad. eid, ename, salaryy degson los atributos de esta entidad. Contiene un constructor predeterminado, así como los métodos setter y getter de esos atributos.

En la jerarquía que se muestra arriba, cree un paquete llamado ‘com.tutorialspoint.eclipselink.entity’, debajo ‘src’Paquete (fuente). Crea una clase llamadaEmployee.java en el paquete dado de la siguiente manera:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

En el código anterior, hemos utilizado la anotación @Entity para hacer de esta clase POJO una entidad.

Antes de pasar al siguiente módulo, necesitamos crear una base de datos para la entidad relacional, que registrará la base de datos en persistence.xmlarchivo. Abra el banco de trabajo MySQL y escriba hte siguiente consulta.

create database jpadb
use jpadb

Persistence.xml

Este módulo juega un papel crucial en el concepto de JPA. En este archivo xml registraremos la base de datos y especificaremos la clase de entidad.

En la jerarquía de paquetes mostrada anteriormente, persistence.xml bajo el paquete de contenido JPA es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
                         	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<properties>
	   <property name="javax.persistence.jdbc.url"
                   value="jdbc:mysql://localhost:3306/jpadb"/>
     	   <property name="javax.persistence.jdbc.user" value="root"/>
	       <property name="javax.persistence.jdbc.password" value="root"/>
	       <property name="javax.persistence.jdbc.driver"
                   value="com.mysql.jdbc.Driver"/>
           <property name="eclipselink.logging.level" value="FINE"/>
	       <property name="eclipselink.ddl-generation" 
		           value="create-tables"/>
	</properties>
	</persistence-unit>
</persistence>

En el xml anterior, <persistence-unit> La etiqueta se define con un nombre específico para la persistencia JPA. los<class>La etiqueta define la clase de entidad con el nombre del paquete. los<properties> define todas las propiedades, y <property>La etiqueta define cada propiedad, como el registro de la base de datos, la especificación de URL, el nombre de usuario y la contraseña. Estas son las propiedades de Eclipselink. Este archivo configurará la base de datos.

Operaciones de persistencia

Las operaciones de persistencia se utilizan para interactuar con una base de datos y son load y storeoperaciones. En un componente empresarial, todas las operaciones de persistencia se incluyen en clases de servicio.

En la jerarquía de paquetes que se muestra arriba, cree un paquete llamado ‘com.tutorialspoint.eclipselink.service’, debajo ‘src’(fuente) paquete. Todas las clases de servicio denominadas CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java y DeleteEmployee.java. viene bajo el paquete dado de la siguiente manera:

Crear empleado

El siguiente segmento de código muestra cómo crear una clase de empleado denominada CreateEmployee.java.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CreateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		Employee employee = new Employee( ); 
		employee.setEid( 1201 );
		employee.setEname( "Gopal" );
		employee.setSalary( 40000 );
		employee.setDeg( "Technical Manager" );
		entitymanager.persist( employee );
		entitymanager.getTransaction( ).commit( );
		
		entitymanager.close( );
		emfactory.close( );
	}
}

En el código anterior el createEntityManagerFactory ()crea una unidad de persistencia proporcionando el mismo nombre único que proporcionamos para la unidad de persistencia en el archivo persistent.xml. losentitymanagerfactory objeto creará el entitymanger instancia usando createEntityManager ()método. losentitymanager el objeto crea entitytransactioninstancia para la gestión de transacciones. Mediante el usoentitymanager objeto, podemos conservar las entidades en la base de datos.

Después de la compilación y ejecución del programa anterior, recibirá notificaciones de la biblioteca eclipselink en el panel de la consola de eclipse IDE.

Para obtener resultados, abra el banco de trabajo MySQL y escriba las siguientes consultas.

use jpadb
select * from employee

La tabla de la base de datos afectada llamada employee se mostrará en formato tabular de la siguiente manera:

Eid Ename Salario Deg
1201 Gopal 40000 Gerente técnico

Actualizar empleado

Para actualizar los registros de un empleado, necesitamos recuperar los registros existentes de la base de datos, hacer cambios y finalmente enviarlos a la base de datos. La clase nombradaUpdateEmployee.java se muestra de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class UpdateEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
				entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		//before update
		System.out.println( employee );
		employee.setSalary( 46000 );
		entitymanager.getTransaction( ).commit( );
        //after update
		System.out.println( employee );
		entitymanager.close();
		emfactory.close();
	}
}

Después de la compilación y ejecución del programa anterior, recibirá notificaciones de la biblioteca Eclipselink en el panel de la consola de eclipse IDE.

Para obtener resultados, abra el banco de trabajo MySQL y escriba las siguientes consultas.

use jpadb
select * from employee

La tabla de la base de datos afectada llamada employee se mostrará en formato tabular de la siguiente manera:

Eid Ename Salario Deg
1201 Gopal 46000 Gerente técnico

El salario del empleado, 1201 se actualiza a 46000.

Encontrar empleado

Para encontrar los registros de un empleado, tendremos que recuperar los datos existentes de la base de datos y mostrarlos. En esta operación, EntityTransaction no se aplica al recuperar un registro.

La clase nombrada FindEmployee.java como sigue.

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class FindEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence
				.createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		Employee employee = entitymanager.
				find( Employee.class, 1201 );
		
		System.out.println("employee ID = "+employee.getEid( ));
		System.out.println("employee NAME = "+employee.getEname( ));
		System.out.println("employee SALARY = "+employee.getSalary( ));
		System.out.println("employee DESIGNATION = "+employee.getDeg( ));
	}
}

Después de compilar y ejecutar el programa anterior, obtendrá el siguiente resultado de la biblioteca Eclipselink en el panel de la consola de eclipse IDE.

employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager

Eliminar empleado

Para eliminar los registros de un empleado, primero buscaremos los registros existentes y luego los eliminaremos. Aquí EntityTransaction juega un papel importante.

La clase nombrada DeleteEmployee.java como sigue:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class DeleteEmployee 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		Employee employee=entitymanager.
				find( Employee.class, 1201 );
		entitymanager.remove( employee );
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

Después de la compilación y ejecución del programa anterior, recibirá notificaciones de la biblioteca Eclipselink en el panel de la consola de eclipse IDE.

Para obtener resultados, abra el banco de trabajo MySQL y escriba las siguientes consultas.

use jpadb
select * from employee

La base de datos afectada llamada employee tendrá registros nulos.

Después de completar todos los módulos en este ejemplo, la jerarquía de paquetes y archivos se ve como sigue:

Este capítulo describe sobre JPQL y cómo funciona con unidades de persistencia. En este capítulo, los ejemplos dados siguen la misma jerarquía de paquetes, que usamos en el capítulo anterior.

Lenguaje de consulta de persistencia de Java

JPQL son las siglas de Java Persistence Query Language. Se utiliza para crear consultas contra entidades para almacenar en una base de datos relacional. JPQL se desarrolla en base a la sintaxis SQL. Pero no afectará directamente a la base de datos.

JPQL puede recuperar datos usando la cláusula SELECT, puede hacer actualizaciones masivas usando la cláusula UPDATE y la cláusula DELETE.

Estructura de consulta

La sintaxis de JPQL es muy similar a la sintaxis de SQL. Tener una sintaxis similar a SQL es una ventaja porque SQL es simple y se usa ampliamente. SQL trabaja directamente contra tablas, registros y campos de bases de datos relacionales, mientras que JPQL trabaja con clases e instancias de Java.

Por ejemplo, una consulta JPQL puede recuperar un objeto de entidad en lugar de un conjunto de resultados de campo de una base de datos, como ocurre con SQL. La estructura de la consulta JPQL de la siguiente manera.

SELECT ... FROM ...
[WHERE ...]
[GROUP BY ... [HAVING ...]]
[ORDER BY ...]

La estructura de las consultas JPQL DELETE y UPDATE es la siguiente.

DELETE FROM ... [WHERE ...]
 
UPDATE ... SET ... [WHERE ...]

Funciones escalares y agregadas

Las funciones escalares devuelven valores resultantes basados ​​en valores de entrada. Las funciones agregadas devuelven los valores resultantes calculando los valores de entrada.

Usaremos el mismo ejemplo de Gestión de empleados que en el capítulo anterior. Aquí repasaremos las clases de servicio utilizando funciones escalares y agregadas de JPQL.

Asumamos el jpadb.employee La tabla contiene los siguientes registros.

Eid Ename Salario Deg
1201 Gopal 40000 Gerente técnico
1202 Manisha 40000 Lector de pruebas
1203 Masthanvali 40000 Escritor técnico
1204 Satish 30000 Escritor técnico
1205 Krishna 30000 Escritor técnico
1206 Kiran 35000 Lector de pruebas

Crea una clase llamada ScalarandAggregateFunctions.java debajo com.tutorialspoint.eclipselink.service paquete de la siguiente manera.

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class ScalarandAggregateFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager();
		//Scalar function
		Query query = entitymanager.
		createQuery("Select UPPER(e.ename) from Employee e");
		List<String> list=query.getResultList();
		
		for(String e:list)
		{
			System.out.println("Employee NAME :"+e);
		}
		//Aggregate function
		Query query1 = entitymanager.
				createQuery("Select MAX(e.salary) from Employee e");
		Double result=(Double) query1.getSingleResult();
		System.out.println("Max Employee Salary :"+result);
	}
}

Después de la compilación y ejecución del programa anterior, obtendrá el siguiente resultado en el panel de la consola de Eclipse IDE.

Employee NAME :GOPAL
Employee NAME :MANISHA
Employee NAME :MASTHANVALI
Employee NAME :SATISH
Employee NAME :KRISHNA
Employee NAME :KIRAN
ax Employee Salary :40000.0

Entre, y, como palabras clave

Between, Andy Likeson las principales palabras clave de JPQL. Estas palabras clave se utilizan despuésWhere clause en una consulta.

Crea una clase llamada BetweenAndLikeFunctions.java debajo com.tutorialspoint.eclipselink.service paquete de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class BetweenAndLikeFunctions 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "where e.salary " +
					     "Between 30000 and 40000" )
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee salary :"+e.getSalary( ));
		}
		
		//Like
		Query query1 = entitymanager.
			createQuery("Select e " +
					    "from Employee e " +
					    "where e.ename LIKE 'M%'");
		List<Employee> list1=(List<Employee>)query1.getResultList( );
		for( Employee e:list1 )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee name :"+e.getEname( ));
		}
	}
}

Después de compilar y ejecutar el programa anterior, obtendrá el siguiente resultado en el panel de la consola de Eclipse IDE.

Employee ID :1201	 Employee salary :40000.0
Employee ID :1202	 Employee salary :40000.0
Employee ID :1203	 Employee salary :40000.0
Employee ID :1204	 Employee salary :30000.0
Employee ID :1205	 Employee salary :30000.0
Employee ID :1206	 Employee salary :35000.0

Employee ID :1202	 Employee name :Manisha
Employee ID :1203	 Employee name :Masthanvali

Ordenar

Para ordenar los registros en JPQL, usamos la cláusula ORDER BY. El uso de esta cláusula es el mismo que en SQL, pero se trata de entidades. El siguiente ejemplo muestra cómo utilizar la cláusula ORDER BY.

Crear una clase Ordering.java debajo com.tutorialspoint.eclipselink.service paquete de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class Ordering 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		//Between
		Query query = entitymanager.
			createQuery( "Select e " +
					     "from Employee e " +
					     "ORDER BY e.ename ASC" );
		List<Employee> list=(List<Employee>)query.getResultList( );
		 
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

Al compilar y ejecutar el programa anterior, producirá la siguiente salida en el panel de la consola de Eclipse IDE.

Employee ID :1201	 Employee Name :Gopal
Employee ID :1206	 Employee Name :Kiran
Employee ID :1205	 Employee Name :Krishna
Employee ID :1202	 Employee Name :Manisha
Employee ID :1203	 Employee Name :Masthanvali
Employee ID :1204	 Employee Name :Satish

Consultas con nombre

Una anotación @NamedQuery se define como una consulta con una cadena de consulta predefinida que no se puede cambiar. A diferencia de las consultas dinámicas, las consultas con nombre pueden mejorar la organización del código al separar las cadenas de consulta JPQL de POJO. También pasa los parámetros de consulta en lugar de incrustar los literales de forma dinámica en la cadena de consulta y, por lo tanto, produce consultas más eficientes.

En primer lugar, agregue la anotación @NamedQuery a la clase de entidad Empleado llamada Employee.java debajo com.tutorialspoint.eclipselink.entity paquete de la siguiente manera:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@Table
@NamedQuery(query = "Select e from Employee e where e.eid = :id", 
		name = "find employee by id")
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

Crea una clase llamada NamedQueries.java debajo com.tutorialspoint.eclipselink.service paquete de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import com.tutorialspoint.eclipselink.entity.Employee;

public class NamedQueries 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
			createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
			createEntityManager();
		Query query = entitymanager.createNamedQuery(
			"find employee by id");
		query.setParameter("id", 1204);
		List<Employee> list = query.getResultList( );
		for( Employee e:list )
		{
			System.out.print("Employee ID :"+e.getEid( ));
			System.out.println("\t Employee Name :"+e.getEname( ));
		}
	}
}

Después de compilar y ejecutar el programa anterior, obtendrá el siguiente resultado en el panel de la consola de Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Después de agregar todas las clases anteriores, la jerarquía de paquetes se ve como sigue:

Búsqueda ansiosa y perezosa

El concepto más importante de JPA es realizar una copia duplicada de la base de datos en la memoria caché. Al realizar transacciones con una base de datos, el JPA primero crea un conjunto duplicado de datos y solo cuando se confirma utilizando un administrador de entidad, los cambios se efectúan en la base de datos.

Hay dos formas de obtener registros de la base de datos.

Búsqueda ansiosa

En la búsqueda ansiosa, los objetos secundarios relacionados se cargan automáticamente mientras se busca un registro en particular.

Búsqueda perezosa

En la búsqueda diferida, los objetos relacionados no se cargan automáticamente a menos que los solicite específicamente. En primer lugar, verifica la disponibilidad de objetos relacionados y notifica. Más tarde, si llama a cualquiera de los métodos getter de esa entidad, obtendrá todos los registros.

La recuperación diferida es posible cuando intenta recuperar los registros por primera vez. De esa manera, una copia de todo el registro ya está almacenada en la memoria caché. Es preferible la búsqueda perezosa en cuanto al rendimiento.

JPA es una biblioteca que se publica con especificaciones Java. Por lo tanto, admite todos los conceptos orientados a objetos para la persistencia de entidades. Hasta ahora, hemos terminado con los conceptos básicos del mapeo relacional de objetos. Este capítulo lo lleva a través de las asignaciones avanzadas entre objetos y entidades relacionales.

Estrategias de herencia

La herencia es el concepto central de cualquier lenguaje orientado a objetos, por lo tanto, podemos usar relaciones o estrategias de herencia entre entidades. JPA admite tres tipos de estrategias de herencia: SINGLE_TABLE, JOINED_TABLE y TABLE_PER_CONCRETE_CLASS.

Consideremos un ejemplo. El siguiente diagrama muestra tres clases, a saber. Personal, personal docente y personal no docente, y sus relaciones.

En el diagrama anterior, Staff es una entidad, mientras que TeachingStaff y NonTeachingStaff son las subentidades de Staff. Aquí usaremos el ejemplo anterior para demostrar las tres estrategias de herencia.

Estrategia de mesa única

La estrategia de una sola tabla toma todos los campos de las clases (tanto las superclases como las subclases) y los mapea en una sola tabla conocida como estrategia SINGLE_TABLE. Aquí, el valor discriminador juega un papel clave en la diferenciación de los valores de tres entidades en una tabla.

Consideremos el ejemplo anterior. TeachingStaff y NonTeachingStaff son las subclases de Staff. Según el concepto de herencia, una subclase hereda las propiedades de su superclase. Por lo tanto, sid y sname son los campos que pertenecen tanto a TeachingStaff como a NonTeachingStaff. Crea un proyecto JPA. Todos los módulos de este proyecto son los siguientes:

Creando Entidades

Crea un paquete llamado ‘com.tutorialspoint.eclipselink.entity’ debajo ‘src’paquete. Crea una nueva clase java llamadaStaff.javabajo paquete dado. La clase de entidad Staff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;
@Entity
@Table
@Inheritance( strategy = InheritanceType.SINGLE_TABLE )
@DiscriminatorColumn( name="type" )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

En el código anterior @DescriminatorColumn especifica el nombre del campo (type) y sus valores muestran los campos restantes (personal docente y no docente).

Cree una subclase (clase) para la clase de personal llamada TeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad TeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value="TS" )
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Cree una subclase (clase) para la clase de personal llamada NonTeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad NonTeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue( value = "NS" )
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

Persistence.xml contiene la información de configuración de la base de datos y la información de registro de las clases de entidad. El archivo xml se muestra a continuación:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	    <class>com.tutorialspoint.eclipselink.entity.Staff</class>
		<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
		<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clase de servicio

Las clases de servicio son la parte de implementación del componente empresarial. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’.

Crea una clase llamada SaveClient.javaen el paquete proporcionado para almacenar los campos de clase Staff, TeachingStaff y NonTeachingStaff. La clase SaveClient se muestra a continuación:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de compilar y ejecutar el programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Compruebe la salida de MySQL workbench. La salida en formato tabular se muestra a continuación:

Sid Tipo Nombre de Área de experiencia Calificación Subjectexpertise
1 TS Gopal MSC MED Matemáticas
2 TS Manisha CAMA BSC Inglés
3 NS Satish Cuentas
4 NS Krishna Administrador de oficina

Finalmente obtendrá una única tabla que contiene el campo de las tres clases con una columna discriminadora llamada Type (campo).

Estrategia de mesa unida

La estrategia de la tabla unida es compartir la columna referenciada que contiene valores únicos para unirse a la tabla y hacer transacciones fáciles. Consideremos el mismo ejemplo anterior.

Cree un proyecto JPA. Todos los módulos del proyecto se muestran a continuación.

Creando Entidades

Crea un paquete llamado ‘com.tutorialspoint.eclipselink.entity’ debajo ‘src’paquete. Crea una nueva clase java llamadaStaff.javabajo paquete dado. La clase de entidad Staff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.JOINED )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Cree una subclase (clase) para la clase de personal llamada TeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad TeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}

	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Cree una subclase (clase) para la clase de personal llamada NonTeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad NonTeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@PrimaryKeyJoinColumn(referencedColumnName="sid")
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise ) 
	{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

El archivo Persistence.xml contiene la información de configuración de la base de datos y la información de registro de las clases de entidad. El archivo xml se muestra a continuación:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clase de servicio

Las clases de servicio son la parte de implementación del componente empresarial. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’.

Crea una clase llamada SaveClient.javaen el paquete dado para almacenar los campos de las clases Staff, TeachingStaff y NonTeachingStaff. Entonces la clase SaveClient se muestra de la siguiente manera:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;

public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
		4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de compilar y ejecutar el programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench.

Aquí se crean tres tablas y el resultado de staff La tabla se muestra en formato tabular.

Sid Dtype Nombre de
1 Personal docente Gopal
2 Personal docente Manisha
3 No DocentePersonal Satish
4 No DocentePersonal Krishna

El resultado de TeachingStaff La tabla se muestra de la siguiente manera:

Sid Calificación Subjectexpertise
1 MSC MED Matemáticas
2 CAMA BSC Inglés

En la tabla anterior, sid es la clave externa (campo de referencia del formulario de tabla de personal) El resultado de NonTeachingStaff La tabla se muestra de la siguiente manera:

Sid Área de experiencia
3 Cuentas
4 Administrador de oficina

Finalmente, las tres tablas se crean utilizando sus respectivos campos y el campo SID es compartido por las tres tablas. En la tabla Staff, SID es la clave principal. En las dos tablas restantes (TeachingStaff y NonTeachingStaff), SID es la clave externa.

Tabla por estrategia de clase

La estrategia de tabla por clase es crear una tabla para cada subentidad. Se creará la tabla Staff, pero contendrá valores nulos. Los valores de campo de la tabla Staff deben ser compartidos por las tablas TeachingStaff y NonTeachingStaff.

Consideremos el mismo ejemplo anterior.

Creando Entidades

Crea un paquete llamado ‘com.tutorialspoint.eclipselink.entity’ debajo ‘src’paquete. Crea una nueva clase java llamadaStaff.javabajo paquete dado. La clase de entidad Staff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Table;

@Entity
@Table
@Inheritance( strategy = InheritanceType.TABLE_PER_CLASS )
public class Staff implements Serializable 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int sid;
	private String sname;
	public Staff( int sid, String sname ) 
	{
		super( );
		this.sid = sid;
		this.sname = sname;
	}
	public Staff( ) 
	{
		super( );
	}
	public int getSid( ) 
	{
		return sid;
	}
	public void setSid( int sid ) 
	{
		this.sid = sid;
	}
	public String getSname( ) 
	{
		return sname;
	}
	public void setSname( String sname ) 
	{
		this.sname = sname;
	}
}

Cree una subclase (clase) para la clase de personal llamada TeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad TeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class TeachingStaff extends Staff 
{
	private String qualification;
	private String subjectexpertise;
	
	public TeachingStaff( int sid, String sname, 
			String qualification,String subjectexpertise ) 
	{
		super( sid, sname );
		this.qualification = qualification;
		this.subjectexpertise = subjectexpertise;
	}
	
	public TeachingStaff( ) 
	{
		super( );
		
	}

	public String getQualification( )
	{
		return qualification;
	}
	public void setQualification( String qualification )
	{
		this.qualification = qualification;
	}

	public String getSubjectexpertise( ) 
	{
		return subjectexpertise;
	}

	public void setSubjectexpertise( String subjectexpertise )
	{
		this.subjectexpertise = subjectexpertise;
	}
}

Cree una subclase (clase) para la clase de personal llamada NonTeachingStaff.java bajo la com.tutorialspoint.eclipselink.entitypaquete. La clase de entidad NonTeachingStaff se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
public class NonTeachingStaff extends Staff 
{
	private String areaexpertise;

	public NonTeachingStaff( int sid, String sname, 
			String areaexpertise )
			{
		super( sid, sname );
		this.areaexpertise = areaexpertise;
	}

	public NonTeachingStaff( ) 
	{
		super( );
	}

	public String getAreaexpertise( ) 
	{
		return areaexpertise;
	}

	public void setAreaexpertise( String areaexpertise )
	{
		this.areaexpertise = areaexpertise;
	}
}

Persistence.xml

El archivo Persistence.xml contiene la información de configuración de la base de datos y la información de registro de las clases de entidad. El archivo xml se muestra a continuación:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Staff</class>
	<class>com.tutorialspoint.eclipselink.entity.NonTeachingStaff</class>
	<class>com.tutorialspoint.eclipselink.entity.TeachingStaff</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
                            value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
                            value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
                            value="create-tables"/>
			</properties>
	</persistence-unit>
</persistence>

Clase de servicio

Las clases de servicio son la parte de implementación del componente empresarial. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’.

Crea una clase llamada SaveClient.javaen el paquete proporcionado para almacenar los campos de clase Staff, TeachingStaff y NonTeachingStaff. La clase SaveClient se muestra a continuación:

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.NonTeachingStaff;
import com.tutorialspoint.eclipselink.entity.TeachingStaff;
public class SaveClient 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Teaching staff entity 
		TeachingStaff ts1=new TeachingStaff(
				1,"Gopal","MSc MEd","Maths");
		TeachingStaff ts2=new TeachingStaff(
				2, "Manisha", "BSc BEd", "English");
		//Non-Teaching Staff entity
		NonTeachingStaff nts1=new NonTeachingStaff(
				3, "Satish", "Accounts");
		NonTeachingStaff nts2=new NonTeachingStaff(
				4, "Krishna", "Office Admin");
		
		//storing all entities
		entitymanager.persist(ts1);
		entitymanager.persist(ts2);
		entitymanager.persist(nts1);
		entitymanager.persist(nts2);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de compilar y ejecutar el programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench.

Aquí se crean las tres tablas y Staff La tabla contiene registros nulos.

El resultado de TeachingStaff se muestra de la siguiente manera:

Sid Calificación Nombre de Subjectexpertise
1 MSC MED Gopal Matemáticas
2 CAMA BSC Manisha Inglés

La tabla anterior TeachingStaff contiene campos de Entidades Staff y TeachingStaff.

El resultado de NonTeachingStaff se muestra de la siguiente manera:

Sid Área de experiencia Nombre de
3 Cuentas Satish
4 Administrador de oficina Krishna

La tabla anterior NonTeachingStaff contiene campos de Entidades Staff y NonTeachingStaff.

Este capítulo lo lleva a través de las relaciones entre entidades. Generalmente, las relaciones son más efectivas entre tablas en la base de datos. Aquí las clases de entidad se tratan como tablas relacionales (concepto de JPA), por lo tanto, las relaciones entre las clases de entidad son las siguientes:

  • @ManyToOne Relation
  • Relación @OneToMany
  • Relación @OneToOne
  • @ManyToMany Relation

@ManyToOne Relation

Existe una relación de varios a uno entre entidades en la que se hace referencia a una entidad (columna o conjunto de columnas) con otra entidad (columna o conjunto de columnas) que contiene valores únicos. En las bases de datos relacionales, estas relaciones se aplican mediante el uso de una clave externa / clave primaria entre las tablas.

Consideremos un ejemplo de una relación entre las entidades Empleado y Departamento. De manera unidireccional, es decir, de Empleado a Departamento, se aplica la relación Muchos a Uno. Eso significa que cada registro de empleado contiene una identificación de departamento, que debe ser una clave principal en la tabla Departamento. Aquí, en la tabla Empleado, el ID de departamento es la clave externa.

El siguiente diagrama muestra la relación de varios a uno entre las dos tablas.

Cree un proyecto JPA en eclipse IDE llamado JPA_Eclipselink_MTO. Todos los módulos de este proyecto se analizan a continuación.

Creando Entidades

Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de clase Departamento se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Cree la segunda entidad en esta relación: clase de entidad de empleado denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	@ManyToOne
	private Department department;
	
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
		
	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}
}

Persistence.xml

Se requiere el archivo Persistence.xml para configurar la base de datos y el registro de clases de entidad.

Persitence.xml será creado por el IDE de eclipse mientras crea un proyecto JPA. Los detalles de configuración son especificaciones del usuario. El archivo persistence.xml se muestra a continuación:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password"
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clases de servicio

Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaManyToOne.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class ManyToOne 
{
	public static void main( String[ ] args ) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
		employee1.setDepartment(department);

		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
		employee2.setDepartment(department);

		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		employee3.setDepartment(department);
		
		//Store Employees
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
				
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de compilar y ejecutar el programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench. En este ejemplo, se crean dos tablas.

Pase la siguiente consulta en la interfaz MySQL y el resultado de Department La tabla se mostrará de la siguiente manera:

Select * from department
CARNÉ DE IDENTIDAD Nombre
101 Desarrollo

Pase la siguiente consulta en la interfaz MySQL y el resultado de Employee La tabla se mostrará de la siguiente manera.

Select * from employee
Eid Deg Ename Salario Department_Id
102 Escritor técnico Satish 45000 101
103 Escritor técnico Krishna 45000 101
104 Escritor técnico Masthanwali 50000 101

En la tabla anterior Deparment_Id es la clave externa (campo de referencia) de la tabla Departamento.

Relación @OneToMany

En esta relación, cada fila de una entidad hace referencia a muchos registros secundarios en otra entidad. Lo importante es que los registros secundarios no pueden tener varios padres. En una relación de uno a muchos entre la Tabla A y la Tabla B, cada fila de la Tabla A se puede vincular a una o varias filas de la Tabla B.

Consideremos el ejemplo anterior. Suponga que las tablas Empleado y Departamento del ejemplo anterior están conectadas de manera unidireccional inversa, entonces la relación se convierte en una relación Uno-a-Muchos. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_OTM. Todos los módulos de este proyecto se analizan a continuación.

Creando Entidades

Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de clase Departamento se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
    
    @OneToMany( targetEntity=Employee.class )
    private List employeelist;

    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }

    public List getEmployeelist() 
    {
	return employeelist;
    }

    public void setEmployeelist(List employeelist) 
    {
	this.employeelist = employeelist;
    }
}

Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}	
}

Persistence.xml

El archivo persistence.xml es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clases de servicio

Este módulo contiene las clases de servicio, que implementa la parte relacional utilizando la inicialización de atributos. Crea un paquete debajo‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaOneToMany.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:

package com.tutorialspointeclipselink.service;

import java.util.List;
import java.util.ArrayList;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Employee1 Entity
		Employee employee1 = new Employee();
		employee1.setEname("Satish");
		employee1.setSalary(45000.0);
		employee1.setDeg("Technical Writer");
								
		//Create Employee2 Entity
		Employee employee2 = new Employee();
		employee2.setEname("Krishna");
		employee2.setSalary(45000.0);
		employee2.setDeg("Technical Writer");
								
		//Create Employee3 Entity
		Employee employee3 = new Employee();
		employee3.setEname("Masthanvali");
		employee3.setSalary(50000.0);
		employee3.setDeg("Technical Writer");
		
		//Store Employee
		entitymanager.persist(employee1);
		entitymanager.persist(employee2);
		entitymanager.persist(employee3);
		
		//Create Employeelist
		List<Employee> emplist = new ArrayList();
		emplist.add(employee1);
		emplist.add(employee2);
		emplist.add(employee3);
		
		//Create Department Entity
		Department department= new Department();
		department.setName("Development");
		department.setEmployeelist(emplist);
				
		//Store Department
		entitymanager.persist(department);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, verifique el banco de trabajo MySQL de la siguiente manera.

En este proyecto se crean tres tablas. Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla department_employee se mostrará de la siguiente manera:

Select * from department_Id;
Department_ID Employee_Eid
254 251
254 252
254 253

En la tabla de arriba, deparment_id y employee_id son las claves externas (campos de referencia) de las tablas de departamento y empleado.

Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla de departamentos se mostrará en formato tabular de la siguiente manera.

Select * from department;
CARNÉ DE IDENTIDAD Nombre
254 Desarrollo

Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla de empleados se mostrará de la siguiente manera:

Select * from employee;
Eid Deg Ename Salario
251 Escritor técnico Satish 45000
252 Escritor técnico Krishna 45000
253 Escritor técnico Masthanwali 50000

Relación @OneToOne

En la relación uno a uno, un elemento se puede vincular solo a otro elemento. Significa que cada fila de una entidad se refiere a una y solo una fila de otra entidad.

Consideremos el ejemplo anterior. Employee y Departmentde manera unidireccional inversa, la relación es una relación Uno-a-Uno. Significa que cada empleado pertenece a un solo departamento. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_OTO. Todos los módulos de este proyecto se analizan a continuación.

Creando Entidades

Siga el diagrama dado arriba para crear entidades. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaDepartment.javabajo paquete dado. La entidad de clase Departamento se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Department 
{
    @Id 
    @GeneratedValue( strategy=GenerationType.AUTO )
    private int id;
    private String name;
   
    public int getId() 
    {
    	return id;
    }
    
    public void setId(int id) 
    {
    	this.id = id;
    }
    
    public String getName( )
    {
    	return name;
    }
    
    public void setName( String deptName )
    {
    	this.name = deptName;
    }
}

Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Employee.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue( strategy= GenerationType.AUTO ) 	
	private int eid;
	private String ename;
	private double salary;
	private String deg;
	
	@OneToOne
	private Department department;
		
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}

	public Department getDepartment() 
	{
		return department;
	}

	public void setDepartment(Department department) 
	{
		this.department = department;
	}	
}

Persistence.xml

Persistence.xml archivo de la siguiente manera:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clases de servicio

Crea un paquete debajo ‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaOneToOne.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:

package com.tutorialspointeclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Department;
import com.tutorialspoint.eclipselink.entity.Employee;

public class OneToOne 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Department Entity
		Department department = new Department();
		department.setName("Development");
		
		//Store Department
		entitymanager.persist(department);
		
		//Create Employee Entity
		Employee employee = new Employee();
		employee.setEname("Satish");
		employee.setSalary(45000.0);
		employee.setDeg("Technical Writer");
		employee.setDepartment(department);
		
		//Store Employee
		entitymanager.persist(employee);
		
		entitymanager.getTransaction().commit();
		entitymanager.close();
		emfactory.close();
	}
}

Después de la compilación y ejecución del programa anterior, recibirá notificaciones en el panel de la consola de Eclipse IDE. Para obtener resultados, consulte MySQL workbench de la siguiente manera.

En el ejemplo anterior, se crean dos tablas. Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla del departamento se mostrará de la siguiente manera:

Select * from department
CARNÉ DE IDENTIDAD Nombre
301 Desarrollo

Pase la siguiente consulta en la interfaz MySQL y el resultado de employee La tabla se mostrará de la siguiente manera:

Select * from employee
Eid Deg Ename Salario Department_id
302 Escritor técnico Satish 45000 301

@ManyToMany Relation

La relación de varios a varios es donde una o más filas de una entidad están asociadas con más de una fila en otra entidad.

Consideremos un ejemplo de relación entre dos entidades: Class y Teacher. De manera bidireccional, tanto la clase como el profesor tienen una relación de varios a uno. Eso significa que cada registro de Clase es referido por el conjunto de Maestros (ID de maestros), que deben ser claves primarias en la tabla de Maestros y almacenados en la tabla de Clase_Profesor y viceversa. Aquí, la tabla Teachers_Class contiene ambos campos de clave externa. Cree un proyecto JPA en eclipse IDE llamadoJPA_Eclipselink_MTM. Todos los módulos de este proyecto se analizan a continuación.

Creando Entidades

Cree entidades siguiendo el esquema que se muestra en el diagrama anterior. Crea un paquete llamado‘com.tutorialspoin.eclipselink.entity’ debajo ‘src’paquete. Crea una clase llamadaClas.javabajo paquete dado. La entidad de clase Departamento se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Clas 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int cid;
	private String cname;
	
	@ManyToMany(targetEntity=Teacher.class)
	private Set teacherSet;
	
	public Clas() 
	{
		super();
	}
	public Clas(int cid, 
			String cname, Set teacherSet) 
	{
		super();
		this.cid = cid;
		this.cname = cname;
		this.teacherSet = teacherSet;
	}
	public int getCid() 
	{
		return cid;
	}
	public void setCid(int cid) 
	{
		this.cid = cid;
	}
	public String getCname() 
	{
		return cname;
	}
	public void setCname(String cname) 
	{
		this.cname = cname;
	}
	public Set getTeacherSet() 
	{
		return teacherSet;
	}
	public void setTeacherSet(Set teacherSet) 
	{
		this.teacherSet = teacherSet;
	}	  
}

Cree la segunda entidad en esta relación: clase de entidad de empleado, denominada Teacher.java debajo ‘com.tutorialspoint.eclipselink.entity’paquete. La clase de entidad Empleado se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Teacher 
{
	@Id
	@GeneratedValue( strategy = GenerationType.AUTO )
	private int tid;
	private String tname;
	private String subject;
	
	@ManyToMany(targetEntity=Clas.class)
	private Set clasSet;
	
	public Teacher() 
	{
		super();
	}
	public Teacher(int tid, String tname, String subject, 
			Set clasSet) 
	{
		super();
		this.tid = tid;
		this.tname = tname;
		this.subject = subject;
		this.clasSet = clasSet;
	}
	public int getTid() 
	{
		return tid;
	}
	public void setTid(int tid) 
	{
		this.tid = tid;
	}
	public String getTname() 
	{
		return tname;
	}
	public void setTname(String tname) 
	{
		this.tname = tname;
	}
	public String getSubject() 
	{
		return subject;
	}
	public void setSubject(String subject) 
	{
		this.subject = subject;
	}
	public Set getClasSet() 
	{
		return clasSet;
	}
	public void setClasSet(Set clasSet) 
	{
		this.clasSet = clasSet;
	}
}

Persistence.xml

Persistence.xml archivo de la siguiente manera:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" 
             xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
	<class>com.tutorialspoint.eclipselink.entity.Department</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
                            value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clases de servicio

Crea un paquete debajo ‘src’ paquete llamado ‘com.tutorialspoint.eclipselink.service’. La clase DAO llamadaManyToMany.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:

package com.tutorialspoint.eclipselink.service;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Clas;
import com.tutorialspoint.eclipselink.entity.Teacher;

public class ManyToMany 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		entitymanager.getTransaction( ).begin( );
		
		//Create Clas Entity
		Clas clas1=new Clas(0,"1st",null);
		Clas clas2=new Clas(0,"2nd",null);
		Clas clas3=new Clas(0,"3rd",null);
		
		//Store Clas
		entitymanager.persist(clas1);
		entitymanager.persist(clas2);
		entitymanager.persist(clas3);
		
		//Create Clas Set1
		Set<Clas> classSet1 = new HashSet();
		classSet1.add(clas1);
		classSet1.add(clas2);
		classSet1.add(clas3);
		
		//Create Clas Set2
		Set<Clas> classSet2 = new HashSet();
		classSet2.add(clas3);
		classSet2.add(clas1);
		classSet2.add(clas2);
				
		//Create Clas Set3
		Set<Clas> classSet3 = new HashSet();
		classSet3.add(clas2);
		classSet3.add(clas3);
		classSet3.add(clas1);
		
		//Create Teacher Entity
		Teacher teacher1 = new Teacher(0,
				"Satish","Java",classSet1);
		Teacher teacher2 = new Teacher(0,
				"Krishna","Adv Java",classSet2);
		Teacher teacher3 = new Teacher(0,
				"Masthanvali","DB2",classSet3);
		
		//Store Teacher
		entitymanager.persist(teacher1);
		entitymanager.persist(teacher2);
		entitymanager.persist(teacher3);
		
		entitymanager.getTransaction( ).commit( );
		entitymanager.close( );
		emfactory.close( );
	}
}

En este proyecto de ejemplo, se crean tres tablas. Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla teacher_clas se mostrará de la siguiente manera:

Select * form teacher_clas
Teacher_tid Classet_cid
354 351
355 351
356 351
354 352
355 352
356 352
354 353
355 353
356 353

En la tabla de arriba teacher_tid es la clave externa de la tabla del profesor, y classet_cides la clave externa de la tabla de clases. Por lo tanto, se asignan diferentes profesores a diferentes clases.

Pase la siguiente consulta en la interfaz MySQL y el resultado de la tabla del profesor se mostrará de la siguiente manera:

Select * from teacher
Tid Tema Tname
354 Java Satish
355 Java avanzado Krishna
356 DB2 Masthanvali

Pase la siguiente consulta en la interfaz MySQL y el resultado de clas La tabla se mostrará de la siguiente manera:

Select * from clas
Cid Cname
351 Primero
352 2do
353 Tercero

Criteria es una API predefinida que se utiliza para definir consultas para entidades. Es una forma alternativa de definir una consulta JPQL. Estas consultas son de tipo seguro, portátiles y fáciles de modificar cambiando la sintaxis. Similar a JPQL, sigue un esquema abstracto (esquema fácil de editar) y objetos incrustados. La API de metadatos se mezcla con la API de criterios para modelar la entidad persistente para las consultas de criterios.

La principal ventaja de Criteria API es que los errores se pueden detectar antes durante el tiempo de compilación. Las consultas JPQL basadas en cadenas y las consultas basadas en criterios JPA son las mismas en rendimiento y eficiencia.

Historial de criterios API

Los criterios se incluyen en todas las versiones de JPA, por lo tanto, cada paso de los criterios se notifica en las especificaciones de JPA.

  • En JPA 2.0, la API de consulta de criterios, se desarrolla la estandarización de consultas.
  • En JPA 2.1, se incluyen la actualización y eliminación de criterios (actualización y eliminación masiva).

Estructura de consulta de criterios

Los Criterios y JPQL están estrechamente relacionados y se les permite diseñar utilizando operadores similares en sus consultas. Siguejavax.persistence.criteriapaquete para diseñar una consulta. La estructura de la consulta significa la consulta de criterios de sintaxis.

La siguiente consulta de criterios simples devuelve todas las instancias de la clase de entidad en la fuente de datos.

EntityManager em = ...;
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Entity class> cq = cb.createQuery(Entity.class);
Root<Entity> from = cq.from(Entity.class);
cq.select(Entity);
TypedQuery<Entity> q = em.createQuery(cq);
List<Entity> allitems = q.getResultList();

La consulta demuestra los pasos básicos para crear un criterio.

  • EntityManager La instancia se utiliza para crear un objeto CriteriaBuilder.

  • CriteriaQueryinstancia se utiliza para crear un objeto de consulta. Los atributos de este objeto de consulta se modificarán con los detalles de la consulta.

  • CriteriaQuery.form se llama al método para establecer la raíz de la consulta.

  • CriteriaQuery.select se llama para establecer el tipo de lista de resultados.

  • TypedQuery<T> La instancia se utiliza para preparar una consulta para su ejecución y especificar el tipo de resultado de la consulta.

  • getResultListen el objeto TypedQuery <T> para ejecutar una consulta. Esta consulta devuelve una colección de entidades, el resultado se almacena en una Lista.

Ejemplo de API de criterios

Consideremos el ejemplo de la base de datos de empleados. Supongamos que la tabla jpadb.employee contiene los siguientes registros:

Eid	 Ename          Salary	Deg
401	 Gopal	        40000	Technical Manager
402	 Manisha	    40000	Proof reader
403	 Masthanvali    35000	Technical Writer
404  Satish	        30000	Technical writer
405	 Krishna	    30000	Technical Writer
406	 Kiran	        35000	Proof reader

Cree un proyecto JPA en el IDE de eclipse llamado JPA_Eclipselink_Criteria. Todos los módulos de este proyecto se comentan a continuación:

Creando Entidades

Crea un paquete llamado com.tutorialspoint.eclipselink.entity debajo ‘src’

Crea una clase llamada Employee.javabajo paquete dado. La entidad clase Empleado se muestra a continuación:

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee 
{
	@Id
	@GeneratedValue(strategy= GenerationType.AUTO) 	
	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) 
	{
		this.ename = ename;
	}
	
	public double getSalary( ) 
	{
		return salary;
	}
	public void setSalary(double salary) 
	{
		this.salary = salary;
	}
	
	public String getDeg( ) 
	{
		return deg;
	}
	public void setDeg(String deg) 
	{
		this.deg = deg;
	}
	@Override
	public String toString() {
		return "Employee [eid=" + eid + ", ename=" + ename + ", salary="
				+ salary + ", deg=" + deg + "]";
	}
}

Persistence.xml

El archivo Persistence.xml es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
	<persistence-unit name="Eclipselink_JPA" 
                        transaction-type="RESOURCE_LOCAL">
	<class>com.tutorialspoint.eclipselink.entity.Employee</class>
		<properties>
			<property name="javax.persistence.jdbc.url" 
			          value="jdbc:mysql://localhost:3306/jpadb"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" 
			          value="root"/>
			<property name="javax.persistence.jdbc.driver" 
			          value="com.mysql.jdbc.Driver"/>
			<property name="eclipselink.logging.level" value="FINE"/>
			<property name="eclipselink.ddl-generation" 
			          value="create-tables"/>
		</properties>
	</persistence-unit>
</persistence>

Clases de servicio

Este módulo contiene las clases de servicio, que implementa la parte de consulta de Criterios utilizando la inicialización de la API de MetaData. Crea un paquete llamado‘com.tutorialspoint.eclipselink.service’. La clase nombradaCriteriaAPI.javase crea bajo el paquete dado. La clase DAO se muestra a continuación:

package com.tutorialspoint.eclipselink.service;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CriteriaApi 
{
	public static void main(String[] args) 
	{
		EntityManagerFactory emfactory = Persistence.
				createEntityManagerFactory( "Eclipselink_JPA" );
		EntityManager entitymanager = emfactory.
				createEntityManager( );
		CriteriaBuilder criteriaBuilder = entitymanager
				.getCriteriaBuilder();
		CriteriaQuery<Object> criteriaQuery = criteriaBuilder
				.createQuery();
		Root<Employee> from = criteriaQuery.from(Employee.class);
		
		//select all records
        System.out.println(“Select all records”);
		CriteriaQuery<Object> select =criteriaQuery.select(from);
		TypedQuery<Object> typedQuery = entitymanager
				.createQuery(select);
		List<Object> resultlist= typedQuery.getResultList();
		
		for(Object o:resultlist)
		{
			Employee e=(Employee)o;
			System.out.println("EID : "+e.getEid()
					+" Ename : "+e.getEname());
		}
		
		//Ordering the records 
        System.out.println(“Select all records by follow ordering”);
		CriteriaQuery<Object> select1 = criteriaQuery.select(from);
        select1.orderBy(criteriaBuilder.asc(from.get("ename")));
        TypedQuery<Object> typedQuery1 = entitymanager
        		.createQuery(select);
        List<Object> resultlist1= typedQuery1.getResultList();
		
		for(Object o:resultlist1)
		{
			Employee e=(Employee)o;
			System.out.println("EID : "+e.getEid()
					+" Ename : "+e.getEname());
		}
		
		entitymanager.close( );
		emfactory.close( );
	}
}

Después de compilar y ejecutar el programa anterior, obtendrá el siguiente resultado en el panel de la consola de Eclipse IDE.

Select All records
EID : 401 Ename : Gopal
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish
EID : 405 Ename : Krishna
EID : 406 Ename : Kiran
Select All records by follow Ordering
EID : 401 Ename : Gopal
EID : 406 Ename : Kiran
EID : 405 Ename : Krishna
EID : 402 Ename : Manisha
EID : 403 Ename : Masthanvali
EID : 404 Ename : Satish