Criar uma classe de entidade a partir do banco de dados

Esta etapa também é bastante mecânica. O NetBeans se encarrega de criar uma classe a partir de uma tabela do banco de dados e colocar as anotações básicas. Em seguida, o desenvolvedor pode modificar o que achar necessário.
Vamos criar uma classe Person, baseada na tabela Person do banco de dados Travel, do Derby: basta utilizar Novo->Outro->Persistência->Classe de entidade a partir do banco de dados.
Em seguida, é só escolher a conexão e a tabela desejada. Na tela seguinte, o nome do pacote deve ser colocado (no nosso caso, modelo) e na última tela pode-se preencher o tipo de recuperação, o tipo de dados que será gerado (pode ser java.util.list) e pronto.
Se houverem tabelas associadas com chaves estrangeiras, o NetBeans se encarrega de criar as outras classes associadas, e colocar as anotações necessárias. Abaixo, a listagem final da classe Person.java - quanto tempo economizado!!

package modelo;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name = "PERSON", catalog = "", schema = "TRAVEL")
@NamedQueries({
@NamedQuery(name = "Person.findAll", query = "SELECT p FROM Person p"),
@NamedQuery(name = "Person.findByPersonid", query = "SELECT p FROM Person p WHERE p.personid = :personid"),
@NamedQuery(name = "Person.findByName", query = "SELECT p FROM Person p WHERE p.name = :name"),
@NamedQuery(name = "Person.findByJobtitle", query = "SELECT p FROM Person p WHERE p.jobtitle = :jobtitle"),
@NamedQuery(name = "Person.findByFrequentflyer", query = "SELECT p FROM Person p WHERE p.frequentflyer = :frequentflyer"),
@NamedQuery(name = "Person.findByLastupdated", query = "SELECT p FROM Person p WHERE p.lastupdated = :lastupdated")})
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Basic(optional = false)
@Column(name = "PERSONID")
private Integer personid;
@Column(name = "NAME")
private String name;
@Column(name = "JOBTITLE")
private String jobtitle;
@Column(name = "FREQUENTFLYER")
private Short frequentflyer;
@Column(name = "LASTUPDATED")
@Temporal(TemporalType.TIMESTAMP)
private Date lastupdated;

public Person() {
}

public Person(Integer personid) {
this.personid = personid;
}

public Integer getPersonid() {
return personid;
}

public void setPersonid(Integer personid) {
this.personid = personid;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getJobtitle() {
return jobtitle;
}

public void setJobtitle(String jobtitle) {
this.jobtitle = jobtitle;
}

public Short getFrequentflyer() {
return frequentflyer;
}

public void setFrequentflyer(Short frequentflyer) {
this.frequentflyer = frequentflyer;
}

public Date getLastupdated() {
return lastupdated;
}

public void setLastupdated(Date lastupdated) {
this.lastupdated = lastupdated;
}

@Override
public int hashCode() {
int hash = 0;
hash += (personid != null ? personid.hashCode() : 0);
return hash;
}

@Override
public boolean equals(Object object) {
if (!(object instanceof Person)) {
return false;
}
Person other = (Person) object;
if ((this.personid == null && other.personid != null) || (this.personid != null && !this.personid.equals(other.personid))) {
return false;
}
return true;
}

@Override
public String toString() {
return "modelo.Person[personid=" + personid + "]";
}

}

Voltar para DataTables básico

Criar os arquivos HibernateUtil.java e hibernate.cfg.xml

Até que enfim uma tarefa menos trabalhosa... criar estes dois arquivos é bem simples. Os requisitos são apenas organização do projeto. O arquivo hibernate.cfg.xml deve ser criado no pacote padrão do projeto, e o arquivo HibernateUtil.java deve ser criado em outro pacote - no nosso caso, vamos chamá-lo de controle.

a) hibernate.cfg.xml:

Clicando com o botão direito sobre o projeto, escolher Novo->Outro->Hibernate->Assistente para configuração de hibernate. Após clicar no botão próximo, será requisitada a base de dados (que já foi criada em outro post). Somente devemos verificar se no final, o arquivo ficou no pacote correto.

b) HibernateUtil.java:

De maneira semelhante, escolher Novo->Outro->Hibernate->HibernateUtil.java. Em seguida, verificar se o nome do arquivo é realmente HibernateUtil e preencher a lacuna do pacote com controle - o NetBeans se encarregará de criar o pacote, se o mesmo não existir.

Ao final, a estrutura do projeto deverá ter um trecho semelhante ao da figura.

Voltar para DataTables básico

Conexão com um banco de dados

A janela Services tem todas as funcionalidades para gerenciar as conexões com os bancos de dados. O item Drivers mostra os já instalados, mas um clique com o botão direito sobre ele permite localizar um arquivo .jar que contenha um novo driver, caso necessário.

O driver para o banco de dados que se pretende utilizar é absolutamente imprescindível. É preciso adicioná-lo aqui para que a conexão seja estabelecida e as outras etapas sejam bem sucedidas.

Uma nova conexão pode ser feita rapidamente, bastando clicar com o botão direito sobre o driver desejado e escolher "Conectar usando", e preencher os campos adequadamente.

No nosso exemplo, vamos utilizar o banco Travel, que na figura já aparece conectado. Para conectar, basta clicar com o botão direito sobre a conexão desejada e escolher Conectar.

Voltar para DataTables básico

DataTables básico

A criação de tabelas (básicas) com IceFaces envolve 7 etapas, já incluindo a persistência de dados com Hibernate. Podemos criar uma tabela utilizando quase que somente recursos da IDE do NetBeans, com poucas e pequenas alterações. Vamos utilizar o banco de dados de exemplo Travel, do Derby, para mostrar os passos necessários.

1. Criar uma conexão com uma base de dados;
2. Criar os arquivos HibernateUtil.java e hibernate.cfg.xml;
3. Criar uma classe de entidade a partir do banco de dados;
4. Criar uma classe controladora (DAO);
5. Criar um mapeamento no Hibernate;
6. Criar um bean gerenciado que retorne uma lista com os dados,
7. Criar a DataTable e colocar um paginador.

A primeira impressão é que são muitas tarefas, mas a IDE vai providenciar a maior parte do trabalho, que na verdade é bem mecânico e não deve desperdiçar o precioso tempo do desenvolvedor.

Diagrama ER no NetBeans 6.8

(Confira minha nova série de posts: Spring + JPA + JTA)

O NetBeans 6.8 não traz mais o suporte a diagrama de entidade-relacionamento (ERD). Mas existe uma maneira de baixar o plugin e instalá-lo: explorando o repositório de updates do NetBeans (http://updates.netbeans.org/netbeans/updates) - no caso do ERD, podemos encontrá-lo em:

http://updates.netbeans.org/netbeans/updates/6.8/uc/m1/dev/modules/extra/org-netbeans-erdbeans.nbm

Para instalar o plugin, basta baixá-lo em uma pasta qualquer e utilizar Ferramentas->Plugins->Baixados->Adicionar, selecionar o arquivo baixado e pronto. Para utilizar o diagrama, é só criar um Novo->Outro->Persistência->ER-Diagram, selecionar o banco de dados e o diagrama será montado automaticamente. Abaixo, um diagrama do banco de dados de exemplo Sample, do Derby:

Instalando IceFaces no NetBeans 6.8

Para instalar o plugin do IceFaces no NetBeans 6.8, basta baixar os arquivos nos links abaixo:

arquivo 1 (12Mb)

arquivo 2 (95Kb)

Depois de salvá-los em qualquer local de sua preferência, no NetBeans escolha Ferramentas->Plugins->Baixados->Adicionar. Em seguida localize e selecione os arquivos, e siga as instruções do NetBeans para terminar a instalação. É recomendável que o NetBeans seja reiniciado após a instalação.

Agora o ambiente de trabalho está pronto. Próximo passo: estrutura dos bancos de dados.

IceFaces e internacionalização

A criação de páginas com IceFaces envolve a configuração de arquivos XML que nem sempre é muito amigável. Vamos começar com uma configuração que será útil para todo o projeto, que é a internacionalização da aplicação.

Os componentes do IceFaces (como o selectInputDate) são exibidos em inglês. se o sistema operacional não estiver configurado adequadamente. Isto é muito comum em laptops com Windows em inglês. Vejamos o exemplo:

Para garantir que os meses e dias da semana sejam exibidos em português, independente da configuração do sistema operacional, basta modificar o arquivo faces-config.xml, de maneira que ele tenha a seguinte sessão:

<application>
<locale-config>
<default-locale>pt</default-locale>
<supported-locale>pt</supported-locale>
<supported-locale>pt_BR</supported-locale>
</locale-config>
</application>

Vejamos agora o componente, após a modificação:

Web + Java. É viável?

Aplicações web construídas com auxílio de java são viáveis? Sim, desde que as aplicações ofereçam ao internauta recursos que há algum tempo não eram muito exigidos.

Exemplos: calendários, validação, abas deslizantes, objetos reposicionáveis, etc. E todos em tempo real (AJAX?), sem recarregar as páginas.

Para consolidar este tema, vamos investigar o uso do framework Icefaces para criar uma aplicação clássica de controle de biblioteca, utilizando inicialmente as tecnologias:

• IDE Netbeans
• Banco de dados Firebird
• Persistência de dados com Hibernate
• IceFaces
• Javaserver Faces

As abordagens irão desde a criação do banco de dados, até a utilização da aplicação com usuários e documentos reais.