Archive for category Java EE

Hello World RichFaces

Posted by Diego Ferreira da Silva in Java EE on 1 de maio de 2009

E ai pessoal, hoje famos fazer um exemplo passo a passo de uma aplicação Hello World utilizando o RichFaces.

Para quem não conhece o RichFaces ele é uma biblioteca de componentes para aplicações web que utilizam o framework JSF. Os componentes desta biblioteca possuem um incrível suporte AJAX, e ela, pode ser considerada uma extensão do Ajax4jsf com inúmeros componentes com Ajax “embutido” e com um suporte a Skins que podem deixar as interfaces da sua aplicação com um visual padronizado.

O ambiente que utilizamos neste post é o seguinte:

  • Eclipse Ganymede
  • Tomcat 6.0
  • RichFaces 3.3.0

Vamos por a mão na massa, primeiro criamos um projeto web no eclipse e damos o nome a ele de HelloRichFaces.

Efetue o download do arquivo richfaces-ui-3.3.0.GA-bin.zip no seguinte link . Descompacte o arquivo e copie os arquivos richfaces-api-3.3.0.GA.jar, richfaces-impl-3.3.0.GA.jar, richfaces-ui-3.3.0.GA.jar para do diretório WEB-INF/lib da nossa aplicação.

Precisamos também copiar os seguintes jars para o diretório WEB-INF/lib da nossa aplicação:

jsf-api.jar, jsf-impl.jar(Jar’s do framework JSF).

jstl.jar, standard.jar.

commons-beanutils-1.8.0.jar, commons-collections-3.2.1.jar, commons-digester-1.8.jar, commons-logging-1.1.1.jar.

Vamos criar agora dentro da nossa pasta WEB-INF um arquivo com o nome faces-config.xml, neste arquivo ficará nossas configurações referente ao JSF(Managed beans, Regras de navegação, etc…).

Agora criaremos dentro da pasta WebContent uma página jsp com o nome: helloWorldRichFaces.jsp

Vamos criar um pacote dentro da pasta src do nosso projeto com o seguinte nome br.com.diegosilva.helloworld

Pronto, nossa estrutura para o helloWorld já está criada, se você chegou até aqui veja abaixo como deve ficar a estrutura de seu projeto.

Imagem-01

Imagem-01

Agora que já temos nossa estrutura do projeto pronta, vamos criar um simples managed bean dentro do pacote br.com.diegosilva.helloworld como o nome de Bean.

Abaixo o código da classe Bean:


package br.com.diegosilva.helloworld;

public class Bean {
private String text;

public Bean() {
}

public String getText() {
return text;
}

public void setText(String text) {
this.text = text;
}
}

O managed bean criado acima será utilizado na nossa página JSF, mas para que possamos utilizá-lo precisamos confirar nosso arquivo faces-config.xml inserindo as confirações necessárias para que nosso manage bean seja reconhecido pela nossa página.

Segue abaixo a configuração do nosso faces-config.xml do nosso exemplo:

<?xml version="1.0" encoding="UTF-8"?>
<faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xi="http://www.w3.org/2001/XInclude" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
<managed-bean>
<managed-bean-name>bean</managed-bean-name>
<managed-bean-class>br.com.diegosilva.helloworld.Bean</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
<managed-property>
<property-name>text</property-name>
<value/>
</managed-property>
</managed-bean>
</faces-config>

O arquivo acima está informando ao JSF que estamos criando um managed bean, que seu nome será bean que a classe será a que está no caminho br.com.diegosilva.helloworld.Bean que o escopo utilizado será como atributo de request e que este bean tem uma propriedade que se chama text.

Agora vamos criar nossa página que utilizará nosso managed bean criado.


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<head>
<title>Hello World RichFaces</title>
</head>
<body>
<f:view>
<h:form>
<rich:panel header="Simples Impressão">
<h:inputText size="50" value="#{bean.text}">
<a4j:support event="onkeyup" reRender="rep" />
</h:inputText>
<h:outputText value="#{bean.text}" id="rep" />
</rich:panel>
</h:form>
</f:view>
</body>
</html>

Na nossa página acima primeiramente fazemos os imports das taglibs utilizadas pelo JSF e RichFaces, dentro ta tag <body> criamos um <f:view>, todos os componentes JSF devem vir dentro de uma tag <f:view>, dentro da nossa tag <f:view> criamos um formulário e dentro desse formulário um painel no qual terá o título de Simples Impressão, dentro desse painel temos um input que irá setar a propriedade text do nosso bean com o valor digitado no input, nesse input adicionamos um evento onkeyup utilizando a api de ajax que o richfaces utiliza, neste evento setamos o atributo reRender=”rep”, no qual rep é o id do nosso outputText declarado logo abaixo, o nosso outputText recebe o valor da propriedade text do nosso bean. O que acontece aqui é que a cada evento de onkeyup nosso bean recebe o valor e o componente de id rep e recebe a atualização desse valor sem refresh na página, totalmente ajax.

Não podemos esquecer de configurar o arquivo web.xml do nosso projeto para que tudo funcione belezinha tem que ser feito algumas configurações neste arquivo.

Segue abaixo nosso arquivo web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<display-name>HelloRichFaces</display-name>
<!-- Rich Faces -->
<context-param>
<param-name>org.richfaces.SKIN</param-name>
<param-value>blueSky</param-value>
</context-param>
<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>server</param-value>
</context-param>
<filter>
<display-name>RichFaces Filter</display-name>
<filter-name>richfaces</filter-name>
<filter-class>org.ajax4jsf.Filter</filter-class>
</filter>
<filter-mapping>
<filter-name>richfaces</filter-name>
<servlet-name>Faces Servlet</servlet-name>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>INCLUDE</dispatcher>
</filter-mapping>
<listener>
<listener-class>com.sun.faces.config.ConfigureListener</listener-class>
</listener>
<!-- Java SErver Faces -->
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<!-- Faces Servlet Mapping -->
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.faces</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>helloWorldRichFaces.faces</welcome-file>
</welcome-file-list>
</web-app>
Imagem 2

Imagem 2

Download do projeto(Sem os Jars).

Bom pessoal é isso ai espero que tenham gostado deste post, e qualquer dúvida é só entrarem em contato.

Abraço.

, ,

6 Comentários

Integrando DWR ao Spring

Posted by Diego Ferreira da Silva in Java, Java EE on 20 de março de 2009

Neste post vamos desenvolver uma pequena aplicação passo a passo mostrando como efetuar as configurações necessárias para integrar o DWR 3.0 ao springframework 2.5.

  • Ambiente:
    • Eclipse Ganymede
    • Tomcat 6.0
    • Spring 2.5
    • DWR 3.0

Primeiramente efetuamos o download do DWR no site, efetue o download do arquivo dwr.jar.

Após o download copie o arquivo dwr.jar para o diretório WEB-INF/lib de sua aplicação(ctrc+c no arquivo, ctrc+v na pasta lib dentro do eclipse).

Agora vamos vazer o download do spring no site, efetue o download do arquivo spring-framework-2.5.6.zip.

Extraia este aquivo em alguma pasta no seu computador e depois copie os arquivos: spring.jar e spring-webmvc.jar para a pasta WEB-INF/lib do seu projeto.

Precisaremos tambem do arquivo commons-logging-xxx.jar que pode ser adiquirido aqui. Após efetuar o downlaod repita o processo acima, extraia o arquivo zip e copie o arquivo commons-logging-xxx.jar para a pasta WEB-INF/lib de sua aplicação.

Pronto! Estamos com o ambiente projeto para utilizar o DWR com o Spring!

Agora crie dois pacotes na dentro da pastar src do seu projeto br.com.diego.bean e br.com.diego.dwr.

Crie uma página jsp dentro de WebContent com o nome index.jsp.

Crite um arquivo applicationContext-DWR.xml dentro da sua pasta WEB-INF.

A estrutura do seu projeto deve ser como esta abaixo:

Estrutura do Projeto

Vamos alterar nosso arquivo web.xml, deixe seu arquivo conforme a configuração abaixo:


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>springDwr</display-name>
<!-- Mapeamento dos arquivos de configuração do spring -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext*.xml</param-value>
</context-param>
<!-- fim mapeamento arquivos spring -->
<!-- Mapemento do filtro do spring -->
<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- Fim do mapeamento do spring -->
<!-- Listerners do spring -->
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--Fim Listerners do spring -->
<!--Servlet DWR - que efetua a integração do DWR com o spring  -->
<servlet>
<servlet-name>dwr</servlet-name>
<servlet-class>org.directwebremoting.spring.DwrSpringServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>crossDomainSessionSecurity</param-name>
<param-value>false</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dwr</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>
<!-- Fim servlet DWR -->
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

Agora vamos criar uma classe no nosso pacote br.com.diego.bean com o nome de UsuarioBean.java com o conteúdo abaixo:


package br.com.diego.bean;

public class UsuarioBean {

private int id;
private String nome;
private String telefone;
private String endereco;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNome() {
return nome;
}

public void setNome(String nome) {
this.nome = nome;
}

public String getTelefone() {
return telefone;
}

public void setTelefone(String telefone) {
this.telefone = telefone;
}

public String getEndereco() {
return endereco;
}

public void setEndereco(String endereco) {
this.endereco = endereco;
}
}

Vamos criar outra classe, agora no nosso pacote br.com.diego.dwr, vamos dar o nome de UsuarioAjax.java, esta classe que terá nosso método que será invocado através do nosso javascrpit através de uma chamada AJAX do DWR. Segue abaixo o conteúdo da classe:


package br.com.diego.dwr;

import br.com.diego.bean.UsuarioBean;

public class UsuarioAjax {

private UsuarioBean usuario;

public UsuarioBean getUsuario() {
return usuario;
}

public void setUsuario(final UsuarioBean usuario) {
this.usuario = usuario;
}

//Método que será invocado pela nossa chamada DWR
public UsuarioBean find(String nome){

getUsuario().setId(1);
getUsuario().setNome(nome);
getUsuario().setEndereco("Rua santo DWR número 555");
getUsuario().setTelefone("9999-9999");

return getUsuario();
}
}

Agora vamos a parte principal do nosso artigo, a configuração do arquivo applicationContext-DWR.xml, pois é neste arquivo que fica nossas configurações do DWR e também nossos beans da aplicação e do DWR.

Segue abaixo a configuração do arquivo applicationContext-DWR.xml:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.directwebremoting.org/schema/spring-dwr

http://directwebremoting.org/schema/spring-dwr-3.0.xsd">
<!-- Configurações de inicialização da Engine do DWR -->
<bean id="dwrHandlerMappings"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="order" value="1" />
<property name="alwaysUseFullPath" value="true"></property>
<property name="mappings">
<props>
<prop key="/dwr/**/*">dwrController</prop>
<prop key="/dwr/*">dwrController</prop>
<prop key="/engine.js">dwrController</prop>
<prop key="/util.js">dwrController</prop>
<prop key="/interface/**">dwrController</prop>
<prop key="/call/**">dwrController</prop>
</props>
</property>
</bean>
<!-- Configurações do DWRControle que é o controlador do DWR -->
<dwr:controller id="dwrController" debug="true">
<dwr:config-param name="activeReverseAjaxEnabled"
value="true" />
</dwr:controller>
<!-- Nosso bean do DWR que converte nosso método find dentro da classe UsuarioAjax em um metodo javascript -->
<bean id="dwrUsuario" class="br.com.diego.dwr.UsuarioAjax">
<dwr:remote javascript="usuarioAjax">
<dwr:include method="find" />
</dwr:remote>
<property name="usuario" ref="usuarioBean"/>
</bean>
<!-- Inserimos uma configuracao do DWR para nossos convertes aqui, estes convertes servem para converter nossos beans java em objetos javascript -->
<dwr:configuration>
<dwr:convert type="bean" class="br.com.diego.bean.UsuarioBean" />
</dwr:configuration>
<!-- Nosso bean referente a classe UsuarioBean, este será injetado na classe UsuarioAjax -->
<bean id="usuarioBean" class="br.com.diego.bean.UsuarioBean"/>
</beans>

Nossa página index.jsp


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Exemplo Spring DWR</title>
<script type='text/javascript'
	src='/springDwr/dwr/interface/usuarioAjax.js'></script>
<script type='text/javascript' src='/springDwr/dwr/engine.js'></script>
<script type='text/javascript' src='/springDwr/dwr/util.js'></script>
<script type="text/javascript">
	function findUser() {
		var nome = document.getElementById("inputNome").value;
		usuarioAjax.find(nome, {
			callback : function(usuarioBean) {
				dwr.util.setValue('divShow', usuarioBean.id + " / "
						+ usuarioBean.nome + " - " + usuarioBean.endereco
						+ " - " + usuarioBean.telefone);
			}
		});
	}
</script>

</head>
<body>
<table>
	<tr>
		<td><label for="inputNome">Nome:</label></td>
		<td><input type="text" id="inputNome" maxlength="20" width="20px"></td>
		<td><input type="button" value="Enviar" onclick=findUser();></td>
	</tr>
</table>
<br>
<div id="divShow"></div>
</body>
</html>

Observe que temos alguns imports de javascript na nossa página jsp, se você criou um projeto idêntico ao que foi passado aqui neste artigo você poderá acessar a url da imagem abaixo para verificar que o próprio DWR lhe fornecess os imports necessários que você deverá incluir na sua página jsp para que tenha acesso a seu método na sua classe java, inclusive tem como até mesmo você testar atravéz desta url de teste do DWR.

Página de Teste DWR

Se deu tudo certo você poderá acessar sua aplicação que você terá o resultado abaixo, ao clicar no botão enviar o DWR irá invocar seu método find dentro da sua classe UsuarioAjax que retornará um bean UsuarioBean que será exibido na página sem refresh algum.

springdwrresultado

Efetutem o donwload do projeto(sem os arquivos jar) aqui.

Bom pessoal este artigo fica por aqui, este é apenas o primeiro de muitos que virão, espero que tenham gostado.

Estou a disposição para esclarecer dúvidas!

Abraços !!!

,

1 Comentário

Novas features do Java EE 6

Posted by Diego Ferreira da Silva in Java, Java EE on 20 de março de 2009

Plataforma Java EE

A plataforma Java EE é especializada no desenvolvimento de aplicações multicamadas, baseadas em componentes distribuidos, executadas em um servidor de aplicações. Esse servidor (compatível com a especificação Java EE) oferece uma série de serviços de infra-estrutura aos componentes da aplicação (ex.  tolerância a falhas, segurança, transações, autenticação, distribuição, etc) que ajudam a garantir a robustez da aplicação sem que o desenvolvedor necessite escrever muitas linhas de código para isso.

Na Java EE 5, o foco foi basicamente na simplicidade de desenvolvimento de componentes, com o uso intensivo de anotações e Injeção de Dependência, a inclusão do JavaServer Faces(JSR 127) e a substituição do padrão Entity Beans pelo padrão Java Persistence API(JSR 220).

Vencida a barreira da complexidade de desenvolvimento, o objetivo na Java EE 6(JSR 316) passa a ser a busca pela maturidade da plataforma, por meio da evolução e fortalecimento de seus padrões, e o aumento na sua flexibilidade de uso e integração.

O maior desafio na especificação da Java EE 6 tem sido na definição de novos conceitos para a plataforma: profiles, extensibility e pruning. Esses conceitos permitem melhor adequação da plataforma às diferentes necessidades do mercado e mais facilidade de integração com novas tecnologias, frameworks e aplicações.

Dentre as melhorias esperadas estão a evolução de algumas APIs mais importantes, como JavaServer Faces 2.0(JSR 314), Java Persistence API 2.0(JSR 317), Enterprise Java-Beans 3.1(JSR 318) e Java Servlet 3.0(JSR 315), e a inclusão de novas APIs como WebBeans(que agora se chama Java Contexts and Dependency Injection JCDI)(JSR 299), Bean Validation(303) e JAX-RS(311).

Profile, Extensibility e Pruning

Desde as primeiras versões da Java EE, várias tecnologias, frameworks e aplicações tem sido criadas para suprir as imperfeições da plataforma ou aumentar sua facilidade de desenvolvimento. Para melhorar a capacidade de integração das aplicações Java EE com essas tecnologias, a versão 6 da plataforma tem dois grandes objetivos: a definição de profiles e o suporte à extensibilidade

Profiles

Um profile é caracterizado por um conjunto de tecnologias, que fazem parte ou não da especificação Java EE completa, necessários para suportar o desenvolvimento de aplicações de diferentes segmentos do mercado.

O uso de profiles na Java EE 6 é a resposta às críticas enfrentadas pela plataforma no que diz respeito ao tamanho da especificação Java EE. Nem todas as aplicações que desenvolvemos necessitam de utilizar o vasto conjunto de tecnologias que fazem parte do Java EE, o que causa um desespedício de suporte quando se utiliza um servidor Java EE completo. Daí a necessidade para a definição de profiles.

Requisitos comuns como serviço de nomes, recursos de injeção de dependência, regras de empacotamento, segurança, entre outros, devem ser compartilhados por todos os profiles para garantir a uniformidade dos produtos e das aplicações Java EE. Além disso, todas as dependências dos componentes suportados por cadas profile devem estar confidos no profile para garantir o seu funcionamento out-of-the-box.

Extensibility

O aspecto da extensibilidade na plataforma Java EE está relacionada com a necessidade de melhorar o suporte de outras tecnologias e frameworks dentro dos servidores de aplicação Java EE. Por exemplo, atualmente, para usar um framework em uma aplicação Java EE é necessário fazer alterações nos deployment descriptors,  criar filtros, ajustar bibliotecas, etc. A proposta de extensibilidade da Java EE 6 é facilitar esse processo criando mais pontos de extensão na plataforma.

Algumas das idéias discutidads para aumentar os pontos de extensão consideram o uso de anotações, injeção de dependência, interceptadores, APIs de serviço (SPIs – Service Providers Interfaces) e, até mesmo,  facilidade de implantar um simples jar dentro da aplicação(sem a necessidade de configurações complexas).

Profiles e extensibility são dois conceitos que estão diretamente relacionados, pois os profiles, além de oferecer o conjunto de tecnologias especificadas, também devem permitir a integração simplificada de outras tenologias, mesmo que estas não sejam padrão Java EE.

Pruning

Apesar de não estar como objetivo principal da especificação, pruning ou “poda” é um objetivo igualmente importante para a Java EE 6, que passa por um momento de amadurecimento.

Alguns dos padrões considerados essenciais em versões anteriores da Java EE agoar não são mais tão importantes. Exemplo disso são os Entity Beans, substituídos por JPA na Java EE 5.

A partir da Java EE 6, tecnologias consideradas de pouca relevância podem ser depreciadas para que, somente nas versões futuras da plataforma, se tornem opcionais. Assim, os vendedores de produtos poderão optar se querem ou não manter suporte a essas tecnologias na próxima versão  da plataforma. Essa é a definição de pruning adotada no JCP.

Na especificação Java EE 6, as tecnologias eleitas para o pruning são: EJB CMP, substituído pelo JPA, e JAX-RPC(JSR-101), substituído por JAX-WS(JSR-224), ambos na Java EE5. Portanto, a partir da próxima versão da Java EE(Java EE 7), os servidores escolhem se mantêm ou não suporte a essas tecnologias.

Novas versões das principais APIs

Com o objetivo de melhorar ainda mais a facilidade de uso e oferecer recursos mais poderosos  para as tecnologias padronizadas na Java EE 6, essa versão também está prevendo uma evolução da principais APIs.

JavaServer Faces 2.0

A versão 2.0 de JavaServer Faces, parte de Java EE 6, está sendo desenvolvida na JSR 314, liberada por Ed Burns e tem como principais novidades:

  • Configuração do estágio do projeto/ Project Stage: Permite configurar qual o estágio de desenvolvimento: Production, Test, Development, UnitTest, System Test, Extension. Possibilitando que a aplicação seja executada de forma diferente, dependendo do estágio do projeto, por exemplo, se a aplicação está em produção pode ter um comportamento de log diferente da mesma aplicação em desenvolvimento.
  • Criação do escopo View: baseado no escopo Page do JBoss Seam e no escopo KeepAlive do RichFaces, permite que um componente esteja associado a uma página, ou seja, estes componentes tem a “duração de uma página”. Quando o usuário sai daquela página o componente não estará mais acessível;
  • Simplificação do desenvolvimento de componentes com conceito similar a TagFiles, baseado em Facelets;
  • Definição de uma PDL(Page Description Language): baseada em Facelets, tornando-se a forma padrão para a criação de páginas em detrimento a JSPs.
  • Melhor suporte a AJAX: trazendo conceitos de diversas bibliotecas do mercado, como DynaFaces, JMaki e Shale Remoting;
  • Introdução do conceito de Resources(recursos): todos os artefatos (arquivos CSS, imagens e scripts) necessários para que o User Agent (geralmente um browser) possa renderizar o componente JSF são chamados recursos e devem ser disponibilizados em um diretório padrão.

Java Persistence API 2.0

A primeira versão da JPA foi  lançada em 2006 como parte da especificação do EJB 3.0(JSR-220) para facilitar o desenvolvimento da camada de persistência das aplicações. Muitas das idéias utilizadas na definição da JPA foram baseadas nas esperiências do mercado com frameworks de persistência. No entanto, a JPA 1.0 teve foco nos requisitos essenciais de persistência, não envolvendo aspectos mais podedoros de mapeamento e pesquisa.

Com o crescente interesse nessa API não apenas na plataforma Java EE, a JPA ganhou sua própria especificação (JSR-317) sob a liderança de Linda DeMichiel, que também foi líder das especificações EJB 2.1 e 3.0.

Essa JSR foi incluída na Java EE 6, sendo que o objetivo na versão 2.0 é a inclusão de recursos mais avançados de ORM e de busca.

Em relação aos recursos de ORM, algumas das melhorias trazidas pela JPA 2.0 são:

  • Suporte ao mapemaneto de coleções de tipos básicos.
  • Suporte a listas ordenadas.
  • Melhor suporte a coleção de tipo Map
  • Suporte ao relacionamento OneToMany unidirecional com mapeamento por chave estrangeira.
  • Inclusão da API de Criteria.

Java Servlet 3.0

Uma das principais melhorias nessa API é a plugabilidade. O objetivo é permitir que frameworks como Struts, JSF, Spring, entre outros, possam ser mais facilmente configurados numa aplicação Web, sem a necessidade de configuração de deployment descriptor como é exigido atualmente. Para isso, o arquivo web.xml passa a ser modular. Cada framework pode definir seu próprio web.xml, usando uma tag específica para definição de fragmentos de aplicação Web, e incluí-lo no diretório META-INF de um arquivo jar. O container é responsável por reconhecer os fragmentos que estão nos jars vinculados à aplicação Web.

A facilidade de desenvolvimento é outro objetivo importante dessa especificação. O uso de recursos da Java SE 5, como anotações e generics, permitem tornar o web.xml opcional e reduzir erros de compilação e execução comumente gerados por implementações e configurações equivocadas. Para criar um servlet na Java EE 6, basta adicionar a anotação @Servlet(url-mapping=”url”) numa classe POJO. Os métodos podem ser anotados com @GET, @POST, entre outras, para identificar o tipo de requisição HTTP atendida. Essas facilidades também estão sendo extendidas para a criação de filtros e listeners.

Um modelo de Servlet assíncrono também está sendo incluído por meio do estilo de programação Comet.

Enterprise JavaBeans 3.1

Na Java EE 5, o componente EJB, que por muitos anos foi criticado por sua complexidade, teve alterações significativas para facilitar o seu uso. O uso de anotações permitiu evitar as interfaces complexas e reduzir as necessidades de configuração no deployment descriptor. Mas a busca pela simplicidade continua na Java EE 6 com o EJB 3.1(JSR 318), liberado por Kenneth Saks.

As interfaces de negócio passam a ser opcionais para acesso local: o loolup pode ocorrer diretamente pela classe do componente, sendo que todos os seus métodos públicos ficam disponíveis. Para oferecer esse suporte, basta não adicionar interfaces para o componente, ou, se uma interface remota(ou mesmo local) já estiver sendo oferecida, basta usar a anotação @LocalBean.

Alguns métodos do EJB podem ser marcados como a anotação @Asynchronous.

O Cliente do componente faz a requisição ao método assíncrono sem precisar esperar pelo retorno imediado, solicitando o resultado quando necessário. O cliente só é bloqueado para esperar um retorno do componente caso a resposta da requisição ainda não tenha sido totalmente concluída quando o cliente a solicita.

Novas APIs

É comum ouvirmos falar que Web Beans é o JBoss Seam, assim JPA é o Hibernate, ou como Facelets está sendo incorporado no JSF 2.0. Mas na verdade a história não é tão simples. Uma analogia válida équando criamos uma classe e depois “extraímos” a interface desta classe. A interface pode não conter todos os métodos e certamente não contém todos os detalhes de implementação da classe. A mesma coisa acontece com os frameworks que estão sendo “incluídos” na Java EE.

Web Beans

A JSR 299: Web Beans, foi criada para unificar os padrões de componentes EJB e JSF Managed Beans, oferecendo um modelo de programação mais simples para aplicações Web. Diversos traços do framework JBoss Seam estão presentes em Web Beans, mas não exatamente como uma réplica, pois diversas funcionalidades de JBoss Seam não serão implementadas. Além disso, houve uma redução  do acoplamento com JavaServer Faces, tornando o Web Beans útil para todos os tipos de aplicação, independente do uso de JSF ou EJB 3.0.

Algumas das principais caracteristicas desta API são:

  • Permitir que qualquer componente possa ser acessado via Unified Expression Language(EL) em páginas JSF e JSP.
  • Introduzir um novo escopo/contexto para as aplicações Web, chamado Conversation, que é maior do que o escopo de Request, e menor do que o escopo Session.
  • Um Web Bean poderá ser injetado em qualquer componente Java EE.

O gerenciador de Web Beans oferece os seguintes serviços para aplicações com EJBs:

  • Injeção de Web Beans em qualquer EJB, Servlet ou Listener ou outro Web Bean;
  • Binding de interceptors e decorators;

Gerenciamento do ciclo de vida dos EJBs, criando e destruindo os componentes e disponibilizando as instâncias no contexto da aplicação.

Existem quatro formas diferentes de criarmos um Web Bean, são elas:

  • Simple Web Bean: uma classe Java simples, concreta;
  • Enterprise Web Bean: é um Web Bean implementado com um Enterprise Java Bean;
  • Producer Methods: são fábricas de objetos que retornam objetos para serem injetados em outros componentes;
  • JMS endpoint: é um Web Bean que representa uma fila ou tópico JMS.

Bean Validation

A JSR 303: A API de validação definida por essa JSR não foi projetada para atender a um tipo específico de aplicação(Web ou Desktop) ou ainda a uma camada específica da aplicação. Pelo contrário, foi criada para unificar a validação em todas as camadas e nos diversos tipos de aplicação Java, sendo vista como uma extensão ao modelo de componentes JavaBeans. Sua configuração pode ser feita por anotações ou XML.

JAX-RS 1.0

Para oferecer suporte ao novo formato de serviços web(REST), a JSR 311 definiu a API JAX-RS 1.0, baseada em anotações da Java SE 5, para viabilizar a disponibilização de RESTFul web services na plataforma Java SE e Java EE.

É isso ai, este artigo fica por aqui!

Abraços!

3 Comentários