The device ‘/dev/sda1′ doesn’t have a valid NTFS.
Maybe you selected the wrong device? Or the whole disk instead of a
partition (e.g. /dev/hda, not /dev/hda1)? Or the other way around?

Nesta partição (sda1) está instalado o Windows XP e com este erro, não é possível montar e muito menos iniciar o sistema.

Ainda não descobri a causa do problema, na verdade, já realizei o processo de particionamento uma série de vezes e nunca tive problemas. De qualquer forma, eu preciso da minha partição de volta ou, pelo menos, dos dados contidos nela!

A solução proposta aqui não se aplica a todos os casos, mas ela pode servir de base para solucionar outros tipos de problemas ligados a recuperação de partições danificadas. Como dizem por aí: siga os passos por conta e risco! Não venha reclamar que perdeu tudo porque seguiu os passos descritos aqui!

Solução adotada:

Depois de pesquisar em vários fóruns, achei um sistema operacional linux chamado System Rescue (http://www.sysresccd.org). Ele possui várias ferramentas interessantes para realizar recuperação de dados e uma delas é a testdisk (http://www.cgsecurity.org/wiki/TestDisk).

No meu caso, instalei a ferramenta no sistema operacional que já estava instalado na máquina em uma outra partição. Se eu não tivesse, uma boa opção seria utilizar o System Rescue mesmo (mais detalhes no site).

Para instalar o testdisk no ubuntu digite: sudo apt-get install testdisk

O site http://www.cgsecurity.org/wiki/TestDisk traz uma série de informações sobre a ferramenta. Ela possui suporte para os seguintes sistemas de arquivo:

• BeFS ( BeOS )
• BSD disklabel ( FreeBSD/OpenBSD/NetBSD )
• CramFS, Compressed File System
• DOS/Windows FAT12, FAT16 and FAT32
• Windows exFAT
• HFS, HFS+ and HFSX, Hierarchical File System
• JFS, IBM’s Journaled File System
• Linux ext2 and ext3
• Linux LUKS encrypted partition
• Linux RAID md 0.9/1.0/1.1/1.2
  • RAID 1: mirroring
  • RAID 4: striped array with parity device
  • RAID 5: striped array with distributed parity information
  • RAID 6: striped array with distributed dual redundancy information
• Linux Swap (versions 1 and 2)
• LVM and LVM2, Linux Logical Volume Manager
• Mac partition map
• Novell Storage Services NSS
• NTFS ( Windows NT/2000/XP/2003/Vista/2008 )
• ReiserFS 3.5, 3.6 and 4
• Sun Solaris i386 disklabel
• Unix File System UFS and UFS2 (Sun/BSD/…)
• XFS, SGI’s Journaled File System

No meu caso, depois de instalar o testdisk, eu executei:

sudo su
testdisk

1. Selecione Create (se quiser criar um log)

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

TestDisk is a free data recovery software designed to help recover lost
partitions and/or make non-booting disks bootable again when these symptoms
are caused by faulty software, certain types of viruses or human error.
It can also be used to repair some filesystem errors.

Information gathered during TestDisk use can be recorded for later
review. If you choose to create the text file, testdisk.log , it
will contain TestDisk options, technical information and various
outputs; including any folder/file names TestDisk was used to find and
list onscreen.

Use arrow keys to select, then press Enter key:
[ Create ]  Create a new log file
[ Append ]  Append information to log file
[ No Log ]  Don’t record anything

2. Selecione o disco que tem as partições que serão recuperadas e selecione proceed. No meu caso foi /dev/sda:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

TestDisk is free software, and
comes with ABSOLUTELY NO WARRANTY.

Select a media (use Arrow keys, then press Enter):
Disk /dev/sda – 160 GB / 149 GiB – ATA ST3160827AS
Disk /dev/sdb – 80 GB / 74 GiB – ATA ST380011A

[Proceed ] [  Quit  ]

3. Selecione o tipo de partição. No meu caso (e na maior parte dos outros) é a opção Intel:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – ATA ST3160827AS

Please select the partition table type, press Enter when done.
[Intel  ]  Intel/PC partition
[EFI GPT]  EFI GPT partition map (Mac i386, some x86_64…)
[Mac    ]  Apple partition map
[None   ]  Non partitioned media
[Sun    ]  Sun Solaris partition
[XBox   ]  XBox partition
[Return ]  Return to disk selection

4. Selecione a opção advanced:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63

[ Analyse  ]  Analyse current partition structure and search for lost partitions
[ Advanced ]  Filesystem Utils
[ Geometry ]  Change disk geometry
[ Options  ]  Modify options
[ MBR Code ]  Write TestDisk MBR code to first sector
[ Delete   ]  Delete all data in the partition table
[ Quit     ]  Return to disk selection

5. Agora selecione boot:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63

Partition                  Start        End    Size in sectors
1 * HPFS – NTFS              0   1  1 12157 254 63  195318207
2 P FAT32                12158   0  1 17020 254 63   78124095 [NO NAME]
3 E extended             17021   0  1 19456 254 63   39134340
5 L HPFS – NTFS          17021   1  1 19456 254 63   39134277 [New Volume]

[  Type  ]  [  Boot  ] [Image Creation]  [  Quit  ]
Boot sector recovery

6. Nesta máquina estou com um problema no Boot Sector. Neste caso, selecione Org. BS. Observe a mensagem Sectors are not identical:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63
Partition                  Start        End    Size in sectors
1 * HPFS – NTFS              0   1  1 12157 254 63  195318207

Boot sector
Status: OK

Backup boot sector
Status: OK

Sectors are not identical.

A valid NTFS Boot sector must be present in order to access
any data; even if the partition is not bootable.

[  Quit  ]  [  List  ]  [Org. BS ] [Backup BS]  [Rebuild BS]  [  Dump  ]

7. Restaurar o backup dos setores de boot. Pressione Y:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Copy original NTFS boot sector over backup boot, confirm ? (Y/N)

8.Observe que agora não há divergencia no boot sector (Sectors are identical):

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63
Partition                  Start        End    Size in sectors
1 * HPFS – NTFS              0   1  1 12157 254 63  195318207

Boot sector
Status: OK

Backup boot sector
Status: OK

Sectors are identical.

A valid NTFS Boot sector must be present in order to access
any data; even if the partition is not bootable.

9. Agora vamos refazer setor de boot:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63
Partition                  Start        End    Size in sectors
1 * HPFS – NTFS              0   1  1 12157 254 63  195318207

Boot sector
Status: OK

Backup boot sector
Status: OK

Sectors are identical.

A valid NTFS Boot sector must be present in order to access
any data; even if the partition is not bootable.

[  Quit  ]  [  List  ]  [Rebuild BS] [Repair MFT]  [  Dump  ]

10. Agora clique na opção Write:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Disk /dev/sda – 160 GB / 149 GiB – CHS 19457 255 63
Partition                  Start        End    Size in sectors
1 * HPFS – NTFS              0   1  1 12157 254 63  195318207

filesystem size           195318207 195318207
sectors_per_cluster       8 8
mft_lcn                   786432 786432
mftmirr_lcn               12207387 144959613018195227
clusters_per_mft_record   -10 -127
clusters_per_index_record 1 114
Extrapolated boot sector and current boot sector are different.

[  Dump  ]  [  List  ]  [ Write  ] [  Quit  ]

11. Confirme a gravação do novo boot pressionando Y:

TestDisk 6.10, Data Recovery Utility, July 2008
Christophe GRENIER <grenier@cgsecurity.org>

http://www.cgsecurity.org

Write new NTFS boot sector, confirm ? (Y/N)

Pressione q várias vezes até sair do programa.
Neste ponto a partição deve estar pronta para ser utilizada. Você poderá monta-la e copiar seus dados para um local seguro.

Como este é um simples PC doméstico, não é sempre que faço backup dos meus dados e esta ferramenta foi a minha salvação. Quem sabe ela também não pode ser a sua!

Introdução

Neste post vou tentar ajudar os iniciantes, com um pouco de conhecimento em linux, na instalação do Oracle 11g Database Server 64bit no Ubuntu Server 9.04 64bit. Provavelmente os passos descritos aqui poderão ser utilizado com futuras versões do Ubuntu/Oracle.

Hardware: A máquina servidor utilizada na instalação foi um AMD64 3200 com 1 Gb de memória RAM, HD de 80Gb, placa de rede Wireless 802.11 g, Ubuntu Server 9.04 64bit usando o novo sistema de arquivos EXT4. A máquina cliente é um notebook HP básico com Ubuntu 9.04 Desktop 32bit.

Os procedimentos a seguir foram executados por mim e não necessariamente representam a melhor forma de se fazer a instalação.

Resumo: para instalar o Oracle Database Server na máquina servidor, que NÃO vem com suporte para aplicações gráficas (por padrão), você precisará de uma máquina cliente, que TEM esse suporte. Presumindo que não temos acesso fácil ao servidor, poderemos usar o aplicativo ssh para conectar, executar as configurações necessárias e no final, enviar as telas que o instalador mostraria no servidor para a máquina cliente. Não vou entrar nos detalhes técnicos de como isso funciona, um outro post seria necessário só para este assunto. É importante lembrar que durante a instalação do Ubuntu Server, você instale também o OpenSSH para executar os passos aqui descritos remotamente. Não é recomendado instalar o servidor gráfico na máquina servidor.

O que motivou a criação deste post foi a falta de informações disponíveis em português para alguns problemas encontrados na instalação da versão 64bit, problemas que não ocorrem na versão 32bit do Ubuntu.

Não fornecerei detalhes sobre a instalação do Ubuntu (Server/Desktop), você poderá procurar algum tutorial para isso na internet, mas acredito ser bastante simples.

Instalação do Banco de Dados

Depois de instalado o sistema operacional e da rede entre a máquina servidor e a cliente estar configurada, precisamos efetuar algumas alterações recomendadas pela Oracle para que o banco de dados funcione adequadamente. É importante lembrar que o Ubuntu não é homologado para a instalação do Oracle Database Server.

Abaixo, colocarei uma longa “receita de bolo” que vai facilitar a configuração.

Observações:
1. O símbolo $ indica que os comandos devem ser executados com o usuário normal
2. O símbolo # indica que os comandos devem ser executados como root ($ sudo su)
3. Onde houver o símbolo S, os comandos devem ser executados no servidor e onde tiver o C, no cliente. Ex 01S indica que os comandos serão executados no servidor (usando o ssh).
4. Para conectar no servidor remoto, utilize o ssh <máquina>. Ex: ssh 192.168.0.100
5. A versão servidor do Ubuntu não vem com o X, portanto a instalação será feita a partir de outra máquina com um servidor X instalado (Ubuntu Desktop por exemplo).

Vamos lá…

01S. Atualize o sistema
# apt-get update
# apt-get dist-upgrade

02S. Baixar pacotes requeridos
# apt-get install gcc make binutils gawk x11-utils rpm alien ksh lsb-rpm libaio1 lesstif2 libmotif3 unzip

03S. Alterar link simbólico
# ln -sf /bin/bash /bin/sh

04S. Criar links simbólicos para alguns programas
# ln -s /usr/bin/awk /bin/awk
# ln -s /usr/bin/rpm /bin/rpm
# ln -s /usr/bin/basename /bin/basename
# ln -s /lib/libgcc_s.so.1 /lib/libgcc_s.so

05S. Adicionar o grupo oinstall, dba e nobody
# addgroup oinstall
# addgroup dba
# addgroup nobody

06S. Alterar o GID do grupo padrão do usuário para o valor especificado
# usermod -g nobody nobody

07S. Criar diretório de usuário Oracle
# mkdir /home/oracle

08S. Alterar os donos do diretório de usuário Oracle
# chown -R oracle:dba /home/oracle

09S. Adicionar usuário oinstall com senha password
# useradd -g oinstall -G dba -p password -d /home/oracle -s /bin/bash oracle

10S. Adicionar comando “su oracle” ao visudo para que todos os usuários do grupo admin possam entrar com usuário oracle sem senha (passo opcional)
# visudo

Na última linha do arquivo adicionar:
%admin ALL=NOPASSWD:/bin/su oracle

Para testar digite no prompt
$ sudo su oracle

11S. Criar /etc/rc.d e seus links
# mkdir /etc/rc.d
# for i in 0 1 2 3 4 5 6 S ; do ln -s /etc/rc$i.d /etc/rc.d/rc$i.d ; done

12S. Criar diretório para a instalação e alterar as permissões
# mkdir -p /u01/app/oracle
# chown -R oracle:dba /u01

13S. Criar e alterar o dono da pasta onde estará o instalador
# mkdir /home/oracle/inst
# chown -R oracle:oinstall /home/oracle/inst

14S. Alterar os parâmetros de configuração do kernel
# cd /etc
# cp sysctl.conf sysctl.conf.original
# pico sysctl.conf

#Linhas para serem adicionadas no final do arquivo
fs.file-max = 65535
kernel.shmall = 2097152
kernel.shmmax = 2147483648
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
net.ipv4.ip_local_port_range = 1024 65535
net.core.rmem_default = 4194304
net.core.rmem_max = 4194304
net.core.wmem_default = 262144
net.core.wmem_max = 262144

15S. Modificar o arquivo /etc/security/limits.conf que impõe limites para usuários
# cd /etc/security/
# cp limits.conf limits.conf.original
# pico /etc/security/limits.conf

#estas configurações devem ser adicionadas no final do arquivo
oracle soft nproc 2047
oracle hard nproc 16383
oracle soft nofile 1023
oracle hard nofile 65535

16S. Modificar configurações de segurança
# cd /etc/pam.d
# cp login login.original
# pico login

#adicionar as linhas no final do arquivo
session required /lib/security/pam_limits.so
session required pam_limits.so

17S. Reinicie o sistema
# reboot

18S. Entre com o usuário Oracle
$ sudo su oracle

19C. Desative os efeitos visuais (caso estejam ativados)

Na máquina onde serão exibidas as telas do instalador as telas podem não ser exibidas corretamente se os efeitos visuais estiverem habilitados.

- Clique em Sistema>Preferências>Aparência e clique na guia Efeitos Visuais
- Clique em Nenhum e depois em Fechar

20C. Verifique se a máquina está com as conexões TCP para o servidor X habilitadas
- Clique no menu Sistema>Administração>Janela de inicio de sessão
- Clique na aba Segurança
- Desabilite a opção “Negar conexões TCP para o servidor X” (caso esteja marcado)

21C. Habilite a conexão TCP do servidor para a máquina cliente indicando o IP do servidor
# xhost +192.168.0.100

22S. Montar o dispositivo com os arquivos da instalação do oracle.
No meu caso é um drive de dvd que está em /dev/scd0. Substitua o /dev/scd0 de acordo com as configurações do seu sistema.
# if [ ! -e /media/cdrom ]; then mkdir -p /media/cdrom; fi
# mount /dev/scd0 /media/cdrom

23S. Copiar o arquivo de instalação do dispositivo
Copiar os arquivos do dvd/pendrive para a pasta /home/oracle/database. No meu caso, os arquivos estão na pasta linux do dvd.
# cp /media/cdrom/linux/linux.x64_11gR1_database_*.zip /home/oracle/inst

24S. Descompactado o arquivo de instalação do oracle.
# cd /home/oracle/inst
# unzip *.zip
# chown -R oracle.oinstall /home/oracle/inst

25S. Algum bug ao descompactar alguns arquivos me obrigaram a criar esta gambiarra (isso ocorreu na versão 64bit)

#sudo su oracle
$ mv /home/oracle/inst/database/install/unzip /home/oracle/inst/database/install/unzip.bak
$ ln -s $(which unzip) /home/oracle/inst/database/install/unzip

26S. Executar a instalação exportando o display para a máquina cliente
* Lembre-se que 192.168.0.105 é a máquina que tem o servidor X instalado (onde as imagens do instalador devem aparecer)
# export DISPLAY=192.168.0.105:0.0
# /home/oracle/inst/database/runInstaller -ignoreSysPrereqs

* Durante a instalação, pode ocorrer um erro ao executar um determinado processo. Ignore e prossiga com o procedimento.

Abaixo coloquei algumas telas do instalador. Você pode observar as opções que eu usei para configurar a sua instalação.

Tela inicial do instalador

Usar o grupo dba

Marcar a versão Enterprise Edition

Mudar o ORACLE_HOME

Clique nas caixas de seleção de requisitos que estão em branco para que sejam marcadas como “verificadas pelo usuário”

Optar por instalar somente o software. O banco de dados poderá ser configurado depois

Mudei os privilégios dos grupos do sistema operacional para dba

Finalmente o sumário

A instalação deve demorar alguns minutos…

Devem ocorrer dois erros como este durante a instalação. Estes erros não impedem a utilização do banco de dados

Nesta tela são exibidos os scripts que devem ser executados como root

Finalizamos a instalação

27S. Editar o arquivo /etc/environment
# pico /etc/environment

Coloque o seguinte conteúdo:

ORACLE_HOME=/u01/app/oracle/product/11.1.0/db_1
PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/u01/app/oracle/product/11.1.0/db_1/bin”

28S. Criar o arquivo oracledb
Depois de ter instalado o banco de dados, vamos criar o arquivo /etc/init.d/oracledb:

# pico /etc/init.d/oracledb

Conteúdo do arquivo:

#!/bin/bash
#
# /etc/init.d/oracledb
#
# Run-level Startup script for the Oracle Listener and Instances
# It relies on the information on /etc/oratab
export ORACLE_BASE=/u01/app/oracle
export ORACLE_HOME=/u01/app/oracle/product/11.1.0/db_1
export ORACLE_OWNR=oracle
export PATH=$PATH:$ORACLE_HOME/bin
if [ ! -f $ORACLE_HOME/bin/dbstart -o ! -d $ORACLE_HOME ]
then
echo “Oracle startup: cannot start”
exit 1
fi
case “$1″ in
start)
# Oracle listener and instance startup
echo -n “Starting Oracle: “
su $ORACLE_OWNR -c “$ORACLE_HOME/bin/lsnrctl start”
su $ORACLE_OWNR -c “$ORACLE_HOME/bin/dbstart $ORACLE_HOME”
touch /var/lock/oracle
echo “OK”
;;
stop)
# Oracle listener and instance shutdown
echo -n “Shutdown Oracle: “
su $ORACLE_OWNR -c “$ORACLE_HOME/bin/lsnrctl stop”
su $ORACLE_OWNR -c “$ORACLE_HOME/bin/dbshut $ORACLE_HOME”
rm -f /var/lock/oracle
echo “OK”
;;
reload|restart)
$0 stop
$0 start
;;
*)
echo “Usage: `basename $0` start|stop|restart|reload”
exit 1
esac
exit 0

29S. Configurar a execução automática
# chmod a+x /etc/init.d/oracledb
# update-rc.d oracledb defaults 99

30S. Crie o banco de dados usando o SID orasrv

Observe que você deve alterar o endereço IP 192.168.0.105 para o da sua máquina cliente!

$ sudo su oracle
$ export DISPLAY=192.168.0.105:0.0
$ export ORACLE_HOME=/u01/app/oracle/product/11.1.0/db_1
$ export PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/u01/app/oracle/product/11.1.0/db_1/bin”
$ dbca

31. Automatizar a execução do Oracle no boot:
# pico /etc/oratab

Altere o último caractere de N para Y assim (exemplo):

[original] orasrv:/u01/app/oracle/product/11.1.0/db_1:N
[alterado] orasrv:/u01/app/oracle/product/11.1.0/db_1:Y

* A última linha só existirá depois que o banco de dados for criado.

“E chegamos ao fim, espero que você tenha conseguido seguir os passos descritos aqui. Se tiver alguma sugestão, por favor, deixe seu comentário“.

Felizmente podemos limitar os dados que são armazenados nas coleções usando a clausula LIMIT. Desta forma, podemos analisar a relação custo/benefício concedendo limites maiores ou menores para nossa coleção.

É importante lembrar que do Oracle Database 10g em diante os cursores (FOR LOOPS) são automaticamente otimizados para velocidades próximas as do BULK COLLECT.

Vamos ver na prática como tudo isso funciona.

Criar tabela teste:

create table tab19x (
id number(5),
nome varchar2(30),
constraint tab19x_pk primary key (id));

Popular a tabela:

begin
insert into tab19x
select level, dbms_random.string(‘a’, 30) from dual connect by level <= 123;
commit;
end;

Abaixo temos um bloco de código PL/SQL anônimo, onde temos um BULK COLLECT limitando a coleção para 50 registros. Isso significa que cada vez que os dados são lidos do cursor, no máximo 50 registros por vez são alocados na memória. Toda vez que a coleção for carregada, uma mesma quantidade de memória será alocada na PGA, mesmo que a tabela aumente de tamanho em número de linhas.

Utilizando o BULK COLLECT

declare
cursor cur_tab19x is
select id, nome
from tab19x;

–Abaixo crio o tipo para a coleção
type trow_tab19x is table of cur_tab19x%rowtype
index by pls_integer;

–Declaro a coleção row_tab19x
row_tab19x trow_tab19x;
begin
open cur_tab19x;
loop
fetch cur_tab19x BULK COLLECT into row_tab19x limit 50;

–NÃO use: exit when cur_tab19x%notfound;
exit when row_tab19x.count = 0;

for i in 1..row_tab19x.count
loop
dbms_output.put_line(‘Cod: ‘ || row_tab19x(i).id || ‘ valor: ‘ || row_tab19x(i).nome);
end loop;
end loop;
close cur_tab19x;
end;

Quando utilizamos BULK COLLECT precisamos lembrar que:

• As coleções são preenchidas sequencialmente, iniciando do índice valor 1;
• Interagir com a coleção de 1 até coleção.COUNT;
• A coleção é vazia quando não tivermos mais linhas depois de um fetch;
• Sempre utilize o método coleção.COUNT para ver se existem mais linhas para serem processadas;
• Ignore os valores retornados pelos atributos do cursor, especialmente o cursor%NOTFOUND;

Fonte: http://www.oracle.com/technology/oramag/oracle/08-mar/o28plsql.html

Depois de uma breve busca no google, desisti de procurar e resolvi tentar resolver os problemas que tive por conta própria. Sou desenvolvedor e usuário do Ubuntu há algum tempo e adoro a praticidade do sistema, porém, a versão de alguns programas instalados pelo apt-get nem sempre é a mais recente. Este é o caso da instalação do JDK.

Este documento fornece algumas dicas para instalar a última versão disponível do java Sun no Ubuntu.

Testado com Ubuntu 9.04/8.10 e JDK 1.6.0_13/JDK 1.6.0_12 mas deve funcionar com versões mais recentes do Ubuntu/JDK.

Removendo a instalação antiga do JDK

1. Remova todos os pacotes instalados da versão anterior (caso tenha instalado). Acho que a maneira mais fácil é ir até o Gerenciador de pacotes Synaptic, digitar  sun-jdk (se foi instalada a versão da sun) na procura e remover todas os pacotes que fazem referencia a ele.

synaptic

Download da nova versão

2. Efetuar o download pelo site da Sun: http://java.sun.com/javase/downloads/index.jsp

Na figura abaixo, temos o JDK 6 Update 12 (jdk-6u12-linux-i586.bin) mas você deve fazer download do mais atual

download-java-site-sun

Configuração

3. Os comandos agora devem ser executados como root:

sudo su

4. Depois que o download terminar, abra o console, entre na pasta onde está o arquivo e digite:

chmod 550 jdk-6u12-linux-i586.bin

./jdk-6u12-linux-i586.bin

* lembre-se de mudar o nome do arquivo caso tenha feito download de uma versão mais recente

Leia os termos e concorde. Isso irá descompactar os arquivos na pasta atual.

5. Eu gosto de manter os programas instalados manualmente na pasta /opt, então, vou mover o arquivo para lá:

mv jdk1.6.0_12 /opt

cd /opt

* lembre-se de mudar o nome da pasta caso tenha feito download de uma versão mais recente.

6. Criar o link simbólico. Este passo não é obrigatório, mas é interessante no caso de uma nova versão do java (1.6.0_13 por exemplo). Será necessário somente recriar o link simbólico sem precisar alterar outros arquivos de configuração:

ln -s jdk1.6.0_12 jdk

* lembre-se de mudar o nome da pasta caso tenha feito download de uma versão mais recente

7. Vamos alterar os parâmetros de ambiente abrindo o arquivo /etc/environment. Eu uso o vi, mas vc pode substitui-lo por gedit por exemplo. Veja:

vi /etc/environment

ou se preferir, use o gedit:

gedit /etc/environment

no inicio do arquivo, adicione a linha:

JAVA_HOME=”/opt/jdk”

e onde está PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games” adicione:

:/opt/jdk/bin

deve ficar assim: PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/opt/jdk/bin“

=> Lembre-se que a linha do PATH é somente um exemplo. Ela pode variar de acordo com as suas configurações. O importante é adicionar JAVA_HOME e incluir mais um parâmetro no PATH como foi descrito acima.

8. Instalar o plugin do java no browser firefox. Este foi o mais chato… eu não conseguia achar uma dica que funcionasse (eu tb não pesquisei muito). Os caminhos apontados pelos tutoriais que achei não resolviam o problema. Eu sabia que tinha que criar um link simbólico para a biblioteca, mas nada dava certo…  O segredo é criar o link simbólico no lugar certo. Veja:

cd /usr/lib/firefox-addons/plugins

ln -sf /opt/jdk/jre/plugin/i386/ns7/libjavaplugin_oji.so

Abra o firefox e veja se o plugin foi instalado corretamente. Digite no endereço:

about:plugins

Deve aparecer uma página com os plugins instalados. Procure pelo do java conforme a figura abaixo:

plugin-java-instalado-firefox

9. Reinicie o computador, entre no console e digite:

java -version

e depois:

javac -version

Deve aparecer algo assim:

java version “1.6.0_12″
Java(TM) SE Runtime Environment (build 1.6.0_12-b04)
Java HotSpot(TM) Server VM (build 11.2-b01, mixed mode)

javac 1.6.0_12

Pronto, você acabou de instalar a versão mais recente do JDK no seu sistema.

Abs!

Publicado em Eletrônica ]]> http://ericogr.wordpress.com/2009/01/15/controle-remoto-caseiro-4-canais/feed/ 4 EricoGR http://ericogr.wordpress.com/2008/04/28/usando-callback-listeners-jpa/ http://ericogr.wordpress.com/2008/04/28/usando-callback-listeners-jpa/#comments Mon, 28 Apr 2008 12:29:03 +0000 ericogr http://ericogr.wordpress.com/?p=14 ]]> Podemos definir “callback listeners” como classes cujos métodos, devidamente anotados, são chamados em resposta a eventos ocorridos dentro do ciclo de vida de eventos de uma entidade. Exemplo: temos uma entidade Nota e queremos criar um log para todas as operações em que ela é adicionada, atualizada ou removida. Também podemos comparar com “triggers” em banco de dados.

As seguintes operações são suportadas:

• Pré-persistência (@PrePersist)
• Pré-atualização (@PreUpdate)
• Pré-remoção (@PreRemove)
• Pós-persistencia (@PostPersist)
• Pós-atualização (@PostUpdate)
• Pós-remoção (@PostRemove)
• Pós-carregamento (@PostLoad)

A entidade que queremos monitorar deve conter a anotação @EntityListener. Veja exemplos da anotação:

• @EntityListeners(ClasseListener.class)
• @EntityListeners({ClasseListener1.class, ClasseListener1.class})

No exemplo que segue, temos uma entidade chamada Nota que terá seus eventos monitorados pela classe NotaEventListener.

Configurações da unidade de persistência em /META-INF

[persistence.xml]

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence version=”1.0″
xmlns=”http://java.sun.com/xml/ns/persistence”>
<persistence-unit name=”testeJpaPU” transaction-type=”RESOURCE_LOCAL”>
<provider>
oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider
</provider>

<!– entidades –>
<class>com.wordpress.ericogr.entities.Nota</class>
<class>com.wordpress.ericogr.entities.ItemNota</class>

<!– toplink/hsqldb –>
<properties>
<property name=”toplink.jdbc.url” value=”jdbc:hsqldb:hsql://localhost/testeJpa” />
<property name=”toplink.jdbc.user” value=”teste” />
<property name=”toplink.jdbc.driver” value=”org.hsqldb.jdbcDriver” />
<property name=”toplink.jdbc.password” value=”123456″ />
<property name=”toplink.target-database” value=”oracle.toplink.essentials.platform.database.HSQLPlatform”/>
<property name=”toplink.ddl-generation” value=”drop-and-create-tables” />
<!– <property name=”toplink.ddl-generation” value=”create-tables” /> –>
<property name=”toplink.logging.level” value=”FINEST” />
</properties>

</persistence-unit>
</persistence>

Esta entidade tem a anotação @EntityListeners onde especificamos quais classes irão monitorar os eventos ocorridos.

[Nota.java]

package com.wordpress.ericogr.entities;

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

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name = “nota”)
@EntityListeners(NotaEventListener.class)
public class Nota implements Serializable {
private static final long serialVersionUID = 1L;

private int id;
private int numero;
private int tipo;
private Date data;
private String descricao;
private Collection<ItemNota> itensNota = new ArrayList<ItemNota>();

public Nota() {
}

public Nota(int id) {
setId(id);
}

@Id
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getDescricao() {
return descricao;
}

public void setDescricao(String descricao) {
this.descricao = descricao;
}

@OneToMany(cascade = CascadeType.ALL)
public Collection<ItemNota> getItensNota() {
return itensNota;
}

public void setItensNota(Collection<ItemNota> itensNota) {
this.itensNota = itensNota;
}

public int getNumero() {
return numero;
}

public void setNumero(int numero) {
this.numero = numero;
}

public int getTipo() {
return tipo;
}

public void setTipo(int tipo) {
this.tipo = tipo;
}

@Temporal(TemporalType.DATE)
public Date getData() {
return data;
}

public void setData(Date data) {
this.data = data;
}

public static long getSerialVersionUID() {
return serialVersionUID;
}
}

Entidade que representa os itens da nota fiscal.

[ItemNota.java]

package com.wordpress.ericogr.entities;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = “item_nota”)
public class ItemNota implements Serializable {
private int id;
private int quantidade;
private Nota nota;

public ItemNota() {
}

public ItemNota(int id, int quantidade) {
setId(id);
setQuantidade(quantidade);
}

@Id
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(name = “quantidade”)
public int getQuantidade() {
return quantidade;
}

public void setQuantidade(int quantidade) {
this.quantidade = quantidade;
}

@ManyToOne
public Nota getNota() {
return nota;
}

public void setNota(Nota nota) {
this.nota = nota;
}
}

Agora a classe que “ouve” os eventos ocorridos na entidade Nota. Para podermos observar o que acontece, coloquei todos os listeners disponíveis nesta classe.

package com.wordpress.ericogr.entities;

import javax.persistence.PostLoad;
import javax.persistence.PostPersist;
import javax.persistence.PostRemove;
import javax.persistence.PostUpdate;
import javax.persistence.PrePersist;
import javax.persistence.PreRemove;
import javax.persistence.PreUpdate;

public class NotaEventListener {

@PrePersist
public void prePersistNotaEvent(Nota nota) {
System.out.println(“PrePersist: ” + nota.getDescricao());
}

@PostPersist
public void postPersistEvent(Nota nota) {
System.out.println(“PostPersist: ” + nota.getDescricao());
}

@PreUpdate
public void preUpdateNotaEvent(Nota nota) {
System.out.println(“PreUpdate: ” + nota.getDescricao());
}

@PostUpdate
public void postUpdateNotaEvent(Nota nota) {
System.out.println(“PostUpdate: ” + nota.getDescricao());
}

@PreRemove
public void preRemoveNotaEvent(Nota nota) {
System.out.println(“PreRemove: ” + nota.getDescricao());
}

@PostRemove
public void postRemoveNotaEvent(Nota nota) {
System.out.println(“PostRemove: ” + nota.getDescricao());
}

@PostLoad
public void postLoadNotaEvent(Nota nota) {
System.out.println(“PostLoad: ” + nota.getDescricao());
}
}

A classe Main é o ponto de entrada para o programa. Ela testa a inserção, remoção, atualização e carga de registros que serão monitorados pelo “listener”.

package com.wordpress.ericogr;

import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import com.wordpress.ericogr.entities.ItemNota;
import com.wordpress.ericogr.entities.Nota;

public class Main {

public static void main(String[] args) {
new Main();
}

@SuppressWarnings(“unchecked”)
public Main() {
EntityManagerFactory emf;
EntityManager em;

Nota nota1;
ItemNota itemNota1, itemNota2;

Query q;

emf = Persistence.createEntityManagerFactory(“testeJpaPU”);
em = emf.createEntityManager();

itemNota1 = new ItemNota(1, 120);
itemNota2 = new ItemNota(2, 151);

//nota
nota1 = new Nota(1);
nota1.setData(new Date());
nota1.setNumero(112412);
nota1.setTipo(512);
nota1.setDescricao(“teste de nota”);
nota1.getItensNota().add(itemNota1);
nota1.getItensNota().add(itemNota2);

//@PrePersist/@PostPersist
em.getTransaction().begin();
em.persist(nota1);
em.getTransaction().commit();

//@PreUpdate/PostUpdate
nota1.setDescricao(“descrição da nota fiscal”);
em.getTransaction().begin();
em.persist(nota1);
em.getTransaction().commit();

//para remover a entidade do contexto, fazendo com que
//o evento @PostLoad seja disparado.
em.clear();

//@PostLoad
q = em.createQuery(“select n from Nota n where n.numero = 112412″);
List<Nota> ns = (List<Nota>)q.getResultList();

System.out.println(“Nota ” + ns.get(0).getDescricao());

em.close();
}
}

Executando o exemplo, a saída conterá as seguintes linhas:

PrePersist: teste de nota
PostPersist: teste de nota
PreUpdate: descrição da nota fiscal
PostUpdate: descrição da nota fiscal
PostLoad: descrição da nota fiscal

O restante das linhas eu ocultei para facilitar a visualização dos eventos. Como podemos ver, é bem fácil e intuitivo usar listeners.

Os seguintes relacionamentos podem ser mapeados com JPA:

• OneToOne
• OneToMany
• ManyToOne
• ManyToMany

Também podemos usar genéricos para especificar os tipos de coleções persistidas. Elas podem ser:

• java.util.Collection
• java.util.Set
• java.util.List
• java.util.Map

Vamos ver um exemplo usando as classes Nota, ItemNota, Produto e Fornecedor. O objeto nota tem um ou mais objetos itemNota. O objeto itemNota tem uma instancia da classe Produto e cada instancia de produto tem uma ou mais instancias da classe Fornecedor. A entidade itemNota tem referencia para a classe Nota.

Este exemplo está configurado para apagar e criar as tabelas do banco de dados a cada nova execução, ou seja, cada vez que este exemplo for executado, as informações anteriores serão perdidas. Veja a configuração do arquivo persistence.xml

[persistence.xml]

</persistence>

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence version=”1.0″
xmlns=”http://java.sun.com/xml/ns/persistence”>
<persistence-unit name=”testeJpaPU” transaction-type=”RESOURCE_LOCAL”>
<provider>
oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider
</provider>

<!– entidades –>
<class>com.wordpress.ericogr.entities.Nota</class>
<class>com.wordpress.ericogr.entities.ItemNota</class>
<class>com.wordpress.ericogr.entities.Produto</class>
<class>com.wordpress.ericogr.entities.Fornecedor</class>

<!– toplink/hsqldb –>
<properties>
<property name=”toplink.jdbc.url” value=”jdbc:hsqldb:hsql://localhost/testeJpa” />
<property name=”toplink.jdbc.user” value=”teste” />
<property name=”toplink.jdbc.driver” value=”org.hsqldb.jdbcDriver” />
<property name=”toplink.jdbc.password” value=”123456″ />
<property name=”toplink.target-database” value=”oracle.toplink.essentials.platform.database.HSQLPlatform”/>
<property name=”toplink.ddl-generation” value=”drop-and-create-tables” />
<property name=”toplink.logging.level” value=”FINEST” />
</properties>

</persistence-unit>

Em alguns relacionamentos, usamos como parâmetro das anotações o código (cascade = CascadeType.ALL). Isto serve para que as alterações realizadas no objeto que a contém sejam propagadas para os dependentes. Para persistir a coleção de itens da nota, precisamos desta anotação, pois do contrário os itens não seriam persistidos (na prática seria disparada uma exceção).

A entidade Nota tem um relacionamento bidirecional com a entidade ItemNota, onde uma nota pode conter um ou mais itens e um item contém uma única nota.

Abaixo está a classe Nota que representa a nota fiscal. Ela tem uma descrição, uma coleção de itens de nota fiscal e uma chave composta, representada pela classe NotaPk. Note que a propriedade getItensNota() foi anotada com @OneToMany(cascade = CascadeType.ALL, mappedBy = “nota”) onde mappedBy indica o nome da propriedade (no caso getNota()) da entidade dona do relacionamento (ItemNota). Aqui poderíamos omitir, pois o nome da entidade Nota é identico ao nome da propriedade na classe ItemNota, porém, para deixar mais claro, decidi colocar.

[Nota.java]

package com.wordpress.ericogr.entities;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = “nota”)
public class Nota implements Serializable {
private String descricao;
private NotaPk notaPk;
private Collection<ItemNota> itensNota = new ArrayList<ItemNota>();

public Nota() {
}

public Nota(NotaPk notaPk) {
setNotaPk(notaPk);
}

@EmbeddedId
public NotaPk getNotaPk() {
return notaPk;
}

public void setNotaPk(NotaPk notaPk) {
this.notaPk = notaPk;
}

@Column(name = “descricao”, nullable = true)
public String getDescricao() {
return descricao;
}

public void setDescricao(String descricao) {
this.descricao = descricao;
}

@OneToMany(cascade = CascadeType.ALL, mappedBy = “nota”)
public Collection<ItemNota> getItensNota() {
return itensNota;
}

public void setItensNota(Collection<ItemNota> itensNota) {
this.itensNota = itensNota;
}
}

Em seguida, tempos a classe NotaPk que representa uma chave composta para a entidade Nota. Precisamos desta classe extra, pois para identificar a entidade nota, temos 3 campos diferentes (número, tipo e data) diferente da classe Produto que tem somente um campo (id).

[NotaPk.java]

package com.wordpress.ericogr.entities;

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

import javax.persistence.Column;
import javax.persistence.Embeddable;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Embeddable
public class NotaPk implements Serializable {
private static final long serialVersionUID = -6450890424150718733L;

private int numero1;
private int tipo;
private Date data;

public NotaPk() {
}

public NotaPk(int numero, int tipo, Date data) {
setNumero(numero);
setTipo(tipo);
setData(data);
}

@Column(name = “numero”)
public int getNumero() {
return numero1;
}

public void setNumero(int numero) {
this.numero1 = numero;
}

@Column(name = “tipo”)
public int getTipo() {
return tipo;
}

public void setTipo(int tipo) {
this.tipo = tipo;
}

@Temporal(value = TemporalType.DATE)
@Column(name = “data”)
public Date getData() {
return data;
}

public void setData(Date data) {
this.data = data;
}

@Override
public boolean equals(Object obj) {
if (obj == null || !(obj instanceof NotaPk)) {
return false;
}

NotaPk pk = (NotaPk)obj;

return (pk.getData().equals(this.getData()) &&
pk.getNumero() == this.getNumero() &&
pk.getTipo() == this.getTipo());
}

@Override
public int hashCode() {
int ret = 0;

ret =
getNumero() ^
getTipo() ^
(getData() != null ? getData().hashCode() : 0);

return ret;
}
}

Agora os itens da nota fiscal. Os itens são compostos por um id que o identifica unicamente, quantidade, produto e nota fiscal a que pertence.

[ItemNota.java]

package com.wordpress.ericogr.entities;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name = “item_nota”)
public class ItemNota implements Serializable {
private int id;
private int quantidade;
private Produto produto;
private Nota nota;

public ItemNota() {
}

public ItemNota(int id, int quantidade, Produto produto) {
setId(id);
setQuantidade(quantidade);
setProduto(produto);
}

@Id
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(name = “quantidade”)
public int getQuantidade() {
return quantidade;
}

public void setQuantidade(int quantidade) {
this.quantidade = quantidade;
}

@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
public Produto getProduto() {
return produto;
}

public void setProduto(Produto produto) {
this.produto = produto;
}

@ManyToOne
public Nota getNota() {
return nota;
}

public void setNota(Nota nota) {
this.nota = nota;
}
}

Produtos da nota fiscal: possui um id que o identifica, nome, peso, imagem (onde podemos gravar a figura do produto) e uma lista de fornecedores.

[Produto.java]

package com.wordpress.ericogr.entities;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = “produto”)
public class Produto implements Serializable {
private int id;
private String nome;
private float peso;
private byte[] imagem;
private List<Fornecedor> fornecedores = new ArrayList<Fornecedor>();

public Produto() {
}

public Produto(int id, String nome, float peso) {
setId(id);
setNome(nome);
setPeso(peso);
}

@Id
@Column(name = “id”)
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

@Column(name = “nome”)
public String getNome() {
return nome;
}

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

@Column(name = “peso”)
public float getPeso() {
return peso;
}

public void setPeso(float peso) {
this.peso = peso;
}

@Column(name = “imagem”)
public byte[] getImagem() {
return imagem;
}

public void setImagem(byte[] imagem) {
this.imagem = imagem;
}

@ManyToMany(cascade = CascadeType.ALL)
public List<Fornecedor> getFornecedores() {
return fornecedores;
}

public void setFornecedores(List<Fornecedor> fornecedores) {
this.fornecedores = fornecedores;
}
}

O Cadastro de fornecedores é composto por um identificador (id), nome, endereço e produtos que fornece.

[Fornecedor.java]

package com.wordpress.ericogr.entities;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name = “fornecedor”)
public class Fornecedor implements Serializable {
private int id;
private String nome;
private String endereco;
private List<Produto> produtos = new ArrayList<Produto>();

public Fornecedor() {
}

public Fornecedor(int id, String nome, String endereco) {
setId(id);
setNome(nome);
setEndereco(endereco);
}

@Id
public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNome() {
return nome;
}

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

public String getEndereco() {
return endereco;
}

public void setEndereco(String endereco) {
this.endereco = endereco;
}

@ManyToMany(cascade = CascadeType.ALL)
public List<Produto> getProdutos() {
return produtos;
}

public void setProdutos(List<Produto> produtos) {
this.produtos = produtos;
}
}

Finalmente a classe principal para testarmos o funcionamento das entidades que mapeamos. Criamos uma nota com itens, produtos e fornecedores e em seguida efetuamos uma consulta.

[Main.java]

package com.wordpress.ericogr;

import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import com.wordpress.ericogr.entities.Fornecedor;
import com.wordpress.ericogr.entities.ItemNota;
import com.wordpress.ericogr.entities.Nota;
import com.wordpress.ericogr.entities.NotaPk;
import com.wordpress.ericogr.entities.Produto;

public class Main {

public static void main(String[] args) {
new Main();
}

@SuppressWarnings(“unchecked”)
public Main() {
EntityManagerFactory emf;
EntityManager em;

Nota nota1;
NotaPk notaPk1;
ItemNota itemNota1, itemNota2;
Produto produto1, produto2;
Fornecedor fornecedor1, fornecedor2;

Query q;

emf = Persistence.createEntityManagerFactory(“testeJpaPU”);
em = emf.createEntityManager();

//produto
produto1 = new Produto(1, “Cimento”, 5000);
produto2 = new Produto(2, “Piso 12×10″, 475.3f);

//fornecedor
fornecedor1 = new Fornecedor(1, “JaxPCimentos”, “Rua Galeteri Blota, 123″);
fornecedor2 = new Fornecedor(2, “Kermit Ltda”, “Av Blogus, 987″);

//fornecedor x produto
fornecedor1.getProdutos().add(produto1);
fornecedor2.getProdutos().add(produto1);
fornecedor2.getProdutos().add(produto2);

//produto x fornecedor
produto1.getFornecedores().add(fornecedor1);
produto2.getFornecedores().add(fornecedor1);
produto2.getFornecedores().add(fornecedor2);

//notaPk
notaPk1 = new NotaPk(1, 2, new Date());

//item Nota
itemNota1 = new ItemNota(1, 120, produto1);
itemNota2 = new ItemNota(2, 151, produto2);

//nota
nota1 = new Nota(notaPk1);
nota1.setDescricao(“teste de nota”);
nota1.getItensNota().add(itemNota1);
nota1.getItensNota().add(itemNota2);

//item nota x nota
itemNota1.setNota(nota1);
itemNota2.setNota(nota1);

em.getTransaction().begin();
em.persist(nota1);
em.getTransaction().commit();

q = em.createQuery(“select n from Nota n where n.notaPk.numero = 1″);
List<Nota> ns = (List<Nota>)q.getResultList();

for (Nota n1 : ns) {
System.out.println(“[Nota]“);
System.out.println(“Nota nr: ” + n1.getNotaPk().getNumero() + “\n” +
“Nota tp: ” + n1.getNotaPk().getTipo() + “\n” +
“Nota dt: ” + n1.getNotaPk().getData() + “\n” +
“Nota ds: ” + n1.getDescricao() + “\n”);
for (ItemNota in : n1.getItensNota()) {
System.out.println(“[Itens]“);
System.out.println(“Item…: ” + in.getId() + “\n” +
“Prod…: ” + in.getProduto().getNome() + “\n” +
“Quant..: ” + in.getQuantidade() + “\n” +
“Ref Not: ” + in.getNota().getNotaPk().getNumero() + “\n”);
for (Fornecedor f : in.getProduto().getFornecedores()) {
System.out.println(“[Fornecedores]“);
System.out.println(“Fornecedor: ” + f.getId() + “\n” +
“Nome…..: ” + f.getNome() + “\n” );
}
}
}

em.close();
}
}

Com este exemplo podemos observar como é fácil mapear os objetos para serem persistidos no banco de dados. Observamos o funcionamento das anotações @OneToOne, @OneToMany, @ManyToOne e @ManyToMany através de um exemplo simples que pode ser incrementado para um caso real.

Com JPA, mapeamos tabelas e relacionamento de banco de dados através de classes chamadas entidades. Toda entidade deve ter uma chave primaria. Esta chave pode ter um ou mais campos que servem para identifica-la. Para chaves de um único campo, podemos especifica-la na própria entidade com a anotação @Id, mas em casos de mais de um, precisamos de classe que a represente, ou seja, para representar uma chave primária composta de mais de um campo, precisamos de uma classe extra. Os tipos aceitos para campos de chaves são os seguintes:

• java.lang.String
• java.util.Date
• java.sql.Date
• qualquer wrapper de tipo primitivo (int -> Integer, long -> Long, etc…) menos (não inteiros como float e double)

A classe que representará nossa primary key deve ser:

• pública
• conter um construtor sem argumentos
• as propriedades (se você as mapeou com get/set) devem ter acesso público ou protegido
• implementar Serializable
• sobrescrever equals e hashcode adequadamente
• deve ser anotada como @Embeddable
• a classe que contiver a classe que representa a primary key deve ser anotada com @EmbaddableClass ou @EmbaddableId

Vamos trabalhar sobre um exemplo. Abaixo criei os passos para inserir e consultar dados com uma única entidade chamada Nota. Tentei simplificar ao máximo para podermos entender como tudo funciona. Esta consulta é feita utilizando um campo dentre três da chave primária. Utilizei este critério pois não é tão comum encontrar como fazer isso (queries com campos de chave primária composta), mas é bem simples. As tabelas no banco de dados são geradas automaticamente, graças ao parâmetro [toplink.ddl-generation= create-tables] em nosso persistence.xml.

1. Criar o arquivo de configuração persistence.xml

Para este exemplo, usamos o banco hsqldb. O arquivo abaixo armazena configurações para suas unidades de persistência. Você poderá adaptá-lo para seu banco de dados.

[persistence.xml]

<?xml version=”1.0″ encoding=”UTF-8″?>
<persistence version=”1.0″
xmlns=”http://java.sun.com/xml/ns/persistence”>
<persistence-unit name=”testeJpaPU” transaction-type=”RESOURCE_LOCAL”>
<provider>
oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider
</provider>

<!– entidades –>
<class>com.wordpress.entities.Nota</class>

<!– toplink/hsqldb –>
<properties>
<property name=”toplink.jdbc.url” value=”jdbc:hsqldb:hsql://localhost/testeJpa” />
<property name=”toplink.jdbc.user” value=”teste” />
<property name=”toplink.jdbc.driver” value=”org.hsqldb.jdbcDriver” />
<property name=”toplink.jdbc.password” value=”123456″ />
<property name=”toplink.target-database” value=”oracle.toplink.essentials.platform.database.HSQLPlatform”/>
<property name=”toplink.ddl-generation” value=”create-tables” />
<property name=”toplink.logging.level” value=”FINE” />
</properties>

</persistence-unit>
</persistence>

Vamos criar um pacote chamado com.wordpress.entities e também a classe entidade Nota:

[Nota.java]

package com.wordpress.entities;

import javax.persistence.EmbeddedId;
import javax.persistence.Entity;

@Entity
public class Nota {

private String descricao;
private NotaPk notaPk;

public Nota() {
}

@EmbeddedId
public NotaPk getNotaPk() {
return notaPk;
}

public void setNotaPk(NotaPk notaPk) {
this.notaPk = notaPk;
}

public String getDescricao() {
return descricao;
}

public void setDescricao(String descricao) {
this.descricao = descricao;
}

}

Agora a classe que representa a chave no banco de dados. Note que precisamos sobrescrever adequadamente os métodos equals e hashcode.

[NotaPk.java]

package com.wordpress.entities;

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

import javax.persistence.Embeddable;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Embeddable
public class NotaPk implements Serializable {
private static final long serialVersionUID = 433046042456099827L;

private int numero1;
private int tipo;
private Date data;

public NotaPk() {
}

public NotaPk(int numero, int tipo, Date data) {
setNumero(numero);
setTipo(tipo);
setData(data);
}

public int getNumero() {
return numero1;
}

public void setNumero(int numero) {
this.numero1 = numero;
}

public int getTipo() {
return tipo;
}

public void setTipo(int tipo) {
this.tipo = tipo;
}

@Temporal(value = TemporalType.DATE)
public Date getData() {
return data;
}

public void setData(Date data) {
this.data = data;
}

@Override
public boolean equals(Object obj) {
if (obj == null || !(obj instanceof NotaPk)) {
return false;
}

NotaPk pk = (NotaPk)obj;

return (pk.getData().equals(this.getData()) &&
pk.getNumero() == this.getNumero() &&
pk.getTipo() == this.getTipo());
}

@Override
public int hashCode() {
int ret = 0;

ret =
getNumero() ^
getTipo() ^
(getData() != null ? getData().hashCode() : 0);

return ret;
}
}

Abaixo a classe principal que irá comprovar o funcionamento. Foi criada também uma query personalizada onde a busca é feita pelo campo número de nota. Veja como é feito o acesso aos campos chaves da entidade Nota.

[Main.java]

import java.util.Date;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import com.wordpress.entities.Nota;
import com.wordpress.entities.NotaPk;

public class Main {

public static void main(String[] args) {

new Main();
}

@SuppressWarnings(“unchecked”)
public Main() {
EntityManagerFactory emf = Persistence.createEntityManagerFactory(“testeJpaPU”);
EntityManager em = emf.createEntityManager();

Nota n = new Nota();
n.setNotaPk(new NotaPk(1, 2, new Date()));
n.setDescricao(“teste de nota”);

em.getTransaction().begin();

if (em.find(Nota.class, n.getNotaPk()) == null) {
em.persist(n);
}

Query q = em.createQuery(“select n from Nota n where n.notaPk.numero = 1“);
List<Nota> ns = (List<Nota>)q.getResultList();

for (Nota n1 : ns) {
System.out.println(“nota ” + n1.getNotaPk().getNumero());
}

em.getTransaction().commit();
em.close();
}

}

Todos os métodos das classes entidade e embeddable, que estiverem no padrão javabeans, serão associados aos campos do banco de dados. Somente os campos anotados com @Transient não serão persistidos.

Aqui utilizei Toplink e Hsqldb, mas podemos usar qualquer outro provedor e banco de dados. Basta especificar corretamente o arquivo persistence.xml

Bibliotecas utilizadas:

• toplink-essentials.jar
• toplink-essentials-agent.jar
• hsqldb.jar

Estrutura de diretórios:

.
| hsqldb.jar
| toplink-essentials-agent.jar
| toplink-essentials.jar
|
\—src
| Main.java
|
+—com
| \—wordpress
| \—entities
| Nota.java
| NotaPk.java
|
\—META-INF
persistence.xml

Versão PDF: Criação de componentes JSF Facelets

Como exemplo, vamos criar um componente chamado FirstJsfTest que renderiza um simples label .
Exemplo:

<label>Teste 123</label>

Premissas

1. · JDK 1.5 ou superior
2. · Biblioteca JSF 1.2 (aqui utilizamos JSF1.2_04)
3. · Seu projeto já deve estar configurado para utilizar a combinação de JSF + Facelets

Criação do componente

1. · Criar uma classe que estenda UIComponent
2. · Programar métodos para salvar e restaurar o estado do componente
3. · Criar método que retorne a família do componente
4. · Criar uma classe que estenda UIComponentELTag
5. · Configurar as propriedades que o componente JSF utilizará
6. · Programar métodos para retornar o tipo de componente e renderizador utilizado
7. · Programar um renderizador
8. · Criar um arquivo .tld (Descritor de biblioteca de tags)
9. · Registre o componente no faces-config.xml
10. · Criar um arquivo de configuração de biblioteca facelets e registrá-lo
11. · Usando o componente
12. · Relacionamento entre código java e os descritivos XML
13. · Referências

1. Crie uma classe que estenda UIComponent

Para começar, vamos criar a classe UIFirstJsfComponent que estende a classe UIOutput (que é subclasse de UIComponent) e criaremos também os atributos do componente.

2. Programar métodos para salvar e restaurar o estado do componente

Abaixo está o trecho de código que fica responsável por salvar e restaurar o estado do componente. Salvamos e restauramos os atributo do nosso componente através dos métodos saveState e restoreState da classe UIOutput.

3. Retornar a família do componente

Precisamos do método getFamily() para retornar a família do componente. O retorno deste método será usado posteriormente para registrar o renderizador no arquivo de configuração do Jsf. Podemos retornar COMPONENT_FAMILY que é uma constante com o valor javax.faces.Output.

4. Criar uma classe que estenda UIComponentELTag

Nos passos anteriores, o componente foi criado. Agora precisamos definir a tag (marcação que ficará na página que estamos criando) que fará uma ponte entre o Jsp e o Jsf. No trecho de código abaixo, está também a propriedade name que será utilizada em nossa tag para passar valor ao componente com propriedade de mesmo nome. Depois mapearemos a tag através do arquivo de configuração de extensão .tld (tag library descriptor).

5. Configurar as propriedades que o componente JSF utilizará

Vamos armazenar o valor configurado para a tag no componente que criamos como mostra o código abaixo:

Como podemos ver, component é uma instância da classe UIFirstJsfComponent onde configuramos seus atributos pelos atributos da tag FirstJsfTag.

6. Programar métodos para retornar o tipo de componente e renderizador utilizado

O retorno deste método será utilizado nos arquivos de configuração do Jsf e Facelets.

7. Programar um renderizador

O renderizador escreverá a saída, que no nosso caso será codificação em HTML. Esta classe estende Renderer e provê uma série de métodos interessantes que podem ser explorados pelo programador, mas este não será o foco.

Este renderizador apenas escreve na página um label com o valor definido na propriedade name. A saída é esta: <label>valor qualquer</label>

8. Criar um arquivo .tld

Depois de ter criado o componente, temos que criar seu descritor, o arquivo tld (Tag Library Descriptor) chamado firstJsfTag.tld (para este exemplo). Normalmente este arquivo fica na pasta da sua aplicação web em /WEB-INF/taglib.

Exemplo: /WEB-INF/taglib/firstJsfTag.tld

9. Registre o componente no faces-config.xml

É necessário registrar o componente no arquivo de configuração do Jsf faces-config.xml. Normalmente este arquivo fica na pasta da sua aplicação web em /WEB-INF. Exemplo: /WEB-INF/faces-config.xml

10. Criar um arquivo de configuração de biblioteca facelets e registrá-lo

Agora precisamos configurar o facelets para utilizar o componente Jsf criado. Para criar essa ponte entre os dois, declaramos em um arquivo de configuração o nome do componente, seu tipo e o tipo do renderizador. Normalmente este arquivo fica na pasta da sua aplicação web em /WEB-INF/taglib. Exemplo: /WEB-INF/taglib/firstJsfTag.taglib.xml

Note que os tipos declarados neste arquivo são os mesmos retornados pelos métodos presentes na classe que estende UIComponentELTag (getComponentType() e getRendererType()).

É preciso também registrar este arquivo como uma biblioteca nos parâmetros de contexto do facelets. Caso exista mais de uma biblioteca, podemos separá-las com “;” ponto e virgula. Normalmente este arquivo fica na pasta da sua aplicação web em /WEB-INF. Exemplo: /WEB-INF/web.xml

11. Usando o componente

Agora podemos usar o componente nas páginas xhtml. Abaixo segue o exemplo de uma página usando o componente.

12. Relacionamento entre código Java e os descritivos XML

Abaixo temos uma figura que exibe trechos de código e de arquivos XML e como eles se relacionam para a composição do componente desenvolvido. Podemos acompanhar se esquecemos de criar algum arquivo ou configuração.

Mapa de referência de arquivos de configuração

Note que a maioria dos arquivos não estão completos, deixei somente a parte interessante para visualizarmos o relacionamento entre eles. Por exemplo, o arquivo FirstJsfTag.java não tem a definição de pacotes, as importações, a declaração de classes, etc.

13. Referências

Abaixo estão alguns sites que serviram de referência para montar este documento.

]]> http://ericogr.wordpress.com/2008/04/09/criacao-de-componentes-facelets-receita-do-bolo/feed/ 0 EricoGR Arquivos, configuração xml e código java