Ejb Trans

Transações
© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 256
Conteúdo
• Conceito de Transação
• Tipos de Transação
• Transações gerenciadas pelo

– Container
– Bean
– Cliente
• Atributos de transação
• Exceções
1
Motivação para transações
• São necessárias para garantir a robustez

da aplicação
– Permitem a escrita de código robusto

• Especificação EJB permite a utilização de
transações sem precisar de codificação
explícita
Operações Atômicas
• Efetuar diversas operações independentes

(discretas) e ainda assim considerá-las
como uma grande e única operação
atômica
• Exemplo: Transferência de dinheiro
– { retirar dinheiro da conta 1
depositar dinheiro na conta 2 }
• Se alguma das operações falhar,a outra
também deve falhar. Elas fazem parte da
mesma transação
2
Transferência de Dinheiro: Código
• Muito Código, pouco try {

legibilidade // retirar dinheiro da conta 1
• Precisa considerar }

todo problema que catch (Exception e) {
// Se ocorreu algum erro, não prossiga
possa ocorrer com return;
rotinas para }
tratamento de erros try {
// Se ok, deposite dinheiro na conta 2
• Com processos mais }
complexos o catch (Exception e) {
tratamento de erro // Se ocorreu algum erro, não prossiga
fica fora de controle // E redeposite o dinnheito na conta 1
return;
• Testar o código é um }
desafio!
Idealmente: Efetuar ambas as operações um uma única e grande

operação atômica, garantindo o sucesso ou falha de ambas.
Falha de Máquina ou na Rede
• Suponha nossa transferência em uma

ambiente distribuído
– Por que?
• Segurança, Escalabilidade, Modularidade

• Quais problemas?
– A rede cai na hora transferência.
• Cliente recebe RemoteException
– Retirada ok? Deposito ok?
– Uma máquina(banco de dados) falha.
– Inconsistência nos dados
• É necessário um processo de recuperação
para prevenir tais falhas.
3
Compartilhamento de dados
• Em um ambiente distribuído, clientes podem estar

compartilhando(alterando) o mesmo conjunto de
dados

Transação: Benefícios
• Uma transação é uma série de operações

que são executas como se fossem um
única grande operação
• Garantem uma execução tudo-ou-nada

– Todas as operações são executadas com
sucesso ou nenhuma delas é
• Controlam o acesso concorrente a um
conjunto de dados compartilhados
– Locking de dados
4
ACID
• Conjunto de propriedades que as transações

fornecem
• Atomicidade(Atomicity)

– Garante que muitas operações se comportem como uma, uma
seja, um unidade de trabalho.
• Consistência(Consistency)
– Garante que a transação, quando terminada, deixará o estado do
sistema consistente
• Ex: Saldo sempre deve estar positivo.
• Isolamento(Isolation)
– Uma transação deve ser executada sem interferência de outros
processos ou outras transações.
• Durabilidade
– Toda alteração nos dados feita durante uma transação deve ser
escrita para algum meio de armazenamento até que a transação
termine, para garantir que as mudanças não sejam perdidas caso
Enterprise Java haja
Beans uma falha no sistema Pág: 264
Modelos Transacionais
• São as diferentes maneiras de como

efetuar as transações
– Flat Transactions
• Requerido pela especificação

– Nested Transactions
• Não suportado pela especificação
5
Flat Transactions
• Consiste em uma série de operações que

são executadas atomicamente como uma
única unidade de trabalho

Nested Transactions
• Permite embutir em uma transação outras

transações.
–Trem(Boston) -> NY, Avião(NY) -> Londres,
Balão(Londres) -> Paris ,Paris = Lotado
6
Demarcação de transações
• Componentes EJB são responsáveis

apenas pela demarcação das transações
– Quando será iniciada

– Quando será concluída
– Não são controlados aspectos de baixo nível
• Interação com o gerenciador de transação
• Existem 3 forma de demarcação de
transação
– Programaticamente(Bean)
– Declarativamente(XML)
– Iniciadas pelo cliente(Servlets, Applets,etc)
Tipos de Demarcação de Transação

7
Demarcação: Bean
public void checkOut() {

UserTransaction ut = context.getUserTransaction();
ut.begin();
anotherBean.validateCredit(customerNum);
checkInventory();
Pega referência para
ut.commit(); UserTransaction do
//or ut.rollback();
contexto
doNonTxStuff();
}
Demarcação: XML
<ejb-jar>
<enterprise-beans>
<session>
<ejb-name>Hello</ejb-name>
<home>examples.HelloHome</home>
<remote>examples.Hello</remote>
<ejb-class>examples.HelloBean</ejb-class>
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
</ejb-jar>
8
Quem pode demarcar transações no
bean?
• Entity CMP só podem utilizar demarcação

declarativamente (XML)
• Entity BMP podem utilizar

programaticamente
Transação em CMP
• A Transação em beans CMP é controlada

com um atributo de transação no arquivo
XML
– <trans-attribute>
• Atributo pode ser especificado para
– Bean
– Método do Bean
• Deve-se especificar os atributos de
transação para:
– Todos os métodos de negócios
– Em entity beans: Métodos Interface Home
(create)
9
Especificando Atributos
• Bean
<container-transaction>
<method>

<ejb-name>Employee</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>Required</trans-attribute>
• Métodos Bean
<method>
<ejb-name>Employee</ejb-name>
<method-name>setName</method-name>
</method>
<trans-attribute>Required</trans-attribute>
</container-transaction>
Atributos
• Existem 6 tipos de atributos que podem ser

utilizados no XML.
– Required
– RequiresNew
– Supports
– Mandatory
– NotSupported
– Never
10
Atributo Required
• Required
– Deve-se utilizar quando se quer que o bean
sempre seja executado em uma transação.

Atributo RequiresNew
• RequiresNew
– Deve-se utilizar quando se quer que o bean
sempre seja executado em uma nova
transação.
11
Atributo Supports
• Supports
– Bean só é executado em transação se cliente
já criou uma, caso contrario é executado sem

estar em uma transação
Atributo Mandatory
• Mandatory
– Exige que já exista uma transação para que
bean seja executado
• javax.ejb.TransactionRequiredException
• javax.ejb.TransactionRequiredLocalException
12
Atributo NotSupported
• NotSupported
– Bean não pode ser executado em uma
transação. Caso seja chamado em um

transação, ela é suspensa.
Atributo Never
• Never
– Bean não pode ser executado em uma
transação.
• java.rmi.RemoteException
• javax.ejb.EJBException
13
Restrições Atributos
• Nem todos os atributos estão disponíveis

para os beans

JTS e JTA
• JTS – Java Transaction Service

– É um mapeamento java-CORBA da
especificação OTS (Object Transaction
Service)
• Conjunto de interfaces que especificam como
transações são executadas.
• Utilizada por fabricantes de containers.(Suporte não
é obrigatório).
• JTA – Java Transaction API
– Utilizada por desenvolvedores.
• Conjunto de interfaces utilizada para definir
demarcação de transações
• Suporte obrigatório pelo container.
14
UserTransaction
• javax.transaction.UserTransaction
– Permite a demarcação de transações
programaticamente.

• begin()
– Inicia Transação
• commit()
– Finaliza transação
• getStatus()
– Retorna status da transação corrente
• rollback()
– Condena transação
• setRollBackOnly()
– Marca transação para rollback.
• setTrasactionTimeout(int)
– Tempo Maximo de uma transação antes de abortar
Demarcação: XML x Bean
/**
* Deposits amt into account.
*/
public void deposit(double amt) throws AccountException {
System.out.println("deposit(" + amt + ") called.");
balance += amt;
}
<tran-atribute> required <tran-atribute/>
/**
* Deposits amt into account.
*/
public void deposit(double amt) throws AccountException {
javax.transaction.UserTransaction userTran = null;
try {
System.out.println("deposit(" + amt + ") called.");
userTran = ctx.getUserTransaction();
userTran.begin();
balance += amt;
userTran.commit();
} Não é feito rollback da variável
catch (Exception e) {
if (userTran != null) userTran.rollback();
throw new AccountException("Deposit failed because of " +
e.toString());
}
}
15
Restrições Demarcação Bean
• Não pode iniciar uma transação antes de

terminar outra.

public void go() {
ut.begin();
doStuff();
ut.begin(); ERRADO!!
// more
}
• Session e Message bean não podem

terminar um método sem terminar uma
transação
public void go() {
ut.begin();
doMore(); Tem de terminar transação!
}
Restrições Demarcação Bean 2
• Um bean BMT não pode invocar métodos

na interface EJBContext: setRollbackOnly()
e getRollbackOnly()
Tem de chamar
UserTransaction!!
public void go() {
mySessionContext.setRollbackOnly();
}
• Somente Stateful Session beans podem

deixa transações em aberto entre
chamadas de métodos.
– Não é um boa idéia, mas é permitido
16
Demarcação pelo cliente
try {
Context ctx = new InitialContext(env);
/** The container is required to

* make the JTA available at the location
* java:comp/UserTranasction.
*/
userTran = (javax.transaction.UserTransaction)
ctx.lookup("java:comp/UserTransaction");
userTran.begin();
// perform business operations
userTran.commit();
}
catch (Exception e) {
// deal with any exceptions, including ones
// indicating an abort.
}
Propogação de Transações
• Transações BMT e
CMT propagam-se em
um bean CMT
• Transação de um
cliente nunca será
utilizada por um bean
BMT
17
Qual demarcação escolher?
• BMT
• Vantagens: Maior controle. Pode-se agrupar
diversos operações menores no método.

• CMT
– Mais simples
– Gerenciado pelo container(eficiente)
– Seguro (evita possível problema de deadlock,
causado pelo programador)
• Transações iniciadas pelo cliente
– Vantagem – Controle em relação a falhas de
rede
– Desvantagem – Se a transação for longa, ela é
ineficiente
Como condenar uma transação?
• CMT
– EJBContext.setRollbackOnly()
– EJBContext.getRollbackOnly()
• BMT
– UserTransaction.setRollbackOnly()
– UserTransaction.getStatus()
18
Transações e EntityBeans
• Se pudéssemos, controlaríamos as
transações nos métodos ejbLoad() e
ejbStore()

– Não temos controle sobre a invocação dos
métodos: container é quem invoca.
• Container invoca ejbLoad() e ejbStore() em
cada transação
– Não invoca em cada chamada de método
– Sincronização e performance podem ser
melhoradas, iniciando a transação o quanto
antes e encerrando-a o mais tarde possível
Transações em Stateful Session

Beans
• Entity beans mantém seu estado no Banco

de Dados.
– Qualquer rollback em uma transação, o
container recupera o estado anterior do bean.

• Stateful session beans mantém seu estado
em variáveis de instâncias
– Bean precisa guardar o estado anterior das
variáveis em caso de rollback
• Se BMT, bean pode guardar variáveis
• SE CMT, temos de implementar interface
SessionSyncronization
19
Interface SessionSynchronization
• Implementada somente por Stateful

Session beans com CMT
• Possui 3 métodos

– afterBegin()
• Chamado logo após a transação ter iniciado
• utilizado para guardar o valor das variaveis
– beforeCompletion()
• Chamado antes do termino da transação
– afterCompletion(boolean state)
• Chamado pelo container logo após o termino da
transação
• Se transação falhar, state == false
Exemplo: SessionSynchronization
public class CountBean implements SessionBean,

SessionSynchronization {
public int val;
public int oldVal;

public void ejbCreate(int val) { Salva estado
this.val=val; da variável
this.oldVal=val;
}
public void afterBegin() { oldVal = val;}
public void beforeCompletion() {}
public void afterCompletion(boolean b) {
if (b == false) val = oldVal;
}
Se transação
public int count() { return ++val; }
falhou, recupera
public void ejbRemove() {}
estado
public void ejbActivate() {}
public void ejbPassivate() {}
public void setSessionContext(SessionContext ctx) {}
}
20
Ciclo de vida Stateful Session Bean

Transações e Tipos de Exceções
• A especificação classifica as exceções em

2 tipos
– Application Exceptions
– System Exceptions
• System Exceptions
– Acusam erros no servidor ou nos seus serviços
– Java.lang.RuntimeException,
java.rmi.RemoteException e seus subtipos
– Rollback automático
• Application Exceptions
– Consistem de erros de lógica no programa(aplicação)
– Qualquer exceção excluindo System Exceptions
– Não causam rollback automático
21
java.lang.RuntimeException
• Quando uma RuntimeException é lançada

(EJBException, NullPointerException,
IndexOutOfBoundsException, etc) o container

– Efetua um rollback
– Log nas exceções para avisar ao administrador do
sistema
– Descarta a instância do EJB
• Regra: Re-lance exceções de sistema como
EJBException para permitir ao container fazer o
rollback automático
• javax.EJBException
– NoSuchEntityException
– NoSuchObjectLocalException
– TransactionRequiredLocalException
java.rmi.RemoteException
• São lançadas pelo o container

– Declaradas nas interfaces remotas e não nos
beans
• Container adota o mesmo procedimento

que RuntimeException
– rollback, log, destrói EJB
• RemoteException
– NoSuchEntityException
– NoSuchObjectException
• javax.transaction -> RemoteException
– TransactionRequired
– TransactionRolledbackException
22
ApplicationExceptions
• São as exceções que são lançadas para o

cliente.
– indicam erros na lógica de negócios

– Não são empacotadas como RemoteException
ou EJBException
• Application Exception
– Exceções específicas da aplicação
– FooException, SQLException,
FileNotFoundException
• Se for exceção grave, para condenar
transação deve chamar
– context.setRollbackOnly()
Applications Exceptions em EJB
• Exceções definidas na especificação que requerem

rollback explícito
• CreateException
– Lançada no método create da interface remota(pode ser lançada também

pelo ejbPostCreate)
• DuplicateKeyException
– Subtipo de CreateException, lançada no método create da interface
remota
– Indica que um EJB com a mesma PK já existe no banco de dados
• FinderExcetion
– Lançada por métodos find na interface remota. Indica que um erro na
aplicação(argumento inválidos, etc) ocorreu.
– Objetos não encontrados
• Collection – retorna coleção vazia para múltiplos objeto ou
• ObjectNotFoundException
– Lançada por métodos find para indicar que objeto não foi
encontrado
• RemoveException
– Lançada pelo método remove(interfaces home e remota) para
indicar que erro quando estava sendo removido
23
24
© 2002, SoftSite Tecnologia. Todos os direitos reservados © 2002, SoftSite Tecnologia. Todos os direitos reservados
Pág: 302
Pág: 303
Exemplo e Exercício
Segurança
Exercício
Exemplo
Enterprise Java Beans

Conteúdo
• Conceitos segurança
– Autorização

– Autenticação
• JAAS e Jboss
– jbosssx
• Segurança EJB
– Tags controle de acesso
– Definição de papéis
Autenticação e Autorização
• Clientes que desejem acessar EJB devem

fazer duas coisas
– Cliente deve se autenticar
• Autenticação checa se o cliente é quem ele afirma

ser.
– login/senha autenticada por um servidor LDAP
• Após autenticação, cliente é associado a uma
identidade por toda a sessão
– Autorização
• Depois de autenticado (identificado) cliente deve
possuir autorização para efetuar operação desejada
• Autenticação deve ser efetuada antes da
chamada a um método. Autorização ocorre
durante a chamada de um método
25
Controle de Acesso
• Autenticação é dependente do servidor e

pode ser implementado utilizando a API
JAAS

– Identidade do usuário é encapsulado no objeto
java.security.Principal
• A autorização, ou controle de acesso, é
baseado em um arquivo XML
– Feita de forma declarativa
• Declaração de papéis
• Associação dos papéis a métodos
• Definição de quais usuários podem acessar os
componentes
Controle de acesso: ejb-jar.xml
<assembly-descriptor>
<security-role>
<role-name>Customer</role-name>
</security-role> Definição de
<security-role> papéis
<role-name>Admin</role-name>
</security-role>
<method-permission>
<unchecked/>
<method> sem autenticação
<ejb-name>ProductEJB</ejb-name>
<method-name>getPrimaryKey</method-name>
</method>
</method-permission>
<method-permission>
<role-name>Admin</role-name> Somente admin pode
<method>
executar métodos do
<ejb-name>ProductEJB</ejb-name>
<method-name>*</method-name> EJB
</method>
<method-permission>
</assembly-descriptor>
26
JAAS
• JAAS é um conjunto de interfaces que permite a

autenticação e autorização de usuários em java
– Quem implementa a maior parte das interfaces é o

servidor.
– Baseada no PAM(Pluggable Authentication Module)
• Classes Principais
– javax.security.auth.subject
– java.security.Principal
– javax.security.auth.callback.Callback
– javax.security.auth.callback.CallbackHandler
– javax.security.auth.LoginContext
– javax.security.auth.spi.LoginModule
JAAS no JBOSS(JbossSX)
• Jboss implementa a API JAAS

– Através do JAASSecurityManager
– Arquivos de configuração
• servidor – login-config.xml
• cliente – auth.conf
– Fornece implementações da
javax.security.auth.spi.LoginModule
• Fornece classes de login para cada tipo de
autenticação
• jboss.xml e jboss-web.xml
– <security-domain> específica o domínio JAAS
27
Implementações de LoginModule
• org.jboss.security.ClientLoginModule
– Implementação para o cliente
• org.jboss.security.auth.spi.UsersLoginModule
– Uma das implementações para o servidor

– arquivos de configuração: users.properties e
roles.properties
• IdentityLoginModule
– Associa uma identidade única para todo um
módulo(somente para testes)
• LdapLoginModule
– Autenticação via servidor LDAP
• DatabaseServerLoginModule
– Autenticação via banco de dados
• ProxyLoginModule
– Criada somente para contornar uma limitação do
classloader do JAAS: classes de login tem de estar no
classpath
Configurações no Jboss
• Cada domínio de segurança precisa ser

configurado no cliente e no servidor
• Servidor
– login-config.xml em
JBOSS_HOME/server/default/conf/
– Criação de domínios e associação com
módulos de login
• Aplicação
– jboss.xml(se autenticação via web container:
jboss-web.xml)
– Declarar domínio de segurança JAAS
– Clientes standalone é necessário informar
domínio de segurança
28
XMLs e JAASSecurityManager

Configurando domínio de segurança

no servidor
• Declaração do domínio no jboss.xml

<jboss>
<security-domain>java:/jaas/dominio-servidor</security-domain>
<session>
<ejb-name>SecureHelloEJB</ejb-name>
<jndi-name>login/HelloHome</jndi-name>
</session>
</jboss>
• Nome do domínio dever ser igual ao declarado

no login-config.xml
<policy> (...) <application-policy name="dominio-servidor">
<authentication>
<login-module code="MyLoginModule" .../>
• Se domínio não existir, domínio default “other”

será utilizado.
– Configurado em UsersRolesLoginModule
29
Serviço JbossSX
UsersRolesLoginModule
• Serviço de login que utiliza par de arquivos

– É a configuração default do login-config.xml

<policy> (...)
<application-policy name="other">
<authentication>
<login-module
code="org.jboss.security.auth.spi.UsersRolesLoginModule"
flag="required" />
</authentication>
</application-policy>
</policy> server/default/conf/login-config.xml
users.properties nome=senha roles.properties nome.Grupo=Role,...Role

julio=cesar Julio.Roles=TestRole, AdminRole
Foo=bar Foo.Roles=NoRole, FooRole
Colocar no classpath do servidor(ou ejb-jar.xml)

Utilizando Banco de Dados
• Pode-ser guardar as informações de

autenticação (domínio, usuário,senha) em um
banco de dados
– Configurar jboss.xml com DatabaseServerLoginModule

– Criar algumas tabelas no banco
• Configuração Módulo: nome DataSource,query
de consulta de senha,query de consulta de Grupo
<application-policy name="dominio-login-servidor">
<authentication>
<login-module code="org.jboss.security.auth.spi.DatabaseServerLoginModule"
flag="required">
<module-option name="dsJndiName">java:/DefaultDS</module-option>
<module-option name="principalsQuery">select senha from usuarios where
id=?</module-option>
<module-option name="rolesQuery">select grupo, 'Roles' from usuarios where
id=?</module-option>
<module-option name="unauthenticatedIdentity">nobody</module-option>
</login-module>
</authentication>
/application-policy>
30
Configuração no Cliente
• Arquivo de configuração tem que estar no

classpath
– Indica no mínimo que login utilizar

dominio-cliente {
// JBoss LoginModule implementation
org.jboss.security.ClientLoginModule required;
};
client-auth.conf
• Informar qual arquivo como propriedade

java app -Djava.security.auth.login.config=client-auth.conf
• Jar Necessário
– jbosssx-client.jar
Domínio de clientes em outros

Containers
• Para clientes que se encontram dentro do

servidor(servlets, JSPs), basta chamar o
mesmo módulo de login através do domínio
especificado no XML
• login-config.xml
<application-policy name="dominio-cliente">
<authentication>
<login-module
code="org.jboss.security.ClientLoginModule"
flag="required">
</login-module>
</authentication>
</application-policy>
31
Cliente Standalone JAAS para login
public class HelloClient {

public static void main(String[] args) throws Exception {
LoginContext loginCtx = null;
try {

// Cria CallBackHandler; Encapsula dados de autenticação
CallbackHandler handler = new HelloCallbackHandler();
// Carrega configuração
loginCtx = new LoginContext("dominio-cliente", handler);
// Faz o login
loginCtx.login();
} catch (LoginException e) {
System.out.println("Login failed"); System.exit(1);
}
// Executa ação privilegiada propagando contexto de segurança
Context ctx = new InitialContext(System.getProperties());
Object obj = ctx.lookup("SecureHelloEJB");
HelloHome home = (HelloHome)
PortableRemoteObject.narrow(obj, HelloHome.class);
Hello hello = home.create();
System.out.println(hello.hello());
}
}
JAAS CallBackHandler
32
Autenticação Jboss

Exemplo JAAS
• Exemplo (Helder da Rocha + MEJB2)

• Configurar
– build.properties
– lib/users.properties, lib/roles.properties
• Executar
– ant jboss.deploy
– ant run.jboss.client
33
ejb-jar.xml
<ejb-jar>
<enterprise-beans>
<session>
<home>examples.HelloHome</home>

<remote>examples.Hello</remote>
<ejb-class>examples.HelloBean</ejb-class>
<session-type>Stateless</session-type>
</session>
</enterprise-beans>
<assembly-descriptor> TestRole
<security-role> acessa todos
<role-name>TestRole</role-name> os métodos
</security-role>
<method-permission>
<role-name>TestRole</role-name>
<method>
<method-name>*</method-name>
</method>
</method-permission>
</assembly-descriptor>
</ejb-jar>
Identidade do Principal
• A identidade do cliente(principal) é
propagada durante as chamadas
– Configurável
<entity>
...
<security-identity>
<use-caller-identity />
<security-identity>
...
</entity>
• Exceção é lançada caso não seja permitido

acesso
34
Troca de identidade
• Um bean pode trocar de identidade, caso

queira executar métodos privilegiados
– Identidade é propagada em todos os métodos

<entity>
...
<security-identity>
<run-as>
<role-name>admin</role-name>
</run-as>
<security-identity>
...
</entity>
Controle programático
• Existem 2 métodos para controle de acesso

no código
String loggedUser = ctx.getCallerPrincipal().getName();

if( !ctx.isCallerInRole("admin")) {
if (!loggedUser.equals(userid)) {
throw new AcessoIlegalException("...");
}
}
35
Alias para papéis no XML
• Permite que o nome utilizado pelo

programador no código fonte seja mapeado
para um papel declarado no XML.

</entity>
...
<security-role-ref>
<role-name>admin</role-name>
<role-link>administrador</role-link>
</security-role-ref>
...
</entity>
<assembly-descriptor>
<security-role>
if( !ctx.isCallerInRole("admin")) { <role-name>admin</role-name>
… </security-role> ...
… </assembly-descriptor>
Exemplo
Exemplo
36
Xdoclet

Conteúdo
• O que é Xdoclet
• Tags Xdoclet para ejb
– ejbdoclet
• Exemplos de Utilização das tags
37
Xdoclet
• Xdoclet é uma ferramenta de geração de

código
–Open Source

–Estende a Javadoc doclet API, permitindo a criação de
novos arquivo baseado nas tags @ do javadoc
–Baseado no ANT
–Extensível através de templates.
• Site:http://xdoclet.sourceforge.net
• Fornece suporte para geração de Arquivos EJB
–ejb-jar.xml, interfaces home, remote etc.
Tarefa no ANT
<target name="ejbdoclet" depends="init">

<taskdef name="ejbdoclet"
classname="xdoclet.modules.ejb.EjbDocletTask"
classpathref="xdoclet.path"> Defini nova

<classpath>
tarefa
<fileset dir="${xdoclet.lib.dir}" includes="*.jar"/>
</classpath>
<ejbdoclet/>
</taskdef>
<ejbdoclet destdir="${xdoclet.gen}" ejbspec="2.0" >
<fileset dir="${src.dir}">
<include name="**/*Bean.java" />
</fileset> Configura tarefa
<remoteinterface/>
<homeinterface/>
subtarefas
<localhomeinterface/>
<homeinterface/>
<deploymentdescriptor destdir="${xdoclet.gen}" />
<jboss/>
</ejbdoclet> Gera arquivo do
</target>
container
38
Definindo classpath
• Incluir bibliotecas
– XDOCLET_HOME/lib

<path id="xdoclet.path">
<pathelement location="${xdoclet.lib.dir}" />
/path>
• Outras
– XDOCLET_HOME/samples/lib
• Jboss-j2ee.jar
• Servlet.jar
• Junit.jar
CountBean.java
/**
* @ejb.bean type="Stateful"
* view-type="both"
* jndi-name="CountHome"
*/
public class CountBean implements SessionBean {

public int val;
/**
* Counts up
* @ejb.interface-method
*/
public int count() {
System.out.println("count()");
return ++val;
}
/*
* @ejb.create-method
*/
public void ejbCreate(int val) throws CreateException {
this.val = val;
System.out.println("ejbCreate()");
}
. . .
39
Algumas Tags EJB
• @ejb.interface-method
– Declara um método como método de negócios
• @ejb.create-method

– Declara método como método ejbCreate
• @ejb.home-method
– Método Home
• @ejb.finder
– Defini método find para interface home e local home
• @ejb.select
– Método do tipo ejbSelect
• @ejb.pk-field
– Cria método findByPrimaryKey na interface home
Tags de container
• O xdoclet pode gerar os arquivos XML

específicos de cada servidor
– <jboss/>
– <websphere/>
– <jonas/>
– <weblogic/>
– <jrun/>
– <resin-ejb-xml/> (resin-ejb.xml)
– <orion/> (orion-ejb-jar.xml)
– <hpas/>
40
Gerando Value Objects
/**
* @ejb.bean type="CMP"
* name="ItemBean"
* jndi-name="ejb/ItemBean"
Tem que

* view-type="both"
* @ejb.value-object adicionar tarefa
*/
. . .
<valueobject/>
/**
* @ejb.persistence
* @ejb.pk-field
*/
public abstract String getID();
/**
*/
public abstract String getType();
/**
*/
public abstract String setType();
Gerando PK
/**
* name="ItemBean" Identifica campo PK
* view-type="both"
* primkey-field="ID";
* @ejb.pk
*/ Adiciona tag PK
public abstract class ItemBean implements EntityBean
{
//Callback methods
..
/**
* @ejb.create-method
*/
public void ejbCreate( String id )
{
setID( id );
}
/**
Identifica método get PK
* @ejb.persistence
* @ejb.pk-field
*/
public abstract String getID();
}
41
papéis de segurança e acesso a
métodos
/**
* @ejb.bean type="Stateful"
* view-type="both"
* jndi-name="${user.bean.jndi}"
*

* @ejb.security-role-ref
* role-name="ADMIN"
* role-link="administrator"
*
*/
public class UserBean implements SessionBean{
/**
* @ejb.permission
* unchecked="true";
*/
public void setUserName( String name )
{
this.name = name;
}
Métodos find e ejbSelect()
/**
* name="ItemBean"
* view-type="both"
*
* @ejb.finder signature="java.util.Collection findAll()"
*/
public abstract class ItemBean implements EntityBean {
public abstract class ItemBean implements EntityBean

{
//various bean methods…
//ejbSelect methods
/**
* @ejb.select query="SELECT OBJECT( i ) FROM Item AS i"
*/
public abstract java.util.Collection ejbSelectAll();
}
42
Métodos Home

/**
* @ejb.home-method
* view-type="both"
*/
public void addDataToAll()
{
//method implementation here
}
Relacionamentos
<relationships>
<ejb-relation>
<ejb-relation-name>OwnerToData</ejb-relation-name>
<ejb-relationship-role >
<multiplicity>One</multiplicity>
<relationship-role-source >
<ejb-name>ch2.Owner</ejb-name>
</relationship-role-source>
<cmr-field>
<cmr-field-name>data</cmr-field-name>
</cmr-field>
</ejb-relationship-role>
<ejb-relationship-role >
<multiplicity>One</multiplicity>
<relationship-role-source >
<ejb-name>ch2.DataBean</ejb-name>
</relationship-role-source> /**
</ejb-relationship-role> * @ejb.interface-method
</ejb-relation> * @ejb.relation
</relationships> name="OwnerToData"
relation-role="Owner"
target-ejb=“examples.DataBean"
*/
public abstract Data getData();
43
Tag destination type para MDB
<ejb-jar>
<enterprise-beans>
<message-driven>
<ejb-name>MDB</ejb-name>
<ejb-class>MessageBean</ejb-class>

<message-driven-destination>
<destination-type>javax.jms.Topic</destination-type>
</message-driven-destination>
</message-driven>
</enterprise-beans>
<ejb-jar>
/**
* @ejb.bean
* name="MessageBean"
* type="MDB"
* destination-type="javax.jms.Queue"
*/
public class MessageBean
implements MessageDrivenBean,
MessageListener {
Seletores de mensagem para MDB
<ejb-jar>
<enterprise-beans>
<message-driven>
<ejb-name>MDB</ejb-name>
<ejb-class>MessageBean</ejb-class>
<message-selector>
<![CDATA[ messageType = 'buyerRequest' ]]>
</message-selector>
</message-driven>
</enterprise-beans>
<ejb-jar>
/**
* @ejb.bean
* name="MessageBean"
* type="MDB"
* message-selector="<![CDATA messageType = 'buyerRequest']]>"
*/
public class MessageBean
implements MessageDrivenBean, MessageListener {
44
45
Pág: 344
Exercício
Exercício
Exemplo

Ejb Trans

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ejb Trans

Загружено:

Авторское право:

Доступные форматы

Transações

© 2002, SoftSite Tecnologia. Todos os direitos reservados

• Transações gerenciadas pelo

Enterprise Java Beans Pág: 257

• São necessárias para garantir a robustez

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 258

• Efetuar diversas operações independentes

Enterprise Java Beans Pág: 259

• Muito Código, pouco try {

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Idealmente: Efetuar ambas as operações um uma única e grande

Enterprise Java Beans Pág: 260

Falha de Máquina ou na Rede

• Suponha nossa transferência em uma

• Segurança, Escalabilidade, Modularidade

• Em um ambiente distribuído, clientes podem estar

© 2002, SoftSite Tecnologia. Todos os direitos reservados

• Uma transação é uma série de operações

• Garantem uma execução tudo-ou-nada

Enterprise Java Beans Pág: 263

• Conjunto de propriedades que as transações

© 2002, SoftSite Tecnologia. Todos os direitos reservados

• São as diferentes maneiras de como

• Requerido pela especificação

Enterprise Java Beans Pág: 265

• Consiste em uma série de operações que

© 2002, SoftSite Tecnologia. Todos os direitos reservados

• Permite embutir em uma transação outras

Balão(Londres) -> Paris ,Paris = Lotado

Enterprise Java Beans Pág: 267

• Componentes EJB são responsáveis

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 268

Tipos de Demarcação de Transação

Enterprise Java Beans Pág: 269

public void checkOut() {

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 270

Enterprise Java Beans Pág: 271

• Entity CMP só podem utilizar demarcação

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 272

• A Transação em beans CMP é controlada

Enterprise Java Beans Pág: 273

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 274

• Existem 6 tipos de atributos que podem ser

Enterprise Java Beans Pág: 275

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 277

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 278

Enterprise Java Beans Pág: 279

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 280

Enterprise Java Beans Pág: 281

• Nem todos os atributos estão disponíveis

© 2002, SoftSite Tecnologia. Todos os direitos reservados

• JTS – Java Transaction Service

© 2002, SoftSite Tecnologia. Todos os direitos reservados

Enterprise Java Beans Pág: 284

Demarcação: XML x Bean