Curso de Linguagem Java

Curso de Linguagem Java 1

Referência Bibliográfica: Enterprise JavaBeans 3.0 Bill Burke & Richard Monson Editora. Prentice Hall Tutorial do J2EE Bodoff Green Haase Jendrock - Pawlan Stearns Editora Campus Revista JavaMagazine edições 8, e 47 Tutorial da Sun sobre JavaEE http://java.sun.com/javaee/5/docs/tutorial/doc/ 2

Aplicações MultiCamadas Camada Cliente Aplicação Desktop / Web Camada Web Request HttpServletRequest Camada de Negócios Servidor de Aplicações / Servidor Web Camada EIS JCA MainFrame HTML XML JavaScript Applet Servlet JSP Response HttpServletResponse EJB JPA / JDBC Aplicações Java Desktop Bancos de Dados 3

EJB Enterprise JavaBean Componente de software padrão executado no lado servidor (camada de negócios) que encapsula a lógica que atende às necessidades de um domínio de negócios. É utilizado na criação de aplicações corporativas distribuídas desenvolvidas com a tecnologia Java. Contêiner EJB É o ambiente responsável por gerenciar o ciclo de vida das instâncias das classes bean(objetos EJB) dentro de um servidor de aplicações. Servidor de Aplicações JavaEE Sistema que deve implementar os seguintes serviços: Enterprise JavaBeans (EJB) Contêiner EJB Java Persistence (JPA) Java Message Service (JMS) Java Transaction Service/Java Transaction API (JTS/JTA) Servlets e JavaServer Pages (JSP) Contêiner Web Java Naming and Directory Interface (JNDI) 4

Disponibiliza também entre outros recursos: Pool de Instâncias EJB Pool de Conexões a Bancos de Dados Controle de Concorrência Conectividade Remota Gerenciamento de Segurança Autenticação (identificação do usuário) Autorização (controle do que um usuário pode acessar) Comunicação (criptografia) Quando usar EJB em suas aplicações Quando a aplicação deve ser escalável, tanto por possuir um número crescente de usuários, como a aplicação pode estar distribuída em múltiplas máquinas. Quando transações são necessárias para garantir a integridade dos dados. Quando a aplicação possuir um alto número de clientes. Como a lógica de negócio fica nos componentes no lado servidor, a manutenção é facilitada. 5

Os três tipos básicos de Enterprise JavaBeans: Beans de Entidadade Entity Beans (JPA-Entity) São persistentes, representam o modelo persistente de dados. São gerenciados pelo serviço EntityManager. Beans de Sessão Session Beans Não são persistentes. São freqüentemente utilizados para gerenciar as interações entre os beans de entidade. Representam um fluxo de tarefa, um processo de negócio. Beans baseados em mensagens Message Driven Beans Recebem e processam mensagens assincronamente. São utilizados na interação com outros aplicativos através de um serviço de mensagens (JMS). Não possuem interfaces Local, nem Remota. Normalmente implementam a interface MessageListener, implementando assim o método onmessage() onde se localiza a lógica de negócio. 6

Beans de Sessão Session Beans Stateful SessionBean (Beans de sessão com informações de estado) Mantém o estado conversacional entre as chamadas de um cliente para o servidor, o que permite manter dados específicos ao cliente entre invocações de método. É uma extensão do aplicativo cliente. Não são mantidos em um pool de instâncias. Stateless SessionBean (Beans de sessão sem informações de estado) Não mantém nenhum estado conversacional entre o cliente e o servidor. São mantidos em um pool de instâncias. Possuem um desempenho maior que os beans de sessão com informações de estado. São utilizados para realizar tarefas que sejam realizadas em uma única chamada de método. 7

Componentes de um aplicativo que utiliza SessionBean. Interfaces Remota e/ou Local Interface remota Anotada com @javax.ejb.remote Define quais os métodos que um cliente tem permissão para invocar. Interface local Anotada com @javax.ejb.local Define quais os métodos que um outro EJB pode invocar dentro da mesma JVM. Classe do Bean Anotada com @javax.ejb.sateless ou @javax.ejb.stateful Contém a lógica de negócio, implementando os métodos descritos nas interfaces remota e/ou local e opcionalmente as interfaces de negócio. Cliente Remoto Aplicação que se conecta ao servidor EJB. Por meio da API JNDI, ele localiza a interface remota do EJB a ser utilizado e através da referência dessa interface aciona os métodos remotos do componente EJB. 8

Instalação e configuração do JBoss Baixe o JBoss no site http://jboss.com/products/jbossas/downloads Para Windows, baixe o arquivo jems-installer-1.2.0.ga.jar e execute-o. Na tela de configuração do tipo de instalação, selecione a opção EJB3. 9

Instalação e configuração do JBoss Nas demais telas, apenas clique em next, selecionando assim as opções padrão. Para iniciar o servidor, basta executar o arquivo de lote run.bat na pasta bin do diretório de instalação. Para encerrar o servidor, pressione <Ctrl><C> no prompt de comandos onde o servidor está sendo executado ou execute o arquivo de lote shutdown.bat com a opção -S. Acesso o endereço http://localhost:8080 para verificar a instalação. É aconselhável que se crie uma variável de ambiente JBOSS_HOME contendo o caminho do diretório de instalação do JBoss. 10

Construção da aplicação exemplo usando JBoss Crie um novo projeto Java e adicione no classpath os arquivos jboss-ejb3x.jar e ejb3-persistence que se encontram na pasta: %JBOSS_HOME%/client/ Torne a classe modelo.aluno serializável. Pois os objetos dessa classe irão trafegar pela rede. Crie no pacote negocio.ejb a Interface Remota AlunoRemote. Adicione o projeto que contém a classe modelo.aluno no buildpath. package negocio.ejb; import javax.ejb.*; import modelo.aluno; @Remote public interface AlunoRemote { public int incluir(aluno a); } Interface Remota 11

Crie no pacote negocio.ejb a classe do bean AlunoBean package negocio.ejb; import modelo.aluno; import javax.persistence.*; import javax.ejb.*; Classe do Bean @Stateless public class AlunoBean implements AlunoRemote { @PersistenceContext(unitName = "teste") private EntityManager em; public int incluir(aluno a) { em.persist(a); return a.getid(); } } 12

Crie no pacote cliente a classe ClienteAlunoEJB package cliente; import modelo.*; import negocio.ejb.*; import javax.naming.*; import java.util.*; Cliente Remoto public class ClienteAlunoEJB { public static void main(string[] args) { Configuração do Contexto JNDI try { (dependente do servidor) Properties prop = new Properties(); prop.put(context.initial_context_factory, "org.jboss.naming.namingcontextfactory"); prop.put(context.provider_url, "localhost:1099"); InitialContext jndicontext = new InitialContext(prop); Object ref = jndicontext.lookup("alunobean/remote"); AlunoRemote refbean = (AlunoRemote) ref; 13

Aluno a = new Aluno(); a.setnome("josé"); a.setra(987654321); a.setms1(7.5); a.setms2(6.0); int id = refbean.incluir(a); } System.out.println("Id do aluno inserido " + id); } catch (NamingException ex) { ex.printstacktrace(); } } 14

Implantação da aplicação. Os arquivos Aluno.class, AlunoBean.class, AlunoRemote.class e o persistence.xml serão empacotados em um arquivo.jar e implantados no diretório de deploy do servidor JBoss. Para se executar a aplicação, algumas configurações deverão ser efetuadas previamente: Criação de uma Fonte de Dados para o Banco MySQL. Criação do arquivo persistence.xml. Criação de um arquivo de build (build.xml) para automatizar a implantação através do aplicativo Apache Ant. 15

Configure o JBoss para fazer conexão com o MYSQL. Crie o arquivo testedb-ds.xml na pasta %JBOSS_HOME%/server/default/deploy <?xml version="1.0" encoding="utf-8"?> <datasources> <local-tx-datasource> <jndi-name>testeds</jndi-name> <connection-url> jdbc:mysql://localhost:3306/uniban </connection-url> <driver-class>com.mysql.jdbc.driver</driver-class> <user-name>root</user-name> <password>admin</password> </local-tx-datasource> </datasources> Copie o driver JDBC do MySQL para a pasta Configuração da Fonte de Dados %JBOSS_HOME%/server/default/lib 16

Crie o arquivo persistence.xml na pasta META-INF em seu projeto. Configuração do persistence.xml <persistence> <persistence-unit name="teste"> <jta-data-source>java:/testeds</jta-data-source> <properties> <property name="hibernate.hbm2ddl.auto" value="update"/> </properties> </persistence-unit> </persistence> 17

Crie o arquivo build.xml na pasta raiz do seu projeto. Criação do arquivo de build <?xml version="1.0"?> <project name="exemploalunoejb" default="ejbjar" basedir="."> <property environment="env"/> <property name="src.dir" value="${basedir}"/> <property name="jboss.home" value="${env.jboss_home}"/> <property name="build.dir" value="${basedir}/build"/> <property name="build.classes.dir" value="${build.dir}/classes"/> <!-- Local onde estão as classes persistentes --> <property name="modelo" value="/javaprog/projetojpa/modelo"/> 18

<!-- Construção do classpath --> <path id="classpath"> <fileset dir="${jboss.home}/server/default/lib"> <include name="*.jar"/> </fileset> <fileset dir="${jboss.home}/server/default/deploy/ejb3.deployer"> <include name="*.jar"/> </fileset> <fileset dir="${jboss.home}/server/default/deploy/jboss-aop-jdk50.deployer"> <include name="*.jar"/> </fileset> <fileset dir="${jboss.home}/lib"> <include name="*.jar"/> </fileset> <fileset dir="${modelo}"> <include name="*.class"/> </fileset> <pathelement location="${build.classes.dir}"/> </path> <property name="build.classpath" refid="classpath"/> 19

<!-- Prepara o diretório de build --> <target name="prepare" > <mkdir dir="${build.dir}"/> <mkdir dir="${build.classes.dir}"/> <mkdir dir="${build.classes.dir}/modelo"/> <copy file="${modelo}/aluno.class" todir="${build.classes.dir}/modelo"/> </target> <!-- Compila os arquivos de código fonte --> <target name="compile" depends="prepare"> <javac srcdir="${src.dir}" destdir="${build.classes.dir}" debug="on" deprecation="on" optimize="off" includes="**"> <classpath refid="classpath"/> </javac> </target> 20

<!-- Cria o arquivo jar e o implanta no servidor de aplicações--> <target name="ejbjar" depends="compile"> <jar jarfile="build/alunoejb.jar"> <fileset dir="${build.classes.dir}"> <include name="modelo/*.class"/> <include name="negocio/ejb/*.class"/> </fileset> <fileset dir="${basedir}/"> <include name="meta-inf/persistence.xml"/> </fileset> </jar> <copy file="build/alunoejb.jar" todir="${jboss.home}/server/default/deploy"/> </target> <!-- Executa o cliente --> <target name="run.client" depends="ejbjar"> <java classname="cliente.clientealunoejb" fork="yes" dir="."> <classpath refid="classpath"/> </java> </target> </project> 21

Abra uma janela do prompt de comando. Mude o diretório corrente para a pasta raiz do seu projeto. Implante a aplicação digitando o comando. > ant Inicie o servidor de aplicações JBoss executando o arquivo run.bat na pasta %JBOSS_HOME%/bin Execute o cliente remoto digitando o comando > ant run.client 22