Componentes no Java EE

Java EE
Unidade IV
Plataforma Java Enterprise Edition
Componentes no Java EE
Java EE
JSP
Servlets
JSF
EJB
JPA
Connectors
Mecanismos
de Comunicação Remota:
JMS e JavaMail
Java EE
Java Server Pages (JSP)
Permite a criação de páginas Web com
conteúdo dinâmico, gerado por código Java
ou por JavaBeans
Usa APIs voltadas para a criação de HTML e
XML
Java Server Faces (JSF)
Framework para criação de aplicações Web
utilizando componentes
Facilita o desenvolvimento de aplicações Web
fornecendo componentes e utilizando eventos
Servlets
Suporte a Web Services
JAX-WS (Java API for XML Web Services):
JAXprovê suporte para criação de serviços web e
seus clientes
JAXP (Java API for XML Processing): realiza o
processamento de dados em XML
Aplicações que rodam em servidores Web
São persistentes, ao contrário de scripts CGI
Recebem requisições pela rede via HTTP ou
HTTPS
3
4
Java EE
2
Java EE
Adiciona ao Java suporte para:
Desenvolvimento de aplicações Web:
JSP, Servlets e JSF
Desenvolvimento de Web Services:
JAX--WS, JAXP, JAXB, JAXJAX
JAX-RPC, SAAJ, JAXR
Componentes de Negócio: EJB
Suporte a Transações: JTA
Interconexão com Sistemas Legados:
Java EE
Suporte a Web Services (cont.)
JAXB (Java API for XML Binding): faz o mapemapeamento entre dados em XML e objetos Java
JAX
JAX--RPC (Java API for XML RPC): permite o
envio de chamadas remotas de procedimento
a serviços web
SAAJ (SOAP with Attachments API for Java):
permite o envio de mensagens SOAP,
inclusive com anexos
JAXR (Java API for XML Registries): permite o
acesso a registros de serviços em repositórios
UDDI e ebXML
Enterprise JavaBeans (EJB)
Componentes que rodam no servidor
Acessam os sistemas legados da empresa
para implementar regras de negócio
Java Transaction API (JTA)
5
API de suporte a transações
Transações são modeladas como objetos Java
6
1
Java EE
Java Messaging Service (JMS)
Arquitetura multimulti-camadas do Java EE
Serviço para comunicação através de
mensagens assíncronas (eventos)
JavaMail
Java EE
API para envio e recepção de ee-mails
Java Connectors
Permite integrar os sistemas legados usados
nas empresas à arquitetura Java EE
© http://java.sun.com
7
8
Java EE
Java EE
Camadas do Java EE
Camada Cliente
Clientes Web: navegador, aplicações web, …
Aplicações Java
Camada Web
Páginas JSP, JSF, Servlets e JavaBeans
Camada de Negócios
Componentes EJB
Camada de Sist. de Informações
Informações Empresaria
Empresariais
is
Integração com BDs e outros sist. legados
Servidor Java EE
Possui duas camadas:
Camada Web
Composta por páginas JSP, JSF, Servlets
e JavaBeans
Acessada pelos clientes Web
Camada de Negócios
Composta por componentes EJB
Usada pela camada Web e por
aplicações clientes escritas em Java
9
10
Java EE
Java EE
Servidor Java EE
Fornece ambientes controlados de execução –
os contêiners – para componentes Java EE
Contêiner Web: para Servlets e Páginas
JSP/JSF
Contêiner EJB: para Enterprise Beans
Provê acesso transparente a serviços:
Transação: JTA
Segurança: JAAS
Localização: JNDI
etc.
Servidor Java EE: Contêiners Web e EJB
© http://java.sun.com
11
12
2
Java EE
Java EE
Camada de Sistemas de Informações
Informações
Empresariais
Empresaria
is (EIS)
Usada pelos componentes EJB da camada de
negócio p/ acesso a software de infraestrutura
Banco de Dados
Monitores de Transaç
Transações
ões
Enterprise Resource Planning (ERP)
Customer Relationship Management (CRM)
... e outros sistemas legados
Estes sistemas geralmente rodam em
mainframes ou servidores de médio porte
Conectores permitem o acesso a sist. legados
Conectores
Integram diversos sistemas à plataforma
Java EE
Fornecido pelo fabricante do sistema legado
ou por terceiros
Para desenvolver um conector geralmente é
necessário escrever código nativo para a
plataforma do sistema legado e integrar ao
Java usando JNI (Java Native Interface),
CORBA ou Sockets
14
13
Java EE
Java EE
Distribuição de aplicações corporativas
Arquivos que compõem uma aplicação Web
são empacotados num arquivo WAR
Arquivos necessários para implantar EJBs
devem ser empacotados em arquivos JAR
Uma aplicação corporativa completa é
empacotada em um arquivo EAR
Contém uma ou mais aplicações Web em
arquivos WAR
Contém um ou mais arquivos JAR com os
componentes EJB da aplicação
Implantação de aplicações corporativas
Arquivos EAR são carregados no servidor Java
EE, que abre o pacote e coloca a aplicação em
execução
Conteúdo de arquivos é WAR implantado no
contêiner Web
Componentes EJB contidos nos arquivos
JAR são implantados no contêiner EJB
A implantação é efetuada com base em
informações obtidas de descritores em XML e
de anotações feitas nas próprias classes Java
15
16
Java EE
Java EE
Interoperabilidade
Java EE é compatível com o CORBA, padrão da
OMG para comunicação remota entre objetos
Interfaces são compatíveis com CORBA IDL
Comunicação via RMI sobre CORBA IIOP
Transações são controladas pelo JTS, que é
uma implementação do serviço de
transações do CORBA
Interoperação com .NET é feita utilizando Web
Services
Modelos para construção de aplicações Web
Modelo 1: Centrado em páginas JSP
Modelo de dados composto por JavaBeans
Indicado para aplicações simples
Modelo 2: ModeloModelo-VisãoVisão-Controlador (MVC)
Usa JavaBeans ou EJB para o modelo de
dados, JSP para visão e servlet controlador
EJB é usado em aplicações de larga escala
Frameworks MVC: simplificam uso do Modelo 2
Struts, Spring, ... e JSF!
18
17
3
JSP
JSP
Java Server Pages
Linguagem para geração de conteúdo Web
Código Java é inserido em páginas HTML,
WML ou XML para gerar conteúdo dinâmico
Páginas pode ser geradas com base em
parâmetros passados na URL, dados mantidos
em um BD, na identificação do usuário, etc.
Cliente Web não tem acesso ao código JSP
Requer um servidor Web compatível com Java
EE para executar o código JSP
Exemplo de JSP
<%@page import=“java.util.Date” %>
<%@page contentType=“text/html; charset=UTFcharset=UTF-8” %>
<html> <head><title>Acesso</title></head> <body>
<% String nome = request.getParameter(“nome”);
if (nome != null) { %>
<p>Usuário: <%=nome
<%=nome%>
%>
<% } else { %>
<p>Usuário: anônimo
<% } %>
<p>Acesso em: <%=new
<%=new Date().toString()%>
Date().toString()%>
<p>IP: <%=request.getLocalAddr()
<%=request.getLocalAddr()%>
%>
</body> </html>
20
19
JSP
JSP
Desenvolvimento de Páginas JSP
Divisão de responsabilidades
Designers devem se preocupar com o
layout das páginas Web
Programadores fazem o desenvolvimento
do código em JSP
É possível separar claramente design de
programação encapsulando o código Java em
componentes JavaBeans
O designer deve apenas chamar o bean a
partir da página JSP
Compilação
A compilação de uma página JSP gera um
servlet que irá tratar as requisições enviadas a
esta página Web
Execução
O servlet é instanciado no servidor e atende
as requisições enviadas à URL correspondente
21
22
JSP
JSP
Declaração de Importação
Declarações de Atributos e Métodos
Exemplo:
<%@ page import=“java.util.*, pacote.*” %>
<%! ...declarações Java... %>
Declaração de Inclusão
Inclusão na tradução da página:
<%@ include file=“arquivo.jsp” %>
Inclusão na execução da página:
<jsp:include page=“arquivo.jsp” />
<%! private MinhaClasse meuAtributo;
public String mensagem;
public void meuMétodo() { ... }
public String getMensagem() {
return mensagem;
}
%>
23
24
4
JSP
JSP
Declaração de Scriptlets
<jsp:useBean id=“meuBean”
class=“pacote.nomeBean” scope=“session”/>
<% ...código Java... %>
Declaração de Expressões
<%= ...expressão Java... %>
Usando JavaBeans em Páginas JSP
Modificando Propriedades
<jsp:setProperty name=“meuBean”
property=“propriedade” value=“Valor” />
<% meuBean.setPropriedade(valor); %>
Exemplo
<% for (int i = 0; i<alunos.length(); i++) { %>
<p>Aluno: <%=aluno[i].getNome()%>
<p>Nota: <%=aluno[i].getNota()%>
<% } %>
Recuperando Propriedades
<jsp:getProperty name=“meuBean”
property=“propriedade” />
<%= meuBean.getPropriedade() %>
25
JSP
Servlets
Objetos Implícitos
ServletContext application
ServletConfig config
JspWriter out
Object page
Contexto da aplicação
Informações de inicialização
Fluxo de saída
Instância do servlet que
processa a página JSP
PageContext pageContext Contexto da página JSP
ServletRequest request
Requisição da página JSP
ServletResponse response Resposta à requisição atual
HttpSession session
Sessão atual
Throwable exception
Informação de erro
Servlets são classes Java que implemenimplementam a interface javax
javax..servlet.
servlet.Servlet
A interface Servlet possui métodos para:
Inicialização do Servlet:
Servlet: método init()
init()
Destruição do Servlet:
Servlet: método destroy()
destroy()
Obtenção de configuração: getServletConfig()
getServletConfig()
Informações sobre o Servlet
Servlet:: getServletInfo()
getServletInfo()
Responder solicitações dos clientes: service()
service()
27
28
Servlets
26
Servlets
Implementações padrão da interface
javax.servlet.Servlet
Servlets HTTP
Agem como plugplug-ins para o servidor Web
Um servidor Java EE, além de permitir o
acesso a conteúdo estático, permite que o
cliente acesse servlets através de uma URL
Não é necessário nenhum suporte especial no
navegador do cliente para exibir a página
Ao receber uma mensagem HTTP, o servlet
executa o método correspondente, gerando
dinamicamente uma página Web que será
enviada ao cliente
GenericServlet
Independente de protocolo
Desenvolvedor precisa tratar as requisições
HttpServlet
Recebe requisições através do protocolo
HTTP (HyperText Transfer Protocol)
É acessado através de uma URL
29
30
5
Servlets
Servlets
Servlet HTTP
Recebe mensagens padrão do protocolo HTTP
GET: acessa conteúdo disponível no servidor
POST: envia dados para o servidor processar
PUT: coloca conteúdo no servidor
DELETE: remove conteúdo do servidor
HEAD: obtém cabeçalho
OPTIONS: lista formas de acesso ao servidor
TRACE: traça o caminho até o servidor
Implementa métodos do<mensagem>() para
tratar as mensagens do HTTP
Exemplo de Servlet HTTP – método doGet()
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
out.println("<html><head><title>Servlet</title>
</head><body>");
out.println("<h2>Acessando o Servlet</h2>");
out.println("<p>Host: " + request.getRemoteAddr());
out.println("<p>Browser: " +
request.getHeader( "User"User-Agent"));
out.println("</body></html>");
out.close();
}
31
JSF
JSF
Java Server Faces é um framework para
construção de aplicações Web em Java
Componentes JSF
O JSF fornece um conjunto de componentes
comumente usados em páginas Web: link,
tabela, botão, combo box,
box, caixa de texto, etc.
Há várias bibliotecas de componentes –
comerciais ou gratuitas – disponíveis para uso
(MyFaces,
MyFaces, RichFaces,
RichFaces, WoodStock,
WoodStock, etc.)
Componentes são representados como tags
em uma página JSP e posteriormente
convertidos para o código HTML equivalente
JSF é baseado em componentes para Web
Adota o padrão ModeloModelo-VisãoVisão-Controlador
Utiliza JavaBeans gerenciados (com injeção de
dependência) e é integrado a JSP e Servlets
Incorpora o conceito de eventos na navegação
pela Web, com tratamento no servidor
Provê ainda APIs para controle de navegação
na Web, validação de entrada, conversão de
valores e suporte a localização e acessibilidade
33
34
JSF
32
JSF
Modelo de eventos
Uma ação na página Web – como clicar um
botão ou selecionar uma opção em um combo
box – resulta em um evento
O evento é tratado por um método do bean
que representa a página, que é executado no
servidor
Retorno do tratador de evento determina o
fluxo de navegação da aplicação
O uso de eventos torna o desenvolvimento de
aplicações Web semelhante ao desktop
Facelets
Forma padrão de implementarviews no JSF2.0
Baseado em XHTML
Permite construir uma árvore de componentes
e referenciar beans gerenciados JSF
Beans Gerenciados
35
São beans usados na aplicação JSF
Seu ciclo de vida é gerenciado pelo servidor
Java EE
36
6
JSF
JSF
Escopo dos Beans Gerenciados JSF
Escopo
Application
Ciclo de Vida
A mesma instância é compartilhada por
todos os usuários da aplicação
Session
Uma instância por sessão (cada usuário
possui a sua instância particular)
Conversation Instâncias criadas/destruídas pela
aplicação para diferenciar janelas/abas
Request
Instância criada/destruída a cada
requisição enviada ao servidor
Dependent Instância criada/removida quando o
objeto que a referencia é criado/removido
37
Exemplo: Facelet index
index..xhtml
O facelet possui um
<?
<?xml
xml version='1.0' encoding='UTF
encoding='UTF--8' ?>
formulário com um
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
campo de texto, no
xmlns:h="http://java.sun.com/jsf/html"
xmlns
:h="http://java.sun.com/jsf/html"
qual deve ser
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns
:ui="http://java.sun.com/jsf/facelets"
digitado um número.
xmlns:f="http://java.sun.com/jsf/core">
xmlns
:f="http://java.sun.com/jsf/core">
Ao clicar no botão
<head>
head>
Enviar, o número é
<title>Adivinhe
title>Adivinhe o número</
número</title
title>
>
armazenado no
</
</head
head>
>
atributo userNumber
<body>
body>
de UserNumberBean
<h5>Entre com um número de 0 a 9:</h5>
e o navegador exibe
<h:form
<h:
form>
>
o facelet response.
<h:inputText
<h:
inputText id="userNumber
id="userNumber"" size
size="2"
="2"
maxlength="2"
maxlength
="2" value="#{
value="#{UserNumberBean
UserNumberBean..userNumber
userNumber}"
}" />
<h:commandButton
<h:
commandButton id="submit
id="submit"" value="Enviar"
value="Enviar"
action="
action
="response
response"" />
</h:form
</h:
form>
>
</
</body
body>
>
</
</html
html>
>
38
JSF
JSF
Exemplo: Facelet resposta.html
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
xmlns
:h="http://java.sun.com/jsf/html">
<head>
head>
<title>Resposta</
title>Resposta</title
title>
>
</
</head
head>
>
O facelet de resposta
tem um campo de texto
no qual é mostrado o
valor retornado pelo
método getResponse
do bean gerenciado. O
botão Voltar retorna ao
facelet index.
Exemplo: Bean gerenciado UserNumberBean
@ManagedBean
ManagedBean((name="
name="UserNumberBean
UserNumberBean")
")
@SessionScoped
// sessão -->uma
-->uma instância por usuário
public class UserNumberBean {
Integer randomInt
randomInt;;
// armazena número sorteado
Integer userNumber
userNumber;;
// armazena número digitado pelo usuário
<body>
body>
<h4>
<h:outputText
<h:
outputText escape="
escape="false
false"" value
value=
=
"#{UserNumberBean
"#{
UserNumberBean..response
response}"/>
}"/>
</h4>
<h:form
<h:
form>
>
<h:commandButton
<h:
commandButton id="back
id="back"" value="Voltar"
value="Voltar" action="
action="index
index"" />
</h:form
</h:
form>
>
</
</body
body>
>
</
</html
html>
>
public UserNumberBean()
UserNumberBean() { // construtor; sorteia número aleatório
Random randomGR = new Random
Random();
();
randomInt = new Integer
Integer((randomGR
randomGR..nextInt(10));
nextInt(10));
System.out.println
System.
out.println("Número
("Número sorteado: " + randomInt);
randomInt);
}
public void setUserNumber(
setUserNumber(Integer userNumber
userNumber)) {
this..userNumber = userNumber;
this
userNumber; // armazena o número digitado
}
...
39
40
JSF
EJB
...
public Integer getUserNumber
getUserNumber()
() {
return userNumber
userNumber;;
// retorna o útimo número digitado
}
Integra um modelo de componentes de negócio
à arquitetura Java EE
Cria uma camada composta de beans
especializados, nãonão-gráficos
Beans rodam em servidores Java EE
public String getResponse()
getResponse() {
if ((
((userNumber
userNumber != null)
null) && (userNumber
(userNumber.. compareTo(
compareTo(randomInt
randomInt))
== 0)) {
// se número digitado == gerado
FacesContext context = FacesContext.
FacesContext.getCurrentInstance
getCurrentInstance();
();
HttpSession session = ((HttpSession
HttpSession))context
context..getExternalContext
getExternalContext().
().
getSession((false
getSession
false);
);
// obtém o objeto de sessão
session..invalidate();
session
invalidate();
// destrói a sessão
return "Você acertou!"; // resposta = acertou
} else {
// resposta = errou
return "<p>Desculpe, o número não é " + userNumber + "</p>"
+ "<p>Tente novamente</p>";
}
}
}
Enterprise JavaBeans
Componentes EJB
São objetos Java escaláveis e reutilizáveis
Utilizam anotações/arquivos XML para informar
ao contêiner como devem ser gerenciados
41
42
7
EJB
EJB
Comunicação
Tipos de Enterprise Beans
EJBs interagem com clientes remotos através de
interfaces/Beans
interfaces/
Beans anotados com @
@Remote
Remote
Beans podem ser acessados remotamente por:
Aplicações Java usando RMI/IIOP
Aplicações CORBA usando IIOP
Clientes Web via páginas JSP ou Servlets
Clientes locais podem interagir com os EJBs
utilizando injeção de dependência ou interfaces/
beans anotados com @Local
Session Beans
Executam
uma tarefa durante uma sessão
de interação entre o Bean o cliente
Entity Beans
Representam
Persistência
dados armazenados em BDs
transparente
Message--Driven Beans
Message
São
consumidores de mensagens JMS
tratadas ao serem recebidas
Mensagens
43
44
EJB
EJB
Session Bean
Representam um cliente em particular no
servidor – ou seja, o bean não é
compartilhado entre os clientes
O cliente invoca métodos do bean para
acessar o servidor – o bean age como uma
extensão do cliente
Pode ser acessado remotamente quando
possui a anotação @Remote
@Remote na classe do
bean ou em uma interface que ela implementa
Estado dos Session Beans
Stateless Session Bean
Não
possui estado que o ligue a um cliente
diferentes são equivalentes se
inativas
Instâncias
Stateful Session Bean
Armazena
estado durante a sessão de um
cliente (entre invocações sucessivas)
O estado não é persistido (é transiente)
45
46
EJB
EJB
Exemplo de Stateless Session Bean
clientes remotos
@Stateless
public class HelloWorldSessionBean
HelloWorldSessionBean{{
public String hello
hello(){
(){
return “Hello World”;
}
}
Stateless Session Bean com suporte a
Anotando a interface com @Remote
@Remote
@Remote
public interface Hello{
Hello{
public String hello();
hello();
}
A anotação @Stateless indica que a classe
anotada é um Stateless Session Bean
47
@Stateless
public class HelloWorldSessionBean implements Hello
Hello{{
public String hello(){
hello(){
return “Hello World”;
}
}
48
8
EJB
EJB
Stateless Session Bean com suporte a
clientes remotos
Ciclo de vida dos Stateless Session Beans
Anotando classe com @Remote
@Remote
Instância do Bean
não existe
public interface Hello
Hello{{
public String hello
hello();
();
}
@Stateless
@Remote(
Remote(Hello
Hello..class
class))
public class HelloWorldSessionBean implements Hello
Hello{{
public String hello
hello(){
(){
return “Hello World”;
}
}
Contêiner
decide quando
é necessário criar
mais instâncias
Contêiner
decide quando
não necessita mais
das instâncias
Pool de Beans
49
50
EJB
EJB
Exemplo de Stateful Session Bean
@Stateful
@Remote
Remote((Count.
Count.class
class))
public class CountBean implements Count {
private int count;
count;
public int getCount
getCount()
() { return this.
this.count;
count; }
public void setCount
setCount((int count)
count) { this.
this.count = count;
count; }
@Remove
public void remove() { }
}
Cliente
invoca
método
Ciclo de vida dos Stateful Session Beans
Instância do Bean
não existe
Cliente invoca
método de remoção
ou ocorre timeout
Cliente obtém uma
referência da
interface de negócio
Pronto
A anotação @Stateful indica que a classe é um
Stateful Session Bean
A anotação @Remove indica que o bean deve ser
removido após a execução do método anotado
Contêiner
desativa bean
Cliente
invoca
método
Cliente invoca
método
Passivo
51
52
EJB
EJB
Message--Driven Beans
Message
Consomem mensagens de uma fila ou
associadas a um determinado tópico
Podem receber mensagens de uma ou de
múltiplas fontes
Não possuem estado nem interfaces remotas
Beans são anotados com @
@MessageDriven
MessageDriven
Sua interface depende do serviço de
mensagens utilizado
Geralmente é usado JMS (Java Message
Service)
Exemplo de Message
Message--Driven Bean
@MessageDriven
MessageDriven((mappedName
mappedName="
="jms
jms//Queue
Queue")
")
public class SimpleMessageBean implements MessageListener {
public void onMessage (Message msg
msg)) {
// utiliza a mensagem
}
}
53
O bean utiliza o JMS, que requer a implemenimplementação da interface javax
javax..jms.
jms.MessageListener
A fila de mensagens especificada na anotação
@MessageDriven é mantida num provedor JMS
54
9
EJB
EJB
Ciclo de vida dos Message
Message--Driven Beans
Entity Beans
São POJOS (Plain Old Java Objects)
Permitem o acesso compartilhado a dados
armazenados em um BD
Dados são materializados na forma de
objetos (mapeamento objetoobjeto-relacional)
Bean = tabela de um BD relacional
Instância do Bean = linha da tabela
Identificador do Bean = chave primária
Utilizam a JPA (Java Persistence API) para
controlar a persistência dos dados
Instância do Bean
não existe
Contêiner
decide quando
criar instâncias
Contêiner
decide quando
destruir instâncias
Pronto
onMessage()
onMessage
()
55
56
JPA
JPA
Java Persistence API
Modelo simplificado e leve de persistência
Pode ser utilizado tanto em contêiners JavaEE
quanto em aplicações JavaSE
Permite utilização de herança e polimorfismo
Permite criação de testes independentes do
contêiner quando utilizado com JavaEE
Possui anotações para definição de
mapeamento objetoobjeto-relacional
Principais implementações da JPA
Hibernate
Oracle
Entidade
No JPA uma entidade é um objeto comum
Java (um POJO) que pode ser gravado pelo
mecanismo de persistência
Uma classe que representa uma entidade é
anotada com @Entity
@Entity
Toda entidade deve possuir um construtor
sem argumentos
Toda entidade deve possuir uma chave
primária, simples ou composta, identificada
pela anotação @Id
Chaves compostas devem ser representadas
por uma classe Java em separado
TopLink
57
58
JPA
JPA
Exemplo de Entidade JPA
Anotações de Relacionamento
@Entity
public class Conta {
@Id
private Long numConta
numConta;;
private String nomeTitular
nomeTitular;;
private long saldo;
public Conta() { } //Construtor sem argumentos é obrigatório
public void setNumConta(
setNumConta(Long numConta
numConta)) {
this.. numConta = numConta
this
numConta;;
}
public Long getNumConta
getNumConta()
() { return this
this..numConta
numConta;; }
//Métodos getters e setters para os outros atributos
}
59
Especificam relacionamento entre entidades e
a cardinalidade da relação
@OneToOne
@OneToMany
@ManyToOne
@ManyToMany
60
10
JPA
JPA
Ciclo de vida das entidades
Estados
new: Estado da entidade após ser criada.
new:
managed:: Entidade persistida, com id
managed
associado a um contexto de persistência.
removed
removed:: marcada para ser removida do BD.
detached
detached:: Entidade possui um id persistente
mas não possui um contexto de persistência.
new
new()
persist()
refresh()
remove()
managed
removed
Fim do contexto de
persistência
persist()
Operações
new():: Cria nova entidade
new()
persist()
persist
():: Persiste uma entidade
refresh
refresh()
():: Atualiza o estado de uma entidade
merge()
merge():: Sincroniza entidade desacoplada
merge()
detached
61
62
JPA
Entity Manager
Controla o ciclo de vida das entidades
Possui métodos para buscar, salvar, remover
e atualizar estado das entidades
Referência para o Entity Manager é obtida
com injeção de dependências, utilizando a
anotação @PersistenceContext
@PersistenceContext
63
11