JPA - Guia Rápido

Qualquer aplicativo corporativo executa operações de banco de dados, armazenando e recuperando grandes quantidades de dados. Apesar de todas as tecnologias disponíveis para gerenciamento de armazenamento, os desenvolvedores de aplicativos normalmente lutam para executar operações de banco de dados com eficiência.

Geralmente, os desenvolvedores Java usam muito código ou usam a estrutura proprietária para interagir com o banco de dados, ao passo que usando JPA, a carga de interagir com o banco de dados diminui significativamente. Ele forma uma ponte entre os modelos de objeto (programa Java) e os modelos relacionais (programa de banco de dados).

Incompatibilidades entre modelos relacionais e de objeto

Os objetos relacionais são representados em um formato tabular, enquanto os modelos de objetos são representados em um gráfico interconectado de formato de objeto. Ao armazenar e recuperar um modelo de objeto de um banco de dados relacional, ocorre alguma incompatibilidade devido aos seguintes motivos:

  • Granularity : O modelo de objeto tem mais granularidade do que o modelo relacional.

  • Subtypes : Subtipos (significa herança) não são suportados por todos os tipos de bancos de dados relacionais.

  • Identity : Como o modelo de objeto, o modelo relacional não expõe identidade ao escrever igualdade.

  • Associations : Modelos relacionais não podem determinar relacionamentos múltiplos enquanto olha para o modelo de domínio de objeto.

  • Data navigation : A navegação de dados entre objetos em uma rede de objetos é diferente em ambos os modelos.

O que é JPA?

Java Persistence API é uma coleção de classes e métodos para armazenar de forma persistente grandes quantidades de dados em um banco de dados fornecido pela Oracle Corporation.

Onde usar JPA?

Para reduzir a carga de escrever códigos para gerenciamento de objetos relacionais, um programador segue a estrutura 'Provedor JPA', que permite fácil interação com a instância do banco de dados. Aqui, a estrutura necessária é assumida pela JPA.

História JPA

Versões anteriores de EJB, camada de persistência definida combinada com camada de lógica de negócios usando a interface javax.ejb.EntityBean.

  • Durante a introdução do EJB 3.0, a camada de persistência foi separada e especificada como JPA 1.0 (Java Persistence API). As especificações desta API foram lançadas junto com as especificações do JAVA EE5 em 11 de maio de 2006 usando JSR 220.

  • O JPA 2.0 foi lançado com as especificações do JAVA EE6 em 10 de dezembro de 2009 como parte do Java Community Process JSR 317.

  • JPA 2.1 foi lançado com a especificação de JAVA EE7 em 22 de abril de 2013 usando JSR 338.

Provedores JPA

JPA é uma API de software livre, portanto, vários fornecedores corporativos, como Oracle, Redhat, Eclipse, etc. fornecem novos produtos adicionando o tipo de persistência JPA a eles. Alguns desses produtos incluem:

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

Java Persistence API é uma fonte para armazenar entidades de negócios como entidades relacionais. Mostra como definir um PLAIN OLD JAVA OBJECT (POJO) como uma entidade e como gerenciar entidades com relações.

Arquitetura de nível de classe

A imagem a seguir mostra a arquitetura de nível de classe do JPA. Mostra as principais classes e interfaces do JPA.

A tabela a seguir descreve cada uma das unidades mostradas na arquitetura acima.

Unidades Descrição
EntityManagerFactory Esta é uma classe de fábrica do EntityManager. Ele cria e gerencia várias instâncias de EntityManager.
EntityManager É uma Interface, gerencia as operações de persistência nos objetos. Funciona como fábrica para a instância Query.
Entity Entidades são os objetos de persistência, armazenados como registros no banco de dados.
EntityTransaction Ele tem relacionamento um para um com EntityManager. Para cada EntityManager, as operações são mantidas pela classe EntityTransaction.
Persistence Esta classe contém métodos estáticos para obter a instância EntityManagerFactory.
Query Essa interface é implementada por cada fornecedor de JPA para obter objetos relacionais que atendam aos critérios.

As classes e interfaces acima são usadas para armazenar entidades em um banco de dados como um registro. Eles ajudam os programadores, reduzindo seus esforços para escrever códigos para armazenar dados em um banco de dados, para que possam se concentrar em atividades mais importantes, como escrever códigos para mapear as classes com tabelas de banco de dados.

Relacionamentos de classe JPA

Na arquitetura acima, as relações entre as classes e interfaces pertencem ao pacote javax.persistence. O diagrama a seguir mostra a relação entre eles.

  • A relação entre EntityManagerFactory e EntityManager é one-to-many. É uma classe de fábrica para instâncias de EntityManager.

  • A relação entre EntityManager e EntityTransaction é one-to-one. Para cada operação EntityManager, há uma instância EntityTransaction.

  • A relação entre EntityManager e Query é one-to-many. Muitos números de consultas podem ser executados usando uma instância de EntityManager.

  • A relação entre EntityManager e Entity é one-to-many. Uma instância do EntityManager pode gerenciar várias entidades.

A maioria dos aplicativos contemporâneos usa banco de dados relacional para armazenar dados. Recentemente, muitos fornecedores mudaram para o banco de dados de objetos para reduzir sua carga na manutenção de dados. Isso significa que o banco de dados de objetos ou as tecnologias relacionais de objetos cuidam do armazenamento, recuperação, atualização e manutenção de dados. A parte central desta tecnologia relacional de objeto é o mapeamento de arquivos orm.xml. Como o xml não requer compilação, podemos facilmente fazer alterações em várias fontes de dados com menos administração.

Mapeamento Relacional de Objeto

O Mapeamento Objeto Relacional (ORM) descreve brevemente o que é ORM e como ele funciona. ORM é uma habilidade de programação para converter dados de tipo de objeto para tipo relacional e vice-versa.

A principal característica do ORM é mapear ou vincular um objeto aos seus dados no banco de dados. Durante o mapeamento, temos que considerar os dados, o tipo de dados e suas relações com a autoentidade ou entidades em qualquer outra tabela.

Características avançadas

  • Idiomatic persistence : Permite que você escreva as classes de persistência usando classes orientadas a objetos.

  • High Performance : Possui muitas técnicas de busca e técnicas de bloqueio esperançosas.

  • Reliable : É altamente estável e usado por muitos programadores profissionais.

Arquitetura ORM

A arquitetura ORM tem a seguinte aparência.

A arquitetura acima explica como os dados do objeto são armazenados no banco de dados relacional em três fases.

Fase 1

A primeira fase, chamada de object data phase, contém classes POJO, interfaces de serviço e classes. É a principal camada de componente de negócios, que possui operações e atributos de lógica de negócios.

Por exemplo, tomemos um banco de dados de funcionários como esquema.

  • A classe POJO do funcionário contém atributos como ID, nome, salário e designação. Ele também contém métodos como setter e getter desses atributos.

  • As classes de DAO / serviço do funcionário contêm métodos de serviço, como criar funcionário, localizar funcionário e excluir funcionário.

Fase 2

A segunda fase, denominada como mapping ou persistence phase, contém o provedor JPA, o arquivo de mapeamento (ORM.xml), o carregador JPA e a grade de objetos.

  • JPA Provider: É o produto do fornecedor que contém o tipo JPA (javax.persistence). Por exemplo Eclipselink, Toplink, Hibernate, etc.

  • Mapping file : O arquivo de mapeamento (ORM.xml) contém a configuração de mapeamento entre os dados em uma classe POJO e os dados em um banco de dados relacional.

  • JPA Loader: O carregador JPA funciona como uma memória cache. Ele pode carregar os dados da grade relacional. Funciona como uma cópia do banco de dados para interagir com classes de serviço para dados POJO (atributos da classe POJO).

  • Object Grid: É um local temporário que pode armazenar uma cópia dos dados relacionais, como uma memória cache. Todas as consultas no banco de dados são efetuadas primeiro nos dados da grade de objetos. Somente depois de confirmado, ele afeta o banco de dados principal.

Fase 3

A terceira fase é a relational data phase. Ele contém os dados relacionais que estão logicamente conectados ao componente de negócios. Conforme discutido acima, apenas quando o componente de negócios confirma os dados, eles são armazenados fisicamente no banco de dados. Até então, os dados modificados são armazenados em uma memória cache como um formato de grade. O processo de obtenção dos dados é idêntico ao de armazenamento dos dados.

O mecanismo de interação programática das três fases acima é chamado de object relational mapping.

Mapping.xml

O arquivo mapping.xml serve para instruir o fornecedor JPA a mapear as classes de Entidade com as tabelas do banco de dados.

Tomemos um exemplo de entidade Employee que contém quatro atributos. A classe POJO da entidade Employee chamadaEmployee.java é o seguinte:

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

O código acima é a classe POJO da entidade Employee. Contém quatro atributoseid, ename, salary, e deg. Considere esses atributos como os campos da tabela em uma tabela eeidcomo a chave primária desta tabela. Agora temos que projetar o arquivo de mapeamento de hibernação para ele. O arquivo de mapeamento chamadomapping.xml é o seguinte:

<? 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>

O script acima é usado para mapear a classe de entidade com a tabela do banco de dados. Neste arquivo

  • <entity-mappings> : tag define a definição do esquema para permitir tags de entidade no arquivo xml.

  • <description> : tag fornece uma descrição sobre o aplicativo.

  • <entity>: tag define a classe de entidade que você deseja converter em tabela em um banco de dados. A classe de atributo define o nome da classe de entidade POJO.

  • <table>: tag define o nome da tabela. Se você deseja ter nomes idênticos para a classe e também para a tabela, esta tag não é necessária.

  • <attributes> : tag define os atributos (campos em uma tabela).

  • <id>: tag define a chave primária da tabela. o<generated-value> tag define como atribuir o valor da chave primária, como Automatic, Manual, ou tirado de Sequence.

  • <basic> : tag é usada para definir os atributos restantes para a tabela.

  • <column-name> : tag é usada para definir nomes de campos de tabela definidos pelo usuário na tabela.

Anotações

Geralmente, os arquivos xml são usados ​​para configurar componentes específicos ou mapear duas especificações diferentes de componentes. Em nosso caso, temos que manter os arquivos xml separadamente em um framework. Isso significa que, ao escrever um arquivo xml de mapeamento, precisamos comparar os atributos da classe POJO com as tags de entidade no arquivo mapping.xml.

Aqui está a solução. Na definição da classe, podemos escrever a parte de configuração usando anotações. As anotações são usadas para classes, propriedades e métodos. As anotações começam com o símbolo '@'. As anotações são declaradas antes de uma classe, propriedade ou método. Todas as anotações de JPA são definidas nojavax.persistence pacote.

Aqui, a lista de anotações usadas em nossos exemplos é fornecida abaixo.

Anotação Descrição
@Entidade Declara a classe como uma entidade ou tabela.
@Mesa Declara o nome da tabela.
@Basic Especifica campos sem restrição explicitamente.
@Embutido Especifica as propriedades da classe ou uma entidade cujo valor é uma instância de uma classe incorporável.
@Eu iria Especifica a propriedade, use para identidade (chave primária de uma tabela) da classe.
@GeneratedValue Especifica como o atributo de identidade pode ser inicializado, como automático, manual ou valor obtido de uma tabela de sequência.
@Transient Especifica a propriedade que não é persistente, ou seja, o valor nunca é armazenado no banco de dados.
@Coluna Especifica o atributo da coluna para a propriedade de persistência.
@SequenceGenerator Especifica o valor da propriedade especificada na anotação @GeneratedValue. Ele cria uma sequência.
@TableGenerator Especifica o gerador de valor para a propriedade especificada na anotação @GeneratedValue. Ele cria uma tabela para geração de valor.
@Tipo de acesso Este tipo de anotação é usado para definir o tipo de acesso. Se você definir @AccessType (FIELD), o acesso ocorrerá por meio do campo. Se você definir @AccessType (PROPERTY), o acesso ocorrerá por meio da propriedade.
@JoinColumn Especifica uma associação de entidade ou coleção de entidades. Isso é usado em associações muitos-para-um e um-para-muitos.
@Restrição única Especifica os campos e as restrições exclusivas para a tabela primária ou secundária.
@ColumnResult Faz referência ao nome de uma coluna na consulta SQL usando a cláusula select.
@Muitos para muitos Define um relacionamento muitos para muitos entre as tabelas de junção.
@ManyToOne Define um relacionamento muitos para um entre as tabelas de junção.
@Um para muitos Define um relacionamento um para muitos entre as tabelas de junção.
@Um a um Define um relacionamento um para um entre as tabelas de junção.
@NamedQueries especifica uma lista de consultas nomeadas.
@NamedQuery Especifica uma consulta usando nome estático.

Java Bean Standard

A classe Java encapsula os valores da instância e seus comportamentos em uma única unidade chamada objeto. Java Bean é um armazenamento temporário e um componente reutilizável ou um objeto. É uma classe serializável que possui um construtor padrão e métodos getter e setter para inicializar os atributos de instância individualmente.

Bean Conventions

  • Bean contém seu construtor padrão ou um arquivo que contém a instância serializada. Portanto, um bean pode instanciar outro bean.

  • As propriedades de um bean podem ser segregadas em propriedades booleanas ou propriedades não booleanas.

  • Propriedade não booleana contém getter e setter métodos.

  • Propriedade booleana contém setter e is método.

  • Getter método de qualquer propriedade deve começar com letras minúsculas get(convenção do método java) e continuou com um nome de campo que começa com letra maiúscula. Por exemplo, o nome do campo ésalary portanto, o método getter deste campo é getSalary ().

  • Setter método de qualquer propriedade deve começar com letras minúsculas set (convenção do método java), continuou com um nome de campo que começa com letra maiúscula e o argument valuepara definir como campo. Por exemplo, o nome do campo ésalary portanto, o método setter deste campo é setSalary ( double sal ).

  • Para propriedade booleana, ismétodo para verificar se é verdadeiro ou falso. Por exemplo, a propriedade booleanaempty, a is método deste campo é isEmpty ().

Este capítulo o conduz pelo processo de configuração de JPA em sistemas baseados em Windows e Linux. O JPA pode ser facilmente instalado e integrado ao seu ambiente Java atual seguindo algumas etapas simples, sem quaisquer procedimentos de configuração complexos. A administração do usuário é necessária durante a instalação.

Requisitos de sistema

JDK Java SE 2 JDK 1.5 ou superior
Memória 1 GB de RAM (recomendado)
Espaço em disco Sem requisitos mínimos
Versão do sistema operacional Windows XP ou superior, Linux

Vamos agora prosseguir com as etapas para instalar o JPA.

Etapa 1: verifique a instalação do Java

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos a seguir, dependendo da plataforma em que está trabalhando.

Se a instalação do Java foi feita corretamente, ele exibirá a versão atual e as especificações de sua instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.

Plataforma Comando Saída de amostra
janelas

Abra o console de comando e digite:

\>java –version

Versão Java "1.7.0_60"

Java (TM) SE Run Time Environment (build 1.7.0_60-b19)

Java Hotspot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Linux

Abra o terminal de comando e digite:

$java –version

versão java "1.7.0_25"

Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64)

Abra o servidor VM JDK de 64 bits (compilação 23.7-b01, modo misto)

Etapa 2: definir seu ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

Plataforma Descrição
janelas Defina JAVA_HOME como C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux Exportar JAVA_HOME = / usr / local / java-current

Anexe o caminho completo do local do compilador Java ao Caminho do sistema.

Plataforma Descrição
janelas Anexe a string "C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ bin" ao final da variável de sistema PATH.
Linux Exportar PATH = $ PATH: $ JAVA_HOME / bin /

Execute o comando java -version no prompt de comando, conforme explicado acima.

Etapa 3: Instalando JPA

Você pode passar pela instalação do JPA usando qualquer um dos Provedores JPA deste tutorial, por exemplo, Eclipselink, Hibernate. Vamos acompanhar a instalação do JPA usando Eclipselink. Para programação JPA, é necessário seguir a estrutura de pasta específica, portanto, é melhor usar o IDE.

Baixe o formulário Eclipse IDE seguindo o link https://www.eclipse.org/downloads/ Escolha o desenvolvedor EclipseIDE para JavaEE que é Eclipse indigo.

Descompacte o arquivo zip do Eclipse na unidade C. Abra o Eclipse IDE.

Instalando JPA usando Eclipselink

Eclipselink é uma biblioteca, portanto, não podemos adicioná-la diretamente ao Eclipse IDE. Para instalar o JPA usando Eclipselink, você precisa seguir as etapas fornecidas abaixo.

  • Crie um novo projeto JPA selecionando File->New->JPA Project no Eclipse IDE da seguinte forma:

  • Você verá uma caixa de diálogo chamada New JPA Project. Insira o nome do projetotutorialspoint_JPA_Eclipselink, Verifica a jre versão e clique em próximo:

  • Clique em baixar biblioteca (se você não tiver a biblioteca) na seção de biblioteca do usuário.

  • Selecione a versão mais recente da biblioteca Eclipselink na caixa de diálogo Baixar biblioteca e clique em Avançar da seguinte forma:

  • Aceite os termos da licença e clique em Concluir para baixar a biblioteca.

  • 6. O download começa conforme mostrado na imagem a seguir.

  • Após o download, selecione a biblioteca baixada na seção de biblioteca do usuário e clique em Concluir.

  • Finalmente, você obtém o arquivo do projeto no Package Explorerno Eclipse IDE. Extraia todos os arquivos, você obterá a hierarquia de pastas e arquivos da seguinte forma:

Adicionando conector MySQL ao projeto

Qualquer exemplo que discutiremos aqui requer conectividade com o banco de dados. Vamos considerar o banco de dados MySQL para operações de banco de dados. Requer jar do conector mysql para interagir com um programa Java.

Siga as etapas para configurar o jar do banco de dados em seu projeto.

  • Vá para propriedades do projeto ->Java Build Path clicando com o botão direito nele. Você obterá uma caixa de diálogo conforme mostrado na captura de tela a seguir. Clique em Adicionar Jars externos.

  • Vá para o local do jar na memória do sistema, selecione o arquivo e clique em abrir.

  • Clique em ok na caixa de diálogo de propriedades. Você obterá o Jar do conector do MySQL em seu projeto. Agora você pode fazer operações de banco de dados usando MySQL.

Este capítulo usa um exemplo simples para demonstrar como o JPA funciona. Vamos considerar a gestão de funcionários como um exemplo. Suponha que o Gerenciamento de funcionários crie, atualize, encontre e exclua os registros de um funcionário. Conforme mencionado, estamos usando o banco de dados MySQL para operações de banco de dados.

Os principais módulos para este exemplo são os seguintes:

  • Model or POJO

    Employee.java

  • Persistence

    Persistence.xml

  • Service

    CreatingEmployee.java

    UpdatingEmployee.java

    FindingEmployee.java

    DeletingEmployee.java

Tomemos a hierarquia de pacotes que usamos na instalação do JPA com o Eclipselink. Siga a hierarquia para este exemplo conforme mostrado abaixo:

Criando Entidades

As entidades nada mais são do que feijões ou modelos. Neste exemplo, usaremosEmployee como uma entidade. eid, ename, salary, e degsão os atributos desta entidade. Ele contém um construtor padrão, bem como os métodos setter e getter desses atributos.

Na hierarquia mostrada acima, crie um pacote chamado ‘com.tutorialspoint.eclipselink.entity’, debaixo ‘src’Pacote (fonte). Crie uma classe chamadaEmployee.java sob determinado pacote da seguinte forma:

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 + "]";
	}
}

No código acima, usamos a anotação @Entity para tornar essa classe POJO uma entidade.

Antes de ir para o próximo módulo, precisamos criar banco de dados para a entidade relacional, que irá registrar o banco de dados em persistence.xmlArquivo. Abra o ambiente de trabalho MySQL e digite hte a seguir a consulta.

create database jpadb
use jpadb

Persistence.xml

Este módulo desempenha um papel crucial no conceito de JPA. Neste arquivo xml iremos registrar o banco de dados e especificar a classe de entidade.

Na hierarquia de pacotes mostrada acima, persistence.xml no pacote de conteúdo JPA é o seguinte:

<?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>

No xml acima, <persistence-unit> tag é definida com um nome específico para persistência JPA. o<class>tag define a classe de entidade com o nome do pacote. o<properties> tag define todas as propriedades, e <property>tag define cada propriedade, como registro de banco de dados, especificação de URL, nome de usuário e senha. Estas são as propriedades do Eclipselink. Este arquivo irá configurar o banco de dados.

Operações de Persistência

As operações de persistência são usadas para interagir com um banco de dados e são load e storeoperações. Em um componente de negócios, todas as operações de persistência se enquadram em classes de serviço.

Na hierarquia de pacotes mostrada acima, crie um pacote chamado ‘com.tutorialspoint.eclipselink.service’, debaixo ‘src’pacote (fonte). Todas as classes de serviço nomeadas como CreateEmloyee.java, UpdateEmployee.java, FindEmployee.java e DeleteEmployee.java. vem no pacote fornecido da seguinte forma:

Criar Funcionário

O segmento de código a seguir mostra como criar uma classe Employee chamada 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( );
	}
}

No código acima o createEntityManagerFactory ()cria uma unidade de persistência fornecendo o mesmo nome exclusivo que fornecemos para a unidade de persistência no arquivo persistent.xml. oentitymanagerfactory objeto criará o entitymanger instância usando createEntityManager ()método. oentitymanager objeto cria entitytransactioninstância para gerenciamento de transações. Usandoentitymanager objeto, podemos persistir entidades no banco de dados.

Após a compilação e execução do programa acima, você receberá notificações da biblioteca eclipselink no painel do console do Eclipse IDE.

Para obter o resultado, abra o ambiente de trabalho MySQL e digite as seguintes consultas.

use jpadb
select * from employee

A tabela de banco de dados afetada chamada employee será mostrado em um formato tabular da seguinte forma:

Eid Ename Salário Grau
1201 Gopal 40.000 Gerente técnico

Funcionário atualizado

Para atualizar os registros de um funcionário, precisamos recuperar os registros existentes no banco de dados, fazer alterações e, finalmente, confirmá-los no banco de dados. A classe chamadaUpdateEmployee.java é mostrado da seguinte forma:

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

Após a compilação e execução do programa acima, você receberá notificações da biblioteca Eclipselink no painel do console do Eclipse IDE.

Para obter o resultado, abra o ambiente de trabalho MySQL e digite as seguintes consultas.

use jpadb
select * from employee

A tabela de banco de dados afetada chamada employee será mostrado em um formato tabular da seguinte forma:

Eid Ename Salário Grau
1201 Gopal 46000 Gerente técnico

O salário do empregado, 1.201, é atualizado para 46.000.

Encontrar funcionário

Para encontrar os registros de um funcionário, teremos que recuperar os dados existentes no banco de dados e exibi-los. Nesta operação, EntityTransaction não é aplicada ao recuperar um registro.

A classe chamada FindEmployee.java do seguinte modo.

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

Depois de compilar e executar o programa acima, você obterá a seguinte saída da biblioteca Eclipselink no painel do console do Eclipse IDE.

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

Excluindo Funcionário

Para excluir os registros de um funcionário, primeiro vamos encontrar os registros existentes e depois excluí-los. Aqui, EntityTransaction desempenha um papel importante.

A classe chamada DeleteEmployee.java do seguinte modo:

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

Após a compilação e execução do programa acima, você receberá notificações da biblioteca Eclipselink no painel do console do Eclipse IDE.

Para obter o resultado, abra o ambiente de trabalho MySQL e digite as seguintes consultas.

use jpadb
select * from employee

O banco de dados afetado chamado employee terá registros nulos.

Após a conclusão de todos os módulos neste exemplo, a hierarquia do pacote e do arquivo tem a seguinte aparência:

Este capítulo descreve sobre JPQL e como ele funciona com unidades de persistência. Neste capítulo, os exemplos fornecidos seguem a mesma hierarquia de pacotes, que usamos no capítulo anterior.

Linguagem Java Persistence Query

JPQL significa Java Persistence Query Language. É usado para criar consultas em entidades para armazenar em um banco de dados relacional. JPQL é desenvolvido com base na sintaxe SQL. Mas isso não afetará o banco de dados diretamente.

JPQL pode recuperar dados usando a cláusula SELECT, pode fazer atualizações em massa usando as cláusulas UPDATE e DELETE.

Estrutura de Consulta

A sintaxe JPQL é muito semelhante à sintaxe SQL. Ter uma sintaxe semelhante ao SQL é uma vantagem porque o SQL é simples e amplamente utilizado. O SQL funciona diretamente em tabelas, registros e campos de banco de dados relacional, enquanto JPQL funciona com classes e instâncias Java.

Por exemplo, uma consulta JPQL pode recuperar um objeto de entidade em vez de conjunto de resultados de campo de um banco de dados, como no SQL. A estrutura da consulta JPQL da seguinte maneira.

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

A estrutura das consultas JPQL DELETE e UPDATE são as seguintes.

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

Funções escalares e agregadas

As funções escalares retornam valores resultantes com base nos valores de entrada. As funções agregadas retornam os valores resultantes calculando os valores de entrada.

Usaremos o mesmo exemplo de Gestão de Funcionários do capítulo anterior. Aqui, vamos percorrer as classes de serviço usando funções escalares e agregadas de JPQL.

Vamos supor que jpadb.employee A tabela contém os seguintes registros.

Eid Ename Salário Grau
1201 Gopal 40.000 Gerente técnico
1202 Manisha 40.000 Leitor de Provas
1203 Masthanvali 40.000 Escritor técnico
1204 Satish 30000 Escritor técnico
1205 Krishna 30000 Escritor técnico
1206 Kiran 35000 Leitor de Provas

Crie uma classe chamada ScalarandAggregateFunctions.java debaixo com.tutorialspoint.eclipselink.service pacote da seguinte forma.

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

Após a compilação e execução do programa acima, você obterá a seguinte saída no painel do console do 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, E, Palavras-chave semelhantes

Between, And, e Likesão as principais palavras-chave do JPQL. Essas palavras-chave são usadas apósWhere clause em uma consulta.

Crie uma classe chamada BetweenAndLikeFunctions.java debaixo com.tutorialspoint.eclipselink.service pacote da seguinte forma:

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

Após compilar e executar o programa acima, você obterá a seguinte saída no painel do console do 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

Encomenda

Para ordenar os registros em JPQL, usamos a cláusula ORDER BY. O uso desta cláusula é o mesmo que em SQL, mas lida com entidades. O exemplo a seguir mostra como usar a cláusula ORDER BY.

Crie uma classe Ordering.java debaixo com.tutorialspoint.eclipselink.service pacote da seguinte forma:

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

Compilando e executando o programa acima, você produzirá a seguinte saída no painel do console do 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 nomeadas

Uma anotação @NamedQuery é definida como uma consulta com uma string de consulta predefinida que é imutável. Em contraste com as consultas dinâmicas, as consultas nomeadas podem melhorar a organização do código, separando as strings de consulta JPQL do POJO. Ele também passa os parâmetros de consulta em vez de incorporar os literais dinamicamente na string de consulta e, portanto, produz consultas mais eficientes.

Primeiro de tudo, adicione a anotação @NamedQuery à classe de entidade Employee chamada Employee.java debaixo com.tutorialspoint.eclipselink.entity pacote da seguinte forma:

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 + "]";
	}
}

Crie uma classe chamada NamedQueries.java debaixo com.tutorialspoint.eclipselink.service pacote da seguinte forma:

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

Após compilar e executar o programa acima, você obterá a seguinte saída no painel do console do Eclipse IDE.

Employee ID :1204	 Employee Name :Satish

Depois de adicionar todas as classes acima, a hierarquia do pacote se parece com a seguinte:

Busca ansiosa e preguiçosa

O conceito mais importante de JPA é fazer uma cópia duplicada do banco de dados na memória cache. Durante a transação com um banco de dados, o JPA primeiro cria um conjunto duplicado de dados e apenas quando é confirmado usando um gerenciador de entidade, as mudanças são efetuadas no banco de dados.

Existem duas maneiras de obter registros do banco de dados.

Eager fetch

Na busca rápida, os objetos filho relacionados são carregados automaticamente durante a busca de um determinado registro.

Preguiçoso

No lazy fetching, os objetos relacionados não são carregados automaticamente, a menos que você os solicite especificamente. Em primeiro lugar, ele verifica a disponibilidade de objetos relacionados e notifica. Posteriormente, se você chamar qualquer um dos métodos getter dessa entidade, ele buscará todos os registros.

A busca lenta é possível quando você tenta buscar os registros pela primeira vez. Dessa forma, uma cópia de todo o registro já fica armazenada na memória cache. Em termos de desempenho, a busca lenta é preferível.

JPA é uma biblioteca lançada com especificações Java. Portanto, ele suporta todos os conceitos orientados a objetos para persistência de entidade. Até agora, concluímos os fundamentos do mapeamento relacional de objetos. Este capítulo o conduz pelos mapeamentos avançados entre objetos e entidades relacionais.

Estratégias de herança

Herança é o conceito central de qualquer linguagem orientada a objetos, portanto, podemos usar relacionamentos ou estratégias de herança entre entidades. O JPA suporta três tipos de estratégias de herança: SINGLE_TABLE, JOINED_TABLE e TABLE_PER_CONCRETE_CLASS.

Vamos considerar um exemplo. O diagrama a seguir mostra três classes, viz. Staff, TeachingStaff e NonTeachingStaff e seus relacionamentos.

No diagrama acima, Staff é uma entidade, enquanto TeachingStaff e NonTeachingStaff são as subentidades de Staff. Aqui, usaremos o exemplo acima para demonstrar as três estratégias de herança.

Estratégia de mesa única

A estratégia de tabela única pega todos os campos de classes (super e subclasses) e os mapeia em uma única tabela conhecida como estratégia SINGLE_TABLE. Aqui, o valor discriminador desempenha um papel fundamental na diferenciação dos valores de três entidades em uma tabela.

Vamos considerar o exemplo acima. TeachingStaff e NonTeachingStaff são as subclasses de Staff. De acordo com o conceito de herança, uma subclasse herda as propriedades de sua superclasse. Portanto, sid e sname são os campos que pertencem a TeachingStaff e NonTeachingStaff. Crie um projeto JPA. Todos os módulos deste projeto são os seguintes:

Criando Entidades

Crie um pacote chamado ‘com.tutorialspoint.eclipselink.entity’ debaixo ‘src’pacote. Crie uma nova classe java chamadaStaff.javasob determinado pacote. A classe de entidade Staff é mostrada da seguinte forma:

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

No código acima @DescriminatorColumn especifica o nome do campo (type) e seus valores mostram os campos restantes (Teaching e NonTeachingStaff).

Crie uma subclasse (classe) para a classe Staff chamada TeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe TeachingStaff Entity é mostrada da seguinte forma:

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

Crie uma subclasse (classe) para a classe Staff chamada NonTeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe NonTeachingStaff Entity é mostrada da seguinte forma:

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 contém as informações de configuração do banco de dados e as informações de registro das classes de entidade. O arquivo xml é mostrado da seguinte forma:

<?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>

Classe de serviço

As classes de serviço são a parte de implementação do componente de negócios. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’.

Crie uma classe chamada SaveClient.javano pacote fornecido para armazenar os campos de classe Staff, TeachingStaff e NonTeachingStaff. A classe SaveClient é mostrada da seguinte forma:

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

Depois de compilar e executar o programa acima, você receberá notificações no painel do console do Eclipse IDE. Verifique o ambiente de trabalho MySQL para saída. A saída em formato tabular é mostrada da seguinte forma:

Sid Tipo Sname Experiência da área Qualificação Experiência do assunto
1 TS Gopal MSC MED Matemáticas
2 TS Manisha BSC BED Inglês
3 NS Satish Contas
4 NS Krishna Admin de escritório

Finalmente você terá uma única tabela contendo o campo de todas as três classes com uma coluna discriminadora chamada Type (campo).

Estratégia de mesa junta

A estratégia da tabela unida é compartilhar a coluna referenciada que contém valores únicos para unir a tabela e fazer transações fáceis. Vamos considerar o mesmo exemplo acima.

Crie um projeto JPA. Todos os módulos do projeto são mostrados abaixo.

Criando Entidades

Crie um pacote chamado ‘com.tutorialspoint.eclipselink.entity’ debaixo ‘src’pacote. Crie uma nova classe java chamadaStaff.javasob determinado pacote. A classe de entidade Staff é mostrada da seguinte forma:

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

Crie uma subclasse (classe) para a classe Staff chamada TeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe TeachingStaff Entity é mostrada da seguinte forma:

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

Crie uma subclasse (classe) para a classe Staff chamada NonTeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe NonTeachingStaff Entity é mostrada da seguinte forma:

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

O arquivo Persistence.xml contém as informações de configuração do banco de dados e as informações de registro das classes de entidade. O arquivo xml é mostrado da seguinte forma:

<?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>

Classe de serviço

As classes de serviço são a parte de implementação do componente de negócios. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’.

Crie uma classe chamada SaveClient.javano pacote fornecido para armazenar os campos da classe Staff, TeachingStaff e NonTeachingStaff. Em seguida, a classe SaveClient é mostrada da seguinte forma:

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

Depois de compilar e executar o programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL.

Aqui três tabelas são criadas e o resultado de staff a tabela é exibida em formato tabular.

Sid Dtype Sname
1 Pessoal docente Gopal
2 Pessoal docente Manisha
3 NonTeachingStaff Satish
4 NonTeachingStaff Krishna

O resultado de TeachingStaff a tabela é exibida da seguinte forma:

Sid Qualificação Experiência do assunto
1 MSC MED Matemáticas
2 BSC BED Inglês

Na tabela acima, sid é a chave estrangeira (campo de referência da tabela de funcionários). O resultado de NonTeachingStaff a tabela é exibida da seguinte forma:

Sid Experiência da área
3 Contas
4 Admin de escritório

Por fim, as três tabelas são criadas usando seus respectivos campos e o campo SID é compartilhado por todas as três tabelas. Na tabela Staff, SID é a chave primária. Nas duas tabelas restantes (TeachingStaff e NonTeachingStaff), SID é a chave estrangeira.

Tabela por estratégia de classe

A estratégia de tabela por classe consiste em criar uma tabela para cada subentidade. A tabela Staff será criada, mas conterá valores nulos. Os valores dos campos da tabela Staff devem ser compartilhados pelas tabelas TeachingStaff e NonTeachingStaff.

Vamos considerar o mesmo exemplo acima.

Criando Entidades

Crie um pacote chamado ‘com.tutorialspoint.eclipselink.entity’ debaixo ‘src’pacote. Crie uma nova classe java chamadaStaff.javasob determinado pacote. A classe de entidade Staff é mostrada da seguinte forma:

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

Crie uma subclasse (classe) para a classe Staff chamada TeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe TeachingStaff Entity é mostrada da seguinte forma:

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

Crie uma subclasse (classe) para a classe Staff chamada NonTeachingStaff.java debaixo de com.tutorialspoint.eclipselink.entitypacote. A classe NonTeachingStaff Entity é mostrada da seguinte forma:

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

O arquivo Persistence.xml contém as informações de configuração do banco de dados e as informações de registro das classes de entidade. O arquivo xml é mostrado da seguinte forma:

<?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>

Classe de serviço

As classes de serviço são a parte de implementação do componente de negócios. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’.

Crie uma classe chamada SaveClient.javano pacote fornecido para armazenar os campos de classe Staff, TeachingStaff e NonTeachingStaff. A classe SaveClient é mostrada da seguinte forma:

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

Depois de compilar e executar o programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL.

Aqui, as três tabelas são criadas e o Staff tabela contém registros nulos.

O resultado de TeachingStaff é exibido da seguinte forma:

Sid Qualificação Sname Experiência do assunto
1 MSC MED Gopal Matemáticas
2 BSC BED Manisha Inglês

A tabela acima TeachingStaff contém campos de entidades Staff e TeachingStaff.

O resultado de NonTeachingStaff é exibido da seguinte forma:

Sid Experiência da área Sname
3 Contas Satish
4 Admin de escritório Krishna

A tabela acima NonTeachingStaff contém campos de Entidades Staff e NonTeachingStaff.

Este capítulo apresenta as relações entre as entidades. Geralmente as relações são mais eficazes entre as tabelas do banco de dados. Aqui, as classes de entidade são tratadas como tabelas relacionais (conceito de JPA), portanto, as relações entre as classes de entidade são as seguintes:

  • Relação @ManyToOne
  • Relação @OneToMany
  • Relação @OneToOne
  • Relação @ManyToMany

Relação @ManyToOne

A relação muitos para um entre entidades existe onde uma entidade (coluna ou conjunto de colunas) é referenciada com outra entidade (coluna ou conjunto de colunas) contendo valores únicos. Em bancos de dados relacionais, essas relações são aplicadas usando chave estrangeira / chave primária entre as tabelas.

Vamos considerar um exemplo de relação entre entidades Funcionário e Departamento. De forma unidirecional, ou seja, de funcionário para departamento, a relação muitos para um é aplicável. Isso significa que cada registro de funcionário contém um ID de departamento, que deve ser uma chave primária na tabela Departamento. Aqui na tabela Employee, Department id é a chave estrangeira.

O diagrama a seguir mostra a relação Muitos-para-um entre as duas tabelas.

Crie um projeto JPA no Eclipse IDE chamado JPA_Eclipselink_MTO. Todos os módulos deste projeto são discutidos abaixo.

Criando Entidades

Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:

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

Crie a segunda entidade nesta relação - classe de entidade de funcionário chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:

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

O arquivo Persistence.xml é necessário para configurar o banco de dados e o registro das classes de entidade.

Persitence.xml será criado pelo Eclipse IDE ao criar um Projeto JPA. Os detalhes da configuração são especificações do usuário. O arquivo persistence.xml é mostrado da seguinte forma:

<?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>

Classes de serviço

Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaManyToOne.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:

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

Depois de compilar e executar o programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL. Neste exemplo, duas tabelas são criadas.

Passe a seguinte consulta na interface MySQL e o resultado de Department a tabela será exibida da seguinte forma:

Select * from department
EU IRIA Nome
101 Desenvolvimento

Passe a seguinte consulta na interface MySQL e o resultado de Employee a tabela será exibida como segue.

Select * from employee
Eid Grau Ename Salário Department_Id
102 Escritor técnico Satish 45000 101
103 Escritor técnico Krishna 45000 101
104 Escritor técnico Masthanwali 50000 101

Na tabela acima, Deparment_Id é a chave estrangeira (campo de referência) da tabela Departamento.

Relação @OneToMany

Nesse relacionamento, cada linha de uma entidade é referenciada a muitos registros filho em outra entidade. O importante é que os registros de filhos não podem ter vários pais. Em uma relação um-para-muitos entre a Tabela A e a Tabela B, cada linha da Tabela A pode ser vinculada a uma ou várias linhas da Tabela B.

Vamos considerar o exemplo acima. Suponha que as tabelas Employee e Department no exemplo acima estejam conectadas de maneira unidirecional reversa, então a relação torna-se uma relação Um-para-Muitos. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_OTM. Todos os módulos deste projeto são discutidos abaixo.

Criando Entidades

Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:

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

Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:

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

O arquivo persistence.xml é o seguinte:

<?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>

Classes de serviço

Este módulo contém as classes de serviço, que implementam a parte relacional utilizando a inicialização do atributo. Crie um pacote em‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaOneToMany.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:

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

Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para a saída, verifique o ambiente de trabalho MySQL da seguinte maneira.

Neste projeto três tabelas são criadas. Passe a seguinte consulta na interface MySQL e o resultado da tabela department_employee será exibido da seguinte forma:

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

Na tabela acima, deparment_id e employee_id são as chaves estrangeiras (campos de referência) das tabelas de departamento e funcionários.

Passe a seguinte consulta na interface MySQL e o resultado da tabela de departamento será exibido em um formato tabular como segue.

Select * from department;
EU IRIA Nome
254 Desenvolvimento

Passe a seguinte consulta na interface MySQL e o resultado da tabela de funcionários será exibido da seguinte forma:

Select * from employee;
Eid Grau Ename Salário
251 Escritor técnico Satish 45000
252 Escritor técnico Krishna 45000
253 Escritor técnico Masthanwali 50000

Relação @OneToOne

No relacionamento Um para Um, um item pode ser vinculado a apenas um outro item. Isso significa que cada linha de uma entidade se refere a uma e apenas uma linha de outra entidade.

Vamos considerar o exemplo acima. Employee e Departmentde maneira unidirecional reversa, a relação é uma relação Um-para-Um. Isso significa que cada funcionário pertence a apenas um departamento. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_OTO. Todos os módulos deste projeto são discutidos abaixo.

Criando Entidades

Siga o diagrama fornecido acima para criar entidades. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaDepartment.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:

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

Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Employee.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:

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

Arquivo Persistence.xml da seguinte maneira:

<?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>

Classes de serviço

Crie um pacote em ‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaOneToOne.javaé criado no pacote fornecido. A classe DAO é mostrada da seguinte forma:

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

Após a compilação e execução do programa acima, você receberá notificações no painel do console do Eclipse IDE. Para saída, verifique o ambiente de trabalho MySQL da seguinte maneira.

No exemplo acima, duas tabelas são criadas. Passe a seguinte consulta na interface MySQL e o resultado da tabela de departamento será exibido da seguinte forma:

Select * from department
EU IRIA Nome
301 Desenvolvimento

Passe a seguinte consulta na interface MySQL e o resultado de employee a tabela será exibida da seguinte forma:

Select * from employee
Eid Grau Ename Salário Department_id
302 Escritor técnico Satish 45000 301

Relação @ManyToMany

O relacionamento muitos para muitos é onde uma ou mais linhas de uma entidade são associadas a mais de uma linha em outra entidade.

Vamos considerar um exemplo de relação entre duas entidades: Class e Teacher. Na maneira bidirecional, tanto a classe quanto o professor têm relação muitos para um. Isso significa que cada registro de Aula é referido por conjunto de Professor (ids de professor), que devem ser chaves primárias na tabela Professor e armazenados na tabela Professor_Classe e vice-versa. Aqui, a tabela Teachers_Class contém ambos os campos de chave estrangeira. Crie um projeto JPA no Eclipse IDE chamadoJPA_Eclipselink_MTM. Todos os módulos deste projeto são discutidos abaixo.

Criando Entidades

Crie entidades seguindo o esquema mostrado no diagrama acima. Crie um pacote chamado‘com.tutorialspoin.eclipselink.entity’ debaixo ‘src’pacote. Crie uma classe chamadaClas.javasob determinado pacote. A classe entidade Department é mostrada da seguinte forma:

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

Crie a segunda entidade nesta relação - classe de entidade do empregado, chamada Teacher.java debaixo ‘com.tutorialspoint.eclipselink.entity’pacote. A classe de entidade Employee é mostrada da seguinte forma:

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

Arquivo Persistence.xml da seguinte maneira:

<?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>

Classes de serviço

Crie um pacote em ‘src’ pacote chamado ‘com.tutorialspoint.eclipselink.service’. A classe DAO chamadaManyToMany.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:

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

Neste projeto de exemplo, três tabelas são criadas. Passe a seguinte consulta na interface MySQL e o resultado da tabela teacher_clas será exibido da seguinte forma:

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

Na tabela acima teacher_tid é a chave estrangeira da mesa do professor, e classet_cidé a chave estrangeira da tabela de classes. Portanto, professores diferentes são atribuídos a classes diferentes.

Passe a seguinte consulta na interface MySQL e o resultado da tabela do professor será exibido da seguinte forma:

Select * from teacher
Tid Sujeito Tname
354 Java Satish
355 Adv Java Krishna
356 DB2 Masthanvali

Passe a seguinte consulta na interface MySQL e o resultado de clas a tabela será exibida da seguinte forma:

Select * from clas
Cid Cname
351 1ª
352 2ª
353 3ª

Criteria é uma API predefinida usada para definir consultas para entidades. É uma forma alternativa de definir uma consulta JPQL. Essas consultas são seguras quanto ao tipo, portáteis e fáceis de modificar alterando a sintaxe. Semelhante ao JPQL, segue um esquema abstrato (esquema fácil de editar) e objetos incorporados. A API de metadados é mesclada com a API de critérios para modelar entidades persistentes para consultas de critérios.

A principal vantagem da API Criteria é que os erros podem ser detectados mais cedo durante o tempo de compilação. As consultas JPQL baseadas em string e as consultas baseadas em critérios JPA são iguais em desempenho e eficiência.

Histórico da API de critérios

Os critérios são incluídos em todas as versões do JPA, portanto, cada etapa dos critérios é notificada nas especificações do JPA.

  • Em JPA 2.0, a API de consulta de critérios, padronização de consultas são desenvolvidas.
  • No JPA 2.1, atualização e exclusão de critérios (atualização e exclusão em massa) estão incluídas.

Estrutura de consulta de critérios

Os critérios e o JPQL estão intimamente relacionados e podem ser projetados usando operadores semelhantes em suas consultas. Segue-sejavax.persistence.criteriapacote para criar uma consulta. A estrutura da consulta significa a consulta de critérios de sintaxe.

A consulta de critérios simples a seguir retorna todas as instâncias da classe de entidade na fonte de dados.

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();

A consulta demonstra as etapas básicas para criar um critério.

  • EntityManager instance é usado para criar um objeto CriteriaBuilder.

  • CriteriaQueryinstância é usada para criar um objeto de consulta. Os atributos deste objeto de consulta serão modificados com os detalhes da consulta.

  • CriteriaQuery.form método é chamado para definir a raiz da consulta.

  • CriteriaQuery.select é chamado para definir o tipo de lista de resultados.

  • TypedQuery<T> instância é usada para preparar uma consulta para execução e especificar o tipo de resultado da consulta.

  • getResultListmétodo no objeto TypedQuery <T> para executar uma consulta. Esta consulta retorna uma coleção de entidades, o resultado é armazenado em uma Lista.

Exemplo de API de critérios

Vamos considerar o exemplo de banco de dados de funcionários. Vamos supor que a tabela jpadb.employee contém os seguintes 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

Crie um projeto JPA no Eclipse IDE chamado JPA_Eclipselink_Criteria. Todos os módulos deste projeto são discutidos abaixo:

Criando Entidades

Crie um pacote chamado com.tutorialspoint.eclipselink.entity debaixo ‘src’

Crie uma classe chamada Employee.javasob determinado pacote. A classe entidade Employee é mostrada da seguinte forma:

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

O arquivo Persistence.xml é o seguinte:

<?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>

Aulas de serviço

Este módulo contém as classes de serviço, que implementam a parte de consulta de critérios usando a inicialização da API MetaData. Crie um pacote chamado‘com.tutorialspoint.eclipselink.service’. A classe chamadaCriteriaAPI.javaé criado sob determinado pacote. A classe DAO é mostrada da seguinte forma:

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

Depois de compilar e executar o programa acima, você obterá a seguinte saída no painel do console do 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