Menu principal

Pular para o conteúdo

 Página Inicial
 Sobre

Navegação de Posts
← Sistema Acadêmico – O Começo
Sistema Acadêmico Parte 2 – Orientador e Validação no servidor →
mar 1 2013
Galeria

Sistema Acadêmico – O Começo

Depois de um tempo sem postar volto com um sistema de cadastro acadêmico,
nesse sistema temos uma boa demostração de uso do JSF com Hibernate. A
explicação de como foi desenvolvido o sistema será exposto em vários posts,
sendo esse o primeiro onde vou explicar como o sistema funciona e os
documentos gerados na elaboração do sistema acadêmico. O código fonte
completo estará em todos os pots, sendo de código aberto vocês poderão
baixar,alterar e corrigir bugs, caso venha a fazer alguma modificação que
acha interessante pode me enviar para o
email wanderson.alves.rodrigues@gmail.com que eu colocarei sua alteração
junto com o código fonte original para que outro possam baixar e aproveitar
as novas funcionalidades.

O sistema é composto por 5 telas de cadastro(aluno, Orientador, Curso,

Publicação e CursoxAluno) e 5 listas. Na especificação foi definido que
Aluno tem que tem associado um Orientador, não poderá existir uma entidade
Aluno sem um Orientador que é responsável pela orientação do
desenvolvimento da publicação acadêmica. Um Aluno só poderá ter um
Orientador associado, mas o Orientador poderá orientar vários Alunos, temos
um relação de 1 para n entre a entidade Aluno com a Orientador. Um Aluno
pode ter fazer vários Cursos, com isso temos uma relação de n para n entre
Aluno com Curso. Seguindo a especificação ficou definido que Aluno poderá
ter várias publicações cadastradas e uma publicação poderá ser realizada por
vários Alunos, não existe nenhuma regra de limite de alunos por publicação,
uma publicação X poderá ser feita por 1,2,n Alunos. Também por fim a
publicação que será feita pelo Aluno também teremos que identificar o
Orientador.
O Diagrama de classe proposto segue abaixo:

Figura 1 – Diagrama de Classe

Visto o diagrama de classe,agora como fica nossa base de dados como os

relacionamentos descrito acima. Para representar o relacionamento n para n
entre Aluno com publicação e Aluno com Curso, foram criados a tabela
publicacao_aluno e curso_aluno, onde temos a chave estrangeiras dos
relacionamentos. O diagrama do modelo relacional segue abaixo:

Figura 2 – MER

Depois dessa pequena introdução de como foi especificado o sistema, vou

mostrar como ficou as telas do sistema deixando para os próximos pots a
explicação da funcionalidade.

1) Cadastros:

a) Aluno
b) Orientador

c) Curso

d) Publicação
e) CursoxAluno

Nos próximos pots vou descrever parte por parte o desenvolvimento do

sistema, mais por enquanto fica os links para poder baixar o sistema completo,
lembrando que como ferramenta de desenvolvimento foi utilizado o esclipse
indigo e o script de dados encontra-se na pasta do projeto.

Sistema Acadêmico Parte 1 – Aluno

Depois da introdução, agora vamos analisar como foi desenvolvido o cadastro
do aluno.

O cadastro de aluno é constituído de : Matrícula, Nome, Sexo, CPF e

Orientador, sendo todos obrigatórios . Uma vez preenchido os dados do
cadastro do aluno temos que adicionar o Orientador selecionando e clicando
no botão Gravar Orientador. Feito todos os passos anteriores é só clicar no
botão Salvar e finalizar o processo. Bem esse é o processo normal de cadastro
de um Aluno, vamos primeiramente para a validação dos campos.

1) Validação dos Campos

No JSF para que um campo do tipo h:inputText fique obrigatório temos que
adicionar required=”true”, caso queira que a mensagem de
erro personalizada temos que usar requiredMessage=”Descrição do
Erro”. O validador f:validateLengthé utilizado para verificar se uma string
possui uma quantidade mínima ou máxima de letras, no exemplo apresentado
quando a quantidade de caracteres for maior que cem e gerado uma mensagem
de erro, que é definida emvalidatorMessage=”A matricula ultrapassou 100
caracteres”. Foi utilizada como exemplo de validação o campo texto da
matrícula, a regra de validação segue para todos os campos obrigatórios ou
que possuem alguma limitação da quantidade de caracteres.
<h:inputText id="txtMatricula" label="lblMatricila"
value="#{alunoBean.aluno.matricula}" required="true" maxlength="100"
requiredMessage="Informe a Matricula" validatorMessage="A matricula
ultrapassou 100 caracteres" styleClass="txtMatricula">
<f:validateLength maximum="100"/>
</h:inputText>

2) Formatação de Data

Em muitos caso temo que formatar ou converter datas e horas.Isso pode ser
feito com o auxílio da tag <f:convertDateTime>.
A tag <f:convertDateTime> exibirá a data formatada para um tipo específico,
que pode ser date, time. O padrão de formatação é definido pelo
atributo pattern e o timeZone defino a região, como foi definido
um timeZone igual a America/Sao_Paulo isso defini que a data exibida de
acordo com o horário de Brasilia.
<h:inputText id="txtDataNascimento" label="lblDataNascimento"
value="#{alunoBean.aluno.dataNascimento.time}" required="true"
requiredMessage="Informe a Data de
Nascimento(dd//MM/yyyy)" styleClass="txtDataNascimento">
<f:convertDateTime pattern="dd/MM/yyyy" timeZone="America/Sao_Paulo"/>
</h:inputText>

3) Classe Aluno

Como estamos usando Hibernate, a classe Aluno utiliza as

anotações @Entity, @Id, @GeneratedValue, @Temporal(TemporalType.D
ATE) e @OneToOne.

 @Entity : Informa que classe é uma Entidade;

 @Id : Informa o atributo na classe que será utilizado como chave
primária;
 @GeneratedValue:Esta anotação é utilizada quando desejamos que o
provedor de persistência gere as chaves;
 @Temporal:Informar que somente iremos persistir à data;
 @OneToOne: Temos o relacionamento de 1 para 1, entre Aluno com
Orientador. Trata-se de um relacionamento onde os atributos das
entidades relacionadas serão persistidas na mesma tabela.

Na classe Aluno temos os atributos:

  idAluno: Chave primária;
 matricula: Matrícula do Aluno, é alfanumérico;
 nome: Nome do Aluno;
 sexo: Sexo do aluno;
 dataNascimento: Data de nascimento do Aluno, essa data é do tipo
Calendar;
 cpf: CPF do aluno;
 Orientador: Temos a associação de orientador em aluno,na tabela essa
associação equivale ao idOrientador que é a chave estrangeria;

Uma coisa importante que muitos acabam esquecendo e a criação

dos gets e sets e também do hashCode e equals. Sem os gets e sets não tem
como setar um valor ou acessar o valor dos atributos nas páginas JSF. A
classe Aluno é um POJO, por isso não temos regra de negócio e sim uma
fabrica de objetos.
package modelo;

import java.io.Serializable;
import java.util.Calendar;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
/**
* @author http://javaes.wordpress.com/
* */
@Entity
public class Aluno implements Serializable {

/**
*
*/
private static final long serialVersionUID = 3228578352397589062L;
@Id
@GeneratedValue
private long idAluno;
private String matricula;
private String nome;
private byte sexo;
@Temporal(TemporalType.DATE)
private Calendar dataNascimento = Calendar.getInstance();
private String cpf;
@OneToOne
@JoinColumn(name="idOrientador")
private Orientador orientador;

public Aluno(){}

public long getIdAluno()

{
return idAluno;
 }

public void setIdAluno(long idAluno)

{
this.idAluno = idAluno;
}

public String getNome()

{
return nome;
}

public void setNome(String nome)

{
this.nome = nome;
}

public Calendar getDataNascimento()

{
return dataNascimento;
}

public void setDataNascimento(Calendar dataNascimento)

{
this.dataNascimento = dataNascimento;
}

public String getCpf()

{
return cpf;
}

public void setCpf(String cpf)

{
this.cpf = cpf;
}

public String getMatricula()

{
return matricula;
}

public void setMatricula(String matricula)

{
this.matricula = matricula;
}

public Orientador getOrientador()

{
return orientador;
}

public void setOrientador(Orientador orientador)

{
this.orientador = orientador;
}

public byte getSexo()

{
return sexo;
}
public void setSexo(byte sexo)
{
this.sexo = sexo;
}

@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + ((cpf == null) ? 0 : cpf.hashCode());
result = prime * result
+ ((dataNascimento == null) ? 0 : dataNascimento.hashCode());
result = prime * result + (int) (idAluno ^ (idAluno >>> 32));
result = prime * result
+ ((matricula == null) ? 0 : matricula.hashCode());
result = prime * result + ((nome == null) ? 0 : nome.hashCode());
result = prime * result
+ ((orientador == null) ? 0 : orientador.hashCode());
result = prime * result + sexo;
return result;
}

@Override
public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Aluno other = (Aluno) obj;
if (cpf == null) {
if (other.cpf != null)
return false;
} else if (!cpf.equals(other.cpf))
return false;
if (dataNascimento == null) {
if (other.dataNascimento != null)
return false;
} else if (!dataNascimento.equals(other.dataNascimento))
return false;
if (idAluno != other.idAluno)
return false;
if (matricula == null) {
if (other.matricula != null)
return false;
} else if (!matricula.equals(other.matricula))
return false;
if (nome == null) {
if (other.nome != null)
return false;
} else if (!nome.equals(other.nome))
return false;
if (orientador == null) {
if (other.orientador != null)
return false;
} else if (!orientador.equals(other.orientador))
return false;
 if (sexo != other.sexo)
return false;
return true;
}
}

4) DAO Aluno

Para a persistência com o banco de dados foi criado a interface AlunoDAO e a

classe AlunoDAOHibernate. Na interface AlunoDAO temos os
comportamento de persistência do objeto aluno em bando de dados: salvar,
excluir, buscar e lista objetos em banco de dados. A
classe AlunoDAOHibernate adiciona a regra aos comportamentos
implementados.
package dao;

import java.util.List;

import modelo.Aluno;
/**
* @author http://javaes.wordpress.com/
* */
public interface AlunoDAO {

void salvar(Aluno aluno) throws Exception;

void deletar(Aluno aluno) throws Exception;
Aluno buscarAlunoID(long id) throws Exception;
Aluno buscarAlunoMatricula(String matricula) throws Exception;
Aluno buscarAlunoCPF(String cpf) throws Exception;
List<Aluno> listar() throws Exception;
boolean verificaExistencia(long id,String nomeTabela,String campo)
throws Exception;
List<Aluno> buscaOrientadorAluno(long id)throws Exception;
}

package dao;

import java.util.List;

import RN.AlunoRN;
import RN.OrientadorRN;

import modelo.Aluno;
import modelo.Orientador;
/**
* @author http://javaes.wordpress.com/
* */
public class AlunoDAOHibernate implements AlunoDAO{

@Override
public void salvar(Aluno aluno) throws Exception
{
InsertUpdate.salvar(aluno);
}
@Override
public void deletar(Aluno aluno) throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
InsertUpdate.deletar(aluno);
}

@Override
public Aluno buscarAlunoID(long id) throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
return (Aluno)obj.buscarObjectID(id, "idAluno");
}

@Override
public Aluno buscarAlunoMatricula(String matricula) throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
return (Aluno)obj.buscarObjectID(matricula, "matricula");
}

@Override
public Aluno buscarAlunoCPF(String cpf) throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
return (Aluno)obj.buscarObjectUnique(cpf, "cpf");
}

@Override
public List<Aluno> listar() throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
return obj.listar();
}

@Override
public boolean verificaExistencia(long id, String nomeTabela, String
campo)throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
return obj.verificaExistencia(id, nomeTabela, campo);
}

@Override
public List<Aluno> buscaOrientadorAluno(long id) throws Exception
{
ObterObject<Aluno> obj = new ObterObject<Aluno>(new Aluno());
Orientador or = OrientadorRN.buscarOrientadorID(id);
return obj.buscaPorIdRelacionamento(or,"orientador");
}

5) Regra de Negócio

Na classe AlunoRN é onde defino todas as regras de negócio.

package RN;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import modelo.Aluno;
import modelo.Publicacao;
import dao.AlunoDAO;
import dao.AlunoDAOHibernate;
import dao.PublicacaoDAOHibernate;
/**
* @author http://javaes.wordpress.com/
* */
public class AlunoRN
{
private static AlunoDAO alunoDAO;

public static void salvar(Aluno aluno) throws Exception

{
alunoDAO = new AlunoDAOHibernate();
alunoDAO.salvar(aluno);
}

public static void deletar(Aluno aluno) throws Exception

{
alunoDAO = new AlunoDAOHibernate();
alunoDAO.deletar(aluno);
}

public static Aluno buscarAlunoID(long id) throws Exception

{
alunoDAO = new AlunoDAOHibernate();
return (Aluno)alunoDAO.buscarAlunoID(id);
}

public static Aluno buscarAlunoMatricula(String matricula) throws

Exception
{
alunoDAO = new AlunoDAOHibernate();
return (Aluno)alunoDAO.buscarAlunoMatricula(matricula);
}

public static Aluno buscarAlunoCPF(String cpf) throws Exception

{
alunoDAO = new AlunoDAOHibernate();
return (Aluno)alunoDAO.buscarAlunoCPF(cpf);
}

public static List<Aluno> listar() throws Exception

{
alunoDAO = new AlunoDAOHibernate();
return alunoDAO.listar();
}

public Calendar parseData(String data){

try
{
Date date = new SimpleDateFormat("dd/MM/yyyy").parse(data);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar;
}catch(Exception e){
throw new IllegalArgumentException(e);
}
}

public static void verificaExistencia(long id) throws Exception

{
alunoDAO = new AlunoDAOHibernate();
if(alunoDAO.verificaExistencia(id, "curso_aluno", "idAluno"))
{
throw new Exception("Não foi possível deletar o aluno,possui curso
relacionado.");
}
if(alunoDAO.verificaExistencia(id, "publicacao_aluno", "idAluno"))
{
throw new Exception("Não foi possível deletar o aluno,possui
publicação relacionada.");
}
}

public static boolean buscaOrientadorAluno(long id)throws Exception

{
alunoDAO = new AlunoDAOHibernate();
List<Aluno> lista = alunoDAO.buscaOrientadorAluno(id);
if(lista.size() > 0)
return true;
else
return false;
}

6) Bean

No AlunoBean estão as propriedades que são usadas no JSF,todas as

funcionalidades que o cadastro de aluno tem que ter foi definida no bean.
package bean;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.faces.bean.SessionScoped;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;

import util.Constantes;
import RN.AlunoRN;
import RN.OrientadorRN;
import modelo.Aluno;
import modelo.Orientador;
/**
* @author http://javaes.wordpress.com/
* */
@ManagedBean
@SessionScoped
public class AlunoBean
{
private Aluno aluno = new Aluno();
private Constantes constantes = new Constantes();
private byte sexo;
private List<Orientador> orientadores;
private List<Aluno> listaAlunos;
private String nomeOrientadorSelecionado;
private long idOrientadorSelecionado;

public Aluno getAluno()

{
return aluno;
}

public void setAluno(Aluno aluno)

{
this.aluno = aluno;
}

public List<Orientador> getOrientadores() throws Exception

{
return OrientadorRN.listar();
}

public Constantes getConstantes()

{
return constantes;
}

public List<Aluno> getListaAlunos() throws Exception

{
if(this.listaAlunos == null)
{
this.listaAlunos = AlunoRN.listar();
}
return this.listaAlunos;
}

public void gravarAluno()

{
try
{
if(aluno.getOrientador() != null)
{
if(this.aluno != null)
{
this.aluno.setSexo(sexo);
AlunoRN.salvar(aluno);
novo();
this.listaAlunos = null;
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Aluno Salvo com Sucesso!"));
}
}
else
{
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Escolha um Orientador."));
}
} catch (Exception e)
{
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Erro a Salvar Aluno"));
}
}

public String excluirAluno()

{
try
{
if(this.aluno != null)
{
AlunoRN.verificaExistencia(aluno.getIdAluno());
AlunoRN.deletar(aluno);
this.listaAlunos = null;
this.novo();
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Aluno Excluido com Sucesso!"));
this.listaAlunos = null;
}
}
catch (Exception erro)
{
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage(erro.getMessage()));
return null;
}
return "listaAluno?faces-redirect=true";
}

public String novo()

{
this.aluno = new Aluno();
this.nomeOrientadorSelecionado = "";
return "aluno?faces-redirect=true";
}

public String editar()

{
this.sexo = aluno.getSexo();
return "aluno?faces-redirect=true";
}

public void gravarOrientador() throws Exception

{
if(this.aluno == null)
this.aluno = new Aluno();
if(this.idOrientadorSelecionado > 0)
{
Orientador orientador =
OrientadorRN.buscarOrientadorID(this.idOrientadorSelecionado);
this.aluno.setOrientador(orientador);
this.nomeOrientadorSelecionado = orientador.getNome();
}
else
{
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Selecione um orientador."));
}
}

public String novoOrientador()

{
return "orientador?faces-redirect=true";
}

public byte getSexo()

{
return sexo;
}

public void setSexo(byte sexo)

{
this.sexo = sexo;
}

public String getNomeOrientadorSelecionado()

{
return nomeOrientadorSelecionado;
}

public void setNomeOrientadorSelecionado(String

nomeOrientadorSelecionado)
{
this.nomeOrientadorSelecionado = nomeOrientadorSelecionado;
}

public long getIdOrientadorSelecionado()

{
return idOrientadorSelecionado;
}

public void setIdOrientadorSelecionado(long idOrientadorSelecionado)

{
this.idOrientadorSelecionado = idOrientadorSelecionado;
}
}

 Vamos agora para as funcionalidades da tela aluno.xhtml

1) Mensagens
Para que as mensagens gerada no processo de validação possa aparecer para o
usuário temos que acrescentar a tag <h:messages/>.

2) Id

Para efetuar a persistência em banco de dados o Hibernate tem que saber se

o objeto existem ou não, para isso é verificado se o campo que foi definido
com id em nossa classe é zero ou nulo ou se tem um valor, nesse caso de
implementação(pode existir outras formas de desenvolver) e bom sempre criar
a tag <h:inputHidden value=”#{alunoBean.aluno.idAluno}”/>, onde temos
o id invisível.

3)Escolha do Sexo
Para definir a escolha do sexo do aluno eu usei a tag selectOneRadio, essa se
comporta como um radio button do html onde só é possível a escolha de um
resultado.

Como funciona no JSF?

<h:outputLabel id="lblSexo" for="lblSexo" value="Sexo:"/>
<h:selectOneRadio value="#{alunoBean.sexo}" required="true"
requiredMessage="Selecione o Sexo" >
<f:selectItems value="#{alunoBean.constantes.sexos}" var="s"
itemLabel="#{s.descricao}" itemValue="#{s.tipo}" />
</h:selectOneRadio>

No que pode ser observado no trecho de código acima, temos a

tag h:selectOneRadio e dentro dessa tag temos os itens a tag f:selectItems. No
atributo value é definido o valor atual do campo. Os itens são adicionados
ao h:selectOneRadio de forma dinâmica através da lista de constantes, o valor
que será apresentado para a interface é definido no atributo itemLabel e o
valor ao selecionar a opção e atribuída no itemValue.

4) Cosntantes

Foi criado a classe Constantes que tem a função de gerar listas estáticas de
valores que não são trazidos do banco de dados. Essa lista é usada para
preencher h:selectOneRadio e h:selectOneMenu,fiz essa classe para ser um
lugar único de inserção de valores estáticos. A Constantes é um classe simples
com outras classes internas que representam por exemplo sexo, titulação e etc.

5) Gravar Orientador

A classe Aluno tem associado um Orientador, todos alunos cadastrado no

sistema é obrigatório a existência do Orientador. Por isso temos que selecionar
o Orientador, ao selecionar temos que associar ao objeto aluno um Orientador
clicando no botão Gravar Orientador.
<h:panelGrid columns="2">
<h:outputLabel id="lblOrientador" for="lblOrientador"
value="Selecione o Orientador:"/>
<h:selectOneMenu id="orientador"
value="#{alunoBean.idOrientadorSelecionado}" styleClass="slOrientador"
required="true" requiredMessage="Escolha um Orientador" >
<f:selectItems value="#{alunoBean.orientadores}" var="orientador"
itemLabel="#{orientador.nome}"
itemValue="#{orientador.idOrientador}"/>
</h:selectOneMenu>
<h:commandButton id="btnGravarOriendaor" value="Gravar Orientador"
action="#{alunoBean.gravarOrientador}">
<f:ajax execute="orientador" render="txtOrientdaorSelecionado"/>
</h:commandButton>
No h:selectOneMenu temos a lista de Orientadores <f:selectItems> que serão
selecionado. No atributo value do f:selectItems busca a lista de orientadores
do AlunoBean. No código abaixo obtém a lista de orientadores do banco que
é usado no value=”#{alunoBean.orientadores}”, lembrando que no JSF é
acessado os métodos públicos no bean. Em itemLabel é apresentado o nome
do orientador e itemValue o id do orientador que é usado para encontra o
orientador.
public List<Orientador> getOrientadores() throws Exception
{
return OrientadorRN.listar();
}

Ao clicar no botão Gravar orientador é acessado o

método gravarOrientador do alunoBean, que associa o objeto orientador ao
aluno.
public void gravarOrientador() throws Exception
{
if(this.aluno == null)
this.aluno = new Aluno();
if(this.idOrientadorSelecionado > 0)
{
Orientador orientador =
OrientadorRN.buscarOrientadorID(this.idOrientadorSelecionado);
this.aluno.setOrientador(orientador);
this.nomeOrientadorSelecionado = orientador.getNome();
}
else
{
FacesContext.getCurrentInstance().addMessage("aluno", new
FacesMessage("Selecione um orientador."));
}
}

O ajax no JSF é obtido através f:ajax, como ao gravar o orientador queremos

que somente a parte designada ao orientador atualize é usada o código abaixo:
<f:ajax execute="orientador" render="txtOrientdaorSelecionado"/>

 event : É atribuído o evento desejado para o objeto. Por padrão é

valueChange.
 execute: Este atributo representa qual componente deve ser executado, sendo
informado seu nome. Por padrão seu valor é @this.
 render: Identifica qual campo deve receber o valor de algum evento executado.

6) Salvar Aluno

Ao clicar Salvar é chamado o método gravarAluno do bean, onde temos a

inserção do aluno no banco de dados.
<h:commandButton
id="btnNovo" value="Novo" styleClass="btnNovo"
action="#{alunoBean.novo}" immediate="true">

Por hoje é só pessoal.

Sistema Acadêmico Parte 2 – Orientador

e Validação no servidor
Continuando pelo sistema acadêmico vamos para o cadastro de Orientador.
Ao cadastra um Orientador temos que informar o nome,cpf,titulação e
instituição de ensino.

A tela de cadastro de Orientador e bem mais simples que a do Aluno, pois só

temos a inserção de dados do objeto orientador não tendo outro como no
Aluno que tínhamos que inserir também o Orientador.

As validações dos campos e salvar, excluir e novo segue o mesmo principio

para todas as telas, nessa parte 2 vou explicar como fazer uma validação e
apresentar o resultado na tela para o usuário.

Como vimos na parte 1, para que as mensagens de validações, avisos e erros

possam ser imprimidas na tela temos que adicionar ao nosso xhtml a
tag <h:messages/>, agora como podemos fazer uma validação interna no
servidor é apresentar ao usuário?. Isso é bem simples é só usar a trecho de
código abaixo:
FacesContext.getCurrentInstance().addMessage("orientador", new
FacesMessage("Orientador Salvo com sucesso!"));

Pelo FacesContext podemos adicionar uma mensagem ao realizar alguma

tarefa no nosso processo.

No trecho de código abaixo é a funcionalidade de excluir um orientador,antes

da exclusão é realizado algumas verificações ser existem em alguma tabela a
referência ao orientador da exclusão. Caso tenha encontrado o uso do
orientador e gerado a mensagem ao usuário que a exclusão não pode ser
efetuada.
public String excluir()
{
try
{

if(PublicacaoRN.buscaOrientadorPublicacao(orientador.getIdOrientador()
))
{
 FacesContext.getCurrentInstance().addMessage("orientador", new
FacesMessage("Não foi possível excluir, pois existe publicação
relacionada."));
return null;
}
else
{
if(AlunoRN.buscaOrientadorAluno(orientador.getIdOrientador()))
{
FacesContext.getCurrentInstance().addMessage("orientador", new
FacesMessage("Não foi possível excluir, pois existe aluno
relacionada."));
return null;
}
else
{
OrientadorRN.deletar(orientador);
this.orientador = new Orientador();
this.constantes = new Constantes();
this.lista = null;
}
}
}
catch (Exception e)
{
FacesContext.getCurrentInstance().addMessage("orientador", new
FacesMessage("Erro ao excluir Orientador"));
}
this.lista = null;
return "listaOrientador?faces-redirect=true";
}

Por hoje é só pessoal.

Sistema Acadêmico Parte 3 – Layout JSF

com CSS e Facelets
No projeto do sistema acadêmico foi definido um layout em css,com é
apresentado na imagem abaixo, no projeto todas as páginas implementam o
mesmo template, caso tenha necessidade de alterar algum detalhe todas as
páginas receberão tal alteração.
 Figura 1 – Layout

Para compor as páginas do projeto com o template, foi usado Facelets que é
um framework de template que diminui a quantidade de código-fonte nas
páginas,padronizando e centralizando as definições visuais e estruturais das
telas do sistema.

O Facelets permite criar uma página modelo, que será base estrutural e visual
para as demais páginas do sistemas. No projeto esse arquivo .xhtml que
possuem tags facelets foi criado no diretório template o
arquivo _template.xhtml.

Figura 2 – Template

1) _template.xhtm

Nesse arquivo armazena o template do nosso projeto com as tags Facelets.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!--
Design by Free CSS Templates

http://www.freecsstemplates.org

Released for free under a Creative Commons Attribution 2.5 License

Name : Accomplishable
Description: A two-column, fixed-width design.
Version : 1.0
Released : 20090731

-->
<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:ui="http://java.sun.com/jsf/facelets">
<h:head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>Gestão Acadêmico</title>
<meta name="keywords" content="" />
<meta name="description" content="" />
<link href="./resources/css/style.css" rel="stylesheet"
type="text/css" media="screen" />
</h:head>
<h:body>

<!-- start header -->

<div id="header">
<h1>Gestão Acadêmico</h1>
<p> Versão 1.0</p>
</div>
<!-- end header -->
<!-- start page -->

<div id="page">
<div id="page-bgtop">
<div id="page-bgbtm">
<!-- start content -->
<div id="content">
<ui:insert name="conteudo">

<div class="post">
<h2 class="title">About This Website</h2>
<div class="entry">

</div>
</div>

</ui:insert>
</div>
<!-- end content -->
<!-- start sidebar -->
<div id="sidebar">
<h:form>
<ul>
<li>
<h2>Cadastros</h2>
<ul>
<li><h:commandLink value="Aluno" action="#{linkBean.linkAluno}"
immediate="true" ></h:commandLink></li>
<li><h:commandLink value="Orientador"
action="#{linkBean.linkOrientador}" immediate="true"
></h:commandLink></li>
<li><h:commandLink value="Curso" action="#{linkBean.linkCurso}"
immediate="true" ></h:commandLink></li>
<li><h:commandLink value="Publicação"
action="#{linkBean.linkPublicacao}" immediate="true"
></h:commandLink></li>
<li><h:commandLink value="CursoxAluno"
action="#{linkBean.linkCursoAluno}" immediate="true"
></h:commandLink></li>
</ul>
</li>
<li>
 <h2>Listas</h2>
<ul>
<li><h:commandLink value="Aluno" action="#{linkBean.listaLinkAluno}"
immediate="true" styleClass="linkAluno"></h:commandLink></li>
<li><h:commandLink value="Orientador"
action="#{linkBean.listaLinkOrientador}" immediate="true"
styleClass="linkOrientador" ></h:commandLink></li>
<li><h:commandLink value="Curso" action="#{linkBean.listaLinkCurso}"
immediate="true" styleClass="linkCurso"></h:commandLink></li>
<li><h:commandLink value="Publicação"
action="#{linkBean.listaLinkPublicacao}" immediate="true"
styleClass="linkPublicacao"></h:commandLink></li>
<li><h:commandLink value="CursoxAluno"
action="#{linkBean.listaLinkCursoAluno}" immediate="true"
styleClass="listaLinkCursoAluno}"></h:commandLink></li>
</ul>
</li>
</ul>

</h:form>
</div>
<!-- end sidebar -->
<div style="clear:both">&nbsp;</div>
</div>
</div>
</div>
<div id="footer">
<p>&copy;2013 All Rights Reserved &nbsp;&bull;&nbsp; Design by <a
href="http://www.freecsstemplates.org">FCT</a> &nbsp;&bull;&nbsp;
Icons by <a href="http://www.famfamfam.com/">FAMFAMFAM</a>.</p>
</div>
</h:body>
</html>

Na análise do código temos:

a) O primeiro e principal elemento é a declaração da taglib do Facelets.

xmlns:ui="http://java.sun.com/jsf/facelets"

b)Tag ui:insert: essa é utilizada na montagem da página de template, ela

define os “espaços vagos”. Essa tag é usada para delimitar a área do template
que poderá ser alterada pelas página que utilizarem o template.
<ui:insert name="conteudo">
<div class="post">
<h2 class="title">About This Website</h2>
<div class="entry">

</div>
</div>
</ui:insert>

2) Aplicação do Template
O Facelets não necessita de nenhuma configuração externa quanto aos
templates a serem utilizados, isso é um grande facilitador no uso
de Facelets em comparação outro frameworks.
Agora para usar o template criado no _template.xhtm, vamos ao exemplo
abaixo:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html>
<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:ui="http://java.sun.com/jsf/facelets">
<ui:composition template="/template/_template.xhtml">
<ui:define name="conteudo">
<h:form>
<h:messages/>
<h:inputHidden value="#{cursoBean.curso.idCurso}"/>
<fieldset>
<LEGEND>Cadastro de Curso</LEGEND>
<h:panelGrid columns="2">
<h:outputLabel id="lblNome" for="lblNome" value="Nome:"/>
<h:inputText id="txtNome" label="lblNome" required="true"
requiredMessage="Informe o nome" value="#{cursoBean.curso.nome}"
styleClass="txtNome" />
</h:panelGrid>
</fieldset>
<br/>
<h:panelGrid columns="3">
<h:commandButton value="Novo" action="#{cursoBean.novo}"
immediate="true"/>
<h:commandButton value="Salvar" action="#{cursoBean.salvar}"/>
<h:commandButton value="Excluir" action="#{cursoBean.excluir}"/>
</h:panelGrid>
</h:form>
</ui:define>
</ui:composition>
</html>

Análise do código:

a) Primeiramente foi delimitada a área que será regida pelo template definido
pelo elemento <ui:composition>.
<ui:composition template="/template/_template.xhtml">

No atributo ‘template’ foi definido onde foi criado nosso template.

b) tag <ui:define>: No corpo da tag <ui:composition>, são colocadas as

tags <ui:define> que define o conteúdo que substituirá cada espaço do
template.
<ui:define name="conteudo">

No caso acima o conteúdo definido entre a tag <ui:define> será substituído,

cada página terá seu corpo diferente.

Por hoje é só pessoal..