Exemplo completo com JSF Primefaces + Hibernate + MySQL

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

O exemplo funciona tanto com MySQL quanto com PostgreSQL

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:

	

		
Seja bem vindo ao sistema AcademicNet!
		Manter Aluno JSF

		Manter Aluno

		Listar Alunos

		Manter Professor

		Listas Professor

		Manter Usuario

		Listar Usuario

		Manter Turma

		Listar Turma

	

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.

	

	
		
			
			

			
			
			
			
			
			
			
			
				
			
		
		
			
			
			
			
			
			

		
	
	
		Lista de Alunos
		
			
		
			
		
		
			
		
			
		
	

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.

	AcademicNetWebEJB
	
		index.jsp
	
	
		javax.faces.PROJECT_STAGE
		Development
	
	
		Faces Servlet
		javax.faces.webapp.FacesServlet
		1
	
	
		Faces Servlet
		*.jsf
		*.faces
		*.xhtml
		

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.

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 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 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 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:

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.

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 listar() {
		List lista = new ArrayList();
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			lista = (List) 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 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) 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

	
		 com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/bdacademicnet
        root
        teco01
        org.hibernate.dialect.MySQLDialect
		true
		true
		20
		
		
		update
		
		
		
				
	


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

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:

The post Exemplo completo com JSF Primefaces + Hibernate + MySQL appeared first on Aprenda Java.

Tecnologias utilizadas no exemplo

1. Introdução

Este exemplo começa uma página inicial index.jsp que exibe as informações de funcionamento do projeto. Ao clicar na imagem principal é exibido o menu.jsp.
Esta página tem a opção de listagem de alunos ou realizar a manutenção (Inclusão, alteração, consulta ou exclusão de um Aluno). Se escolhermos a opção de cadastro será exibida a tela de manutenção.
Veja os campos disponíveis.

img 1 – Visão macro do nosso projeto

Para maior facilidade as classes e páginas também foram comentadas para auxiliar no entendimento e estudo do código.

    Você deverá ter conhecimento prévio de Aplicação Web Java e utilização do Tomcat. 
Caso ainda não tenha, acesse os links informados no final deste artigo.

2 . Criação da tabela no banco de dados

Script de criação da tabela no Banco de dados:

CREATE TABLE  IF NOT EXISTS tbaluno(
  matricula bigint NOT NULL,  
  nome character varying(255),
  telefone character varying(255),  
  email character varying(255),
  datacadastro date,
  CONSTRAINT tbaluno_pkey PRIMARY KEY (matricula)
);

É criado o comando que gera a tabela caso ela ainda não exista.

3 . Construção do projeto

Nela temos o nome do projeto (AcademicNetWeb)
Abaixo os nós mais importantes são:
-> Java Resources (src) (Aqui teremos os códigos fontes arquivos .java)
-> WebContent (Aqui ficam os arquivos web JSPs, imagens, JavaScript).

Para criar o projeto, no Eclipse, acesse o menu File >> Other…>> Na tela que aparece escolha Web >> Dynamic Web Project.
Dê o nome de “AcademicNetWeb” … Next >> Next … Na última tela Selecione a opição “Generate web.xml deployment descriptor”. >> Finish

Para saber mais sobre criação de projeto web no Eclipse Clique Aqui

Vamos criar a classe de entidade Aluno. O conteúdo deve ser o seguinte:

package br.com.feltex.entidade;

import java.io.Serializable;
import java.util.Date;

/**
 * 
 * Classe de entidade que possui os atributos do aluno 
 *
 */
public class Aluno implements Serializable {
	private static final long serialVersionUID = -309513637403441918L;

	private Long matricula;

	private String nome;

	private String telefone;

	private String email;

	private Date dataCadastro;

	public Aluno() {}

	public Aluno(Long matricula) {
		super();
		this.matricula = matricula;
	}

	public Aluno(Long matricula, String nome) {
		super();
		this.matricula = matricula;
		this.nome = nome;
	}

	public Date getDataCadastro() {
		return dataCadastro;
	}

	public String getEmail() {
		return email;
	}

	public Long getMatricula() {
		return matricula;
	}

	public String getNome() {
		return nome;
	}

	public String getTelefone() {
		return telefone;
	}

	public void setDataCadastro(Date dataCadastro) {
		this.dataCadastro = dataCadastro;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public void setMatricula(Long matricula) {
		this.matricula = matricula;
	}

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

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

	@Override
	public String toString() {
		return "Aluno [matricula=" + matricula + ", nome=" + nome
				+ ", telefone=" + telefone + ", email=" + email
				+ ", dataCadastro=" + dataCadastro + "]";
	}
}

A Classe DAO é a classe que utilizamos para conectar como Banco de Dados PostgreSQL.

package br.com.feltex.dao;

import java.sql.Connection;
import java.sql.DriverManager;

/**
 * Classe responsável pela Conexão com o Banco de dados. É utilizada por outras
 * classes de persistência de dados.
 * 
 */
public class DAO {
	public Connection getConexao() {
		Connection conexao = null;
		String usuario = "postgres";
		String senha = "teco01";
		String nomeBancoDados = "bdacademicnet";

		try {
			Class.forName("org.postgresql.Driver");
			conexao = DriverManager.getConnection("jdbc:postgresql://localhost:5432/" + nomeBancoDados,
					 usuario, senha);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conexao;
	}
}

A classe AlunoDAO é responsável por realizar todas as operações com Banco de dados.
Nela encontramos os métodos de persistência (
alterar – alteração de um registro no banco de dados
excluir – exclui um registro no banco de dados
existe – Verifica a existência de uma matrícula informada no banco de dados
inserir – incluirá os dados de um aluno no banco de dados
listar – retorna todos os registros existentes no banco de dados
consultar – retorna um registro identificado com a matrícula informada
)

package br.com.feltex.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import br.com.feltex.entidade.Aluno;

/**
 * 
 * Classe de Persistência de dados dos objetos de Aluno
 * é "filha" da Classe DAO. 
 *
 */

public class AlunoDAO extends DAO {

	public void alterar(Aluno aluno) {
		try {
			Connection conexao = getConexao();

			PreparedStatement pstmt = conexao
					.prepareStatement("Update tbaluno SET nome = ?, telefone = ?, email = ?, datacadastro = ?"
							+ " WHERE matricula = ? ");
			pstmt.setString(1, aluno.getNome());
			pstmt.setString(2, aluno.getTelefone());
			pstmt.setString(3, aluno.getEmail());
			pstmt.setDate(4, new java.sql.Date(aluno.getDataCadastro().getTime()));
			pstmt.setLong(5, aluno.getMatricula());
			pstmt.execute();
			pstmt.close();
			conexao.close();

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void excluir(Aluno aluno) {
		try {
			Connection conexao = getConexao();
			PreparedStatement pstm = conexao
					.prepareStatement("Delete from	tbaluno where matricula = ? ");
			pstm.setLong(1, aluno.getMatricula());
			pstm.execute();
			pstm.close();
			conexao.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public boolean existe(Aluno aluno) {
		boolean achou = false;
		try {
			Connection conexao = getConexao();
			PreparedStatement pstm = conexao
					.prepareStatement("Select * from tbaluno where matricula =	?");
			pstm.setLong(1, aluno.getMatricula());
			ResultSet rs = pstm.executeQuery();
			if (rs.next()) {
				achou = true;
			}
			pstm.close();
			conexao.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return achou;
	}

	public void inserir(Aluno aluno) {
		try {
			Connection conexao = getConexao();
			PreparedStatement pstm = conexao
					.prepareStatement("Insert into	tbaluno (matricula, nome, telefone, email, datacadastro) values	(?,?,?,?,?)");
			pstm.setLong(1, aluno.getMatricula());
			pstm.setString(2, aluno.getNome());
			pstm.setString(3, aluno.getTelefone());
			pstm.setString(4, aluno.getEmail());
			pstm.setDate(5, new java.sql.Date(aluno.getDataCadastro()
					.getTime()));
			pstm.execute();
			pstm.close();
			conexao.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public List listar() {
		List lista = new ArrayList<>();
		try {
			Connection conexao = getConexao();
			Statement stm = conexao.createStatement();
			ResultSet rs = stm.executeQuery("Select * from tbaluno");
			while (rs.next()) {
				Aluno aluno = new Aluno();
				aluno.setMatricula(rs.getLong("matricula"));
				aluno.setNome(rs.getString("nome"));
				aluno.setTelefone(rs.getString("telefone"));
				aluno.setEmail(rs.getString("email"));
				aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime()));
				lista.add(aluno);
			}
			stm.close();
			conexao.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return lista;
	}

	public Aluno consultar(Aluno aluno) {
		try {
			Connection conexao = getConexao();
			PreparedStatement pstm = conexao
					.prepareStatement("Select * from tbaluno where matricula =	?");
			pstm.setLong(1, aluno.getMatricula());
			ResultSet rs = pstm.executeQuery();
			if (rs.next()) {
				aluno.setMatricula(rs.getLong("matricula"));
				aluno.setNome(rs.getString("nome"));
				aluno.setTelefone(rs.getString("telefone"));
				aluno.setEmail(rs.getString("email"));
				aluno.setDataCadastro(new java.util.Date(rs.getDate("datacadastro").getTime()));
			}
			pstm.close();
			conexao.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return aluno;
	}
}

AlunoServlet a principal classe do nosso projeto. Ela é a controladora da navegação. Todas as requisições de acesso ao banco de dados, controle de navegação, leitura de dados da tela ou envio para o destino de erro ou sucesso é responsabilidade desta classe. Seguindo o padrão MVC ela é o Contoller.

package br.com.feltex.servlet;

import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import br.com.feltex.dao.AlunoDAO;
import br.com.feltex.entidade.Aluno;

@WebServlet("/AlunoServlet")
public class AlunoServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		String acao = request.getParameter("acao");
		String destino = "sucesso.jsp";
		String mensagem = "";
		List lista = new ArrayList<>();

		
		Aluno aluno = new Aluno();
		AlunoDAO dao = new AlunoDAO();
		
		try {

			//Se a ação for DIFERENTE de Listar são lidos os dados da tela
			if (!acao.equalsIgnoreCase("Listar")) {
				aluno.setMatricula(Long.parseLong(request.getParameter("matricula")));
				aluno.setNome(request.getParameter("nome"));
				aluno.setTelefone(request.getParameter("telefone"));
				aluno.setEmail(request.getParameter("email"));
				
				//Faz a leitura da data de cadastro. Caso ocorra um erro de formatação
				// o sistema utilizará a data atual
				try {
					DateFormat df = new SimpleDateFormat("dd/MM/yyyy");					
					aluno.setDataCadastro(df.parse(request.getParameter("dataCadastro")));
				} catch (Exception e) {
					aluno.setDataCadastro(new Date());	
				}
				
			}

			if (acao.equalsIgnoreCase("Incluir")) {
				// Verifica se a matrícula informada já existe no Banco de Dados
				// Se existir enviar uma mensagem senão faz a inclusão
				if (dao.existe(aluno)) {
					mensagem = "Matrícula informada já existe!";
				} else {
					dao.inserir(aluno);
				}
			} else if (acao.equalsIgnoreCase("Alterar")) {
				dao.alterar(aluno);
			} else if (acao.equalsIgnoreCase("Excluir")) {
				dao.excluir(aluno);
			} else if (acao.equalsIgnoreCase("Consultar")) {
				request.setAttribute("aluno", aluno);
				aluno = dao.consultar(aluno);
				destino = "aluno.jsp";
			}
		} catch (Exception e) {
			mensagem += e.getMessage();
			destino = "erro.jsp";
			e.printStackTrace();
		}
		
		// Se a mensagem estiver vazia significa que houve sucesso!
		// Senão será exibida a tela de erro do sistema.
		if (mensagem.length() == 0) {
			mensagem = "Aluno Cadastrado com sucesso!";
		} else {
			destino = "erro.jsp";
		}

		// Lista todos os registros existente no Banco de Dados
		lista = dao.listar();
		request.setAttribute("listaAluno", lista);
		request.setAttribute("mensagem", mensagem);
		

		//O sistema é direcionado para a página 
		//sucesso.jsp Se tudo ocorreu bem
		//erro.jsp se houver algum problema.
		RequestDispatcher rd = request.getRequestDispatcher(destino);
		rd.forward(request, response);
	}
}

4. Criação das páginas

index.jsp Página inicial do nosso projeto. Utilizamos aqui conteúdo HTML5 puro. Uma página simples, sem conteúdo dinâmico e que possui os links para o menu da aplicação quando clicamos na imagem.

	

	
 Seja bem vindo ao sistema AcademicNet!
	

	  Nesta versão utilizaremos as tecnologias: JSP + JSTL + Servlet + JDBC + PostGreSQL.
	
	   
	    
	    		  
	
	
  http://www.feltex.com.br			

menu.jsp Página que conterá as opções de cadastros no nosso sistema. Também uma página simples, sem conteúdo dinâmico e que possui os links para o menu da aplicação quando clicamos nos links. O primeiro chamará a página aluno.jsp. O Segundo chamará o Servlet AlunoServlet com a opção de listar todos os usuários cadastrados no Banco de Dados.

 





	

		
Seja bem vindo ao sistema AcademicNet!
		Manter Aluno

		Listar Alunos

	

aluno.jsp Página que contém código dinâmico. Quando encontramos a marcação “${…}” significa que é um conteúdo que deve ser recebido pela página e que será exibido. Nos campos de texto recebemos os dados de aluno, veja o exemplo: value=”${aluno.nome}” que recebe o campo nome do aluno.

Nesta página utilizamos HTML5. Então podemos ver no campo matrícula a palavra required. Isso informa que este campo é obrigatório. Não será possível enviar os dados ao servidor sem o preenchimento dele.

Na linha abaixo definimos que o método de envio dos dados para o servidor será “post” e o destino no servidor será a nossa Classe Servlet: “AlunoServlet”

O Atributo “autofocus” no campo nome determina que este campo receberá o cursor assim que a página for carregada no seu browser.
O atributo “placeholder” é o valor que será exibido nos campos quando eles estiverem vazios. Isso serve para informar ao usuário um valor possível a ser utilizado.

As linhas

Informam que temos um botão “submit” que envia os dados ao servidor e também um botão “reset” que limpa os valores exibidos nos campos do formulário.

	

		
			

				
Cadastro de Alunos
				Matrícula: 
 
				Name:

					
				 Telefone:

				 Email:
	
				Data Cadastro:
 Ação 
					Incluir
					Alterar
					Excluir
					Consultar
				
   

			
		
	

alunoLista.jsp É uma página dinâmica que utilizamos vários recursos de JSTL. Nas primeiras linhas são declaradas as tags que serão utilizadas. Isso é feito com as marcações
“@ taglib” para cada linha dessa há um “prefix” que será utilizado como abreviação no uso da TagLib.

A tag a seguir realiza um loop. Neste caso é lido o atributo “listaAluno” que foi enviado do AlunoServlet e será realizado um loop adicionando cada elemento a variável “aluno”.

Já na linha ““ utilizamos TagLib para realizar a formatação de data no padrão dia/mês/ano (10/10/2014).

<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>






	

		
Lista de Alunos
		
				

			

				
Matricula
				
Nome
				
Telefone
				
Data Cadastro
				
Comandos
			
			

					
${aluno.matricula}
					
${aluno.nome}
					
${aluno.telefone}
					
  
					
Excluir
				
			
		
		
   		Existem ${fn:length(listaAluno)} alunos!
 		
 		
	
	Voltar
	

sucesso.jsp Esta página é exibida quando há uma atualização bem sucedida no banco de dados. É feito o uso de JSTL aqui.
Temos o uso do que é usado para exibir o atributo mensagem que recebido do AlunoServlet. Na linh “”
é realizado um include dinâmico da página de lista de alunos. Isso significa que será exibida a listagem de alunos ao carregar esta página.

 
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>





Mensagem JSTL:	
	



  

A página erro.jsp é responsável por receber a variável “mensagem” e exibi-la. Esta página é mostrada sempre que há um problema de atualização de dados dos no Banco de dados.

Verifique o erro: ${mensagem}

Voltar

Por fim temos o nosso arquivo web.xml que é bem simples para o nosso projeto. Ele apenas define qual será a página inicial da nossa aplicação. Atualmente é index.jsp. Caso você queira uma página diferente, por exemplo, a de login. basta alterar a linha “index.jsp” para menu.jsp

	
		index.jsp
	

Observe que temos também, nas pasta WEB-INF\lib os arquivos:
jstl.jar e standard.jar (Contém as tags que precisamos para uso de JSTL)
postgresql-9.3-1100.jdbc4.jar (Driver para realizar a conexão como Banco de dados PostgreSQL)

Esses arquivos são necessário para que o nosso projeto funcione.

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 é um projeto simples que explica os conceitos necessários para construção de um aplicativo completo para Java Web.
Ele pode ser utilizado em qualquer Servidor Web (JBoss, Tomcat, Websphere, Weblogic), pois não há nenhuma configuração específica para uma implementação de servidor.
Para utilizar este projeto com outros bancos de Dados (MySQL, SQL Server, Oracle, DB2) basta alterar a forma de conexão na classe “DAO”.

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
Java Web
JDBC

Projetos Completos em Java – aprenda na prática

Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS

Exemplo completo com JSF Primefaces + EJB + Hibernate + MySQL + JMS (Topic)

Abraços e bons estudos.

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

The post Exemplo completo com JSP JSTL Servlet JDBC PostGreSQL appeared first on Aprenda Java.

Hoje iremos fazer a configuração do nosso projeto no Servidor de SVN através do Eclipse e do plugin Subversive.

Importaremos o projeto no Eclipse. Utilizarei o Sistema de avaliação. Acesse File > Import >> war. Next
Selecione o Arquivo “SistemaAvaliacao06.war” e Finish. Agora com o projeto em nosso workspace devemos instalar o plugin Subeclipse.
Acesse: Help => Eclipse Marketplace => Digite “Subversive”

Clique no botão “Install” => Next => Aceite o termo de uso => Finish
O Eclipse pedirá permissão para reiniciar. Selecione OK.

O Eclipse terá que reiniciar. Confirme.

Após o Reinício. Agora você deve atualizar os plugins disponíveis. Acesse Help “Check for updates”.

Selecione os plug-ins disponíveis para atualização. Next >> Next. Aceite o termo de licença e Finish. Pronto. Já podemos compartilhar o nosso projeto.
Selecione o seu projeto com o botão direito >> Team >> Share Project

Selecione a opção SVN e clique em next.
Copie a URL do nosso projeto e cole no no campo URL: https://academicnet01.googlecode.com/svn/trunk/
Preencha os campos Usuário e senha conforme os dados cadastrados no Google Codes “Aba Source”.

Lembre-se: o usuário é o seu e-mail do Gmail, mas a senha é gerada pelo Google Code e tem que ser copiada no link disponível nessa página.
O Eclipse solicitará a criação de perguntas e respostas para recuperação de configuração. Preencha da melhor forma que desejar.

Será exibida a seguinte tela:

Pronto. Agora o nosso projeto está compartilhado. Podemos fazer várias atividades de atualização, mudanças de versão, reversão.

Seu workspace deve se parecer com a seguinte imagem.

Pronto. Agora o nosso projeto está compartilhado. Podemos fazer várias atividades de atualização, mudanças de versão, reversão.

Abra a classe Usuario. Altere a linha 11 de “public class Usuario {“

Para “public class Usuario implements Serializable{“. E salve o arquivo arquivos em seguida.

Observe que o arquivo a parti de agora tem um sinal “>” no início do nome, isto significa que o arquivo foi alterado na sua máquina.
Selecione a classe Usuário com o botão direito >> Team >> Commit. Isto é uma ação gera uma ação de envio do arquivo para o servidor.
Você é obrigado a incluir um comentário.
Procure sempre adicionar informações concisas para os próximos desenvolvedores entenderem o que foi feito.

>

Selecione OK. Pronto o arquivo já está disponível no servidor.
Agora você pode acessa-lo via TortoiseSVN (Repo Brawser) ou pelo Browser acessando o Site do Google Codes.

Comandos mais importantes:

Sincronize with Repository: Verifica as diferenças entre o seu computador e o servidor.
Commit: Enviar dados para o Servidor
Update: Receber as atualizações dos outros usuários do servidor
Update to Version: Você define qual versão será utilizada para atualização dos seus arquivos locais, por exemplo, estamos na versão 10 e queremos ver a versão 5. Informamos update to version 5.
Revert: Quando fizermos uma alteração local e desfazer pegando a versão do servidor.

Pronto. Bem vindo ao mundo do SVN. E vida que segue!

The post Controle de Versão com Eclipse e Subversive appeared first on Aprenda Java.

Configurando o Eclipse Keppler

Eclipse é uma das IDEs para Java mais utilizada no mercado Java atualmente. Ela surgiu a partir de um projeto da IBM que criou uma interface gráfica para desenvolvimento de software e após alguns anos disponibilizou para a comunidade livre o código fonte. Configurando o Eclipse Keppler você será capaz de desenvolver aplicativos Java em seu computador.

Os produtos mais famosos da IBM, hoje, utilizam esse padrão de IDE. A chamada suit Rational (RAD – Rational Application Developer, RSA – Rational System Architect, WASD – Rational Application Developer for WebSphere Software, entre outros).

A atividade é bem simples. Configurando o Eclipse Keppler seguindo o passo a passo.
Onde fazer o download clique aqui.

O Eclipse não precisa de instalador. Basta copiar o arquivo para o Hard Disk descompactar e iniciar o aplicativo com o arquivo “eclipse.exe”.

O Eclipse não precisa de instalador. Basta copiar o arquivo para o Hard Disk descompactar e iniciar o aplicativo com o arquivo “eclipse.exe”.

Veja a tela inicial:

Você tem a opção de utilizar os links: visão geral, exemplos, tutoriais e novidades da versão. Explore um pouco estas opções para conhecer mais a IDE.
Selecionaremos a opção workbench* no canto superior direito, que nos levará a seguinte tela.

*O Eclipse tem um conceito de Workspace que é uma divisão de áreas de trabalho. Ela pode ser comparada ao que é realizado em configurações de desktop nos sistemas operacionais, onde cada login tem suas definições próprias.
Cada workspace tem suas configurações definidas e independentes. Tanto layouts, bibliotecas, configurações de servidores, abas, menus, perspectivas, entre outras são específicas para cada workspace.

Amigos por hoje é só. E vida que segue!

Links relacionados

Como aprender Java

The post Configurando o Eclipse Keppler appeared first on Aprenda Java.