Java EE 6

Elvis Henrique Rocha

Especialista JBoss
elvis.rocha@tecnisys.com.br

JavaEE 6
Tpicos:

JavaEE 6 Overview

Java Persistence 2.0

Enterprise JavaBeans 3.1

Contexts and Dependency Injection for Java 1.0

JavaEE 6 Overview

Desenvolvimento Simplificado (+ Annotations, + POJO)

Perfis: (Web Profile e Full Profile)

Novidades:
JAX-RS
Managed Beans
CDI
Bean Validation
EJB 3.1 (Interceptors 1.1)


Container Architecture

Tiers

Profiles

Java Persistence API 2.0

Arquitetura do Hibernate:

Hibernate / JPA Entity (EJB 3) Regras:
Classes anotadas com @Entity e com pelo menos um @Id definido
Classes devem seguir a conven o JavaBeans
Classes, mtodos ou variveis no podem usar final
Deve ter um constructor sem argumentos (public ou protected)
Collections devem ser interfaces (no podem ser implementa es)
Classes de alto nvel (no pode ser classe interna ou aninhada)
Um Enum ou uma Interface no podem ser classes persistentes
Classes abstratas e concretas podem ser persistentes
Usar serializable para objetos detachados
Sem interface para implementar ou classes para extender
Sem programa o intrusiva nas classes

@Entity
@Table(name = "messages")
public class Message {
@Id
@GeneratedValue
private Long id;
@Column(nullable = false)
private String text;
@ManyToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST})
@JoinColumn(name = "message_sender_id")
private Sender sender;
. . .
}
JPA Entity:

Tipos de dados:
- Componentes
@Embedded ou @Embeddable (Classes embutidas, as colunas da
classe embeddable ficam na Entity)
@ElementCollection (Cole o de componentes)
- Tipos bsicos da JDK:
integer, long, short, float, double, big_decimal, big_integer,
character, string, byte, boolean, yes_no, true_false
- Date/Time:
date, time, timestamp, calendar, calendar_date
- Binary e Large Objects:
binary, text, serializable, clob, blob
- Outros tipos da JDK:
class, locale, timezone, currency

Identidade:
- @Id
Geralmente Integer ou Long
Pode ser gerado atravs das seguintes estratgias:
GenerationType.SEQUENCE
GenerationType.TABLE
GenerationType.IDENTITY
GenerationType.AUTO
- Quando uma entidade igual a outra?
Implementar os mtodos equals( ) e hashcode( )
equals: Deve verificar a diferena das entidades comparando os
campos de acordo com o objetivo do negcio

Outras anota es:
@Transient - A propriedade no ser persistida
@Basic - Para definir a estratgia de Fetch
@Columns - Usado para sobrescrever configura es padro para
colunas do banco de dados
@Lob - Usado para definir uma especializa o do tipo Lob
@Temporal - Usado para definir uma especializa o do tipo Date
@Version Para controle de concorrncia na entidade, deve ser
usada em conjunto com uma configura o especfica de Lock
LockModeType.OPTIMISTIC_FORCE_INCREMENT ou
LockModeType.PESSIMISTIC_FORCE_INCREMENT

public class Item implements Serializable {
@Id @GeneratedValue
@Column(name = "ITEM_ID")
private Long id = null;
@Version
@Column(name = "OBJ_VERSION")
private int version = 0;
@Column(name = "ITEM_NAME", length = 255, nullable = false, updatable = false)
private String name;
@Embedded
@AttributeOverrides( {
@AttributeOverride(name = "street", column = @Column(name="HOME_STREET", length = 255) ),
@AttributeOverride(name = "city", column = @Column(name="HOME_CITY", length = 255) )
})
private Address homeAddress;
@Temporal(TemporalType.TIMESTAMP)
private Date created = new Date();
. . .
JPA Entity:

Abordagem para mapeamento:

Top Down: hbm2dll
Bottom up: hbm2java
Middle out: Ambos

Configura o:
persistence.xml (JPA)
hibernate.cfg.xml (Hibernate)

Persistence Context:
Estado em que as entidades so gerenciadas pelo JPA

Persistence Unit:
Unidade agrupadora de entidades e configura o

<persistence>
<persistence-unit name="samplePU" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<non-jta-data-source/>
<class>com.jboss.sample.Message</class>
<class>com.jboss.sample.Sender</class>
<exclude-unlisted-classes/>
<properties>
<property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver"/>
<property name="javax.persistence.jdbc.user" value="sa"/>
<property name="javax.persistence.jdbc.password" value=""/>
<property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:."/>
<property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
<property name="hibernate.hbm2ddl.auto" value="create-drop"/>
<property name="cache.provider_class" value="org.hibernate.cache.NoCacheProvider"/>
</properties>
</persistence-unit>
</persistence>
persistence.xml:

final EntityManager em = emf.createEntityManager();
try {
em.getTransaction().begin();
em.persist(new Message("Hello world");
em.getTransaction().commit();
} catch (RuntimeException relevantException) {
if (em.getTransaction().isActive()) {
try {
em.getTransaction().rollback();
} catch (PersistenceException rollBackException) {
logger.warn("Rollback of open transaction failed", RollBackException);
}
throw relevantException;
}
} finally {
em.close();
}
Entity Manager:
EntityManager:
- N o reutilizar
- Fechar no final - close()
- Em caso de erro dar rollback na transa o
para liberar recursos do banco de dados

sender.setName("Correct name");
final EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
Sender newSenderInstance = em.merge(sender);
em.getTransaction().commit();
em.close();
// Hibernate
Session session = (Session) em.getDelegate();
session.update(sender);
// alternatively
session.buildLockRequest(LockOptions.NONE).lock(sender);
Mtodos do Entity Manager:
- Inserir:
persist( ), save( )
- Atualizar:
update( ), merge( ), saveOrUpdate( )
- Reatachar um objeto no modificado:
lock( )

final EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
Sender sender = em.find(Sender.class, '1');
em.remove(sender);
em.getTransaction().commit();
em.close();
// Hibernate
Session session = (Session) em.getDelegate();
Sender sender = session.get(Sender.class, '1');
session.delete(sender);
Mtodos do Entity Manager:
- Remover:
remove( ), delete( )
- A entidade precisa estar atachada para ser removida.

Relacionamento de entidades:
@Embedded
@OneToOne
@OneToOne Bidirecional
@OneToMany
@OneToMany Bidirecional
@ManyToMany

@Entity
public class Address {
@OneToOne
@JoinColumn(name="user_id")
private User user;
@OneToOne:
@Entity
public class User {
@Id
@GeneratedValue(generator = "foreign_id")
private Integer id;
@OneToOne(mappedBy=user)
private Address address;
Exemplo 1:
Usando uma Foreign Key
Exemplo 1:
Usando o mesmo valor de Primary Key
@PrimaryKeyJoinColumn
Usa o mesmo valor de Id para ambas as tabelas

@Entity
public class Item {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "SELLER_ID", nullable = false, updatable = false)
private User seller;
. . .
}
@ManyToOne e @OneToMany:
@Entity
public class User {
@OneToMany(mappedBy = "seller")
private Collection<Item> itemsForSale = new ArrayList<Item>();
. . .
}
Exemplo 1:
ManyToOne Unidirecional
Exemplo 2:
ManyToOne Bidirecional (mappedBy)

@Entity
public class Category {
@ManyToMany
@JoinTable(name = "CATEGORY_ITEM",
joinColumns = @JoinColumn(name = "CATEGORY_ID"),
InverseJoinColumns = @JoinColumn(name = "ITEM_ID") )
private List<Item> items = new ArrayList<Item>();
. . .
}
@ManyToMany:
@Entity
public class Item {
@ManyToMany(mappedBy="items")
private Set<Category> categories = new HashSet<Category>();
. . .
}
Exemplo 1:
ManyToMany Unidirecional
Exemplo 2:
ManyToMany Bidirecional (mappedBy)

public class StudentCourse {
private StudentCourseID pk = new StudentCourseID();
@Column(name = "CAPACITY", nullable = false, length = 10)
private String capacity;
@EmbeddedId
public StudentCourseID getPk() {
return pk;
}
@ManyToMany com campo adicional:
@Embeddable
public class StudentCourseID implements java.io.Serializable {
private Student student;
private Course course;
@ManyToOne
public Course getCourse() {
return course;
}
@ManyToOne
public Student getStudent() {
return student;
}
Exemplo 1:
Classe Associativa com o campo adicional capacity
Exemplo 2:
Classe embutida definida como EmbeddableId

@Entity
public class Item {
. . .
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "ITEM_ID", nullable = false)
@org.hibernate.annotations.IndexColumn(name = "BID_POSITION")
private List<Bid> bids = new ArrayList<Bid>();
}
@IndexColumn e @OrderBy:
@Entity
public class Category implements Serializable, Comparable<Object> {
. . .
@OneToMany(mappedBy="parentCategory", cascade={CascadeType.PERSIST, CascadeType.MERGE})
@org.hibernate.annotations.OrderBy(clause="CATEGORY_NAME asc")
private List<Category> childCategories = new ArrayList<Category>();
Exemplo 1:
@IndexColumn para definir o campo ndice na lista
e evitar entidades duplicadas (bag semantics)
Exemplo 2:
@OrderBy define o ordenamento padro

Estratgias de Herana:
Table per Class:
As classes so mapeadas em uma nica tabela, a coluna que
define a entidade configurada atravs da anota o
@DiscriminatorColumn
Table per Subclass:
Schema normalizado, cada subclasse na hierarquia tem sua
prpria tabela e o relacionamento definido atravs de Foreign
Keys.
Table per Concrete Class:
Cada tabela concreta tem sua prpria tabela, no h o conceito
de herana a nvel de banco de dados, os campos da tabela pai
so duplicados em cada uma das tabelas.

Table per Class (SINGLE_TABLE):
Melhor performance
Melhor representa o de polimorfismo
N o normalizado
Requer uma coluna para especificar o tipo de classe

Table per Subclass (JOINED):
Schema claro e conciso
Totalmente normalizado
Fcil de implementar e de entender
Queries polimrficas podem ter um desempenho ruim se a
hierarquia for muito grande
Maior dificuldade na escrita de consultas SQL

Table per Concrete Class (TABLE_PER_CLASS):
Sem no o de herana a nvel de banco de dados
Sem detalhes de herana no mapeamento
Complexidade em evoluir o schema
N o suporta Queries JPA totalmente polimrficas

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name=BILLING_TYPE, discriminatorType = DiscriminatorType.STRING)
public class BillingDetails implements Serializable, Comparable { . . . }
@Entity
public class CreditCard extends BillingDetails{ . . }
Table per Class:
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class BillingDetails implements Serializable, Comparable { . . . }
@Entity
public class CreditCard extends BillingDetails{ . . }
Table per Subclass:

@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public class BillingDetails implements Serializable, Comparable { . . . }
@Entity
public class CreditCard extends BillingDetails{ . . }
Table per Concrete Class:

Cascade:
JPA:
MERGE
PERSIST
REMOVE
REFRESH
DETACH
Hibernate:
MERGE
PERSIST
REMOVE
REFRESH
DELETE
SAVE_UPDATE
REPLICATE
DELETE_ORPHAN
LOCK
EVICT
@OneToMany(cascade={
javax.persistence.CascadeType.PERSIST,
javax.persistence.CascadeType.MERGE})
@org.hibernate.annotations.Cascade(value = {
CascadeType.SAVE_UPDATE,
CascadeType.PERSIST,
CascadeType.MERGE})
private Set<Item> items = new HashSet<Item>();

Fetch:
EAGER:
Traz as entidades filhas quando a entidade pai carregada.
LAZY:
Traz as entidades filhas somente quando o mtodo for
chamado (sob demanda).
@Entity
public class Item {
. . .
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "ITEM_ID", nullable = false)
private List<Bid> bids = new ArrayList<Bid>();
. . .
}

Entity Manager e ciclo de vida das entidades:

Entity Manager e ciclo de vida das entidades:

Entity Manager e ciclo de vida das entidades:
Persistence Context o cache de 1 nvel onde esto todas as
entidades gerenciadas pelo Hibernate
Inicia no entityManager.open() e se encerra no
entityManager.close()
Pode ser usado no modo extendido para escopo de
Conversa o
Faz Dirty Checking automaticamente (verifica se o objeto foi
alterado por outra thread antes do commit)
Sincronizado automaticamente com o banco de dados no fim
da transa o ou quando chamado o mtodo flush()
(FlushMode.AUTO), outros modos: (FlushMode.COMMIT,
FlushMode.MANUAL)
possvel excluir objetos do cache atravs dos mtodos
evict( ) e clear( )

Entity Manager e ciclo de vida das entidades:
Entidades passam de Transient para Persistent atravs do
save( ) ou persist( )
Entidades obtidas atravs de Query tambm so Persistent
Quando Persistent elas so gerenciadas e transacionais se
houver transa o
Passam de Persistent para Transient atravs do remove( ) ou
quando perdem a referncia, exemplo: Orphan delete
So detachadas atravs do evict( ), clear( ) ou close( )
Recarregadas do banco atravs do refresh( )

Caso de uso: Detachar / Reatachar Entitidades

Caso de uso: Modo Extendido

Transa es (ACID)
Atomicidade, Consistncia, Isolamento e Durabilidade
Forma programtica:
Hibernate Transaction API
JPA Entity Transaction API
Standard JTA UserTransaction API
JDBC API
Forma declarativa (requer uma infraestrutura necessria):
EJB
Spring
Interceptors / AOP (Customizada)

Transa es
// Programtica
UserTransaction utx = (UserTransaction) new InitialContext().lookup(java:comp/UserTransaction);
EntityManager em = null;
try {
utx.begin();
em = get().createEntityManager();
concludeAuction(session);
em.flush();
utx.commit();
}
. . .
// Declarativa
@Stateless
public class ManageAuctionBean implements ManageAuction{
@PersistenceContext
private EntityManager em;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void endAuction( Item item) {
em.merge(item);
}
}

Cache

Cache
1st level cache (sempre ativo)
Recomenda es:
N o carregar objetos demais na memria
N o usar ORM para uma carga muito grande, usar Stored
procedures ou SQL
Use scroll( ) para carregar objetos incrementalmente (cursor)
Use evict( ) e clear( ) em processos batch
javax.persistence.cache.retrieveMode
CacheRetrieveMode.USE
CacheRetrieveMode.BYPASS
javax.persistence.cache.storeMode
CacheStoreMode.USE
CacheStoreMode.BYPASS
CacheStoreMode.REFRESH

Cache
2nd level cache
Recomenda es:
Usar para dados compartilhados entre usurios e no
especficos de um usurio
Usar para dados que mudam raramente
Usar para dados no crticos e que no so compartilhados
com outras aplica es
N o utilizar para um nmero muito grande de objetos
Providers:
EhCache
OpenSymphony OSCache
JBossCache
Infinispan

Cache
Estratgia de Concorrncia
transactional
Isolamento total acima de repeatable-read, usar quando for
crtico preservar o estado dos dados em transa es
concorrentes
read-write
Isolamento read-commited, em ambientes no-clusterizados, usa
um mecanismo de timestamp para a maioria dos dados
nonstrict-read-write
N o garante a consistncia, tem um tempo de expira o
read-only
Para dados que nunca mudam, dados usados como referncia

Isolation-levels
SERIALIZABLE
Lock de read e write na transa es
Se houver coliso somente um faz o commit
Nvel mais alto de confiabilidade, no ocorre phantom reads
REPEATABLE_READ
Lock de read e write na transa es
Pode ocorrer phantom reads (ler no incio da transa o e no
final o dado j ter sido alterado por outra transa o)
READ_COMMITED
Lock de read em selects e write em transa es
Pode ocorrer phantom reads, mas s l o que foi feito commit de
outras transa es
READ_UNCOMMITED
N o faz lock
Faz Dirty Reads (l dados de outras transa es que ainda no
sofreram commit)

Estratgias de Fetch
@Fetch(FetchMode.SELECT)
Estratgia default de fetch
@Fetch(FetchMode.JOIN)
Traz a Entity pai e suas collections com um nico select atravs
de Join quando a Entity pai carregada
@Fetch(FetchMode.SUBSELECT)
Traz a Entity pai e suas collections com um nico select atravs
de subselect quando a Entity pai carregada
@BatchSize(size = 10)
Para cada elemento que possui uma collection, ele faz (1+n)
selects, sendo n o size da collection, o Batch vai fazer com que faa
um select para trazer 10 elementos de uma vez ao invs de um
select para cada elemento

Estratgias de Fetch
@Fetch(FetchMode.SELECT)
Estratgia default de fetch
@Fetch(FetchMode.JOIN)
Traz a Entity pai e suas collections com um nico select atravs
de Join quando a Entity pai carregada
@Fetch(FetchMode.SUBSELECT)
Traz a Entity pai e suas collections com um nico select atravs
de subselect quando a Entity pai carregada
@BatchSize(size = 10)
Problema: Para cada elemento que possui uma collection, ele faz
(1+n) selects, sendo n o size da collection, o Batch vai fazer com que
faa um select para trazer 10 elementos de uma vez ao invs de um
select para cada elemento

Extra Lazy Collections
@LazyCollection(LazyCollectionOption.EXTRA)
N o traz o contedo da collection se somente os mtodos size( )
ou contains( ) foram chamados.
Solu o para o problema n+1
Usar o Fetch quando necessrio de acordo com a necessidade
de negcio
// CRITERIA
List results = session.createCriteria(Item.class).setFetchMode("bids", FetchMode.JOIN).list();
// HQL
List results = session.createQuery("select i from Item i left
join fetch i.bids").list();
// DISTINCT
session.createCriteria(Item.class)
.setFetchMode("bids", FetchMode.JOIN)
.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).list();

Tuning e melhores prticas
Um join mais rpido que dois selects?
Complexidade das queries, HQL, SQL ou Criteria? Recuperar pelo id
Quantidade de hits no banco, usar cache?
Compresso no cliente e no servidor ( - Memria = + CPU )
Onde e quais objetos devo guardar? ( escopos, 2nd level cache )
@RequestScoped - Acaba no fim da requisi o, no tem lembrana
@ViewScoped - Escopo de tela (mantem os componentes, ajax)
@SessionScoped - N o guardar listas, s dados de usurio, perfil, etc.
@ApplicationScoped - Comum para a aplica o
@Conversation - N o esquecer do @End
Usar DAO? Usar DTO?
Usar estratgias de Fetch

Enterprise JavaBeans 3.1

Enterprise Java Beans
Session Beans
Message Driven Beans
Entity Beans
Benefcios:
Foco na lgica de negcio, segurana, acesso remoto, suporte a
transa o e concorrncia, multithreading, connection pool, gerncia do
cico de vida dos objetos

Novidades EJB 3.1
Interfaces so opcionais
Singleton Beans
EJB Assncrono
Timer
EJB.Lite
Suporte para EJBs no servlet container (deploy de um EJB em um
arquivo WAR)
Suporte para Stateful Web Services via Stateful Endpoints
Entity Beans = Entidades JPA

Stateful Session Beans
Mantem estado conversacional com o cliente
Objetos POJO Based
Para acesso local no necessrio implementar uma interface,
somente usar a anota o @Stateful
Se for acessado remotamente deve ser criada uma interface e anotada
com @Remote
Um mtodo deve ser anotado com @Remove para indicar onde se
encerra o contexto conversacional
Utiliza por padro o EntityManager no modo EXTENDED
Mtodos do ciclo de vida:
@PreDestroy, @PostContruct
@PrePassivate, @PostActivate

Stateful Session Beans
@Stateful
public class Cart {
List<String> items;
public ShoppingCart() {
items = new ArrayList<Item>();
}
public void addItem(String item) {
items.add(item);
}
public void removeItem(String item) {
items.remove(item);
}
public void purchase() {
// . . .
}
@Remove
public void remove() {
items = null;
}
}

Stateless Session Beans
N o mantm estado conversacional
Objetos POJO Based
Para acesso local no necessrio implementar uma interface,
somente usar anota o @Stateless
Se for acessado remotamente deve ser criada uma interface e anotada
com @Remote
Mtodos do ciclo de vida:
@PreDestroy, @PostContruct

Stateless Session Beans
@Remote
public interface Account {
public float withdraw();
public void deposit(float amount);
}
@Stateless
public class AccountSessionBean implements Account {
public float withdraw() {
// . . .
}
public void deposit(String item) {
// . . .
}
}

Singleton Session Beans
Instanciado uma vez na aplica o, prov acesso compartilhado
Uma instncia por JVM, suporte a concorrncia
N o necessrio implementar uma interface, somente usar anota o
@Singleton
O Container automaticamente inicializa o EJB Singleton mas pode ser
anotado com @Startup para inicializa o no modo Eager
A concorrncia definida de forma declarativa em cada mtodo com
@Lock(LockType.READ) ou @Lock(LockType.WRITE)
Para forma programtica deve ser usado synchronized e volatile
Mtodos do ciclo de vida:
@PreDestroy, @PostContruct

Singleton Session Beans
@Startup
@Singleton
public class MySingleton {
public void delivery() {
// . . .
}
}

Message-Driven Beans
Prov objetos de negcio para suporte a messages assncronas
JMS Based, Stateless
preciso implementar a interface MessageListener e utilizar a
anota o @MessageDriven, a interface prov o mtodo: onMessage( )
Configura o do MDB atravs de @ActivationConfigProperty
Mtodos do ciclo de vida:
@PreDestroy, @PostContruct

Message-Driven Beans
@MessageDriven(mappedName="jms/Queue", activationConfig = {
@ActivationConfigProperty(propertyName = "acknowledgeMode",
propertyValue = "Auto-acknowledge"),
@ActivationConfigProperty(propertyName = "destinationType",
propertyValue = "javax.jms.Queue")
@ActivationConfigProperty(propertyName = "subscriptionDurability",
propertyValue = "Durable")
})
public class MyMessageBean implements MessageListener {
@Override
public void onMessage(Message message) {
try {
// process the message
} catch (JMSException ex) {
// . . .
}
}
}

EJB Assncrono
Um EJB Stateless pode ser definido como assncrono atravs da
anota o @Asynchronous
A assinatura do mtodo deve retornar a interface Future que contm
na sua API a lgica para saber se o resultado est disponvel atravs do
mtodo isDone( ) ou cancelar a execu o atravs do mtodo cancel( )
A transa o no propagada nesse tipo de EJB, ento por padro
seus mtodos sempre vo ser do tipo REQUIRES_NEW
Mtodos do ciclo de vida:
@PreDestroy, @PostContruct

EJB Assncrono
@Stateless
@Asynchronous
public class MyAsyncBean {
public Future<Integer> addNumbers(int n1, int n2) {
Integer result;
result = n1 + n2;
// simulate a long running query
. . .
return new AsyncResult(result);
}
}

Timers
Um EJB Timer um servio de execu o de tarefa agendada definido
com uma anota o @Schedule em um de seus mtodos.
O tempo/perodo de execu o pode ser definido atravs da anota o
@Schedule ou da interface TimerService
O mtodo que vai fazer a execu o da tarefa pode ser o mtodo
ejbTimeout(Timer t) da interface TimerService ou um mtodo qualquer
anotado com @Timeout que tenha como argumento (Timer t)
Mtodos do ciclo de vida:
initTimer

Timers
@Stateless
public class MyTimer {
@Schedule(hour=*, minute=*, second=*/10)
public void printTime( ) {
// . . .
}
}
public class MyTimer implements TimedObject {
@Resource TimerService timerService;
@PostConstruct
public void initTimer() {
timerService.createCalendarTimer(
new ScheduleExpression().
hour(*).
minute(*).
second(*/10),
new TimerConfig(myTimer, true)
);
}
}

EJB.Lite
Um EJB Lite um componente de negcio com recursos limitados para
execu o no Web Profile JavaEE

Nomes Globais JNDI
EJBs podem ser acessados via JNDI atravs de endereo global:
java:global[ /app-name ] /module-name /bean-name
[ !fully-qualified-interface-name ]
Exemplos:
java:global/bank/AccountSession ou
java:global/bank/AccountSession!org.sample.AccountSessionBean
Outros nomes JNDI:
java:global/bank/AccountSessionBean
java:app/AccountSessionBean
java:module/AccountSessionBean

Transa es - @TransactionAttribute
MANDATORY
Sempre deve ser chamado em um contexto de transa o
REQUIRED
Se estiver em um contexto de transa o ele propaga, se no
estiver ele cria uma nova transa o
REQUIRES_NEW
Sempre cria uma nova transa o, se j estiver em um contexto
transacional ele suspende e retorna aps a nova transa o
SUPPORTS
Se j existir uma transa o ele suporta, se no existir ele no cria
NOT_SUPPORTED
Se j existir uma transa o ele suspende e retorna aps o mtodo
NEVER
Se j existir uma transa o ele gera javax.ejb.EJBException

Contexts and Dependency Injection

Contexts and Dependency Injection
Mecanismo de inje o de dependncias da plataforma JavaEE
Permite a incluso de componentes com resolu o segura de tipos e
valida o das dependncias em tempo de deploy, promove o baixo
acoplamento tirando a responsabilidade do desenvolvedor de cuidar do
componente
Um Bean CDI ao ser criado tem seu ciclo de vida gerenciado e bem
definido de acordo com qual contexto foi atribudo
EJBs e outros componentes de negcio so tratados pelo JSF como os
Managed Beans criando uma integra o da camada Web com a camada
transacional
A Integra o se extende tambm para Expression Language (EL)
permitindo a qualquer objeto ser usado diretamente da camada de
integra o at o JSF ou JSP

Defini o de um CDI Bean
Praticamente qualquer POJO pode ser definido como Bean CDI, EJBs,
Entidades JPA, recursos JNDI, basta colocar um arquivo beans.xml na
pasta META-INF e cada Bean do pacote pode ser definido como um
bean CDI
// Interface Shipping
public interface Shipping {
public String rate(String name);
}
// Implementa o de Shipping
public class PriorityShipping implements Shipping {
public String rate(String name) {
return Hello + name;
}
}

Pontos de Inje o
Um Bean injetado usando a anota o @Inject que pode ser definida
no campo, no mtodo ou no construtor da classe
@Stateless
public class ShippingService {
// Campo
@Inject Shipping shipping;
. . .
// Mtodo Set
@Inject
public setShipping(Shipping shipping) {
this.shipping = shipping;
}
. . .
// Construtor
@Inject
public SimpleShipping(Shipping shipping) {
this.shipping = shipping;
}
}

Qualificadores
Um Qualificador serve para dizer ao CDI qual implementa o entre
vrias de uma determinada interface deve ser usada
public interface Shipping {
public String getRate( );
}
public class ExpressShipping implements Shipping {
. . . // Por padro essa classe tem o @Default, a implementa o padro de Shipping
}
public class PriorityShipping implements Shipping {
. . . // Com essa implementa o o Inject no vai funcionar pois so duas
// implementa es da mesma interface
}

Qualificadores
@Qualifier
@Retention(RUNTIME)
@Target( { TYPE, METHOD, PARAMETER, FIELD })
public @interface Express{ }
. . .
public class PriorityShipping implements Shipping {
. . .
}
@Express
public class ExpressShipping implements Shipping {
. . .
}
As seguintes inje es podem ser usadas:
@Inject Shipping shipping; -> Injeta priority
@Inject @Any @Default Shipping shipping; -> Injeta pirority
@Inject @Any @Express Shipping shipping; -> Injeta express
@Inject @Any Shipping shipping; -> Vai dar erro
@Inject @Default Shipping shipping -> tambm injeta priority
@Inject @Express Shipping shipping -> tambm injeta express

Qualificadores
@New
@RequestScoped
public class PriorityShipping implements Shipping {
. . .
}
Ao usar o qualificar @New a classe vai para o escopo @Dependent e perde os qualificadores
@Any e @Default
@Inject @New Shipping shipping;
@Named
Permite ao Bean ser acessado via EL (JSF), recomenda-se a
anota o @Named na classe e no no ponto de inje o
@Default
@Named
public class PriorityShipping implements Shipping {
. . .
}

Alternatives
Com alternatives voc pode escolher qual Bean utilizar em tempo
de deploy sem alterar a aplica o
public class PriorityShipping implements Shipping {
. . .
}
@Alternative
public class ExpressShipping implements Shipping {
. . .
}
@Inject Shipping shipping;-> Dessa forma ir injetar PriorityShipping
Definir no beans.xml:
<beans ... >
<alternatives>
<class>shipping.ExpressShipping</class>
</alternatives>
</beans>
@Inject Shipping shipping;-> A Inje o agora ir injetar o ExpressShipping
Obs.: Se s houver a implementa o @Alternative e no tiver definido no beans.xml a
inje o no vai funcionar

Producer e Disposer
Com alternatives voc tem inje o esttica, se precisar de
inje o dinmica voc precisa usar Producer
@Produces
public List<String> getShippings() {
List<String> response = new ArrayList<String>();
return response;
}
Por padro o escopo @Depedent, producer pode vir com o escopo definido:
@Produces @RequestScoped
public List<String> getShippings() {
List<String> response = new ArrayList<String>();
return response;
}
@Inject List<String> listShippings;
Objetos criados com Producer precisam de uma distrui o explcita @Disposes:
void close(@Disposes Connection connection) {
connection.close();
}

Interceptors
Interceptors tem a fun o de aplicar implementa o automtica
em um Bean e fazer com que o cdigo seja executado durante o
ciclo de vida do objeto
@InterceptorBinding
@Retention(RUNTIME)
@Target({METHOD,TYPE})
public @interface Logging { . . . }
@Interceptor
@Logging
public class LoggingInterceptor {
@AroundInvoke // Ir interpor os mtodos de negcio
public Object log(InvocationContext context) throws Exception {
Logger.getLogger(getClass().getName().info(context.getMethod().getName());
return context.proceed();
}
}

Interceptors
@Logging
public class ExpressShipping { . . . }
ou
public class ExpressShipping {
@Logging
public String greet(String name) { . . . }
}
@Interceptor
@Transactional
public class TransactionInterceptor {
@Resource UserTransaction tx;
@AroundInvoke
public Object manageTransaction(InvocationContext context) {
tx.begin();
Object response = context.proceed();
tx.commit();
return response;
}
}
preciso habilitar no beans.xml:
<interceptors>
<class>org.sample.TransactionInterceptor</class>
</interceptors>

Decorators
Um Decorator uma implementa o adicional ao Bean, para os
conceitos relacionados ao negcio, contm ainda um ponto de
inje o com @Delegate que indica onde ele vai delegar essa
implementa o
@Decorator
public abstract class ShippingDecorator implements Shipping {

@Inject
@Delegate
@Any
Shipping shipping;

public String labelString(String s, int tval) {
int len = s.length();
return "\"" + s + "\" label " + "\"" + coder.labelString(s, tval) + len + " length";
}
}

Escopos
Um Bean criado em um escopo e associado a um contexto, o contexto
gerencia e define o seu ciclo de vida e visibilidade.
@RequestScoped
Disponvel durante o request, destrudo quando o request tem fim.
@SessionScoped
Compartilhado entre requests da mesma sesso, destrudo quando a
sesso d timeout ou destruida.
@ApplicationScoped
Criado quando a aplica o sobe, destrudo quando ela derrubada.
@ConversationScoped: Transient e Long-running.
Transient (default): O Bean criado num request JSF e destrudo no fim
do request, pode ser convertido para um long-running atravs de
Conversation.begin( ) e destrudo no Conversation.end( )
@Dependent
Pseudo-escopo, os beans que no tem nenhum escopo declarado.

Stereotype
Encapsula e agrupa papis em um nico local, reduz a quantidade
de anota es necessrias e cria anota es condizentes com o
Bean
@Stereotype
@Retention(RUNTIME)
@Target(TYPE)
@Transactional
@Logging
public @interface MyShippingService { . . . }
Obs.: @Interceptor, @Decorator e @Model so Stereotypes pr-definidos.

Eventos
Eventos prov um modelo de eventos baseado em anota es
como o Pattern Observer, quem gera o evento e quem consome
so desacoplados e se comunicam na mudana de estado
Definindo um evento:
@Inject @Any Event<ServiceShipping> shippingEvent;
ServiceShipping service = new ServiceShipping(product, address);
shippingEvent.fire(service);
Escutando o evento:
public class ProcessItems {
public void processItems(@Observes ServiceShipping service) {
// ... Processa os items a serem entregues.
}
}

Obrigado!