Baixe o app para aproveitar ainda mais
Prévia do material em texto
2016 Programação Para Web II Prof. Cristiano Roberto Franco Copyright © UNIASSELVI 2016 Elaboração: Prof. Cristiano Roberto Franco Revisão, Diagramação e Produção: Centro Universitário Leonardo da Vinci – UNIASSELVI Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri UNIASSELVI – Indaial. Impresso por: 005.276 F825p Franco, Cristiano Roberto Programação Web II / Cristiano Roberto Franco. Indaial : UNIASSELVI, 2016. 192 p. : il. ISBN 978-85-7830-950-3 1.Programação para internet. I. Centro Universitário Leonardo Da Vinci. III aPresentação O mundo mudou! Enquanto você lê esse texto, muito provavelmente na tela de seu computador desktop, notebook ou dispositivo móvel, milhões de pessoas ao redor do globo estão trafegando dados digitalmente transformados na autoestrada da informação conhecida como internet. Você não usa mais essa autoestrada somente para estudar e trabalhar, você a usa para comprar, viajar, ouvir música, ver TV, filmes e seriados, fazer operações bancárias, pagar contas, falar com amigos e familiares distantes, namorar e até mesmo para compartilhar com o mundo que você fez uma omelete no café da manhã. E você quer poder fazer tudo isso a qualquer hora e de qualquer lugar. Tamanha conectividade é possível, mas não vem de graça. Ela cobra um preço caro. Além de antenas, redes, roteadores e demais dispositivos físicos (que não são o objeto desta disciplina e por isso não serão abordados), você precisa de software que possa atender a essa demanda voraz por informação. E não é qualquer software... conforme a lei de Moore vai chegando ao seu limite, decidimos por outras estratégias para ampliar o desempenho dos computadores e consequentemente do software que executa neles. Processadores multicores, virtualização, computação em grid e cloud são apenas alguns dos artifícios que usamos para garantir o desempenho das aplicações. Porque no final das contas, sempre que você compra, viaja, ouve música, vê TV, filmes e seriados e compartilha com o mundo que fez uma omelete no café da manhã, você o faz através de uma aplicação. É nesse contexto que atua a tecnologia que estudaremos nesta disciplina. A plataforma Java nos apresenta o Java Enterprise Edition (JEE), especialmente desenvolvido e planejado para ambientes com grande demanda por desempenho e robustez. É a mesma tecnologia que dá vazão a alguns dos serviços mais conhecidos e utilizados da internet, como Twitter, Linkedin e Netflix. Destaque especial para o fato de que, em momentos de pico, o Netflix concentra 37% de todo o tráfego de internet da América do Norte (TODD, 2015). Conforme Evans et al. (2011), os desenvolvedores de software reconhecem cada vez mais a necessidade de aplicações que sejam distribuídas, transacionais, portáveis e que permitam alavancar o desempenho, segurança e confiabilidade das tecnologias server-side. Para atender à crescente demanda, as tecnologias devem permitir que estas aplicações sejam projetadas e construídas mais rapidamente, com menos recursos computacionais e menor custo. Parece inacreditável, mas não... é simplesmente a evolução de uma tecnologia aberta que já existe há aproximadamente 20 anos e que conta com o feedback intenso do Java Community Process para definir seus rumos e roadmap. IV Apesar de o JEE ter como um dos focos principais a facilidade de desenvolvimento, a complexidade intrínseca do ambiente para o qual foi projetado e o número de tecnologias envolvidas o tornam relativamente denso. Tenha em mente que você não está estudando uma tecnologia para fazer um “sitezinho para seu tio que tem uma quitanda”, mas sim para construir aplicações distribuídas, robustas, portáveis e seguras. Lembre-se de que você não está sozinho nesta jornada. O meu trabalho ao longo deste caderno é tentar facilitar ao máximo a compreensão das tecnologias envolvidas no JEE. Para atingir tal objetivo, farei uso de exemplos pequenos e simples na demonstração de cada tecnologia, combinando-os em um exemplo maior e mais complexo como autoatividade no final de cada seção. Tal metodologia de ensino e aprendizagem é sugerida por Nicholas Negroponte do MIT Media Lab, em seu artigo Learning by Doing: Don´t dissect the frog. Built it (NEGROPONTE, 2004). Aproveito esse momento para destacar que os exercícios NÃO SÃO OPCIONAIS. O objetivo de cada exercício deste caderno é a fixação de determinado conceito através da prática. É aí que reside a importância da realização de todos. Sugerimos fortemente que em caso de dúvida em algum exercício você entre em contato com seu tutor externo ou com a tutoria da Uniasselvi e que não passe para o exercício seguinte enquanto o atual não estiver completamente compreendido. Aprender a programar utilizando a tecnologia JEE sem exercitar os conceitos de forma prática, somente com a leitura do caderno, é equivalente a ir a um restaurante e tentar matar a fome lendo o cardápio. Instruções detalhadas de como preparar o ambiente para a resolução dos exercícios em seu computador são mostrados na Unidade 1. Você precisará de muita determinação e força de vontade, pois o conteúdo abordado neste caderno não é fácil e você levará mais do que um semestre para compreendê-lo totalmente, entretanto, aqui forneceremos um início sólido e consistente. Desta forma, passe por esse período de estudos com muita dedicação, pois você que hoje é acadêmico(a), amanhã será um profissional de Tecnologia da Informação com o compromisso de construir uma nação melhor. Lembre-se de que o encantamento com a programação deriva do seu entendimento; a beleza desta área do conhecimento é a compreensão da lógica envolvida na construção de programas. Por isso, bons programadores são apaixonados por linguagens de programação e ambientes de desenvolvimento e estão sempre buscando novos conhecimentos. Como disse Drew Houston, criador do DropBox: “Programar é a coisa mais parecida que temos com superpoderes”. Bons códigos! Prof. Cristiano Roberto Franco V Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto para você que está chegando agora à UNIASSELVI quanto para você que já é veterano, há novidades em nosso material. Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é o material base da disciplina. A partir de 2017, nossos livros estão de visual novo, com um formato mais prático, que cabe na bolsa e facilita a leitura. O conteúdo continua na íntegra, mas a estrutura interna foi aperfeiçoada com nova diagramação no texto, aproveitando ao máximo o espaço da página, o que também contribui para diminuir a extração de árvores para produção de folhas de papel, por exemplo. Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente, apresenta também este livro no formato digital. Assim, você, acadêmico, tem a possibilidade de estudá-lo com versatilidade nas telas do celular, tablet ou computador. Eu mesmo, UNI, ganhei um novo layout, você me verá frequentemente e surgirei para apresentar dicas de vídeos e outras fontes de conhecimento que complementam o assunto em questão. Todos esses ajustes foram pensados a partir de relatos que recebemos nas pesquisas institucionais sobre os materiais impressos, para que você, nossa maior prioridade, possa continuar seus estudos com um material de qualidade. Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de Desempenho de Estudantes – ENADE. Bons estudos! NOTA VI VII UNIDADE 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION ............................................... 1 TÓPICO 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS ................................................................................................................3 1 INTRODUÇÃO ..................................................................................................................................... 3 2 PRINCIPAIS TECNOLOGIAS ........................................................................................................... 7 2.1 A ARQUITETURA DOS CONTAINERS ...................................................................................... 9 RESUMO DO TÓPICO 1........................................................................................................................ 11 AUTOATIVIDADE ................................................................................................................................. 12 TÓPICO 2 – CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT .... 13 1 INTRODUÇÃO ..................................................................................................................................... 13 1.1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO – WILDFLY ................................................ 13 2 INSTALAÇÃO DO NETBEANS ........................................................................................................ 19 3 INTEGRAÇÃO WILDFLY-MYSQL ................................................................................................... 22 4 INTEGRAÇÃO GLASSFISH-MYSQL ............................................................................................... 26 RESUMO DO TÓPICO 2........................................................................................................................ 34 AUTOATIVIDADE ................................................................................................................................. 35 TÓPICO 3 – JAVA SERVER FACES (JSF) ........................................................................................... 37 1 INTRODUÇÃO ..................................................................................................................................... 37 2 CRIAÇÃO DA PRIMEIRA APLICAÇÃO ........................................................................................ 39 3 CICLO DE VIDA E ESCOPOS DO JSF ............................................................................................ 46 LEITURA COMPLEMENTAR ............................................................................................................... 53 RESUMO DO TÓPICO 3........................................................................................................................ 57 AUTOATIVIDADE ................................................................................................................................. 58 UNIDADE 2 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES E JAVA PERSISTENCE API ....................................................................................................... 59 TÓPICO 1 – COMPONENTES GRÁFICOS DO JAVA SERVER FACES ....................................... 61 1 INTRODUÇÃO ..................................................................................................................................... 61 2 COMPONENTES DE FORMULÁRIO ............................................................................................. 61 3 TABELAS ................................................................................................................................................ 73 4 SUPORTE NATIVO A AJAX .............................................................................................................. 78 5 ADICIONANDO UMA BIBLIOTECA EXTERNA DE COMPONENTES VISUAIS .............. 80 RESUMO DO TÓPICO 1........................................................................................................................ 90 AUTOATIVIDADE ................................................................................................................................. 91 TÓPICO 2 – JAVA PERSISTENCE API ............................................................................................... 93 1 INTRODUÇÃO ..................................................................................................................................... 93 2 MAPEAMENTO OBJETO RELACIONAL ...................................................................................... 94 2.1 ARQUITETURA DO DATA ACCESS OBJECT ............................................................................ 96 sumárIo VIII 3 JAVA PERSISTENCE API (JPA) ......................................................................................................... 98 4 CONCEITOS E INTERFACES DO JPA ............................................................................................ 99 4.1 MAPEAMENTO DE ENTIDADES .............................................................................................100 4.2 RELACIONAMENTOS ENTRE ENTIDADES ..........................................................................111 LEITURA COMPLEMENTAR .............................................................................................................114 RESUMO DO TÓPICO 2......................................................................................................................125 AUTOATIVIDADE ...............................................................................................................................127 UNIDADE 3 – ENTERPRISE JAVA BEANS (EJB) E CONTEXT AND DEPENDENCY INJECTION (CDI) ........................................................................................................129 TÓPICO 1 – STATELESS SESSION BEANS ....................................................................................131 1 INTRODUÇÃO ...................................................................................................................................131 2 STATELESS SESSION BEANS ...........................................................................................................132 2.1 EJB 3.0 ..............................................................................................................................................132 2.2 EJB 3.1 ..............................................................................................................................................134 2.3 TESTANDO O EJB .........................................................................................................................135 2.4 CICLO DE VIDA ............................................................................................................................138 2.5 ESCALABILIDADE, POOL E CALL-BACKS .............................................................................139 2.6 MÉTODOS ASSÍNCRONOS ........................................................................................................140 RESUMO DO TÓPICO 1......................................................................................................................142 AUTOATIVIDADE ...............................................................................................................................143 TÓPICO 2 – STATEFUL SESSION BEAN E SINGLETON SESSION BEANS ..............................145 1 INTRODUÇÃO ...................................................................................................................................145 2 STATEFULL SESSION BEANS 3.0 ....................................................................................................146 3 STATEFULL SESSION BEANS 3.1 ..................................................................................................147 3.1 CICLO DE VIDA DOS STATEFULL SESSION BEANS ............................................................147 3.2 CALLBACKS....................................................................................................................................150 4 SINGLETON SESSION BEANS ........................................................................................................1504.1 CICLO DE VIDA ............................................................................................................................152 RESUMO DO TÓPICO 2......................................................................................................................154 AUTOATIVIDADE ...............................................................................................................................155 TÓPICO 3 – CONTEXT AND DEPENDENCY INJECTION ...........................................................157 1 INTRODUÇÃO ...................................................................................................................................157 2 PRODUCER METHODS E ATTRIBUTES .......................................................................................158 3 EXPRESSION LANGUAGE (EL) NAME .........................................................................................159 4 ESCOPOS E CONTEXTOS ...............................................................................................................160 RESUMO DO TÓPICO 3......................................................................................................................162 AUTOATIVIDADE ...............................................................................................................................163 TÓPICO 4 – JAVA MESSAGE SERVICE (JMS)............................................................................... 165 1 INTRODUÇÃO ...................................................................................................................................165 2 FILAS E TÓPICOS ..............................................................................................................................165 3 MODOS DE RECEBIMENTO .....................................................................................................169 LEITURA COMPLEMENTAR .............................................................................................................173 RESUMO DO TÓPICO 4......................................................................................................................183 AUTOATIVIDADE ...............................................................................................................................184 REFERÊNCIAS .......................................................................................................................................185 1 UNIDADE 1 INTRODUÇÃO AO JAVA ENTERPRISE EDITION OBJETIVOS DE APRENDIZAGEM PLANO DE ESTUDOS Ao final desta unidade, você será capaz de: • identificar e descrever algumas das tecnologias que fazem parte da especificação JEE; • identificar quais tipos de situações e ambientes são mais adequados para a utilização de tais tecnologias; • montar um ambiente de desenvolvimento e deployment de aplicações JEE usando a IDE Eclipse e o Servidor de Aplicações WildFly. Esta unidade de ensino está dividida em três tópicos, sendo que no final de cada um deles, você encontrará atividades que contribuirão para a apropriação dos conteúdos. TÓPICO 1 – INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS TÓPICO 2 – CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E DEPLOYMENT TÓPICO 3 – JAVA SERVER FACES (JSF) 2 3 TÓPICO 1 UNIDADE 1 INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS 1 INTRODUÇÃO O Java Enterprise Edition (JEE) inicialmente evoluiu como uma plataforma de desenvolvimento para aplicações enterprise que focava em robustez, webservices e facilidade. Continuamente moldado através do feedback fornecido pelo Java Community Process (JCP), o JEE hoje representa um padrão universal para TI empresarial, facilitando o desenvolvimento, instalação e gerenciamento de aplicações multi-tier e server-centric. O sucesso na adoção da plataforma é inegável. Em maio de 2013, os componentes JEE6 da Oracle e outros fornecedores já contabilizavam 50 milhões de downloads (ORACLE, 2014). O JCP é o mecanismo através do qual são definidas as especificações técnicas para a tecnologia Java. Ele é aberto para a participação de qualquer pessoa. Maiores detalhes em: <https://www.jcp.org/>. IMPORTANT E Conforme Evans et al. (2011), o modelo de aplicação do JEE começa com a linguagem de programação Java e a Java Virtual Machine. A já conhecida e comprovada portabilidade, segurança e produtividade no desenvolvimento que ela oferece formam a base deste modelo. A plataforma JEE é projetada para suportar aplicações que possuem elevado grau de complexidade, acessando dados das mais variadas fontes e atendendo a um grande número de clientes e requisições. Sua arquitetura facilita o gerenciamento da escalabilidade, pré-requisito para ambientes corporativos de alto desempenho. Esta arquitetura divide o trabalho em duas partes: 1) A lógica de negócio e apresentação: implementadas pelo desenvolvedor. 2) Os serviços-padrão que tais aplicações necessitam: ofertadas pela plataforma JEE através do servidor de aplicações. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 4 A Figura 1 apresenta uma arquitetura JEE típica: FIGURA 1 - ARQUITURA JEE TÍPICA FONTE: Evans et al. (2011) Para compreender a figura, inicialmente é necessária a compreensão do conceito de tier (camada lógica) e de layer (camada física). Tanto a tier quanto a layer podem ser definidas como um conjunto de tecnologias que representa um conceito que faz parte da aplicação. A tier é sempre composta por software, ou seja, é lógica. A layer é sempre composta por hardware, ou seja, é física. No caso da figura, temos quatro tiers e três layers: 1) Client Tier: representa a camada cliente, ou seja, o que os usuários efetivamente acessam da aplicação. Perceba que a figura a define com duas tecnologias: a aplicação cliente, normalmente uma aplicação desktop desenvolvida com Swing ou JavaFX, e as páginas web, acessadas através de um navegador. Ambas as tecnologias estão no layer representado pela máquina do usuário, ou seja, o computador onde ele acessa a aplicação. 2) Web Tier: representa a camada responsável por fazer a ligação entre as páginas web e a lógica de negócio, representada aqui pela tecnologia Java Server Faces (JSF). Em alguns casos, esta camada é dispensável. Perceba que na figura, as aplicações clientes acessam a lógica de negócio diretamente, sem esse intermédio. Esta camada poderia ainda ser representada por tecnologias como TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS 5 Servlets e Java Server Pages, que não fazem parte do escopo deste caderno. Se considerarmos a layer, esta parte fica alocada no JEEServer. 3) Business Tier: representa a lógica de negócios da aplicação, aqui implementada em Enterprise Beans individuais para a aplicação cliente e para as páginas web. Em termos de layer, ainda estamos no JEEServer. 4) Enterprise Information Server (EIS) Tier: representa as fontes de dados que as aplicações acessam através da business tier, normalmente um SGBDR. Esta fonte de dados também pode ser alguma aplicação legada já existente no ambiente corporativo. Agora estamos na layer Database Server. É importante mencionar alguns detalhes a respeito destas definições. A Web Tier pode ser implementada em Servlet Containers, que são uma espécie de “mini” servidores de aplicação mais leves e ágeis, entretanto não disponibilizam todos os serviços dos servidores de aplicação. O Apache Tomcat é um exemplo de Servlet Container. Em muitas situações, é mais produtivo desenvolver aplicações somente com Servlet Containers, colocando a lógica de negócio em Plain Old Java Objects (POJOs) do que acrescentar o peso de um servidor de aplicação com Enterprise Beans. É por este motivo que a layer JEEServer é dividida em Web Tier e Business Tier. Cada caso é um caso e deve ser avaliado pesando os prós e contras de cada tecnologia. É o eterno tradeoff da arquitetura de software. Outro detalhe importanteé que as layers, com exceção da Client Machine, podem ser todas implementadas em uma única camada física. É possível colocar o JEEServer (com ou sem Web Tier) e o DataBase Server em um único computador, embora isso não seja recomendado. A grande premissa por trás do JEE é que o desenvolvedor pode confiar na plataforma para facilitar a implementação destes serviços-padrão, normalmente representados por requisitos não funcionais. Como tudo na plataforma Java, o JEE é simplesmente uma especificação, ou seja, definições e documentos descrevendo como a tecnologia deve se comportar, além de padrões que devem ser obedecidos no desenvolvimento, definidos através do JCP. No caso do JEE, um dos componentes principais (se não o principal) é o servidor de aplicação. É este servidor de aplicação que encapsulará internamente os serviços que a plataforma oferece. Cabe ao desenvolvedor utilizá-los através das tecnologias definidas para tal. Como exemplos de implementações desta especificação podemos citar o Jboss, o WildFly e o GlassFish. O Swing e o JavaFX são tecnologias definidas pela Oracle para a criação de interfaces em aplicações Desktop. Maiores detalhes podem ser encontrados em: <http:// docs.oracle.com/javase/8/javase-clienttechnologies.htm>. IMPORTANT E UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 6 Mas que serviços são estes? Com o advento e popularização da internet e das tecnologias móveis, o número de usuários aumentou exponencialmente. Para atender à estas demandas, diversos requisitos não funcionais passaram a ter uma importância ainda maior para estas aplicações. Termos como escalabilidade, segurança, gerenciamento do ciclo de vida de objetos, remotabilidade, controle de transações, entre outros, vieram a fazer parte do dia a dia dos desenvolvedores. Ou seja, se transformaram em preocupações para os desenvolvedores, que agora não escrevem código somente para lidar com a lógica de negócios e os requisitos funcionais. Algumas das tecnologias disponibilizadas pelo JEE permitem que o desenvolvedor simplesmente sinalize em seu código aspectos relacionados à segurança, remotabilidade, transações etc., e o servidor de aplicações faz todo o resto. Isto libera o desenvolvedor para fazer mais o que realmente é importante: escrever código relacionado às necessidades do usuário e a lógica do negócio. De acordo com ORACLE (2013), o modelo simplificado de programação do JEE faz com que os descritores de deployment em XML sejam opcionais. Ao invés disso, o desenvolvedor pode colocar uma informação diretamente no código fonte através das annotations e o servidor irá configurar o componente em tempo de execução. Estas annotations em geral servem para embutir no programa dados que serial de outra forma fornecidos em um deployment descriptor. Com as annotations, você pode colocar a especificação do serviço do servidor ao lado do código que será afetado por ele. Abaixo estão listados alguns dos serviços disponibilizados pelas tecnologias envolvidas na plataforma K19 (2013). • Transações: A arquitetura Enterprise Java Beans (EJB) define um suporte sofisticado para utilização de transações. Esse suporte é integrado com a Java Transaction API (JTA) e oferece inclusive a possibilidade de realizar transações distribuídas. • Segurança: Suporte para realizar autenticação e autorização de forma transparente. Os desenvolvedores das aplicações não precisam implementar a lógica de segurança, pois ela faz parte da arquitetura JEE. • Remotabilidade: Aplicações JEE podem ser acessadas remotamente através de diversos protocolos de comunicação. Consequentemente, é possível desenvolver aplicações clientes de diversos tipos. Por exemplo, aplicações EJB podem ser acessadas como Web Services. • Multithreading e Concorrência: A arquitetura JEE permite que as aplicações sejam acessadas por múltiplos usuários simultaneamente de maneira controlada para evitar problemas de concorrência. • Persistência: Facilidades para utilizar os serviços dos provedores de persistência que seguem a especificação JPA. • Gerenciamento de Objetos: Mecanismos de injeção de dependências e controle de ciclo de vida são oferecidos aos objetos de uma aplicação JEE. O mecanismo de controle de ciclo de vida pode garantir a escalabilidade de uma aplicação. TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS 7 • Integração: A arquitetura EJB é fortemente integrada com os componentes da plataforma Java EE. Podemos, por exemplo, facilmente integrar os recursos do JSF em uma aplicação EJB. Os enterprise java beans, conhecidos como EJBs fazem parte da especificação JEE e fornecem boa parte dos serviços da plataforma. Estudaremos detalhadamente esta tecnologia na Unidade 3 deste Caderno de Estudos. IMPORTANT E 2 PRINCIPAIS TECNOLOGIAS Como descrevemos anteriormente, o servidor de aplicação JEE tem como principal característica o oferecimento de serviços para as aplicações nele instalados. Serviços estes geralmente relacionados com requisitos não funcionais como escalabilidade, remotabilidade etc. Para cada um destes serviços existe uma ou mais tecnologias que, trabalhando individualmente ou em conjunto, abstraem o desenvolvedor de detalhes específicos da implementação do mesmo. A seguir faremos uma rápida introdução às principais tecnologias que compõem o JEE, conforme definido em ORACLE (2014), destacando as que serão abordadas neste Caderno de Estudos. Componentes JEE: As aplicações JEE são feitas de componentes. Estes componentes são unidades encapsuladas de software funcionais que fazem parte das aplicações. Cada componente possui suas próprias classes e arquivos e se comunica com outros componentes. A especificação JEE define os seguintes componentes: • Aplicação cliente e applets que executam no cliente. • Servlets, Java Server Faces e Java Server Pages como componentes que executam no servidor. • Enterprise Java Beans, como componentes de negócio que executam no servidor. Todos estes componentes são escritos na linguagem de programação Java e compilados da mesma forma como qualquer outro programa. A diferença é que estes componentes são “embutidos” dentro de aplicações que obedecem às especificações JEE e são, portanto, gerenciadas pelo servidor de aplicação. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 8 Java Server Faces (JSF): É um framework para a construção de aplicações web. Permite a utilização de classes Java como implementações de componentes HTML. Oferece validação de entrada, gerenciamento de eventos, conversão de dados entre componentes e objetos de domínio, configuração de navegação, controle do ciclo de vida dos objetos e a expression language (EL), que permite que componentes da interface gráfica conversem diretamente com o controlador. Java Persistence API (JPA): Apresenta uma solução para a persistência de objetos em ambientes relacionais, usando uma estratégia de mapeamento objeto relacional. A JPA também pode ser utilizada em aplicações não JEE fora do ambiente do servidor. Consiste de uma api de persistência, uma linguagem de query e metadados para mapeamento objeto relacional. Java Transaction API (JTA): Oferece uma inferface-padrão para a demarcação de transações. A arquitetura JEE possui auto commit como default para gerenciar commits e rollbacks dentro de transações. Isso significa que qualquer aplicação que está visualizando um dado que está sendo alterado verá o mesmo atualizado depois de cada operação de leitura ou escrita. Entretanto, caso sua aplicação realize duas operações de acesso a dados em bases diferentes que dependem uma da outra, você pode utilizar a JTA API para demarcar onde a transação inteira começa, termina ou mesmo execute um rollback. Nas tecnologias de bancos de dados, um rollback significa que o banco de dados pode voltar a determinado estado anterior, evitando que um erro seja propagado e mantido no mesmo. IMPORTANT E Context and Dependency Injection for JavaEE (CDI): Define um conjunto de serviços do JEE acessíveis via contexto. Projetado para uso com objetos que possuam estado, o CDI tem aplicações diversas, pois representa a injeção de recursos em uma classe através de annotations, garantindo a flexibilidade e o baixo acoplamento no desenvolvimento. Java Message Service API (JMS): Define um padrão de mensageria que permite que os componentes das aplicações JEE criem, enviem, recebam e leiam mensagens. Permite a comunicação distribuída de forma desacoplada, confiável e assíncrona. Java Authentication and Authorization Service (JAAS): É o serviço que permite a autenticação e autorização de um usuário específico ou de um grupo de usuários. Oferece uma maneira desacoplada para a definição de aspectos de TÓPICO 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION E PRINCIPAIS TECNOLOGIAS 9 segurança em uma aplicação JEE. O modelo do JEE permite que as restrições de segurança sejam definidas em tempo de deployment e torna as aplicações portáveis para uma vasta gama de implementações de diferentes fornecedores. As regras de controle de acesso são declarativas e definidas pelo desenvolvedor. Estas regras são interpretadas quando a aplicação é instalada no servidor, protegendo os desenvolvedores da complexidade da implementação de requisitos de segurança. O JEE permite ainda a utilização de mecanismos de segurança externos, como Active Directory e LDAP, por exemplo. A mesma aplicação pode fazer uso de diversos mecanismos de segurança sem nenhuma alteração no código fonte da mesma. Enterprise Java Beans (EJB): São componentes que possuem atributos e métodos para implementar lógica de negócios. Você pode pensar neles como um bloco de construção que pode ser utilizado individualmente ou em conjunto com outros beans para executar lógica de negócios na aplicação JEE. Os Enterprise Beans podem ser de dois tipos: • Session beans: representa uma conversação transiente com o cliente. Quando o cliente encerra a execução, o bean e seus dados são perdidos. • Message driven beans: combina características de um session bean e um ouvinte de mensagens, permitindo que um componente de negócios receba mensagens de forma assíncrona. 2.1 A ARQUITETURA DOS CONTAINERS Uma das vantagens do JEE é a possibilidade de utilizá-lo em aplicações de praticamente qualquer porte. Seu modelo desacoplado e flexível facilita a utilização somente dos componentes que fazem sentido para a aplicação. Para entender esta arquitetura, é importante entender de que forma o servidor de aplicação está dividido em containers. A figura a seguir ilustra o relacionamento entre os containers JEE. FIGURA 2 - RELACIONAMENTO ENTRE CONTAINERS FONTE: Oracle (2014) UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 10 Perceba que o JEE Server possui dois containers, o Web Container e o EJB Container. A compreensão do funcionamento destes dois containers é fundamental para que se faça bom uso dos serviços do servidor de aplicação e da plataforma JEE. Dentro do Web Container podemos perceber as tecnologias Java Server Faces e Servlet. Uma figura mais completa conteria ainda as Java Server Pages (JSP). Estas tecnologias representam uma forma de disponibilizar a aplicação através de um navegador web. Sem um webcontainer não é possível publicar páginas html, xhtml e outras, o que impede a criação de aplicações web. Caso sua aplicação seja mandatoriamente acessada através de um navegador, você precisará de um webcontainer. Já o EJB Container é responsável pelo gerenciamento dos Enterprise Java Beans. A maioria dos serviços referentes a requisitos não funcionais ficam sob encargo deste container. Em geral, o acesso aos dados é feito através dele, visto que a JTA não está disponível no Webcontainer. Já dissemos aqui que nada impede a colocação de regras de negócio em POJOs dentro do Webcontainer e mesmo de acessar dados através dele, é simplesmente uma questão de analisar os prós e os contras. No modelo da figura, os componentes Web interagem com os componentes EJB para a lógica de negócios e o acesso aos dados. Na figura, ainda existe o que é chamado de Client System, composto pelo Browser e pelo Application Client Container. Este componente representa a interface da aplicação com o cliente, seja pelo navegador, seja por uma aplicação Swing, JavaFX ou mesmo console. Perceba que o application client acessa os EJBs sem intermédio do Webcontainer. Chegando ao final deste tópico, onde fizemos a introdução da plataforma Java Enterprise Edition e das principais tecnologias que a compõem, você deve pensar “é muita coisa para estudar”. E realmente, você tem razão, se considerarmos todo o conjunto das tecnologias que compõem o JEE, o volume de APIs é imenso. Entretanto, analisando o escopo de nossa disciplina e deste caderno, nos concentraremos nas tecnologias mais importantes e que impactarão diretamente sua produtividade como desenvolvedor. Nosso objetivo não é esgotar o tema, e sim colocar você produzindo aplicações JEE com as principais tecnologias que a plataforma disponibiliza. Seu sucesso dependerá diretamente de seus estudos futuros, entretanto, aqui forneceremos um embasamento sólido. E então...que tal pôr nossas mãos à obra? Como disse Linus Torvalds, criador do sistema operacional Linux: “Talk is cheap... show me the code”. No próximo tópico aprenderemos como configurar e preparar o ambiente que dará suporte ao desenvolvimento JEE. Bons estudos! 11 Neste tópico você viu que: • O Java Enterprise Edition (JEE) inicialmente evoluiu como uma plataforma de desenvolvimento para aplicações enterprise que focava em robustez, webservices e facilidade. • A plataforma JEE é projetada para suportar aplicações que possuem elevado grau de complexidade, acessando dados das mais variadas fontes e atendendo a um grande número de clientes e requisições. • A tier é sempre composta por software, ou seja, é lógica. A layer é sempre composta por hardware, ou seja, é física. • A Web Tier pode ser implementada em Servlet Containers, que são uma espécie de “mini” servidores de aplicação mais leves e ágeis, entretanto não disponibilizam todos os serviços dos servidores de aplicação. • A grande premissa por trás do JEE é que o desenvolvedor pode confiar na plataforma para facilitar a implementação destes serviços padrão, normalmente representados por requisitos não funcionais. • Para cada um destes serviços existe uma ou mais tecnologias que, trabalhando individualmente ou em conjunto, abstraem o desenvolvedor de detalhes específicos da implementação do mesmo. • Algumas das tecnologias disponibilizadas pelo JEE permitem que o desenvolvedor simplesmente sinalize em seu código aspectos relacionados à segurança, remotabilidade, transações etc., e o servidor de aplicações faz todo o resto. • Uma das vantagens do JEE é a possibilidade de utilizá-lo em aplicações de praticamente qualquer porte. Seu modelo desacoplado e flexível facilita a utilização somente dos componentes que fazem sentido para a aplicação. RESUMO DO TÓPICO 1 12 1 Diferencie um servidor de aplicação de um webcontainer e forneça exemplos da aplicabilidade de ambos. 2 Explique detalhadamente e exemplifique a diferença entre uma layer e uma tier, no contexto de arquitetura de software. 3 Uma das vantagens da utilização de um AS que obedeça às especificações JEE é a disponibilização de serviços que antes eram implementados manualmente pelos desenvolvedores. Com vistas a isto, avalie a lista de serviços abaixo. I- Segurança através do JAAS. II- Mensageria através do JMS. III- Remotabilidade. IV- Componentização através do JTA. Agora assinale a alternativa que lista corretamente os serviços disponibilizados pelos servidores de aplicação JEE 7: a) I, II e III. b) II e III. c) I e III. d) II e IV. AUTOATIVIDADE 13 TÓPICO 2 CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT UNIDADE 1 1 INTRODUÇÃO 1.1 INSTALAÇÃO DO SERVIDOR DE APLICAÇÃO – WILDFLY Conforme vimosnos tópicos anteriores, para podermos desenvolver, implantar e testar aplicações que utilizem as tecnologias que fazem parte da especificação JEE, precisamos de um servidor de aplicação – application server (AS). Utilizaremos, neste caderno, o WildFly Application Server, conhecido anteriomente como JBoss. A Red Hat, empresa que desenvolve o AS, justifica a mudança dizendo que o nome WildFly representa melhor o software na atualidade, pois lembra leveza, agilidade e liberdade. A figura a seguir mostra o website do projeto. O projeto WildFly pode ser acessado através da URL: <http://wildfly.org>. NOTA Apesar de você poder fazer o download do software pelo website e instalação separadamente através do arquivo, utilizaremos aqui uma abordagem diferente: instalaremos através da própria Integrated Development Environment (IDE) Eclipse. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 14 FIGURA 3 - WEBSITE DO SERVIDOR DE APLICAÇÃO WILDFLY FONTE: O autor Inicialmente precisaremos fazer com que o Eclipse mostre a aba dos servidores, visto que passaremos a utilizá-la com bastante frequência. Na figura a seguir mostramos a aba dos servidores na IDE. FIGURA 4 - ABA SERVIDORES NO ECLIPSE FONTE: O autor Caso a aba não esteja aparecendo para você, é possível adicioná-la através da seleção do menu Window -> Show View -> Other. Você deve digitar a palavra server, de modo que esta opção fique acessível para seleção, conforme a figura a seguir. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 15 FIGURA 5 - SELEÇÃO DA ABA SERVERS NO ECLIPSE FONTE: O autor FONTE: O autor Uma vez que a aba está disponível, devemos clicar com o botão direito do mouse e selecionar a opção New - > Server. Esta ação abrirá um novo diálogo, onde devemos selecionar a opção destacada na Figura 6. A próxima tela traz os servidores disponíveis para instalação no Eclipse. Devemos selecionar a opção JbossAS Tools, confirmar todas as licenças e prosseguir com a instalação, conforme a Figura 7. Ao longo da instalação, algumas mensagens de aviso serão mostradas e ao final, você será solicitado para reiniciar a IDE. Finalize o procedimento e aguarde a reinicialização do Eclipse. FIGURA 6 - DEFINIÇÃO DE UM NOVO SERVER UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 16 FIGURA 7 - SELEÇÃO DO JBOSSAS TOOLS FONTE: O autor Ao concluir a instalação e reinicialização da IDE, na aba Servers, clique com o botão direito do mouse e selecione a opção New -> Server. No momento em que este caderno foi escrito, somente tínhamos a versão 8 do WildFly para instalar. Caso a versão 9 ou posteriores aparecem para você, selecione a última versão que for compatível com a o JEE 7. Esta informação está disponível no website do WildFly. Você deverá criar um novo runtime para o servidor, através das telas mostradas nas figuras 8 e 9. Você deve deixar a configuração exatamente como mostrado nas figuras, com exceção do Execution Environment, que deverá respeitar a versão do Java utilizada por você na IDE, e do caminho de instalação do servidor, ambas na Figura 9. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 17 FONTE: O autor FONTE: O autor FIGURA 8 - INSTALAÇÃO DO WILDFLY Ao final, pressione Finish e estaremos prontos para testar a instalação de nosso servidor de aplicação. Na aba Server do Eclipse, deverá aparecer o servidor que acabamos de instalar. Clique com o botão direito no mouse no servidor e selecione a opção Start. O tempo necessário para a inicialização do WildFly dependerá diretamente do desempenho de seu computador. Automaticamente, o Eclipse seleciona a aba Console e várias mensagens geradas pelo WildFly aparecerão na tela. É vital que você se habitue a observar atentamente o console quando for testar suas aplicações, pois as mensagens de erro aparecem nesta aba. FIGURA 9 - INSTALAÇÃO DO WILDFLY UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 18 Quando a inicialização do servidor encerrar, você deverá ver uma mensagem semelhante à destacada na Figura 10, indicando que o processo foi bem-sucedido. As mensagens acima da mensagem destacada e inclusive a versão e codinome do servidor podem variar, de acordo com o que foi selecionado e instalado nas etapas anteriores. FIGURA 10 - INICIALIZAÇÃO DO WILDFLY FONTE: O autor FONTE: O autor FIGURA 11 - PÁGINA INICIAL DO WILDFLY EXECUTANDO EM LOCALHOST Por fim, para testarmos se a instalação foi bem-sucedida, devemos digitar a seguinte URL no navegador: <http://localhost:8080>. O navegador deverá mostrar a seguinte página, que é a página inicial do WildFly, que está executando localmente na porta 8080, conforme a Figura 11. Caso você prefira utilizar uma IDE que já tenha o ambiente de Desenvolvimento completo embutido, pode utilizar o NetBeans, que já vem com uma implementação de referência da especificação JEE 7, conhecida como GlassFish. O procedimento para instalação do NetBeans será demonstrado a seguir. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 19 FONTE: O autor 2 INSTALAÇÃO DO NETBEANS O NetBeans é uma IDE desenvolvida pela Oracle que permite que você desenvolva aplicações desktop, web e mobile em Java, bem como aplicações com HTML5, JavaScript e CSS. A IDE possui ainda uma vasta gama de ferramentas para desenvolvedores PHP e C/C++. É gratuita, open source e tem uma grande comunidade de usuários e desenvolvedores ao redor do mundo (NETBEANS, 2015). Ela pode ser obtida através do endereço <https://netbeans.org/downloads/ index.html>, conforme a Figura 12. Neste endereço existem diversas versões para download, para diversos sistemas operacionais e em diversos idiomas. Você deve selecionar a opção destacada. FIGURA 12 - DOWNLOAD DO NETBEANS Essa versão possui diversas ferramentas embutidas, o que praticamente elimina a necessidade de configuração, além de dois servidores, o GlassFish e o Tomcat. Em nossa disciplina precisaremos do GlassFish, visto que o Tomcat não é um Application Server, mas sim um servlet container. Uma vez feito o download, podemos proceder com a instalação do NetBeans. O instalador da ferramenta é bem simples e, embora demore um pouco para concluir todo o processo, exige pouca interação por parte do usuário. Na Figura 13 podemos perceber uma janela informando quais softwares serão instalados em seu computador. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 20 FIGURA 13 - TELA DO INSTALADOR FONTE: O autor Caso deseje personalizar a instalação, retirando ou colocando itens, basta selecionar a opção “Personalizar”. Esta opção leva para a tela de configuração mostrada na Figura 14. Recomendamos que você mantenha todas as funcionalidades, com exceção do PHP e C/C++, que são completamente opcionais. O Tomcat deve ser selecionado pois, caso sua aplicação não utilize funcionalidades específicas de servidores de aplicação, ele representa uma opção mais leve e performática. Aprenderemos que funcionalidades específicas são essas ao longo do caderno. A última tela antes da instalação propriamente dita é mostrada na Figura 15. Basta selecionar a opção onde você diz que aceita os termos da licença e clicar em finalizar. O instalador procederá automaticamente com a cópia, descompactação e download dos arquivos necessários ao NetBeans. Lembramos que a versão da ferramenta poderá variar, dependendo de quando você fará a leitura do caderno e download da mesma. O importante é sempre manter-se em versões superiores à utilizada aqui, aumentando a probabilidade de compatibilidade. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 21 FIGURA 14 - CONFIGURAÇÃO DO INSTALADOR FONTE: O autor FIGURA 15 - CONTRATO DE LICENÇA FONTE: O autor Uma vez que a instalação foi concluída, ao abrir a IDE nos deparamos com a tela mostrada na Figura 16. Não é objetivo deste caderno a explicação das funcionalidades do NetBeans, visto que inclusive utilizaremos o Eclipse para o desenvolvimento de nossos exemplos. OEclipse é melhor em algumas atividades e o NetBeans em outras. Com o tempo e a utilização, você elegerá a sua favorita. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 22 FIGURA 16 - INTERFACE DO NETBEANS FONTE: O autor Tutoriais sobre o NetBeans podem ser acessados gratuitamente no endereço: <https://netbeans.org/kb/docs/java/quickstart-gui.html>. ATENCAO Para o desenvolvimento das aplicações, precisaremos estabelecer conexão com bancos de dados relacionais. A plataforma Java, através do JDBC e mais recentemente do JPA, permite a conexão com os principais players do mercado. Para facilitar o aprendizado e reduzir a configuração, trabalharemos com o banco de dados MySQL, que já foi utilizado por você em disciplinas anteriores. 3 INTEGRAÇÃO WILDFLY-MYSQL Conforme K19 (2013), aplicações Java se comunicam com banco de dados através de conexões JDBC. Para estabelecer uma conexão JDBC, algumas informações como usuário, senha e base de dados são necessárias. As configurações relativas às conexões JDBC podem ser definidas nas aplicações ou nos servidores de aplicação. Em um servidor de aplicação, as configurações JDBC são definidas em componentes chamados Data Sources. Os Data Sources permitem que uma única configuração JDBC seja utilizada por diversas aplicações. Eles TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 23 também permitem que outros tipos de configurações sejam compartilhadas, como por exemplo, a configuração de um Connection Pool. Além disso, através de Data Sources podemos utilizar facilmente o serviço de transações dos servidores de aplicação. Esse serviço é definido pela especificação Java Transaction API (JTA), que será abordada na Unidade 3 deste Caderno de Estudos. Inicialmente devemos fazer o download do driver jdbc para o MySQL, disponível em <http://dev.mysql.com/downloads/connector/j/>, conforme a Figura 17. É recomendável fazer o download do driver independente de plataforma, visto que ele funciona em qualquer sistema operacional. Uma vez que o download foi concluído, passamos para a integração do driver com o WildFly. Lembramos que a função do driver JDBC é estabelecer a comunicação entre o Sistema Gerenciador de Banco de Dados Relacional (SGBDR) e a plataforma Java, neste caso, representado pelo servidor de aplicações. FIGURA 17 - DRIVER JDBC FONTE: O autor O próximo passo consiste em copiar o driver para o diretório adequado dentro da instalação do WildFly. Inicialmente localize o diretório onde o WildFly está instalado e lá dentro, localize o diretório modules/com. Agora crie um diretório chamado mysql e, dentro deste, outro diretório chamado main. O driver MySQL deverá ser copiado para esta pasta recém criada. Crie também neste diretório um arquivo vazio chamado module.xml. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 24 FIGURA 18 - LOCAL DO DRIVER JDBC FONTE: O autor FONTE: O autor O conteúdo deste arquivo deverá ser igual ao da imagem abaixo, respeitando o nome do arquivo que você copiou para dentro da pasta após o atributo path, na linha 4. Este arquivo representará a instalação de um módulo adicional no WildFly. Ao encerrar, verifique o código fonte escrito com cuidado, salve e feche o arquivo. FIGURA 19 - ARQUIVO MODULE.XML A próxima (e última) etapa consiste na configuração do arquivo standalone.xml, disponível no caminho /standalone/configuration, no diretório de instalação do WildFly. Dentro deste arquivo, encontre a tag <datasources> e insira a configuração de um novo datasource e um novo driver, conforme mostrado na Figura 20. Caso já existam configurações para outros datasources e drivers, você não precisa excluí-los, uma vez que eles em geral servem como exemplo e o WildFly pode trabalhar com múltiplos datasources. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 25 Na Figura 20 podemos ainda perceber o nome de nosso datasource (java:/ MYSQL_DS), representado pelo número 1 e também o nome do módulo que instalamos no arquivo module.xml, representado pelo número 2. Outros aspectos importantes a serem destacados são o usuário e senha dentro da tag <security> e a url de conexão, dentro da tag <connection-url>. Estes valores deverão refletir a condição de seu SGBD. No caso deste exemplo, o usuário e senha do banco de dados são “root” e o nome da base de dados é JEE7. Faça as alterações de acordo com as configurações do MySQL instalado em seu computador. Ao encerrar, verifique o código fonte escrito com cuidado, salve e feche o arquivo. FIGURA 20 - CRIAÇÃO DO DATASOURCE FONTE: O autor FONTE: O autor Para podermos realizar os testes da configuração que acabamos de fazer, verifique se o MySQL está funcionando corretamente em seu computador, de outra forma, não podemos nos conectar com ele através do WildFly. Feita esta verificação, abra o Eclipse e encontre o WildFly na aba Servers, iniciando-o. Diversas mensagens aparecerão no console, sendo que ao final devemos encontrar a mesma mensagem que mostramos na Figura 10 desta unidade, o que demonstra que o servidor iniciou sem erros. A garantia de que o datasource foi configurado corretamente vem através de uma mensagem no console que mostra o nome de todos os datasources configurados para aquela instância do servidor de aplicação. No nosso caso, devemos buscar pelo nome java:/MYSQL_DS, conforme mostra a Figura 21. FIGURA 21 - CONFIGURAÇÃO DEMONSTRADA NO CONSOLE UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 26 4 INTEGRAÇÃO GLASSFISH-MYSQL Neste tópico, demonstraremos de que forma fazer a integração entre o MySQL e o Servidor de aplicações Glassfish através do NetBeans. Em nossos exemplos, o Netbeans está configurado para o idioma inglês, ao invés do português que é instalado automaticamente. Caso deseja trocar o idioma, o procedimento é demonstrado em: <http://www.frameworksystem.com/blog/alterando-a- linguagem-no-netbeans/>. ATENCAO Inicialmente, acesse a aba Services, demonstrada na Figura 22. Nesta aba, clique com o botão direito no mouse na opção Databases, selecionando New Connection. Selecionando esta opção, aparecerá uma janela que permitirá selecionar a qual banco de dados nos conectaremos. Selecione a opção MySQL e o próprio Netbeans sugerirá um driver, conforme a Figura 23. FIGURA 22 - INTEGRAÇÃO GLASSFISH-MYSQL FONTE: O autor TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 27 FIGURA 23 - MYSQL JDBC DRIVER FONTE: O autor Pressione o botão Next e preencha as configurações mostradas na Figura 24 de acordo com as configurações do MySQL instalado em seu computador. Ao finalizar as configurações, pressione o botão Test Connection e aguarde pela mensagem Conection Succeeded, indicando que o Netbeans encontrou o banco de dados e conseguiu se conectar. Antes de realizar o procedimento de teste da conexão, certifique-se de que o MySQL está funcionando corretamente em seu computador e de que o mesmo foi inicializado. ATENCAO UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 28 FIGURA 24 - CONFIGURAÇÃO DO MYSQL FONTE: O autor Existem algumas configurações adicionais, mas com o objetivo de simplificar o processo de configuração, podemos pressionar o botão Finish e aguardar o resultado demonstrado na Figura 25. O número 1 mostra a nova conexão com o banco MySQL através de sua adição às databases. O número 2 indica os Schemas ou databases disponíveis no banco de dados com o qual nos conectamos. Em seu computador, o número dois trará Schemas diferentes dos mostrados na Figura. Em nosso exemplo, a conexão foi renomeada para MYSQL_DS, selecionando a mesma com o botão direito e clicando na opção renomear. Este passo é opcional e não interferirá diretamente com o resto do procedimento. O importante é você conseguir encontrar a conexão que criou dentro do Netbeans. Seguindo este procedimento, você configurou uma nova conexão com o banco de dados MySQL diretamente através do Netbeans. Para fazer a configuração do datasourcee do pool de conexões, devemos acessar a interface de administrador do Glassfish, disponível na url <http://localhost:4848>, sem esquecer de antes inicializar o servidor dentro do Netbeans. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 29 FIGURA 25 - CONEXÃO COM O MYSQL FONTE: O autor Para inicializar o Glassfish, basta ir até a aba Services e escolher a opção Server. Dentre os servidores listados, clique com o botão direito do mouse no Glassfish e em seguinda na opção Start, conforme a Figura 26. Quando o servidor terminar seu processo de inicialização, você pode ir até o navegador web e digitar a URL supracitada. Pronto! Você agora está na interface de administração do Glassfish (Figura 27). Da mesma forma que no WildFly, existem inúmeras configurações que podem ser feitas para otimizar o desempenho e performance do servidor de aplicação, mas como este não é o objetivo desta disciplina, faremos as configurações mínimas necessárias para o funcionamento dos exemplos que utilizaremos. UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 30 FIGURA 26 - INICIALIZAÇÃO DO GLASSFISH FONTE: O autor FONTE: O autor FIGURA 27 - INTERFACE DE ADMINISTRAÇÃO DO GLASSFISH TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 31 FONTE: O autor Uma vez na interface de administração, selecione a opção JDBC/JDBC Connection Pools, onde criaremos o pool de conexões para nosso datasource. Um pool de conexões é uma espécie de cache de conexões com o banco de dados, mantidas de forma que possam ser reutilizadas quando futuras requisições forem feitas, otimizando recursos computacionais. A próxima tela lista todos os pools já existentes e, para criar um novo pool, clique no botão New. A Figura 28 mostra as configurações do primeiro passo para a criação do pool. Após preencher estas configurações, clique em Next. FIGURA 28 - CONFIGURAÇÃO DO POOL DE CONEXÕES Na tela seguinte existem vários campos que permitem configuração, mas para nossa finalidade, devemos alterar somente as propriedades adicionais listadas na Tabela 1: TABELA 1 - PROPRIEDADES DO POOL DE CONEXÕES FONTE: O autor Propriedade Valor user <usuário do seu banco de dados MySQL> ServerName localhost DatabaseName jee7 Password <senha do seu banco de dados MySQL> Url jdbc:mysql://localhost:3306/jee7 URL jdbc:mysql://localhost:3306/jee7 Para concluir o processo, clique em Finish e aguarde a criação do novo pool de conexões. Ao final, o Glassfish exibirá todos os pools de conexão disponíveis, entre os quais deverá estar o que você acabou de criar (Figura 29). UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION 32 FIGURA 29 - LISTAGEM DOS POOLS DE CONEXÃO FONTE: O autor Ao clicar no pool recém criado, você será levado a uma tela que permite o teste do mesmo através do botão Ping. Se o pool estiver funcionando, haverá uma mensagem informando que o ping foi bem sucedido (Figura 30). FIGURA 30 - TESTE DO POOL DE CONEXÕES FONTE: O autor Como último passo do processo, precisaremos criar o datasource propriamente dito. Ainda na interface de administração do Glassfish, selecione a opção JDBC/JDBC Resources. Nesta tela estão listados todos os datasources disponíveis no Glassfish. Para criar um novo, clique no botão New e preencha as configurações da tela seguinte conforme demonstrado na Figura 31. TÓPICO 2 | CONSTRUÇÃO DO AMBIENTE DE DESENVOLVIMENTO E EPLOYMENT 33 FIGURA 31 - CONFIGURAÇÃO DO DATASOURCE FONTE: O autor JNDI é o acrônimo de Java Naming and Directory Interface, cujo objetivo é permitir a busca de objetos de forma distribuída simplesmente através de um nome. Com essa tecnologia, o cliente abstrai totalmente os detalhes referentes à implementação do recurso que está sendo buscado. Maiores detalhes sobre o JNDI podem ser obtidos em: <http://docs.oracle.com/javase/tutorial/jndi/overview/>. ATENCAO Assim encerramos o processo de criação dos DataSources nos servidores de aplicação e IDEs que você poderá utilizar ao longo da disciplina. Agora estamos prontos para efetivamente pôr a “mão na massa” e começar a fazer os exercícios e criar nossas próprias aplicações utilizando JEE 7 e os servidores de aplicação WildFly e Glassfish. Caso você queira utilizar o Glassfish com o Eclipse ou o WildFly com o Netbeans, basta configurá-los da forma como demonstramos ao longo deste tópico. 34 RESUMO DO TÓPICO 2 Neste tópico você viu que: • De modo a podermos desenvolver, implantar e testar aplicações que utilizem as tecnologias que fazem parte da especificação JEE, precisamos de um servidor de aplicação - application server (AS). • Entre as principais opções estão o Wildfly Application Server, disponibilizado pela Red Hat e o GlassFish Application Server, disponibilizado pela Oracle. • Para desenvolver aplicações corporativas podemos utilizar o Netbeans ou o Eclipse, bastando configurá-lo para acessar o AS. • O servidor de aplicação disponibiliza serviços de persistência através de JDBC, JPA e JTA, havendo necessidade de configuração de fontes de dados (Datasources) para que os serviços funcionem. 35 1 Configure as duas IDEs (eclipse e netbeans) para trabalharem ambas com os servidores de aplicação GlassFish e WildFly: 2 Configure mais um datasource para cada servidor de aplicação, preferencialmente utilizando um banco de dados diferente do MySQL: 3 Encontre e descreva pelo menos mais três implementações de Servidores de Aplicação compatíveis com a especificação JEE 7. Estes servidores de aplicação podem ser tanto proprietários como open source. AUTOATIVIDADE 36 37 TÓPICO 3 JAVA SERVER FACES (JSF) UNIDADE 1 1 INTRODUÇÃO O Java Server Faces (JSF) é o framework padrão da plataforma Java para a construção de aplicações web com JEE. Ele define e implementa um modelo de componentes visuais para WEB, utilizando uma arquitetura MVC (model- view-controller). Esta arquitetura propõe a divisão das responsabilidades de uma aplicação em três camadas distintas (Figura 32): 1. View: responsável pela renderização da interface gráfica da aplicação. 2. Controller: responsável por receber e tratar os eventos da View. 3. Model: responsável pela implementação da lógica de negócios. FIGURA 32 - ARQUITETURA MVC FONTE: Disponível em: <http://stackoverflow.com/questions/29594105/mvc-is-it- model-to-view-or-controller-to-view>. Acesso em: 20 set. 2015. 38 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION Da mesma forma que as demais tecnologias que fazem parte da plataforma Java, o JSF é definido por uma especificação mantida pelo JCP através de JSRs. Ele define uma API padrão e extensível através de classes e interfaces, simplificando o desenvolvimento e aumentando a produtividade de aplicações em Java para Web. As principais funcionalidades que o JSF traz para uma aplicação web incluem (SOFTPLAN, 2015): • Gerenciamento do ciclo de vida dos componentes visuais e a responsabilidade na geração do HTML a partir deles. • Disponibilização de uma biblioteca de componentes visuais básicos análogos aos componentes HTML. • Suporte à templates de tela para reuso de estruturas de interfaces Web; • Desenvolvimento de componentes visuais personalizados; • Suporte embutido à ajax. • Validação, conversão e formatação de dados de formulários. • Tratamento de eventos entre telas Web. • Gerenciamento da navegabilidade da aplicação. O JSF funciona baseado em objetos que são mantidos em memória no servidor e que ficam responsáveis pela geração do HTML que será enviado ao navegador. Esta estratégia permite que os valores contidos nos componentes mantenham seu estado, permitindo sua recuperação mesmo após várias requisições. O objetivo desta arquitetura é a limitação imposta pela característica stateless do HTTP. A Figura 33, retirada de SOFTPLAN (2015), exemplifica o funcionamento do JSF. Imagine um cliente que faz uma primeira requisição para uma aplicação web em um AS. O JSF utiliza um arquivo no formato xHTML para descrever uma interface daaplicação. Quando o recurso representado por esse arquivo é solicitado, uma árvore de componentes é gerada no servidor e um HTML é enviado ao cliente. Para as próximas requisições a este recurso pelo mesmo cliente, o servidor utiliza a árvore já em memória para montar o HTML. Este processo faz parte do ciclo de vida do JSF. FIGURA 33 - ARQUITETURA DO JSF FONTE: SOFTPLAN, 2015 TÓPICO 3 | JAVA SERVER FACES (JSF) 39 2 CRIAÇÃO DA PRIMEIRA APLICAÇÃO Vamos agora demonstrar como criar uma pequena aplicação utilizando as capacidades básicas do JSF. Abra o Eclipse e selecione um projeto do tipo Dynamic Web Project, conforme a Figura 34. FIGURA 34 - CRIAÇÃO DO PROJETO NO ECLIPSE FONTE: O autor. A próxima etapa consiste em configurar o projeto de forma que ele permita a utilização das tecnologias que veremos ao longo do caderno. A Figura 35 ilustra a interface de configuração deste tipo de projeto. Os números 1, 2 e 3 destacam o nome do projeto, o AS que utilizaremos e quais APIs farão parte do projeto, respectivamente. Para o nome do projeto, você pode colocar o que achar mais adequado. O Servidor de Aplicação que utilizaremos será o mesmo que instalamos no tópico anterior, o WildFly. A configuração, entretanto, exige um pouco mais de cuidado. Clicando no botão modify, a imagem da Figura 36 permite que selecionemos somente as APIs que utilizaremos no projeto. Para o nosso projeto, selecione as mesmas APIs da figura e clique no botão OK. 40 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION FIGURA 35 - CONFIGURAÇÃO DO PROJETO FONTE: O autor. De volta a tela principal de configuração, prossiga clicando no botão Next até encontrar a tela mostrada na Figura 37. Esta é a tela de configuração da implementação para o JPA. Sugerimos configurar exatamente como mostrado na figura, pois embora não iremos utilizar JPA no primeiro exemplo, a configuração do mesmo neste momento nos poupará esforço futuro. Não se esqueça de configurar também a conexão com o MySQL. TÓPICO 3 | JAVA SERVER FACES (JSF) 41 FIGURA 36 - APIS UTILIZADAS FONTE: O autor. FIGURA 37 - CONFIGURAÇÃO DO JPA FONTE: O autor. 42 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION Prossiga pressionando o botão Next até se deparar com a tela mostrada na Figura 38. Esta tela configura a geração automática do arquivo beans.xml, necessário para se utilizar CDI. Mantenha a configuração como na figura e pressione o botão Finish. FIGURA 38 - CONFIGURAÇÃO DO CDI FONTE: O autor FONTE: O autor Pronto! A partir de agora utilizaremos este projeto para nossos exemplos. Para conferir se a criação foi feita corretamente, basta expandir o projeto recém-criado no Eclipse. A estrutura de diretórios deve ficar semelhante à mostrada na Figura 39. FIGURA 39 - ESTRUTURA DO PROJETO Para criar nosso primeiro JSF, clique com o botão direito do mouse no diretório WebContent e selecione a opção New XHTML Page. Dê o nome formulario.xhtml para a mesma e clique no botão Next. Na tela apresentada a seguir, mantenha a configuração mostrada na Figura a seguir e clique em Finish. Isso criará um template XHTML vazio para nossa aplicação. TÓPICO 3 | JAVA SERVER FACES (JSF) 43 FIGURA 40 - CONFIGURAÇÃO DO TEMPLATE XHTML FONTE: O autor O Eclipse gera um template vazio para uma página XHTML, entretanto, a importação das bibliotecas que contém os componentes visuais já está feita. Na Figura 41 podemos perceber a existência destas bibliotecas e sua efetiva utilização. Entre as linhas 2 e 5 são referenciadas URLs através dos prefixos ui, f e h. Estes prefixos servirão para utilizar os componentes visuais, de acordo com sua natureza. Isto pode ser percebido através do componente head que aqui ele é <h:head>, o que indica que a importação ocorrerá através da URL referenciado no prefixo h. O exemplo contendo o código fonte completo pode ser visualizado na Figura 42. A linha 1 foi removida para simplificar o exemplo. Da mesma forma que no HTML, os componentes visíveis ficam dentro da tag <body>. Na linha 11 criamos um formulário que contém um Label, um InputText e um Button, todos componentes visuais do JSF. O InputText é mapeado diretamente para um atributo do formularioMB e o Button é mapeado diretamente para um método do mesmo arquivo. No exemplo em questão, não faremos a criação do model e utilizaremos o controller para simular esta função. 44 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION Note que este mapeamento de um componente de formulário diretamente para um atributo e de um botão diretamente para um método aumenta muito a produtividade no desenvolvimento. Em algumas IDEs, é possível inclusive gerar Views e Controllers automaticamente a partir de classes de domínio. FIGURA 41 - IMPORTAÇÃO DAS BIBLIOTECAS FONTE: O autor FIGURA 42 - CÓDIGO FONTE DO ARQUIVO JSF FONTE: O autor Mas o que é o formularioMB? O JSF funciona através de uma arquitetura MVC, o que exige a presença de um intermediário entre o model e a view. Este intermediário é o controller, que no caso do JSF é chamado de Managed Bean (MB). Cabe ao MB mapear os componentes para o model, instanciar os objetos no lado do servidor e também reagir aos eventos gerados na view. O MB sempre é uma classe serializável com métodos getters e setters para permitir o acesso aos componentes visuais. A figura a seguir mostra o código-fonte de um MB. Inicialmente, a anotação named permite que o MB seja visualizado dentro dos arquivos XHTML. É por causa desta anotação que conseguimos referenciar métodos públicos e atributos do MB. A anotação @RequestScoped indica que o escopo do MB é de request, ou seja, os valores da árvore de objetos devem ser mantidos somente durante o request. TÓPICO 3 | JAVA SERVER FACES (JSF) 45 FIGURA 43 – CÓDIGO-FONTE DO MB FONTE: O autor Para este exemplo utilizamos uma String como o objeto de domínio, para fins de simplificação. Na verdade, o MB segue a convenção Java Bean: métodos getters e setters para todos os atributos, um construtor vazio e a implementação da interface Serializable. O método executar serve simplesmente para ilustrarmos o funcionamento do botão. Para criar esta classe, expanda o diretório Java Resources de seu projeto e clique com o botão direito do mouse no diretório src. Selecione a opção Java Class e copie o código-fonte contido na imagem do MB. Atenção para o nome do pacote, pois o utilizaremos nos exemplos posteriores. Uma vez que a classe esteja pronta, clique com o botão direito do mouse no arquivo formulario.xhml e selecione a opção Run on Server. 46 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION FIGURA 44 - DEPLOYMENT E EXECUÇÃO DO PROJETO FONTE: O autor FONTE: O autor Ao seguir este procedimento, a aplicação então é exibida no navegador interno do Eclipse. Ao testá-la, podemos ver mensagens sendo exibidas no console do AS. 3 CICLO DE VIDA E ESCOPOS DO JSF Para entendermos de que forma o JSF se comporta na questão da árvore de objetos em memória, e consequentemente extrairmos o máximo da tecnologia, é essencial entender o ciclo de vida e os escopos do JSF. FIGURA 45 - TESTE DA APLICAÇÃO JSF TÓPICO 3 | JAVA SERVER FACES (JSF) 47 Conforme SOFTPLAN (2015), o ciclo de vida do JSF é simplesmente a sequência dos passos que o Front Controller do JSF executa ao receber uma requisição de um cliente, conforme descrito a seguir: 1. O primeiro passo é a restauração da árvore de componentes. Caso seja o primeiro acesso daquele cliente, o JSF cria a árvore de acordo com a descrição do arquivo .xhtml. Caso não seja o primeiro acesso, a árvore é recuperada da memória no servidor. 2. O segundo passo é a extração dos valores de campos de formulários vindos com a requisição e atribuição dos mesmos aos respectivos componentes dentro da árvore, atualizando-os. Neste momento ocorre também a conversão dos dados. 3. O terceiro passo consiste na validação dos valores dos componentes que possuírem regras de validação associadas. Por exemplo, um campoobrigatório que é submetido sem nenhum valor ou um campo numérico que vem com um valor alfanumérico. Neste passo, caso alguma das validações não seja bem sucedida, o JSF interrompe seu ciclo de vida retornando para o navegador do usuário com uma mensagem de erro. 4. Caso a validação seja bem sucedida, o próximo passo é atualizar os valores dos campos dentro do Managed Bean. Neste momento, todos os métodos setters dentro do MB serão invocados. 5. Neste passo os métodos associados a ações de botões são executados dentro do MB. 6. Aqui o JSF gera o HTML a ser enviado para o usuário com base na árvore de componentes. Antes disso, os valores dos componentes são extraídos do MB, através da invocação de todos os métodos getters. Quando o processo encerra, o HTML é finalmente enviado ao navegador. O Front Controller é um padrão de projeto relacionado a aplicações web. Consiste basicamente de um ponto central de entrada que gerencia as requisições de usuários. É o que ocorre com o JSF. Maiores detalhes podem ser obtidos em: <http://www. martinfowler.com/eaaCatalog/frontController.html>. ATENCAO Faremos a seguir algumas modificações em nosso exemplo anterior que permitirão a compreensão deste mecanismo. A primeira etapa já está pronta e consiste na impressão de uma mensagem no momento em que o construtor vazio do MB é invocado. Colocaremos mensagens ainda dentro do método getNome() e do método setNome(), conforme ilustrado na Figura 46. 48 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION Agora faremos novamente a publicação da aplicação, clicando com o botão direito do mouse sobre o arquivo formulario.xhtml e selecionando a opção Run As->Run On Server. Essa ação permitirá a visualização das alterações em nosso exemplo. FIGURA 46 - O CICLO DE VIDA DO JSF FONTE: O autor Na Figura 47, podemos perceber que a aplicação carregou normalmente no navegador, mas o importante é conseguir observar as mensagens do console. Neste caso, o construtor do MB foi invocado e também o método getter. É possível ainda notar que duas instâncias do MB são criadas, ao invés de somente uma. O motivo para tal comportamento será explicado na Unidade 3 deste Caderno de Estudos. Mas por que o valor de nome é igual a null? Isso ocorre devido ao próprio ciclo de vida do JSF, onde o MB é instanciado e, como esta é a primeira requisição, a árvore de componentes deve ser montada com base no arquivo xhtml e alocada na memória. O último passo antes de renderizar o HTML é atribuir os valores do MB aos componentes visuais. Como nosso MB não possui nenhum valor, o getNome aparece retornando null. TÓPICO 3 | JAVA SERVER FACES (JSF) 49 FONTE: O autor FIGURA 47 - CICLO DE VIDA DO JSF Mas o que acontece quando colocamos um valor para Nome e clicamos em executar? Faça o teste em sua aplicação que eu explicarei os resultados obtidos aqui. Depois da primeira requisição, ciclo de vida do JSF é executado sempre da mesma forma, como podemos avaliar observando a Figura 48. Cada número indica um passo do ciclo de vida. A linha destacada pelo número 1 ilustra a criação de uma nova instância do MB, enquanto a linha 2 trata da busca da árvore dos componentes visuais e dos valores dos atributos do MB. Por enquanto o nome continua nulo. Na linha destacada pelo número 3, os métodos setters do MB são invocados e, como agora possuímos o valor “Catarina” no componente associado ao nome, o MB recebe este valor. O número 4 mostra as duas linhas que são impressas ao invocarmos o método executar. Lembre- se de que a ação que efetivamente faz essa invocação é o clique no botão. Por fim, o número 5 trata da renderização dos componentes em HTML para envio ao navegador. Neste passo, o valor dos componentes é atualizado com o valor existente no atributo do MB associado através da expression language. 50 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION FIGURA 48 - CONTINUAÇÃO DO CICLO DE VIDA JSF FONTE: O autor Cada vez que você clicar no botão Executar, uma nova instância de FormularioMB é criada e o getNome retornará null. Este comportamento é característico da annotation @RequestScoped, onde uma nova instância de FormularioMB é criada a cada requisição do usuário. Esta anotação define que o tempo de vida deste objeto é marcado pela requisição do usuário. Outro escopo existente é o SessionScope, onde o tempo de vida do MB é marcado pela sessão do usuário. Caso nenhuma configuração adicional seja feita, o MB se mantém desde pressionarmos o botão até fecharmos o navegador. Este tipo de escopo é interessante para guardar uma sessão de login do usuário, garantindo que ele tenha passado por uma página e se identificado antes de acessar a parte protegida de uma aplicação. Você já deve ter visto aplicações web onde o tempo de sessão é definido em minutos, para aumentar a segurança. Em geral, este tipo de configuração é utilizado em aplicações de Home Banking e cartões de crédito. Na figura a seguir demonstramos como alterar o escopo de nosso MB para Session. Basta alterar a annotation @RequestScoped para @SessionScoped. Perceba que o comportamento da primeira e segunda vez que executamos (1) é o mesmo do @RequestScoped, entretanto, no terceiro acesso (2), o método getNome busca o valor já existente no MB, agora persistente entre as requisições do usuário. No próximo passo, o método setter é invocado e o nome Catarina é substituído por Cecilia no MB (3). O método executar é invocado novamente (4) e, finalmente, o HTML é renderizado com o valor atualizado no componente, obtido através do método getNome (5). TÓPICO 3 | JAVA SERVER FACES (JSF) 51 FONTE: O autor FIGURA 49 - MANAGED BEAN COM ESCOPO DE SESSÃO Uma experiência interessante para comprovar o funcionamento deste escopo é pegar a URL do navegador interno do Eclipse, copiá-la e acessar a aplicação através de um navegador externo. Mas espere aí... os valores que eu coloquei não aparecem fora do Eclipse. Isto ocorre porque o AS trata este acesso como um segundo acesso feito por outro usuário. Se você observar os logs do servidor, perceberá que ele obedecerá o mesmo ciclo de vida. Mas e por que ele não cria uma nova instância do MB? Isto significa que os valores se confundirão entre os usuários? Vou responder a esta pergunta com outra. Você se lembra de quando acessamos nossa aplicação pela primeira vez e o servidor criou duas instâncias do FormularioMB? O segundo usuário está acessando nossa aplicação através daquela segunda instância, que o AS já criou para evitar o overhead de instanciação de um novo objeto e melhorar a performance da aplicação. Lembrando que esta característica é configurável. A última experiência consiste em abrir uma instância da aplicação através de outro navegador (se você abriu o Chrome, tente acessar a aplicação do Firefox e, em último caso, do Internet Explorer). Observando o log no console, percebemos que o mesmo mostra a criação de uma nova instância do FormularioMB, pois para o servidor somos um novo usuário e nossas duas instâncias iniciais já estão ocupadas. 52 UNIDADE 1 | INTRODUÇÃO AO JAVA ENTERPRISE EDITION Existem outros escopos no JSF além do Request e Session. Para maiores detalhes acesse: http://uaihebert.com/jsf-mini-livro-dicas-conceitos-e-boas-praticas/ ATENCAO Nesta unidade percorremos bastante conteúdo... entendemos o contexto onde são aplicadas as aplicações JEE, compreendemos a necessidade de um servidor de aplicação, criamos e configuramos um ambiente para a criação de aplicações enterprise e, por fim, introduzimos as Java Server Faces de forma prática, enfatizando a caracterização de sua arquitetura e seu ciclo de vida. Nas próximas unidades abordaremos aspectos avançados de JSF e demonstraremos o funcionamento de outras tecnologias chave que fazem parte da especificação JEE, como CDI e EJB. Novamente queremos destacar a necessidade de realização das autoatividades e de todas as implementações que são solicitadas no caderno. É somente
Compartilhar