Java ee 5

Jul 23, 2012Java EE 5 - EJB 3.0, JSF 1.2 e NetBeans 5.5


Java EE 5 – EJB 3.0, JSF 1.2, NetBeans IDE 5.5 – Case Site Disponibilização

O novo Java Enterprise Edition – EJB 3.0, JSF 1.2 e NetBeans IDE 5.5 – Juarez Barbosa – Systems Architect


Objetivos

• Apresentar a nova versão da plataforma Java Enterprise Edition – Java EE 5

• Apresentar a API Enterprise JavaBeans – EJB 3.0 – JSR - 220

• Apresentar a API Java ServerFaces – JSF 1.2 – JSR - 252

• Apresentar a IDE NetBeans 5.5 e o Visual Web Pack


Agenda

• Introdução Java EE 5 - Overview

• EJB 3.0

• JSF 1.2

• NetBeans 5.5

• Case Site Disponibilização e apresentação de exemplos de código


Java EE 5

• “Java EE 5 significantly reduces the cost and complexity of developing and deploying multi-tier solutions, resulting in services that can be rapidly deployed and easily enhanced.”

• Especificação Java EE 5 (umbrella)– Java Platform, Enterprise Edition 5 (Java EE 5)

• JSR-244


Java EE 5 - Especificações

• Web Services Technologies– Implementing Enterprise Web Services

• JSR-109– Java API for XML-Based Web Services (JAX-WS) 2.0

• JSR-224– Java API for XML-Based RPC (JAX-RPC) 1.1

• JSR-101– Java Architecture for XML Binding (JAXB) 2.0

• JSR-222– SOAP with Attachments API for Java (SAAJ)

• JSR-67– Streaming API for XML

• JSR-173– Web Service Metadata for the Java Platform

• JSR-181



• Web Application Technologies– Java Servlet 2.5

• JSR-154

– JavaServer Faces 1.2• JSR-252

– JavaServer Pages 2.1• JSR-245

– JavaServer Pages Standard Tag Library• JSR-52



• Enterprise Technologies– Enterprise JavaBeans 3.0

• JSR-220– J2EE Connector Architecture 1.5

• JSR-112– Common Annotations for the Java Platform

• JSR-250– Java Message Service API

• JSR-914– Java Persistence API

• JSR-220– Java Transaction API (JTA)

• JSR-907– JavaBeans Activation Framework (JAF) 1.1

• JSR-925– JavaMail

• JSR-919



• Management and Security Technologies– J2EE Application Deployment

• JSR-88

– J2EE Management• JSR-77

– Java Authorization Contract for Containers• JSR-115


Java EE 5 x J2EE - Diferenças

• J2EE, poderoso mas complexo– Java EE 5 mantêm as características mas de forma muito

mais simples e produtiva, foco principal da JSR-244

• Características do Java EE 5– Annotations

• Não afeta a semântica diretamente, mas afeta a forma como as bibliotecas e as ferramentas tratam o código

– Conventions (or container defaults)• o desenvolvedor deixa a maioria do trabalho de configuração

para os containers, que fornecem um conjunto bem definido de valores default, considerando os casos mais comuns. Desenvolvedor usa "Configuration by Exception“.



• Características do Java EE 5– Dependency Injection

• “Do not call me, I will call you”. As dependências são injetadas automaticamente nos componentes pelo container, com ajuda das annotations. Não é preciso buscar os recursos explicitamente;

– “boilerplate code” ficou obsoleto e os deployment descriptors são opcionais;



• Características do Java EE 5– Lightweight Persistence

• JPA - Modelo de persistência unificado, não limitado a EJBs. As classes podem ser usadas em outros componentes, inclusive fora do servidor de aplicação. As Entities agora são classes POJO, suportando herança e polimorfismo;

– Entity Manager API• principal API do Java EE 5 para interação com banco de

dados. O EM gerencia o ciclo de vida e estado das entities, suportando CRUD, pesquisa, execução de queries (inclusive dinâmicas), mecanismo de vinculação, liberação e unificação (attach/detach/merge);



• Características do Java EE 5– JP-QL – Java Persistence QL

• O antigo EJB-QL 2.1 foi melhorado e agora suporta: named queries, queries com named parameters, dynamic queries, bulk updates e deletes. O JP-QL também suporta queries SQL nativas.

• Características herdadas dos “concorrentes” – JBoss Hibernate, Oracle Toplink, JDO.



• Características do Java EE 5– JavaServer Faces

• O JSF permite a construção e controle de GUIs geradas dinamicamente pelo servidor através de componentes reutilizáveis. O JSF trabalha integrado com a tecnologia JSP e ambos possuem uma Expression Language unificada (EL). O JSF fornece tratamento de eventos facilitado, validação, navegação, suporte I18N e acessibilidade.



• Características do Java EE 5– Web Services

• O suporte ficou mais abrangente, porém mais simples, através do JAX-WS e JAXB. Utilização de annotations e defaults, dispensando deployment descriptors. Suporte nativo SOAP 1.1, SOAP 1.2, XML Schema e extensões para outros protocolos e encodings;


EJB 3.0 x EJB 2.x

• EJB 2.1– Apesar de poderoso (mas incompleto),

é muito complexo• Muitas classes, interfaces• JNDI lookups• Uso de interfaces do pacote javax.ejb• Modelo de programação confuso• Deployment Descriptors• Anti-patterns - Entity Beans


EJB 3.0 x EJB 2.x

• EJB 2.1– Limitações

• Para criar um EJB simples você precisar criar vários DDs;

• Um conjunto de três arquivos fonte (pelo menos) deve ser criado;

• Múltiplos métodos callback devem ser implementados e alguns possivelmente nem serão usados;

• Você tem que arremesar e tratar vários tipos de exceções, desnecessariamente;

• Os EJBs não podem ser testados fora do container;

• EJB-QL é limitada e difícil de usar, forçando a utilização de JDBC e SQL ou outro mecanismo de persistência


EJB 3.0

• EJB 3.0 - características

– Facilidade no desenvolvimento, simplicidade• Poucas classes e interfaces• Dependency Injection (sem JNDI lookups)• Não requer implementação de interfaces• Não requer deployment descriptors (opcional)• Mecanismo de persistência simplificado• Mapeamento O/R robusto (herança, polimorfismo, etc)


EJB 3.0

• JSR-000220 Enterprise JavaBeans 3.0 – FR - Specs

– Desenvolvedores de aplicações que desejam usar EJB 3.0• Enterprise JavaBeans 3.0 Final Release (ejbcore)

– ejb-3_0-fr-spec-ejbcore.pdf

• Enterprise JavaBeans 3.0 Final Release (persistence)– ejb-3_0-fr-spec-persistence.pdf

• Enterprise JavaBeans 3.0 Final Release (simplified)– ejb-3_0-fr-spec-simplified.pdf

– Desenvolvedores que desejam construir uma implementação de EJB 3.0


EJB 3.0• DI – Dependency Injection

– Os recursos são injetados quando a instância é construída. Referências para:

• EJBContext• DataSources• UserTransaction• Environment Entries• EntityManager• TimerService• Outros EJBs


EJB 3.0• Client View Simplificada

– Session beans agora usam interfaces Java simples• Não requer EJB(Local)Home interfaces• Não requer EJB(Local)Object interfaces

– A Bean class é uma classe Java simples, portanto:• É uma classe Java plana (POJO)• Implementa interfaces Java comuns (POJI)


EJB 3.0 - Client View

...

@EJB

ShoppingCart myCart;

...

Collection widgets = myCart.startToShop(“widgets”);...

OBS: A versão atual do JBoss (4.0.5) ainda não suporta a annotation @EJB. Portanto, ainda é necessário o JNDI lookup (utilizar um Service Locator).


EJB 3.0• Persistence API – Objetivos

– Simplifica o modelo de programação de entities

– Suporte para modelagem, incluindo herança e polimorfismo

– Endereça as limitações anteriores que existiam para as queries

– Suporta mapeamento O/R de forma robusta

– As entidades podem ser usadas (e testadas) fora do container

– Remove a necessidade de VOs/DTOs e outros anti-patterns


EJB 3.0• Entity Manager

– O EntityManager serve como uma “home” genérica, para operações que envolvem entities;

– Possui métodos para gerenciamento do ciclo de vida• Persist, remove, merge, flush, refresh, etc

– Funcionalidade similar ao Hibernate Session, JDO PersistenceManager, etcc


EJB 3.0• Foco – Mapeamento O/R

– Facilidade para que os desenvolvedores Java executem o mapeamento de um modelo de objetos para um banco relacional

– O desenvolvedor fica seguro sobre o mapeamento entre o DB Schema e o modelo de domínio dos objetos• O desenvolvedor controla o mapeamento• O desenvolvedor pode confiar no mapeamento e semântica do

mesmo

– Os mapeamentos podem ser expressos usando annotations ou XML• Mapeametos default são fornecidos


EJB 3.0• Interoperabilidade com EJB 2.X

– Aplicações escritas usando a API EJB 2.1 e anteriores funcionam sem alterações nos containers EJB 3.0

– Caminho para migração• Novas aplicações usando EJB 3.0 podem ser clientes de EJBs

antigos (specs anteriores), sem mudanças na cliente view pré-existente


EJB 3.0 - SLSB...

@Stateless

public class ServidorFacade implements ServidorFacadeLocal {

@PersistenceContext

private EntityManager em;

/** Creates a new instance of ServidorFacade */

public ServidorFacade() {

}

public void create(Servidor servidor) {

em.persist(servidor);

}

public void edit(Servidor servidor) {

em.merge(servidor);

}

...


EJB 3.0 - SLSB...

@Local

public interface ServidorFacadeLocal {

void create(Servidor servidor);

void edit(Servidor servidor);

void destroy(Servidor servidor);

Servidor find(Object pk);

List findAll();

List findAllIds();

}

...


EJB 3.0 - Entities...

@Entity

@Table(name = "servidor")

@NamedQueries( {

@NamedQuery(name = "Servidor.findAllIds", query = "SELECT s.codServidor FROM Servidor s ORDER BY s.codServidor DESC"),

@NamedQuery(name = "Servidor.findByCodServidor", query = "SELECT s FROM Servidor s WHERE s.codServidor = :codServidor"),... })

public class Servidor implements Serializable {

@Id

@Column(name = "COD_SERVIDOR", nullable = false)

private BigDecimal codServidor;

@Column(name = "NOM_SERVIDOR", nullable = false)

private String nomServidor;...

@OneToMany(cascade = CascadeType.ALL, mappedBy = "servidor")

private java.util.Collection <com.unisys.ciwebview.model.PerfilConfiguracao> perfilConfiguracaoCollection;

/** Creates a new instance of Servidor */

public Servidor() {

}


JSF 1.2• Características

– Arquitetura MVC Model 2

– Framework de componentes de interface (GUI), server side, para aplicações web baseadas em tecnologia Java

– Permite construir uma aplicação utilizando drag-and-drop a composição visual

– Modelo de componentes de interface bem extensível

– Modelo de renderização flexível

– Modelo de tratamento de eventos



– Framework de validação (mais simples que Struts Validator)

– Suporte ao controle de fluxo (navegação) entre páginas

– Internacionalização

– Acessibilidade

– Suportado por IDEs e ferramentas que possibilitam o aumento de produtividade

– Flexibilidade - Independente do dispositivo cliente



– Framework de validação (mais simples que Struts Validator)

– Suporte ao controle de fluxo (navegação) entre páginas

– Internacionalização

– Acessibilidade

– Suportado por IDEs e ferramentas que possibilitam o aumento de produtividade


JSF - Arquitetura


JSF - Componentes• Uma página JavaServer Faces é representada por uma

árvore de componentes, chamada de view– Uma view é uma árvore de componentes

– Conceito familiar considerando o design de interfaces

– Mapeia bem para o XML

– Componentes Faces são JavaBeans, eles têm propriedades, métodos e eventos/ouvintes

• Os componentes de apoio são anexados aos componentes JSF– Validators, Converters, Listeners


JSF – Componentes GUI


JSF – Passos para desenvolvimento• Passos para o desenvolvimento de uma aplicação JSF

– 1) Desenvolver as classes do modelo (managed beans) que possuem os dados associados ao componente JSF;

– 2) Adicionar as declarações dos managed beans ao arquivo faces-config.xml (elementos <managed-bean>);

– 3) Criar as páginas JSF (JSP) utilizando os componentes GUI e as tag libraries do JSF (JSF Core Tags, JSF HTML Tags);

– 4) Definir o fluxo de navegação utilizando o arquivo faces-config.xml (elementos <navigation-rule>);

– 5) Configurar o arquivo web.xml da aplicação (configurar Faces Servlet, etc).


JSF – Passos 1• Passo 1: Desenvolver os Managed Beans

– Representa o modelo (M) no MVC

– O Managed Bean é um componente JavaBean comum com um conjunto de métdos get e set para todos os atributos

– Ele pode conter métodos action (similar Struts DispatchAction) e manipuladores de eventos

– Utilizado para armazenar os dados enviados por uma página UI (JSP)

– A criação e o ciclo de vida são gerenciados pelo JSF runtime• application, session, request, etc

– O JSF runtime mantém os dados do bean sincronizados com os dados da interface


MB - ServidorHelper.javapublic class ServidorHelper { //POJO

private boolean mode;

private Servidor servidor = new Servidor();

public ServidorHelper() { //NO-ARG CONSTRUCTOR

}

public String incluirServidor(){ //ACTION METHOD

ServidorFacadeLocal local = (ServidorFacadeLocal) serviceLocator.lookupFacade(servidorFacade);

List IDs = local.findAllIds();

BigDecimal novoID = null;

if(IDs.isEmpty()){

novoID = new BigDecimal(0);

} else{

novoID = (BigDecimal) IDs.get(0);

}

novoID = novoID.add(new BigDecimal(1));

servidor.setCodServidor(novoID);

local.create(servidor);

return NavigationUtils.SUCCESS;

}

//SETTERS AND GETTERS

public Servidor getServidor() {

return servidor;

}

public void setServidor(Servidor servidor) {

this.servidor = servidor;

}


JSF - Passo 2 - Adicionar MBs > faces-config.xml • Adicionar as declarações dos managed beans ao arquivo

faces-config.xml (elementos <managed-bean>)

<managed-bean>

<description>Backing bean for Servidor</description>

<managed-bean-name>ServidorBean</managed-bean-name>

<managed-bean-class>com.unisys.ciwebview.control.ServidorHelper</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>


JSF - Passo 3 - Criar as páginas JSF (JSPs)• Criar as páginas JSF (JSP) utilizando os componentes GUI

e as tag libraries do JSF (JSF Core Tags, JSF HTML Tags)

– É obrigatório incluir as tag libraries JSF utilizadas• HTML e Core Tags

– Todas as tags JSF devem estar entre um par de view - <f:view> - tags

– Utilizar os componentes GUI da JSF• <h:input_text> e não <input type=”text”>• <h:command_button> e não <input type=”submit”>

– Validators e Event Listeners podem ser definidos para qualquer componente JSF


UI Binding – servidor.jsp > ServidorBeanArquivo JSP:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<f:view>

<h:form id="servidorForm">

<h1><h:outputText value="Servidor"/></h1>

<h:panelGrid columns="3" columnClasses="section">

<h:outputLabel value="Nome Servidor: " for="nomServidor" />

<h:inputText id="nomServidor" value="#{ServidorBean.servidor.nomServidor}" required="true" />

<h:message for="nomServidor" />

</h:panelGrid>

<h:panelGroup>

<h:commandButton id="submitIncluirServidor" action="#{ServidorBean.incluirServidor}" value="Incluir" styleClass="inputfonte" rendered="#{not ServidorBean.mode}" />

<h:commandButton id="submitAtualizarServidor" action="#{ServidorBean.atualizarServidor}" value="Atualizar" styleClass="inputfonte" rendered="#{ServidorBean.mode}" />

</h:panelGroup>

</h:form>

</f:view>


JSF - Passo 4 – Regras de Navegação• Definir o fluxo de navegação utilizando o arquivo faces-

config.xml (elementos <navigation-rule>)– As regras de navegação são configuradas no arquivo faces-

config.xml

– O NavigationHandler (default) controla o fluxo baseado em:• Qual component tree (ex, página) está sendo processada no

momento?• Originária da página/view (from-view);• Qual resultado retornado pela ação?• Originária do resultado de uma action (from-outcome);• Qual a próxima página a ser exibida (to-view).

JSF - Passo 4 – Regras de Navegação• Definir o fluxo de navegação utilizando o arquivo faces-config.xml



<navigation-rule>

<from-view-id>/main.jsp</from-view-id>

<navigation-case>

<from-outcome>adm_servidores</from-outcome>

<to-view-id>/adm_servidores.jsp</to-view-id>

</navigation-case>

</navigation-rule>

...



<navigation-rule>

<from-view-id>/adm_servidores.jsp</from-view-id>

<navigation-case>

<from-outcome>success</from-outcome>

<to-view-id>/lista_servidores.jsp</to-view-id>

</navigation-case>

</navigation-rule>


JSF - Passo 5 – configurar web.xml• Configurar o arquivo web.xml da aplicação (Faces Servlet, Context Parameters, etc)

<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" ...>...

<context-param>

<param-name>com.sun.faces.validateXml</param-name>

<param-value>true</param-value>

</context-param>

...

<servlet>

<servlet-name>Faces Servlet</servlet-name>

<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>Faces Servlet</servlet-name>

<url-pattern>/faces/*</url-pattern>

</servlet-mapping>

...

</web-app>


JSF – Componentes (WAR)• Quais componentes e recursos fazem parte de uma aplicação JSF? Arquivo

WAR com:your.jpg

your.jsp

WEB-INF/web.xml

WEB-INF/faces-config.xml

WEB-INF/classes/your.class

WEB-INF/lib/your.jar

(if not running in Java WSDP)

WEB-INF/lib/jsf-api.jar

WEB-INF/lib/jsf-ri.jar

WEB-INF/lib/jstl.jar

WEB-INF/lib/jsf-el.jar

WEB-INF/lib/standard.jar

WEB-INF/lib/commons-beanutils.jar

WEB-INF/lib/commons-digester.jar

WEB-INF/lib/commons-collections.jar

WEB-INF/lib/commons-logging.jar


JSF – Componentes• Exemplos de componentes JSF comerciais e

open-source (free):– https://javaserverfaces.dev.java.net/

– https://facelets.dev.java.net/

– http://myfaces.apache.org/

– http://component-showcase.icefaces.org/component-showcase/

– http://livedemo.exadel.com/richfaces-demo/

https://javaserverfaces.dev.java.net/

https://facelets.dev.java.net/

http://myfaces.apache.org/

http://component-showcase.icefaces.org/component-showcase/

http://livedemo.exadel.com/richfaces-demo/


NetBeans 5.5• Características

– Primeira IDE open-source, free, com suporte a Java 5– Suporte desenvolvimento nas três plataformas – JSE, JEE, JME

(mobile, desktop, web e enterprise)– Ambiente open-source, multi-plataforma, 100% Java– Fácil instalação, descomplicada e sem a necessidade de plug-ins

(apenas se utilizado algum framework ou produto específico)– Swing GUI Builder, Web Application Development, Enterprise

Development,– Web Services and Application Servers Integration, Developer

Collaboration, Advanced Source Code Editor, Java Mobility (Java ME), Visual Web Development, Service-Oriented Architecture (SOA), C/C++ development.

– Screenshots• http://www.netbeans.org/products/ide/screenshots.html

http://www.netbeans.org/products/ide/screenshots.html


Case – Site Disponibilização GCI• Em desenvolvimento, proposta para visualização de

informações considerando os ambientes do GCI

• Boa oportunidade para uma prova de conceito– JSF 1.1, EJB 3.0

– NetBeans 5.5, Visual Web Pack

– JBoss 4.0.4, MySQL (dev only)


Referências• JSR 220: Enterprise JavaBeansTM 3.0

– http://jcp.org/en/jsr/detail?id=220

• JSR 252: JavaServer Faces 1.2– http://jcp.org/en/jsr/detail?id=252

• NetBeans 5.5– http://www.netbeans.org/

• NetBeans Visual Web Pack 5.5– http://www.netbeans.org/products/visualweb/

• JCP – Java Community Process– http://jcp.org/en/home/index

http://jcp.org/en/jsr/detail?id=220





http://www.netbeans.org/



http://www.netbeans.org/products/visualweb/

http://jcp.org/en/home/index



Java ee 5

Documents

Transcript of Java ee 5