Fundamentos de EJB

1. Fundamentos de EJB Componentes do framework Ricardo Cavalcanti roc3@cin.ufpe.br Jobson Ronan jrjs@cin.ufpe.br

2. Relembrando • Enterprise bean: componente server-side que pode ser implantado num ambiente distribuído e multicamadas • Interface determina os serviços oferecidos pelo bean • Deve seguir a especificação EJB • Para garantir que o container possa gerenciá-lo

3. Transaction Service Security Service Database Service Relembrando (2) Objeto Remoto Cliente Enterprise bean Interceptador de requisições Stub Skeleton Rede

4. Componentes do EJB • Um EJB deve estar empacotado em um JAR contendo • Uma classe que implementa o bean • Interface(s) do(s) interceptador(es) (Remota ou Local) • Interface(s) de fábrica: Home (Remota ou Local) • Deployment descriptor • Descritores específicos para o servidor • Classes auxiliares: geradas pelo container • Arquivo Ejb-jar

5. Classe do bean • Contém a lógica de negócio • Pode também implementar rotinas de persistência • Implementações diferem, dependendo do tipo • Session Beans - lógica relacionada a processos de negócio (computar preços, transferir fundos) • Entity Beans - lógica relacionada a dados (mudar o nome de um cliente, reduzir o saldo) • Message-driven Beans - lógica orientada a mensagens (eventos), lógica assíncrona

6. Interface EnterpriseBean • Todo bean implementa javax.ejb.EnterpriseBean • Na verdade, todo bean implementa uma interfacederivada de EnterpriseBean SessionBean extends EnterpriseBean EntityBean extends EnterpriseBean MessageDrivenBean extends EnterpriseBean public interface javax.ejb.EnterpriseBean extends java.io.Serializable{ }

7. Exemplo: HelloBean import java.rmi.RemoteException; import javax.ejb.EJBException; import javax.ejb.SessionContext; public class HelloBean implements javax.ejb.SessionBean { public void ejbCreate(){..} public void setSessionContext(SessionContext ctx) {...} public void ejbRemove() {...} public void ejbActivate() {...} public void ejbPassivate() {...} public String hello() { System.out.println("hello"); return "Hello, World!"; } }

8. Interface do componente • Component interface: referência para o componente • Remote component interface • Local component interface • Para criar uma interface de componente, é preciso estender interfaces EJBObject ou EJBLocalObject • O container criará automaticamente interceptadores contendo todos os métodos de negócio declarados • As exceções de aplicação devem ser declaradas aqui • Um bean só precisa de um tipo de interceptador (ou Local ou Remoto) mas pode ter ambos, se necessário

9. Interface do componente • Interceptador EJBObject é objeto remoto RMI-IIOP • É gerado pelo container e delega chamadas ao bean • Interface javax.ejb.EJBObject estende java.rmi.Remote • Define métodos de negócio remotos expostos pelo bean • Todos os métodos devem indicar que lançam RemoteException

10. Transaction Service Security Service Database Service Interface do componente Objeto Remoto Cliente Enterprise bean Interceptador de requisições Stub Skeleton ComponentInterface Rede

11. Exemplo: Interface remota package hello.ejb; /** * Esta eh a interface remota do HelloBean. * * Esta é a interface com a qual os clientes irão operar * quando eles interagirem com objetos EJB. O container irá * implementar esta interface; * o objeto implementado é o EJB object * que irá delegar as invocações para o bean */ public interface Hello extends javax.ejb.EJBObject { /** * Método único que retorna olá para o cliente! */ public String hello() throws java.rmi.RemoteException; }

12. Interface de fábrica • Estende javax.ejb.EJBHome, que define as operações para gerenciar o ciclo de vida • Objetos EJBHome servem para • Criar objetos EJB: métodos create • Encontrar objetos EJB existentes (em Entity Beans): métodos findXXX • Remover objetos EJB: método remove • Fábrica usada para que clientes possam adquirir referências remotas a objetos EJB • Evita ter que registrar cada objeto: registra-se só a fábrica • Para obter uma referência a um objeto EJB, cliente chama métodos do EJBHome • Os objetos EJBHome são parte do container e gerados automaticamente • O programador define uma interface Home estendida de EJBhome

13. Interface de fábrica • Métodos create devem indicar que lançam javax.ejb.CreateException • Também pode ser local ou remota • EJBLocalHome e EJBHome • Se for remota pode lança RemoteException

14. Exemplo: Interface Home /** * Esta é a interface home do HelloBean. Esta interface * é implementada pelas ferramentas do servidor - o objeto * implementado é chamado de EJB Home Object * e serve como uma fábrica de Beans. * * Cada método create() na Home Interface * corresponde a um ejbCreate() no HelloBean * */ public interface HelloHome extends javax.ejb.EJBHome{ /** * Este método cria um EJ Object. * * @return Um EJB Object recém criado. */ Hello create() throws java.rmi.RemoteException, javax.ejb.CreateException; }

15. Interfaces locais x remotas • Um problema das interfaces remotas: lentidão para criar objetos • Cliente chama um stub local • Stub transforma os parâmetros em formato adequado à rede • Stub passa os dados pela rede • Esqueleto reconstrói os parâmetros • Esqueleto chama o EJBObject • EJBObject realiza operações de middleware como connection pooling, transações, segurança e serviços de ciclo de vida • Depois que o EJBObject chama o Enterprise Bean, processo é repetido no sentido contrário • Desde EJB 2.0 é possível chamar EJBs através de sua interface local • Cliente chama objeto local • Objeto EJB local realiza middleware • Depois que o trabalho termina devolve o controle a quem chamou

16. Interfaces locais • Interfaces locais são definidas para objetos EJBHome e para EJBObject (interfaces EJBLocal e EJBLocalHome) • Benefícios • Melhoria de performance mesmo com beans simples • Uso típico: fachadas Session que acessam Entities que não são acessíveis remotamente • São opcionais • Substituem ou complementam as interfaces remotas existentes • Efeitos colaterais • Só funcionam ao chamar beans do mesmo processo (não dá para mudar o modelo de deployment sem alterar o código) • Parâmetros são passados por referência e não por valor: muda a semântica da aplicação!!! • Uso típico: Entity Beans geralmente só têm interfaces locais

17. Exemplo: Interface local package hello.ejb; /** * Esta eh a interface local do HelloBean. * * Esta é a interface com a qual os clientes irão operar * quando eles interagirem com objetos EJB. O container irá * implementar esta interface; * o objeto implementado é o EJB object * que irá delegar as invocações para o bean */ public interface HelloLocal extends javax.ejb.EJBLocalObject { /** * Método único que retorna olá para o cliente! */ public String hello(); //não há necessidade de lançar RemoteException }

18. Exemplo: Interface Local Home /** * Esta é a interface local home do HelloBean. Esta interface * é implementada pelas ferramentas do servidor - o objeto * implementado é chamado de EJB Home Object * e serve como uma fábrica de Beans. * * Cada método create() na Home Interface * corresponde a um ejbCreate() no HelloBean * */ public interface HelloLocalHome extends javax.ejb.EJBLocalHome{ /** * Este método cria um EJ Object. * * @return Um EJB Object recém criado. */ Hello create() throws javax.ejb.CreateException; //não há necessidade de lançar RemoteException }

19. Exemplo clássico Cliente HTML Servlet Cliente WebService JSP Cliente CORBA Cliente Swing Taglib remote remote Session Bean Session Bean local local local Entity bean Entity bean Entity bean BD

20. Exceções e EJB • Dois tipos de exceções • System-level exceptions: representam erros críticos, falhas no banco etc. • Application-level exceptions: exceção de rotina, indicam violação de regras de negócio • Por que dividir? • Transparent fail-over

21. Rule of thumb • Application-level exceptions: lançadas para o cliente. • System-level exceptions: • O container deve decidir o que fazer • O bean pode lançar RuntimeException ou RemoteException

22. EjbContext EJBHome EJBLocal Home Interface EJBContext • Através do contexto, o bean pode ter acesso... • Ao objeto que implementa sua interface Home • Ao usuário e perfil do usuário logado • Ao status de transações • Subtipos para cada tipo de bean handlers transações Principal Bean inRole?

23. Exceções de sistema • Erros graves devem ser encapsulados em EJBException public void procurar(){ try{ //codigo } catch (SQLException e){ throw new EJBException(e); } }

24. Deployment Descriptor • Arquivo de configurações em XML • Informa ao container sobre as necessidades de middleware • Informações sobre a estrutura e gerência e ciclo de vida • Home, o Remote • Tipo do bean • Modelo de persistência para Entity Beans • Configuração de transações • Segurança • ... • Nome padrão: ejb-jar.xml

25. Exemplo: ejb-jar.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/dtd/ejb-jar_2_0.dtd"> <ejb-jar > <enterprise-beans> <session > <ejb-name>Hello</ejb-name> <home>exemplo.hello.HelloHome</home> <remote>exemplo.hello.Hello</remote> <local-home>exemplo.hello.HelloLocalHome</local-home> <local>exemplo.hello.HelloLocal</local> <ejb-class>exemplo.hello.HelloBean</ejb-class> <session-type>Stateless</session-type> <transaction-type>Container</transaction-type> </session> </enterprise-beans> </ejb-jar>

26. Arquivos específicos do fabricante • Cada servidor tem recursos adicionais que necessitam configuração específica • Load-balancing • Clustering • Pooling • Monitoramento • Mapeamento JNDI • Geralmente são gerados por ferramentas no próprio servidor • Podem também ser codificados à mão (jboss.xml) • Devem ser incluídos no bean antes do deployment

27. Exemplo: jboss.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE jboss PUBLIC "-//JBoss//DTD JBOSS 3.0//EN""http://www.jboss.org/j2ee/dtd/jboss_3_0.dtd"> <jboss> <enterprise-beans> </session> <session> <ejb-name>Hello</ejb-name> <jndi-name>ejb/Hello</jndi-name> <local-jndi-name>HelloLocal</local-jndi-name> </session> </enterprise-beans> <resource-managers> </resource-managers> </jboss>

28. EJB-JAR • Arquivo JAR que contém tudo o que descrevemos • Uma vez feito o EJB-JAR, o bean já pode ser implantado no application server • Ferramentas dos containers podem descomprimir, ler e extrair informações contidas no EJB-JAR • Depois, ferramentas realizam tarefas específicas do fabricante para gerar EJB Objects, EJB Home, importar seu bean no container, etc. • Pode-se ter vários beans em um ejb-jar • O EJB-JAR é um JAR comum. Exigência apenas quanto à localização dos deployment descriptors (padrão e do fabricante). • Coloque as classes em seus pacotes a partir da raiz • Coloque os deployment descriptors no META-INF

29. Construindo o 1º. EJB • Escreva os arquivos java: interface do interceptador, interface home, a classe do bean e qualquer classe auxiliar. • Escreva o Deployment Descriptor (ou use XDoclet) • Compile as classes do passo 1 • Crie um EJB-jar contendo o DD e os .class • Faça o deploy no seu container • Configure seu Servidor para hospedar seu arquivo ejb-jar (Conexões como BD, thread pools etc.) • Inicie seu container EJB e confirme que ele carregou seu EJB-jar. • Se quiser, escreva uma classe cliente ou utilize ferramentas para exercitar a API do seu bean.