Home   IDE   Eclipse   Exemplo completo com JSF Primefaces + Hibernate + MySQL

Exemplo completo com JSF Primefaces + Hibernate + MySQL

Exemplo completo com JSF Primefaces + Hibernate + MySQL


Olá Amigos,

Hoje criaremos um projeto completo com as tecnologias java: JSF (Primefaces) + Hibernate + MySQL ou PostgreSQL.
E como de costume iniciaremos com uma breve descrição de cada uma delas.
Vamos utilizar o nosso sistema acadêmico chamado de AcademicNet para aplicar os conceitos.

Tecnologias utilizadas no exemplo

  • JSF (Java Serer Faces) é a tecnologia Java para construção de páginas dinâmicas.
  • Primefaces é uma biblioteca de componentes para RIA – Rich Internet Application. O que torna os sistemas com uma interface mais amigável para os usuários.
  • Hibernate é um framework para o mapeamento objeto-relacional. Facilita o mapeamento dos atributos entre um Banco de dados Relacional e o modelo de objetos de uma aplicação.
  • O exemplo funciona tanto com MySQL quanto com PostgreSQL

  • MySQL – Banco de dados Relacional muito utilizado no mundo corporativo.
  • Primefaces

    Nossa aplicação funcionará da seguinte maneira.

    A página inicial é a index.jsp Ela faz a apresentação do projeto e quando clicamos na imagem será exibido o menu.jsp nesse menu podemos escolher várias opções de CRUD. A primeira é a mais importante para nós. “Manter Aluno JSF”.

    Veja o código abaixo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    
    <!DOCTYPE html>
    <html lang="pt">
    <head>
    <title>Menu de opções</title>
    </head>
    <body>
    	<div align="center">
    		<H1>Seja bem vindo ao sistema AcademicNet!</H1>
    		<a href="cadastroAluno.xhtml">Manter Aluno JSF</a><br>
    		<a href="aluno.jsp">Manter Aluno</a><br>
    		<a href="AlunoServlet?acao=Listar">Listar Alunos</a><br>
    		<a href="professor.jsp">Manter Professor</a><br>
    		<a href="ProfessorServlet?acao=Listar">Listas Professor</a><br>
    		<a href="usuario.jsp">Manter Usuario</a><br>
    		<a href="UsuarioServlet?acao=Listar">Listar Usuario</a><br>
    		<a href="turma.jsp">Manter Turma</a><br>
    		<a href="TurmaServlet?acao=Listar">Listar Turma</a><br>
    	</div>
    </body>
    </html>

    Essa opção de menu nos levará até a página de cadastro utilizando JSF.

    As primeiras linhas determinam que vamos utilizar JFS, com as URIs dentro da tag . A URI xmlns:p=”http://primefaces.org/ui” informa que utilizaremos o framework Primefaces.

    Observe que para cada campo texto temos um atributo value apontando para uma propriedade da entidade aluno. Veja o exemplo de matrícula:
    . Isso significa que tudo que eu digitado no campo matrícula será atribuído a um objeto aluno.matrícula. Isso ocorre através de uma classe Managed Bean. Ela faz, de forma mais simples, o que as classes Servlets fazem.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    
    <html xmlns="http://www.w3.org/1999/xhtml"
    	xmlns:h="http://java.sun.com/jsf/html"
    	xmlns:f="http://java.sun.com/jsf/core"
    	xmlns:p="http://primefaces.org/ui">
    <h:head>
    </h:head>
    <h:body>
    	<p:growl  id="mensagem" showDetail="true" autoUpdate="true"
    		closable="true" />
     
    	<h:form id="frmAluno">
    		<p:panelGrid columns="2" style="horizontal-align:center">
    			<h:outputText value="Matricula:" />
    			<h:inputText id="matricula" value="#{alunoMB.aluno.matricula}" />
     
    			<h:outputLabel for="nome" value="Nome:" />
    			<h:inputText id="nome" value="#{alunoMB.aluno.nome}" />
    			<h:outputLabel value="Telefone:" />
    			<h:inputText id="telefone" value="#{alunoMB.aluno.telefone}" />
    			<h:outputLabel value="Email:" />
    			<h:inputText id="email" value="#{alunoMB.aluno.email}" />
    			<h:outputLabel value="Data Cadastro:" />
    			<p:calendar value="#{alunoMB.aluno.dataCadastro}" locale="pt_BR"
    				id="dataCadastro" showButtonPanel="true">
    				<f:convertDateTime pattern="dd/MM/yyyy" />
    			</p:calendar>
    		</p:panelGrid>
    		<p:panelGrid columns="6">
    			<h:commandButton action="#{alunoMB.incluir}" value="Incluir" update="tabela" />
    			<h:commandButton action="#{alunoMB.alterar}" value="alterar"	update="tabela" />
    			<h:commandButton action="#{alunoMB.consultar}" value="Consultar" update="tabela, :frmAluno" />
    			<h:commandButton action="#{alunoMB.listar}" value="Listar" update="tabela" />
    			<h:commandButton action="#{alunoMB.excluir}" value="Excluir"	update="tabela" />
    			<h:commandButton action="#{alunoMB.limpar}" value="Limpar" update="tabela" />
     
    		</p:panelGrid>
    	</h:form>
    	<p:dataTable id="tabela" var="item" value="#{alunoMB.lista}"
    		paginator="true" rows="50" emptyMessage="Não há registros na lista"
    		paginatorTemplate="{CurrentPageReport}  {FirstPageLink} {PreviousPageLink} {PageLinks} {NextPageLink} {LastPageLink} {RowsPerPageDropdown}"
    		rowsPerPageTemplate="10,15,25,50,100">
    		<f:facet name="header">Lista de Alunos</f:facet>
    		<p:column headerText="ID" style="width: 10%;"
    			sortBy="#{item.matricula}">
    			<h:outputText value="#{item.matricula}" />
    		</p:column>
    		<p:column headerText="Nome" style="width: 25%;" sortBy="#{item.nome}">	<h:outputText value="#{item.nome}" />
    		</p:column>
    		<p:column headerText="Telefone" style="width: 25%;" sortBy="#{item.telefone}">
    			<h:outputText value="#{item.telefone}" /></p:column>
    		<p:column headerText="E-mail" style="width: 25%;" sortBy="#{item.email}">
    			<h:outputText value="#{item.email}" />
    		</p:column>
    	</p:dataTable>
    </h:body>
    </html>

    No arquivo web.xml fazemos algumas configurações para que o nosso projeto esteja preparado para executar JSF. Essas configurações são opcionais para utilização do Framework Primefaces.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    
     
    <?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_3_0.xsd"
    	id="WebApp_ID" version="3.0">
    	<display-name>AcademicNetWebEJB</display-name>
    	<welcome-file-list>
    		<welcome-file>index.jsp</welcome-file>
    	</welcome-file-list>
    	<context-param>
    		<param-name>javax.faces.PROJECT_STAGE</param-name>
    		<param-value>Development</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>*.jsf</url-pattern>
    		<url-pattern>*.faces</url-pattern>
    		<url-pattern>*.xhtml</url-pattern>
    	</servlet-mapping>	
    </web-app>

    Veja o código do nosso “alunoMB”. A novidade aqui é a anotação @ManagedBean. Isso determina que nossa classe é um tipo especial e que pode ser associada a uma
    tela. Neste caso este Managed Bean está associado à tela de aluno. Ela tem os métodos necessários para incluir, alterar, consultar, excluir e listar alunos.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    
     
    package br.com.feltex.academicnet.mb;
     
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
     
    import javax.faces.application.FacesMessage;
    import javax.faces.bean.ManagedBean;
    import javax.faces.context.FacesContext;
     
    import br.com.feltex.academicnet.dao.AlunoDAO;
    import br.com.feltex.academicnet.dao.DAOFactory;
    import br.com.feltex.academicnet.entidade.Aluno;
     
    @ManagedBean(name = "alunoMB")
    public class AlunoMB implements Serializable {
     
    	private static final long serialVersionUID = 8103328274400432976L;
    	private Aluno aluno;
    	private List<Aluno> lista = new ArrayList<>();
     
    	AlunoDAO dao = DAOFactory.getAlunoDAO();
     
    	public AlunoMB() {
    		aluno = new Aluno();
    		listar();
    	}
     
    	public void alterar() {
    		System.out.println("Alterar aluno");
    		dao.alterar(aluno);
    		listar();
    		FacesContext.getCurrentInstance().addMessage(
    				null,
    				new FacesMessage(FacesMessage.SEVERITY_INFO,
    						"Manutenção de usuário: ",
    						"Usuario alterado com sucesso!"));
    	}
     
    	public void consultar() {
    		long matriculaConsulta = aluno.getMatricula();
    				System.out.println("Consultar");
    		aluno = dao.consultar(aluno);
    		if (aluno == null || aluno.getMatricula() == 0) {
    			FacesContext.getCurrentInstance().addMessage(
    					null,
    					new FacesMessage(FacesMessage.SEVERITY_ERROR,
    							"Manutenção de usuário: ",
    							"Usuario não encontrado matrícula:" + matriculaConsulta + "!"));
    		}
    		listar();
     
    	}
     
    	public void excluir() {
    		System.out.println("Excluir aluno");
    		dao.excluir(aluno);
    		listar();
    		FacesContext.getCurrentInstance().addMessage(
    				null,
    				new FacesMessage(FacesMessage.SEVERITY_INFO,
    						"Manutenção de usuário: ",
    						"Usuario excluído com sucesso!"));
    	}
     
    	public Aluno getAluno() {
    		return aluno;
    	}
     
    	public List<Aluno> getLista() {
    		return lista;
    	}
     
    	public void incluir() {
    		System.out.println("Incluir aluno");
    		dao.inserir(aluno);
    		listar();
    		FacesContext.getCurrentInstance().addMessage(
    				null,
    				new FacesMessage(FacesMessage.SEVERITY_INFO,
    						"Manutenção de usuário: ",
    						"Usuario incluido com sucesso!"));
    	}
     
    	public void limpar() {
    		System.out.println("Limpar");
    		System.out.println(aluno);
    		aluno = new Aluno();
    	}
     
    	public void listar() {
    		System.out.println("Listar aluno");
    		lista = dao.listar();
    	}
     
    	public void setAluno(Aluno aluno) {
    		this.aluno = aluno;
    	}
     
    	public void setLista(List<Aluno> lista) {
    		this.lista = lista;
    	}
    }

    Depois compare esse managedBean com o servlet “AlunoServlet”.

    O nosso ManagedBean utilizar um padrão de projeto DAOFactory, ou seja, existe uma classe que gera uma instância de um objeto que acessa o Banco de dados.
    AlunoDAO dao = DAOFactory.getAlunoDAO();

    Código abaixo:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    
    package br.com.feltex.academicnet.dao;
     
    import br.com.feltex.academicnet.dao.hibernate.AlunoHibernateDAO;
    import br.com.feltex.academicnet.dao.jdbc.ProfessorDAO;
    import br.com.feltex.academicnet.dao.jdbc.ProfessorJDBCDAO;
    import br.com.feltex.academicnet.dao.jdbc.TurmaDAO;
    import br.com.feltex.academicnet.dao.jdbc.TurmaJDBCDAO;
    import br.com.feltex.academicnet.dao.jdbc.UsuarioJDCBDAO;
     
    public class DAOFactory {
     
    	public static AlunoDAO getAlunoDAO() {
    		return new AlunoHibernateDAO();
    	}
     
    	public static ProfessorDAO getProfessorDAO() {
    		return new ProfessorJDBCDAO();
    	}
     
    	public static TurmaDAO getTurmaDAO() {
    		return new TurmaJDBCDAO();
    	}
     
    	public static UsuarioDAO getUsuarioDAO() {
    		return new UsuarioJDCBDAO();
    	}
    }

    Por exemplo o método “getAlunoDAO” nos retorna um objeto que acessa o banco de dados via Hibernate e o método getProfessorDAO retorna um acesso ao mesmo Banco de Dados via JDBC. Você pode pensar, mas quando isso seria útil de verdade?

    Imagine um sistema que temos Sistema de PDV (Ponto de Vendas). Meu sistema deve estar preparado para acessar qualquer banco de dados. Para isso o meu DAOFactory pode nos atender gerando objetos diferentes de acordo com parâmetros que eu informar.

    Minha classe “AlunoHibernateDAO” implementa a interface “AlunoDAO” que define a assinatura de todos os métodos necessários para acesso a banco de dados para a tabela aluno. Neste exemplo todo o controle de transação é gerenciado por nossa aplicação. É o chamado Bean Transation Management.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    
    package br.com.feltex.academicnet.dao.hibernate;
     
    import java.util.ArrayList;
    import java.util.List;
     
    import org.hibernate.Criteria;
    import org.hibernate.Session;
    import org.hibernate.criterion.Order;
    import org.hibernate.criterion.Restrictions;
     
    import br.com.feltex.academicnet.dao.AlunoDAO;
    import br.com.feltex.academicnet.entidade.Aluno;
    import br.com.feltex.hibernate.util.HibernateUtil;
     
    public class AlunoHibernateDAO implements AlunoDAO {
     
    	private Session session;
     
    	public void alterar(Aluno p) {
    		try {
    			session = HibernateUtil.getSession();
    			session.beginTransaction();
    			session.update(p);
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			session.getTransaction().rollback();
    			e.printStackTrace();
    		} finally {
    			session.close();
    		}
    	}
     
    	public Aluno consultar(Aluno aluno) {
    		Aluno retorno = new Aluno();
    		try {
    			session = HibernateUtil.getSession();
    			session.beginTransaction();
    			retorno = (Aluno) session.get(Aluno.class, aluno.getMatricula());
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			session.getTransaction().rollback();
    			e.printStackTrace();
    		} finally {
    			session.close();
    		}
    		return retorno;
    	}
     
    	public void excluir(Aluno p) {
    		try {
    			session = HibernateUtil.getSession();
    			session.beginTransaction();
    			session.delete(p);
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			session.getTransaction().rollback();
    			e.printStackTrace();
    		} finally {
    			session.close();
    		}
    	}
     
    	public boolean existe(Aluno aluno) {
     
    		Aluno a = consultar(aluno);
    		return (a.getMatricula() != null);
    	}
     
    	public void inserir(Aluno p) {
    		try {
    			session = HibernateUtil.getSession();
    			session.beginTransaction();
    			session.save(p);
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			session.getTransaction().rollback();
    			e.printStackTrace();
    		} finally {
    			session.close();
    		}
    	}
     
    	@SuppressWarnings("unchecked")
    	public List<Aluno> listar() {
    		List<Aluno> lista = new ArrayList<Aluno>();
    		try {
    			session = HibernateUtil.getSession();
    			session.beginTransaction();
    			lista = (List<Aluno>) session.createCriteria(Aluno.class).list();
    			session.getTransaction().commit();
    		} catch (Exception e) {
    			session.getTransaction().rollback();
    			e.printStackTrace();
    		} finally {
    			session.close();
    		}
    		return lista;
    	}
     
    	@SuppressWarnings("unchecked")
    	public List<Aluno> listar(Aluno aluno) {
    		Criteria c = session.createCriteria(Aluno.class);
    		if (aluno.getNome().length() > 0) {
    			c.add(Restrictions.like("nome", aluno.getNome() + "%"));
    		}
    		c.addOrder(Order.asc("nome"));
    		return (List<Aluno>) c.list();
    	}
    }

    O arquivo de configuração hibernate.cfg.xml. É nele que informação os dados de configuração de acesso ao banco de dados. Servidor, Porta, Nome do Banco, usuário e senha são as informações básicas para acesso do nosso Banco.

    hibernate.dialect => Define qual o "dialeto" será utilizado no banco de dados. Neste caso o dialeto para MySQL. Veja no final deste artigo o link para o catálogo de dialects
    hibernate.show_sql => Define se os comandos SQL gerados pelo Hibernate devem ser mostrados. (true ou false)
    hibernate.format_sql => Define se os comando SQL terão quebra de linha a parte significativa do script
    hibernate.jdbc.batch_size => Define a gravação de dados em lote.
    hibernate.hbm2ddl.auto => Possíveis valores e ações
    validate: validar o esquema, não faz alterações para o banco de dados.
    update: atualizar o esquema.
    create: cria o esquema, destruindo dados anteriores.
    create-drop: remover o esquema no final da sessão.

    No final a tag serve para mapear as entidades que serão utilizadas no Hibernate.

    ATENÇÃO> Não esqueça de adicionar a annotation @Entity a todas classes que foram informadas nas tags mapping

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
    	<session-factory>
    		 <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/bdacademicnet</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">teco01</property>
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		<property name="hibernate.show_sql">true</property>
    		<property name="hibernate.format_sql">true</property>
    		<property name="hibernate.jdbc.batch_size">20</property>
     
     
    		<property name="hibernate.hbm2ddl.auto">update</property>
     
    		<!-- validate | update | create | create-drop -->
    		<mapping class="br.com.feltex.academicnet.entidade.Aluno" />
    		<mapping class="br.com.feltex.academicnet.entidade.Turma" />		
    	</session-factory>
    </hibernate-configuration>


    DICA: Existem 2 arquivos extras de configuração do Hibernate. Esses arquivos não são necessários no projeto.
    Caso você queria ver exemplos de configuração para PostgreSQL(hibernate.postgresql.cfg.xml) ou MySQL(hibernate.mysql.cfg.xml).
    Servem como apoio para alterações do arquivo: hibernate.cfg.xml

    Deixei disponível o projeto completo com o código fonte para auxiliar a todos no processo de aprendizado. Para baixar: Clique aqui

    Conclusão


    Este artigo mostra como fazer um CRUD simples com utilização do JSF utilizando o framework Primefaces junto com MySQL e Hibernate. Este mesmo exemplo funciona com JSP, JDBC e Servlet. Assim o leitor poderá fazer comparações de como funcionam essas tecnologias.

    Links relacionados

    Recomendo que leia: Como gerenciar a transação JPA com Hibernate via Filtro em projeto Web

    Leia também: Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS (Topic)

    Você irá gostar:Bean Transaction Management
    Hibernate Manual
    Hibernate Dialects

    Abraços e bons estudos.

    Não se esqueça de curtir este post nas redes sociais. Dê a sua contribuição social e ajude o autor:

    Deixe uma resposta

    Get Best Services from Our Business.