Projeto CRUD com JPA no NetBeans

Prévia do material em texto

PROJETO CRUD COM 
JPA USANDO 
NETBEANS 
Do banco de dados ao desenvolvimento 
 
Trabalho realizado pelo 4º período de Analise desenvolvimento de sistemas da 
Faculdade UNIVC em São Mateus/ES: 
• Bruna de Assis Zordan 
• Thaise dos Santos Nascimento 
• Kênia Ramos Pinheiro 
• Emanuel Carneiro dos Reis 
• Arthur Scopel Santos 
• Rodolfo Pereira Katachinski 
• Tayana Inyth Cunha Rozario 
• Lana Codeco de Matos 
• Nickson Corradi Barbosa 
 
 
 
 
2012 
Prof. Douglas Tybel 
FACULDADE VALE DO CRICARÉ - UNIVC 
17/10/2012 
1 
 
ABRIR PHPMYADMIN............................................................................................................................. 2 
CRIAR BANCO DE DADOS ....................................................................................................................... 3 
CRIAR TABELAS ...................................................................................................................................... 4 
DEFINIR STORAGE ENGINE ............................................................................................................................... 5 
DEFINIR RELAÇÕES ENTRE TABELAS .................................................................................................................... 6 
ADICIONANDO UM NOVO CAMPO – CHAVE ESTRANGEIRA ...................................................................................... 8 
DESENVOLVER O APLICATIVO CRUD - NETBEANS ................................................................................. 12 
CRIAR NOVO PROJETO NO NETBEANS ............................................................................................................... 12 
NOVO FORMULÁRIO DE AMOSTRA MESTRE/DETALHES – COMO CRIA-LO ................................................................. 13 
COMPILANDO O PROJETO .............................................................................................................................. 20 
FORMULÁRIO CRUD - TESTES ....................................................................................................................... 21 
TIPOS DE CAMPO PARA CHAVE ESTRANGEIRA - NOTAÇÃO .................................................................................... 27 
RELACIONAMENTO ENTRE ENTIDADES – NOTAÇÃO MANYTOONE ......................................................................... 31 
CHAVE ESTRANGEIRA – CAIXA DE COMBINAÇÃO ................................................................................................. 33 
BINDING ELEMENTS – VINCULAR ELEMENTOS DE UMA ENTIDADE A CAIXA DE COMBINAÇÃO ....................................... 35 
CAIXA DE COMBINAÇÃO – RENDERER .............................................................................................................. 36 
CONFIGURAR COMPONENTE JTABLE - TABELA ................................................................................................... 40 
CONFIGURAÇÃO DA CHAVE ESTRANGEIRA – NOTAÇÃO @JOINCOLUMN ................................................................. 43 
FINALIZANDO PROJETO – COMPILAR E TESTAR ................................................................................................... 45 
 
2 
 
ABRIR PHPMYADMIN 
 
Figura 1 - Tela para criar Bando de Dados 
Fonte: Própria (2012) 
 
Para abrir o PHPMyAdmin acesse seu servidor de pagina, no nosso exemplo será utilizado o 
servidor xampp. 
Acesse c:\xampp e execute o arquivo “xampp-control”. Feito isso, inicie o Apache e o MySQL 
clicando nos respectivos botões: “Start” ou “Iniciar”. 
 
Figura 2 - Xampp Control Panel 
Fonte: Propria (2012) 
 
Abra o PHPmyadmin, para isso clique no botão “admin” que está na frente do “MySql” do 
Xampp Control. 
 
 
3 
 
CRIAR BANCO DE DADOS 
No PHPMyAdmin(http://localhost/phpmyadmin/) defina nome para o seu banco de dados para 
“colaboradores” e clique no botão “criar”. 
 
Figura 3 - Criação de Banco de Dados 
Fonte: Propria (2012) 
 
Imediatamente será criado um banco de dados. 
Para visualizar as configurações do banco de dados criado, clique no nome do banco de dados 
que se encontra no lado esquerdo de sua tela. 
 
Figura 4 - Selecionar Banco de Dados 
Fonte: Própria (2012) 
 
 
4 
 
CRIAR TABELAS 
Próximo passo é criar uma tabela, clique em “Create Table” que se encontra ao lado esquerdo 
de sua tela. Essa funcionalidade surgirá independente da versão do PHPMySQLAdmin, caso 
tenha efetuado um clique no banco de dados. 
Preencha o campo “Nome:” com a tabela: Funcoes 
 
 
Figura 5 - Criar tabela 
Fonte: Propria (2012) 
 
Após definir o nome da tabela e o número de colunas que vai existir em seu projeto, em 
seguida clique no botão “Executar”. 
 
 
 
Figura 6 - Definir nome e número de colunas na tabela 
Fonte: Própria (2012) 
 
Feito isso aparecerá uma tabela com o número de colunas que já foi definido, repare que as 
colunas ficaram em branco para que seja preenchida de acordo com a estrutura do seu banco 
de dados. 
 
Figura 7 - Estrutura da tabela 
Fonte: Própria (2012) 
 
5 
 
Definir Storage Engine 
 
Não se esqueça de mudar o campo “Storage Engine” para “InnoDB”. 
InnoDB é um módulo ou estratégia de armazenamento para o MySQL, sua principal função é 
dar suporte a transações e chaves estrangeiras, evoluindo muito em relação ao antigo 
MyISAM. 
 
Figura 8 - Mudança do campo "Strorage Engine" para "InnoDB" 
Fonte: Própria (2012) 
 
 
Com a estrutura toda montada, faça sua ultima conferência e observe os tipos de campos, 
chaves entre outros. Em seguida clique no botão “Salvar”. 
 
 
Figura 9 - Salvando tabela 
Fonte: Própria (2012) 
 
Uma mensagem de confirmação de que a tabela foi criada aparecerá na tela. 
6 
 
 
 
Figura 10 - Confirmação de criação de tabela 
Fonte: Propria (2012) 
 
O próximo passo é clicar no nome de sua tabela para visualizarmos sua estrutura e outras 
funcionalidades. 
 
 
Figura 11 - Selecionar tabela para o acesso a mesma 
Fonte: Própria (2012) 
 
Definir relações entre tabelas 
 
O banco de dados relacional nos permite realizar as relações entre as tabelas. Para isso, basta 
clicar no Banco de dados Colaboradores >> Na tabela funções >> Aba Estrutura >> Link abaixo 
“Ver relações”. 
 
 
Figura 12 - Dentro da tabela - criar relações 
Fonte: Própria (2012) 
 
Esse passo é totalmente facultativo, uma vez que não é obrigatório, mas para nível de 
conhecimento, faremos com que a coluna estrangeira de funções, liste as funções, ao invés de 
seus respectivos códigos. Desta forma facilitará o cadastro e testes dos técnicos em 
7 
 
desenvolvimento. Ainda na tela de estrutura irão aparecer às relações existentes em sua 
tabela, vá à opção “Choose column to display” e mude para a coluna desejada. 
 
 
Figura 13 - Mudança de visualização para a coluna desejada 
Fonte: Própria (2012) 
 
Seguindo nosso exemplo a coluna “funcao" foi escolhida. Clique em “Salvar” no lado direito de 
sua tela. 
 
 
Figura 14 - Salvar alterações 
Fonte: Própria (2012) 
 
Em seguida será criada outra tabela mais uma vez no botão “Create Table” que se encontra ao 
lado esquerdo de sua tela. 
 
 
Figura 15 - Criação de uma nova tabela 
Fonte: Própria (2012) 
 
 
8 
 
Adicionando um novo campo – chave estrangeira 
 
Defina mais uma vez as estruturas de suas colunas. Siga exatamente como está na imagem 
acima. 
 
 
Figura 16 - Definir estruturas das colunas 
Fonte: Própria (2012) 
 
Clique em “Executar” que se encontra ao lado direito de sua tela, para criar mais uma coluna 
que chamaremos de “cod_funcao”, chave estrangeira da tabela de funções. 
 
Figura 17 - Executar alterações 
Fonte: Própria (2012) 
 
 
 
9 
 
Veja na figuraacima que foi criado mais uma coluna totalmente em branco para ser 
preenchida. 
 
 
Figura 18 - Criação de mais uma coluna 
Fonte: Própria (2012) 
 
Defina as estruturas dessa coluna que foi adicionada, abaixo segue os detalhes. 
Preencher o campo “cod_funcao” conforme imagem. 
 
 
Figura 19 – Preencher campos de tabela 
Fonte: Propria (2012) 
 
Repare que apenas o nome do campo e o tipo foram modificados do padrão. Clique em 
“Salvar” 
10 
 
 
 
Figura 20 - Salvar alterações de tabela 
Fonte: Própria (2012) 
 
Clique no nome da ultima tabela criada que se encontra do lado esquerdo de sua tela. No caso 
do nosso exemplo, clique em “funcionarios”. 
 
 
Figura 21 - Selecionar nome da ultima tabela criada 
Fonte: Própria (2012) 
 
Adicionaremos os campos como chave estrangeira. Clique em “Ver relações”. 
 
 
Figura 22 – Verificando relações 
Fonte: Própria (2012) 
 
 
11 
 
Nas relações da coluna mude a relação da coluna desejada. 
 
 
Figura 23 - Mudança de relação da coluna desejada 
Fonte: Própria (2012) 
 
Clique na tabela “funcionários”, na aba “Estrutura” observe o grupo “Relações”, veja que na 
coluna “cod_funcao” existe um combo com as opções de chave. Clique na caixa de seleção de 
“cod_funcao” escolha a chave: “colaboradores.funcoes.cod_funcao”, conforme mostra na figura 
abaixo: 
 
Figura 24 - Tela para adicionar chave estrangeira 
Fonte: Própria (2012) 
 
Depois de te escolhido essa opção, clique em “Salvar”. 
Parabéns, as definições das tabelas estão prontas! 
 
12 
 
DESENVOLVER O APLICATIVO CRUD - NETBEANS 
Agora podemos passar para a próxima etapa que será no NetBeans. 
O NetBeans IDE é um ambiente de desenvolvimento integrado (IDE) gratuito e de código 
aberto para desenvolvedores de software nas linguagens Java, C, C++, PHP, Groovy, Ruby, 
entre outras. 
Criar novo projeto no Netbeans 
Para criarmos um novo projeto, vá ao menu Arquivo >> Novo >> Projeto ou pode utilizar os 
atalhos Ctrl+Shift+N. Na janela para escolha um novo projeto, escolha na Categoria “Java” e na 
Subcategoria de projetos, escolha: “Aplicativo Java” e clique em próximo. 
 
Figura 25 - NetBeans – Novo Projeto 
Fonte: Própria (2012) 
 
 
13 
 
Abrirá uma nova janela chamada novo aplicativo Java. Informe o nome do projeto 
“Colaboradores”. Todas as demais opções devem estar conforme figura abaixo, com exceção 
dos caminhos que serão assumidos de acordo com cada micro. Clique em “Finalizar”. 
 
Figura 26 - Netbeans – Novo Aplicativo Java 
Fonte: Própria (2012) 
 
Novo formulário de amostra mestre/detalhes – Como cria-lo 
Clique sobre o pacote “colaboradores” com o botão direito vá em Novo e depois em “Outro...” 
 
Figura 27 - Tela para criar outro formulário 
Fonte: Própria (2012) 
 
 
14 
 
Abrirá uma nova janela de novo arquivo, neste sentido clique na categoria “Formulários GUI 
Swing” e depois em “Tipo de arquivos”, selecione o item: “Formulário de amostra 
mestre/detalhe”. Clique em próximo. 
Esse é o 1º passo, a escolha do tipo de arquivo. 
 
Figura 6 – Netbeans – Tela Novo arquivo 
Fonte: Própria (2012) 
 
Aparecerá uma nova janela como o nome novo formulário mestre/detalhe. Iremos para o 2º 
passo que se trata do nome e local. Mude o nome da classe para “JFFuncoes”. Clique em 
próximo. 
 
Figura 7 – Tela do 2º passo do nome e local 
Fonte: Própria (2012) 
Aparecerá uma nova janela para damos continuidade ao 3º passo, que é a tabela mestre. Vá 
até “Conexão de banco de dados” na caixa de seleção, procure pela opção “Nova conexão 
15 
 
com banco de dados...” e selecione com um clique. Isso possibilitará o vinculação do NetBeans 
com o banco de dados. 
 
Figura 28 - Tela para adicionar nova conexão de banco de dados 
Fonte: Própria (2012) 
 
Na janela “Assistente nova conexão” terá varias opções de driver. Escolha a opção MySQL 
(connector / J driver). 
 
Figura 9 - Tela Assistente de nova conexão 
Fonte: Própria (2012) 
 
Clique em próximo como mostra a figura: 
16 
 
 
Figura 10 - Tela para localizar driver 
Fonte: Própria (2012) 
 
A definição da tela de configuração da conexão fica a cargo de cada um. 
Caso esteja usando servidor xampp, então a configuração será praticamente a mesma. Não é 
obrigatório informar senha, mais no caso da figura abaixo a senha é “root”. 
 
Figura 29 – Assistente de nova conexão - testar conexão 
Fonte: Própria (2012) 
 
 
17 
 
Clique em finalizar como mostrar a figura abaixo: 
 
Figura 30 - Assistente de nova conexão - Finalizar 
Fonte: Própria (2012) 
 
Aparecerá o 3º passo “Tabela mestre”. Esse assistente gerará um formulário com os campos 
da tabela e uma grade. Neste passo você definirá quais campos deseja na grade e o ultimo 
passo os campos do formulário. Normalmente escolhemos todos os campos ou pelo menos os 
essenciais, mais uma regra é importante: Não remova o campo chave “cod_funcao”. Mesmo 
que você não o queira, deixe-o, senão pode ocorrer erros. Posteriormente se quiser pode 
removê-lo. 
 
Figura 31 - Tela para criar tabela mestre 
Fonte: Própria (2012) 
 
 
Após ter selecionados todas as colunas disponíveis e passado da esquerda para direita em 
“Colunas a serem incluídas”, deste modo é possível prosseguir clicando no botão “Proximo”: 
18 
 
 
Figura 32 - Tela tabela mestre (Finalizando) 
Fonte: Própria (2012) 
 
Agora vamos passar para 4º passo, visto que neste momento escolheremos os campos a 
serem dispostos no formulário. 
Normalmente incluímos todos os campos com exceção dos campos AI (Auto incremento). Visto 
que uma PK geralmente é AI, então neste caso, o campo retornará a esquerda, para a listagem 
dos campos disponíveis. 
Basta selecionar o campo chave que está na listagem da direita e clicar no botão “<” que o 
“removerá” da listagem de campos disponíveis. Em nosso exemplo o campo chave é 
“cod_funcao”. 
 
Figura 33 - Opções de detalhe 
Fonte: Própria (2012) 
 
Veja abaixo a ilustração. 
19 
 
 
Figura 34 - Opções de detalhe (Campo AI) 
Fonte: Própria (2012) 
 
Clique no botão finalizar como mostra a figura abaixo : 
 
Figura 35 - Opções de detalhe (Finalizar) 
Fonte: Própria (2012) 
 
Agora seu formulário e a tabela mestre foi criada. Aguarde a barra de progresso do processo 
de criação. 
 
Figura 36 - Opções de detalhe (Campo AI) 
Fonte: Própria (2012) 
 
 
20 
 
Compilando o projeto 
Para que todos os arquivos de propriedade estejam atualizados, vá ate a barra de ferramenta 
superior e clique em executar e clique na opção para limpar e construir projeto principal, ou 
simplesmente usar as teclas Shift+F11 como atalho. 
 
Figura 20 - Tela para limpar e construir projeto principal 
Fonte: Própria (2012) 
 
Para executar o formulário que acabou de gerar, clique com botão direito sobre o JFFuncao e 
clique em “Executar arquivo” ou use as teclas Shift + F6 como atalho. 
 
Figura 37 - Tela executar o projeto 
Fonte: Própria (2012) 
 
Seu formulário foi gerado com as funcionalidades CRUD no designer padrão. 
CRUD (acrônimo de Create, Read, Update e Delete em língua Inglesa) para as quatro 
operações básicas utilizadas em bancos de dados relacionais. 
A abreviação CRUD mapeada para o padrão ISO/SQL: 
Create INSERT 
Read (Retrieve) SELECT 
Update UPDATE 
Delete (Destroy) DELETE 
Veja abaixo que existem botões de comando para persistência de dados. 
21 
 
A persistência de dados, na computação, refere-se ao armazenamento não-volátil de dados, 
por exemplo, o armazenamento de campos para entrada de dados sendo salvos no banco de 
dados. 
 
Figura 38 - Tela CRUD para Funções (Novo) 
Fonte: Própria (2012) 
 
Formulário CRUD - Testes 
Vamoscadastrar algumas funções para verificarmos se as funcionalidades CRUD estão todas 
em funcionamento. Após preencher o campo função, clique em “Save” para salvar como 
mostra a figura: 
 
 
Figura 39 - Tela CRUD para Funções (Salvar) 
Fonte: Própria (2012) 
 
 
22 
 
Pronto! Para visualizar os códigos gerados pelo AI, no campo “cod_funcao”, basta clicar no 
botão “Refresh”. 
 
Figura 40 - Tela CRUD para Funções (Atualizar) 
Fonte: Própria (2012) 
 
Compare abaixo os códigos gerados. 
 
Figura 41 - Tela CRUD para Funções (Campo AI) 
Fonte: Própria (2012) 
 
Geralmente começamos a gerar os formulários pelas tabelas que não tem chaves estrangeiras, 
isso para facilitar. 
Para criarmos o formulário CRUD da tabela de “Funcionarios”, clique com o botão direito do 
mouse no seu pacote “colaboradores” > Novo > Outro... 
23 
 
 
 
Figura 42 - Tela inicial do Netbeans (Outro...) 
Fonte: Própria (2012) 
 
Selecione a Opção “Formulários GUI Swing” e “Formulário de amostra mestre/detalhe” 
 
Figura 43 - Tela Novo Arquivo 
Fonte: Própria (2012) 
24 
 
Declare o nome da classe “JFFuncionarios” no pacote “colaboradores” e clique em Avançar. 
 
Figura 44 - Novo Formulário 
Fonte: Própria (2012) 
 
Selecione a conexão com o banco de dados (O nome do pacote a ser usado) “[root em 
Esquema padrão]”. 
A mesma conexão criada em passos anteriores, pois uma vez criada, não será mais 
necessário. 
 
Figura 45 - Novo Formulário (Conexão) 
Fonte: Própria (2012) 
 
 
25 
 
Selecione a tabela do banco de dados. 
 
Figura 46 - Novo Formulário (Tabela) 
Fonte: Própria (2012) 
 
Verifique as Colunas a serem incluídas e selecione “avançar” 
 
Figura 47 - Novo Formulário (Tabela Meste) 
Fonte: Própria (2012) 
 
26 
 
Selecione o campo “cod_funcionario” e selecione o botão (<) conforme a imagem.
 
Figura 48 – Novo Formulário (Opções de detalhe) 
Fonte: Própria (2012) 
 
O Campo “cod_funcionario” será incluído em “Campos disponíveis” e não será incluso no form, 
isso por ser um campo AI, conforme já explicado anteriormente. 
 
Figura 49 - Novo Formulário(Opções de detalhe – Campos disponíveis) 
Fonte: Própria (2012) 
 
 
27 
 
Selecione “Finalizar” com os campos incluídos ( funcionário, cod_funcao) e o campo ( 
cod_funcionario ) não será incluído no form. 
 
Figura 50 - Novo Formulário (Finalizar) 
Fonte: Própria (2012) 
 
Tipos de campo para chave estrangeira - Notação 
Quando o formulário contem campos de chave estrangeira como o “cod_funcao”, teremos que 
efetuar sua relação na classe gerada pelo IDE Netbeans. 
No pacote colaboradores, escolha o campo “Funcionarios.java” com o botão direito do mouse > 
Abrir. 
 
 
Figura 51 – Classe Funcionários – Abrir 
Fonte: Própria (2012) 
 
A tabela do código fonte do programa surgirá. 
 
Figura 52 - Classe Funcionários - Código 
Fonte: Própria (2012) 
 
Aproximadamente entre as linhas 45 a 47 você deve achar private int codFuncao . 
28 
 
 
 
Figura 53 - Classe Funcionários – Declaração da chave estrangeira 
Fonte: Própria (2012) 
 
A IDE Netbeans gera automaticamente a declaração os campos das tabelas, com seus 
respectivos tipos de dados que são obtida através do dicionário de dados do bando de dados. 
Para que a Entidade “Funcionarios” possa ter acesso a “Funcoes”, será necessário dentro dela 
para realizar uma notação que as ligará por meio de cardinalidade. 
O pronto de partida para esta relação seja realizada é que a declaração do campo seja 
alterada do seu tipo padrão que está no banco de dados, neste caso: de “int” para o tipo de 
dados de Entidade: “Funcoes”, veja como realizar. 
1. Localize o trecho: “private int codFuncao”. 
2. Apague o tipo “int” e com ajuda do atalho “Ctrl+ESPAÇO” digite “Funcoes” e o 
programa irá te auxiliar na escolha. 
 
Figura 54 - Classe Funcionários – Tipo de dados da chave estrangeira 
Fonte: Própria (2012) 
 
Depois de selecionado, normalmente o nome ficara grifado na cor amarelo. 
29 
 
 
Figura 55 - Classe Funcionários – Campos chaves estrangeiras 
Fonte: Própria (2012) 
 
Logo abaixo entre as linhas 54 e 56 pode ser encontrado o seguinte trecho: “public 
Funcionarios (integer codFuncionario, String funcionário, int codFuncao)”. 
 
 
Figura 56 - Classe Funcionários – Construtor 
Fonte: Própria (2012) 
 
Em todos os lugares onde o campo “cod_funcao” estiver declarado com o tipo “int”, deverá ser 
alterado para o tipo “Funcoes”. Para realizar esse passo selecione o tipo int e substitua para 
Funcoes assim como a figura abaixo (não se esqueça de usar Ctrl+ESPAÇO para o auxílio da 
escrita). 
 
 
Figura 57 - Classe Funcionários – Tipo Funcoes 
Fonte: Própria (2012) 
 
Normalmente o nome da classe Funcoes ficará grifado de amarelo, devido sua seleção. 
30 
 
 
Figura 58 - Classe Funcionários – Alterando tipo 
Fonte: Própria (2012) 
 
Para encontrar os pontos mais facilmente, na barra de rolagem do lado direito de um clique no 
ponto vermelho conforme a imagem abaixo: 
 
Figura 59 - Classe Funcionários - Demarcações de erro 
Fonte: Própria (2012) 
 
Aproximadamente na linha 80 você encontrará public int getCodFuncao () { 
 
Figura 60 - Classe Funcionários – Método getCodFuncao() 
Fonte: Própria (2012) 
 
public int getCodFuncao () - Troque o tipo primitivo “int” por “Funcoes” ( Não se esqueça de 
usar Ctrl+ESPAÇO ). 
 
Figura 61 - Classe Funcionários – Alterando tipo 
Fonte: Própria (2012) 
 
Logo abaixo entre as linhas 84 e 88 pode ser encontrado o trecho public void setCodFuncao 
(int codFuncao). 
31 
 
 
Figura 62 - Classe Funcionários – Encapsulamento (setCodFuncao) 
Fonte: Própria (2012) 
 
public void setCodFuncao (int codFuncao) - mude o int para Funcoes ( Não esqueça de usar o 
atalho Ctrl+ESPAÇO para o auxílio da escrita). 
 
Figura 63 - Classe Funcionários – Alterando encapsulamento 
Fonte: Própria (2012) 
 
O assistente pode surgir em algumas ocasiões. 
O tipo abaixo pode ser alterado manualmente, ou através do assistente “Lampada amarela”, 
basta clicar e selecionar “Alterar tipo de...” 
O texto irá se corrigir automaticamente. 
 
Figura 64 - Classe Funcionários - oldCodFuncao 
Fonte: Própria (2012) 
 
Relacionamento entre Entidades – Notação ManyToOne 
Na barre de rolagem selecione o traço de cor laranja, para definirmos o relacionamento. 
 
Figura 65 - Classe Funcionários – Criar o relacionamento 
Fonte: Própria (2012) 
 
Selecione o símbolo do inicio do texto “Criar relacionamento bidirecional ManyToOne” 
32 
 
 
Figura 66 - Classe Funcionários – ManyToOne (Cardinalidade) 
Fonte: Própria (2012) 
 
A tela para criar um relacionamento bidirecional surgirá. 
1. Apague o ultimo “s” do nome “funcionarioss”. 
2. Complete o nome com “List”. 
3. Ficará dessa forma: “funcionariosList”. 
4. Clique no botão OK 
 
Figura 67 - Classe Funcionários – Criar relacionamento bidirecional 
Fonte: Própria (2012) 
 
Neste momento, na classe “Funcoes” será adicionado um campo chamado: “funcionariosList” 
do tipo lista. Isso para que possamos através da classe que representa função, relacionar 
todos os funcionários. 
Salve o projeto no menu Arquivo >> “Salvar Todos”. 
33 
 
 
Figura 68 – Salvar projeto 
Fonte: Própria (2012) 
 
Para que todos os arquivos de propriedade estejam atualizados, selecione no menu Executar 
>> “Limpar e construir projeto principal”. 
 
Figura 69 – Executar – Limpar e construir 
Fonte: Própria (2012) 
 
Chave estrangeira – Caixa de combinação 
No pacote “colaboradores” selecione abrir em “JFFuncionarios.java” 
 
Figura 70 – Abrir formulário JFFuncionarios 
Fonte: Própria (2012) 
 
Exclua o campode texto de Cod_Funcao. 
34 
 
 
Figura 71 – Formulário Funcionarios – Campo cod_funcao 
Fonte: Própria (2012) 
 
O campo de texto de “cod_funcao” ficará sem nada a sua frente. 
 
Figura 72 – Formulário Funcionarios – Campo Cod Funcao 
Fonte: Própria (2012) 
 
Abra Paleta no menu Controle Swing e selecione Caixa de combinação e arraste para o campo 
em frente ao Cod_Funcao. 
35 
 
 
Figura 73 – Formulário Funcionarios (caixa de combinação para campos chaves estrangeira) 
Fonte: Própria (2012) 
 
Redimensione a “Caixa de combinação” até alinhar com os outros campos. 
 
Figura 74 – Caixa de combinação - Redimensionar 
Fonte: Própria (2012) 
 
Binding Elements – Vincular elementos de uma entidade a caixa de 
combinação 
Para preenchermos a caixa de combinação com a listagem com todas as funções ligadas ao 
banco de dados, é preciso com o botão direito clicar na caixa de combinação e selecione 
Vincular > elements. 
Esse processo chama-se “Binding” que significa vinculação. 
 
Figura 75 – Caixa de combinação - Vincular 
Fonte: Própria (2012) 
 
Na tela Vincular clique em “Importar dados para o formulário”. 
36 
 
 
Figura 76 – Caixa de combinação – Importar dados para o formulário 
Fonte: Própria (2012) 
 
Escolha a aba vinculação na tela que se abrirá, escolha a tabela “Funcoes” e clique em OK, 
conforme a figura abaixo. 
 
Figura 77 - Caixa de combinação – Elementos 
Fonte: Própria (2012) 
 
Caixa de combinação – Renderer 
No painel do projeto em propriedade do campo Cod Funcao. 
Para que a listagem retorne o nome da função ao invés dos códigos, colocaremos um retorno 
na caixa de seleção através de propriedades > RENDERER. 
Clique no botão “...”, tres pontinhos a frente da propriedade “renderer”. 
 
Figura 78 - Caixa de combinação – Renderer 
Fonte: Própria (2012) 
 
37 
 
Após executar o passo anterior aparecerá uma tela como está abaixo. 
 
 
Figura 79 - Seletor de componente 
Fonte: Própria (2012) 
 
Iniciaremos assim o processo de definição da propriedade, selecionando os devidos campos, 
SELETOR DE COMPONENTE>CÓDIGO PERSONALIZADO. 
 
Figura 80 - Seletor - Personalizar componente 
Fonte: Própria (2012) 
 
 
38 
 
Após clicar em código personalizado, escreva o seguinte código dentro do espaço: 
“jComboBox1.setRenderer” , e clique em “OK” logo em seguida no botão “OK” da janela. 
 
new DefaultListCellRenderer() { 
 @Override 
 public Component getListCellRendererComponent( 
 JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { 
 super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); 
 if (value instanceof Funcoes) { 
 Funcoes mec = (Funcoes)value; 
 setText(mec.getFuncao()); 
 } 
 return this; 
} 
 } 
 
No código acima, substitua os trechos em negrito e sublinhado por sua classe, neste exemplo 
“Funcoes”. 
 
Figura 81 - Caixa de combinação – renderer 
Fonte: Própria (2012) 
 
Ainda no campo PROPRIEDADES, clique em FECHAR. 
39 
 
O IDE Netbeans mostrará a seguinte janela e com o campo da caixa de texto do Cod Funcao 
criado na interface, ainda selecionado, selecione o botão Código-fonte da barra de ferramenta, 
que irá permitir exibir o código-fonte da classe. 
 
Figura 82 - Código fonte da classe 
Fonte: Própria (2012) 
 
Siga as orientações conforme figura abaixo e clique sobre o demarcador de erro que aparece 
ao lado da barra de rolagem. 
 
 
Figura 83 - Demarcação de erro 
Fonte: Própria (2012) 
 
Quando adicionamos o código ao renderer, no código fonte acusou falta das bibliotecas 
necessárias, sendo assim, faremos a importação. Clique com botão direito em um espaço 
vazio do código-fonte e em Corrigir importações. 
 
Figura 84 - Corrigir importações 
Fonte: Própria (2012) 
 
Agora que os erros de importação foram corrigidos. Clique no campo Projeto para retornarmos 
a interface gráfica. 
40 
 
 
Figura 85 - Visualizar projeto 
Fonte: Própria (2012) 
 
Configurar componente JTable - Tabela 
Na grade o campo onde deveria aparecer a função, ainda está “cod Funcao”. Para corrigirmos 
isso, iremos acessar o conteúdo da tabela e alterar. Clique com o botão direito do mouse e 
selecione a opção Conteúdo da tabela. 
 
Figura 86 - Conteúdo da tabela 
Fonte: Própria (2012) 
 
Após executar o passo anterior, aparecerá a seguinte janela, clique na Aba Colunas para editar 
os campos. 
 
Figura 87 - Tabela (Colunas) 
Fonte: Própria (2012) 
 
 
41 
 
Na Caixa de diálogo Personalizador, clique na aba COLUNAS>COD FUNCAO. 
Selecione o campo Expressão, clique em “+” da pasta CodFuncao. Ao expandir os campos 
contidos dentro da pasta e clique sobre “funcao". 
 
Figura 88 - Personalizador (funcao) 
Fonte: Própria (2012) 
 
Após realização desse passo, a janela pode ser fechada, basta clicar no botão FECHAR. 
Para definirmos qual item será marcado ao escolher uma função na caixa de combinações, 
selecionaremos a caixa de combinação do “Cod função” e com um clique com o botão direito 
do mouse, Vincular > selectedItem. 
 
Figura 89 - Vincular Item 
Fonte: Própria (2012) 
 
 
42 
 
Na aba Vinculação, no campo “Origem da vinculação” escola a opção “masterTable”. 
 
Figura 90 – Origem da vinculação 
Fonte: Própria (2012) 
 
Logo depois de escolher a Origem de Vinculação, precisaremos escolher a Expressão de 
Vinculação. Então deveremos Clicar no “+” em “selectedElement colaboradeos.Funcionarios” 
para abrir a pasta. 
Ao abrirmos a pasta requerida, selecione como Expressão de Vinculação “codFuncao 
colaboradores.Funcoes”, para seguir em frente. 
 
 
Figura 91 - Expressão de vinculação 
Fonte: Própria (2012) 
 
 
43 
 
A vinculação deverá ficar conforme abaixo. Clique em fechar. 
 
Figura 92 - Vinculação concluída 
Fonte: Própria (2012) 
 
Configuração da chave estrangeira – Notação @JoinColumn 
Voltando a tela principal. Para abrirmos a classe clique com o botão direito do mouse sobre a 
classe “Funcionarios.java” e em seguida “Abrir”. 
 
Figura 93 - Abrir classe Funcionarios 
Fonte: Própria (2012) 
 
Os passos seguintes são muito importantes, uma vez que faremos a ligação entre as entidades 
e sua cardinalidade usando notações JPA. 
Java Persistence API, chamada apenas de JPA, é uma API padrão do java para persistência 
que deve ser implementada por frameworks que queiram seguir o padrão. A JPA define um 
meio de mapeamento objeto-relacional para objetos Java simples e comuns (POJOs), 
denominados beans de entidade. 
Removeremos a notação @Basic da chave estrangeira. 
Perceba que na linha 45(está escrito: @Basic (optional = false)), selecione a linha e exclu-a. 
 
Figura 94 - Notação @Basic 
Fonte: Própria (2012) 
 
Faremos o mesmo processo com a linha 46(que está escrito: @Column(name=”cod_funcao”)). 
Selecione-a e exclu-a. 
44 
 
Essa notação @Column será substituída por um @JoinColumn. 
 
Figura 95 - Notação @Column 
Fonte: Própria (2012) 
 
Utilizando “ctrl + barra de espaço”, coloque um comando na linha 46, o “@JoinColumn”. 
Repare que entre os parênteses não tem absolutamente nada, por isso devemos, utilizando o 
“ctrl + espaço”, digitar “name”(sem aspas). 
 
Figura 96 - Notação @JoinColumn - Primeiros passos 
Fonte: Própria (2012) 
 
A notação deve ficar conforme abaixo: 
@JoinColumn (name=”cod_funcao”,referencedColumnName=”cod_funcao”) 
 
Figura 97 - @JoinColumn (completa) 
Fonte: Própria (2012) 
 
 
Finalizando o projeto precisamos saber se está tudo funcionando, por isso devemos limpar oprojeto principal e construí-lo. Portanto vá até a Barra de Ferramentas no menu Executar >> 
Limpar e Contruir o Projeto Principal (ou através das teclas de atalho Shift+F11). 
45 
 
 
Figura 98 - Limpar e Construir o Projeto Principal 
Fonte: Própria (2012) 
 
Finalizando projeto – Compilar e testar 
Depois de limpo e construído, podemos vê-lo funcionar, ou seja, executá-lo. Para isso 
deveremos clicar com o botão direito em “JFFuncionarios” e no menu escolher “Executar 
arquivo”. (Shift+F6). 
 
Figura 99 - Executar arquivo 
Fonte: Própria (2012) 
 
 
46 
 
E finalmente irá aparecer a tela do programa rodando. Para testar as funcionalidades CRUD, 
inicie clicando em “New” (do inglês: Novo). 
 
Figura 100 - Formulário Funcionarios - Primeira execução 
Fonte: Própria (2012) 
 
Coloque o nome do Funcionário e selecione sua função. Usaremos de exemplo o funcionário 
Douglas e sua função será Analista. 
Depois de colocar o nome e a função, salve clicando em “Save” (do inglês: Salvar). 
 
Figura 101 - Formulário Funcionarios – Salvando 
Fonte: Própria (2012) 
 
Pronto, agora é só atualizar para o programa mostrar o Codigo do Funcionário. Para atualizar 
deverá clicar em Refresh (do inglês: Refrescar; Atualizar).