Este documento resume as principais tecnologias para desenvolvimento de sistemas web em Java, incluindo Facelets, Java Server Faces (JSF), Hibernate e RichFaces. O documento discute o funcionamento e configuração dessas tecnologias e fornece exemplos de código.

1. Sistemas WEB em Java
utilizando as tecnologias
Hibernate, JSF, Facelets e
Richfaces
Rogério Napoleão Júnior
rogerionj@gmail.com
@rogerionj

2. O que estaremos
utilizando?
• Eclipse JEE
• Tomcat 7.0
• MySQL
• Importar projeto modelo para o Eclipse

3. Facelets
• Framework de código aberto
• Feito especificamente para o JSF
• Norteado por 3 ideias centrais:
o Integração com JSF
o Templates
o Composições de Componentes

4. Facelets - Características
• Disponibiliza um novo compilador de páginas
baseado em XHTML
• Realiza a criação da árvore de componentes
das telas JSF
• Criação de templates de tela JSF e reuso
(herança) de telas
• Facelets é de 30% a 50% mais rápido que JSP

5. Facelets

6. Facelets

7. Configuração
• Importe o arquivo facelets.jar para dentro da pasta
lib da aplicação
• Dentro do arquivo faces-config.xml inclua o trecho
a seguir:
<application>
<view-handler>com.sun.facelets.FaceletViewHandler</view-handler>
</application>

8. Configuração
• No arquivo web.xml adicionar:
<context-param>
<param-name>javax.faces.DEFAULT_SUFFIX</param-name>
<param-value>.xhtml</param-value>
</context-param>

9. Funcionamento
• O Facelets oferece um ótimo mecanismo para geração
de templates, o que torna a construção de uma
aplicação toda com o mesmo layout, muito simples e
rápida, além de evitar a repetição de código html
• Na criação do template, definimos os “espaços” que
podem ser substituídos no template através da tag
<ui:insert> e o atributo name dessa tag define o nome
desse “espaço”.
<div id="esquerda">
<ui:insert name="menu" />
</div>
<div id="centro">
<ui:insert name="corpo" />
</div>

10. Funcionamento
• Para informarmos que estamos utilizando um template
incluímos a tag <ui:composition> com o seu atributo
template que define o diretório onde está o template.
<ui:composition template="/pages/TemplateDiv.xhtml">
• Utilizando a tag <ui:define> definimos o que vai
preencher o “espaço” do template
<ui:define name="menu">
<h:outputText value="Menu1:" /><br/>
<h:outputText value="Menu2:" /><br/>
<h:outputText value="Menu3:"/><br/>
</ui:define>

11. Java Server Faces
• JavaServer Faces é um framework MVC para o
desenvolvimento de aplicaçoes WEB.
• O JSF é atualmente considerado por muitos como
a última palavra em termos de desenvolvimento de
aplicações Web, resultado da experiência e
maturidade adquiridas com o JSP/Servet.

12. Java Server Faces
• Permite que o desenvolvedor crie UIs (User
Interfaces) através de um conjunto de
componentes UIs pré-definidos;
• Fornece um conjunto de tags JSP para acessar os
componentes;
• Reutiliza componentes da página;
• Associa os eventos do lado cliente com os
manipuladores dos eventos do lado do servidor (os
componentes de entrada possuem um valor local
representando o estado no lado servidor);

13. Java Server Faces
• Fornece separação de funções que envolvem a
construção de aplicações Web.
• A estrutura das aplicações permanecem a mesma.
• Continuam existindo Servlet e JSP, na mesma
aplicação.
• Novos elementos de marcação de texto
são presentes nas páginas.

14. Java Server Faces

15. Configurando JSF
• Importar arquivos jsf-api.jar, jsf-impl.jar e jstl.jar para
pasta lib do projeto
• Incluir no web.xml a seguinte configuração
<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>*.jsf</url-pattern>
</servlet-mapping>

16. Configurando JSF
• Criar o arquivo faces-config.xml na pasta WEB-INF
com o seguinte conteúdo:
<faces-config>
</faces-config>
Obs.: Ajustar o build.xml para copiar este arquivo

17. Primeiro exemplo
• hello.jsp:
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<html>
<head>
<title>Teste JSF</title>
</head>
<body>
<f:view>
<h:outputText value="Hello"/>
</f:view>
</body>
</html>

18. Tag Library
Documentation - JSF
• http://download.oracle.com/javaee/5/javaserverf
aces/1.2/docs/tlddocs/
• Contém todas as tags disponívels do JSF.

19. Managed Bean
• Managed Bean é um JavaBean gerenciado pelo
framework JSF, ou seja, ele é instanciado, e
colocado no escopo de acordo com as
configurações encontradas no faces-config.xml
• Um ManagedBean também é chamado de
backing bean, pois contém os dados e os métodos
que serão executados quando algum dos
componentes da página JSF tiver que executar
uma ação.

20. Criando um Managed
Bean
• Criar uma classe java HelloManagedBean
o Siga os passos
• Declaração do Managed Bean no faces-
config.xml:
<managed-bean>
<managed-bean-name>hello</managed-bean-name>
<managed-bean-class>
br.com.projedata.projeto.view.backbean.HelloBackBean
</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>

21. Managed Bean
• Utilizamos Taglibs e EL (Expression Language) para
associar (fazer o binding) de um componente de UI
com um ManagedBean.
• Ex: <h:outputText value=“#{hello.msg}”/>

22. Regras de navegação
• As regras de navegação no JSF são definidas no faces-config.xml.
Isso possibilita a partir do retorno de um método, seguir para o
destino desejado.
• Exemplo:
<navigation-rule>
<from-view-id>/hello.jsp</from-view-id>
<navigation-case>
<from-outcome>stringRetorno</from-outcome>
<to-view-id>/hello2.jsp</to-view-id>
</navigation-case>
</navigation-rule>

23. Richfaces
• Framework ajax para JSF Ajax4JSF
• Funciona em qualquer conteiner Java
• Skins dinâmicos
• Decidimos que parte da pagina atualizar
(reRender)
• Web 2.0

24. Configuração Richfaces
• Inserir no web.xml:
<context-param>
<param-name>org.richfaces.SKIN</param-name>
<param-value>blueSky</param-value>
</context-param>
<filter>
<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>

25. Configuração Richfaces
• Inserir na pasta os arquivos:
o richfaces-api-3.3.3.Final.jar
o richfaces-impl-3.3.3.Final.jar
o richfaces-ui-3.3.3.Final.jar
o commons-logging.jar
o commons-digester.jar
o commons-collections.jar
o commons-beanutils.jar

26. Richfaces - TLD
• http://docs.jboss.org/richfaces/latest_3_3_X/en/tldd
oc/
• Live demo:
o http://livedemo.exadel.com/richfaces-demo/index.jsp

27. Hibernate – O que é?
• Framework opensource de mapeamento objeto-
relacional.
• Representa um modelo de Objetos para um
modelo Relacional.
• Possibilita a persistência através de objetos, e não
de comandos SQL’s escritos diretamente.

28. Hibernate – Por que usar?
• O aumento da popularidade da orientação a
objetos
• Uso de Banco de Dados do Modelo Relacional
• Dificuldade de utilizar os dois juntos

29. Hibernate - Características
• Visa diminuir a complexidade no tratamento dos dados
provenientes de um banco;
• Torna o programa portável, deixando-o independente do
banco de dados;
• Gera automaticamente todo o schema do banco de dados;
• Pode ser utilizado em um servidor de aplicações ou
standalone.
• Para mapear as classes, são utilizadas configurações em
arquivos XML ou JPA;

30. Hibernate -
Funcionamento
• O Hibernate configura-se como uma camada entre a
aplicação e o banco de dados;
• Uma classe Java é mapeada no Hibernate como uma tabela
no banco;
• Cada instância dessa classe corresponde a um registro da
tabela alocado na memória;

31. Hibernate -
Funcionamento

32. Hibernate - Configuração
• Criar pasta META-INF no src do projeto.
• Criar arquivo persistence.xml e colocar dentro da pasta
META-INF:
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="projetoPU" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name="hibernate.connection.url" value="jdbc:mysql://localhost/test"/>
<property name="hibernate.connection.driver_class"
value="com.mysql.jdbc.Driver"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
<property name="hibernate.connection.password" value=""/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>

33. Hibernate - Configuração
• Adicionar as libs a seguir na pasta lib:
o ejb3-persistence.jar
o hibernate-entitymanager.jar
o hibernate-annotations.jar
o hibernate-commons-annotations.jar
o hibernate-core.jar
o hibernate-validator.jar
o dom4j.jar
o slf4j-api-1.5.6.jar
o slf4j-log4j12-1.5.6.jar
o log4j.jar
o javassist.jar
o jboss-javaee.jar
o antlr.jar

34. Hibernate com Anotações
• Hibernate precisa de metadados para transformar
de uma representação para outra.
• Sem necessidades de mapeamento XML, apenas
com anotações
• As anotações são antecedidas por um arroba(@)

35. Algumas anotações
• @Entity – deve ser posto em uma classe de
entidade
• @Table – dados da tabela
• @Id – Identificador
• @GeneratedValue – Gerador de valor da chave
primaria
• @Column – transforma um atributo do objeto em
campos da tabela

36. Relacionamentos
• @OneToOne – um para um
• @OneToMany – um para muitos
• @ManyToMany – muitos para muitos
• @JoinColumn – coluna que recebera os dados de
outra tabela
• @JoinTable – tabela intermediaria do
relacionamento

37. Exemplo
• Mapear UsuarioBean

38. •
Operações com Hibernate
EntityManagerProvider – Fornece a conexão para a transação da
operação através do Hibernate:
public class EntityManagerProvider {
private static EntityManagerFactory emf;
private EntityManagerProvider(){
}
public static EntityManagerFactory getEntityManagerFactory(){
if(emf == null){
emf = Persistence.createEntityManagerFactory("projetoPU");
}
return emf;
}
}

39. Operações com Hibernate
• Exemplo de execução de transação:
public static EntityManager em;
public void inserirUsuario(UsuarioBean usuario){
em =
EntityManagerProvider.getEntityManagerFactory().createEntityManager();
try{
em.getTransaction().begin();
em.persist(usuario);
em.getTransaction().commit();
}finally{
em.close();
}
}

40. HQL
• Hibernate Query Language
• Totalmente orientada a objetos
• Possui paradigmas de herança, polimorfismo e
encapsulamento.
• O HQL é bastante similar ao SQL, porém ao invés
de usar tabelas ele usa as classes de entidades.

41. HQL
• Consultas podem ser tanto em SQL como em HQL
• Exemplo:
o “from UsuarioBean where nome = “Rogério””
o Onde o nome é o nome do atributo da entidade e não o nome da
coluna!

42. Relacionamentos - Lazy e
Eager
• Lazy – Não carrega os objetos do relacionamento
• Eager – Carrega os objetos do relacionamento da
classe
• Qual pode ser o impacto disto?

43. Class genérica de
persistência
• Criar classe genérica de exemplo
• Pode ser empacotada em um jar, e ser utilizada
como framework.

44. Perguntas?
• Email: rogerionj@gmail.com
• Twitter: @rogerionj
• Linkedin: http://br.linkedin.com/in/rogerionapoleao