A arquitetura projetada pela Sun sugere que usemos EJBs para isolar a parte de acesso a dados, no entanto essa tecnologia não faz parte da ementa da nossa disciplina e portanto não discutimos isso (embora possam ser gerados pelo Netbeans também.) E aí temos um problema, o tutorial anterior pressupõe que o uso do JPA seria gerenciado, mas isso não é possível quando usamos Servlets.

Se quisermos usar JPA com Servlets (que é o que estamos fazendo atualmente) precisamos de algumas pequenas modificações em relação ao tutorial inicial.

A primeira delas é que quando criamos o persistence.xml, devemos desmarcar a opção de usar JTA.

A segunda modificação diz respeito ao JPAController, quando o Netbeans cria a classe com alguns conceitos voltados para a injeção de dependência, mas o que é isso ? É quando o próprio ambiente insere para nós os recursos que são necessários para executar nosso software, isso é uma grande inovação em relação a tudo que precisavamos fazer para conseguir referenciar conexões por exemplo.

Como disse antes, a visão da Sun é que uma aplicação web seja feita para interagir com componentes EJB, mas se não é isso que você quer fazer então temos um problema aqui para gerenciar as dependências. O que pode ser feito é criar um EntityManagerFactory a partir do persistence unit diretamente. Para isso precisamos fazer algumas modificações no código gerado pelo Netbeans.

Como o código já foi gerado no outro tutorial vou apenas mostrar as modificações no código.

O código:

@Resource
private UserTransaction utx = null;
@PersistenceUnit(unitName = “TesteJPAWebPU”)
private EntityManagerFactory emf = null;

Deve ser modificado para:

EntityManagerFactory emf = Persistence.createEntityManagerFactory(“TesteJPAWebPU”);

O código do método create gerado é:

Deve ser substituído pelo seguinte código:

Note os detalhes relacionados a troca da criação da transação para um processo manual.

Com essas duas pequenas modificações já podemos usar o JPA dentro de Servlets para gravar nossos dados com mais facilidades. É claro que os outros métodos como edit e destroy devem ser modificados de forma semelhante.

Vamos começar com o que será necessário. Primeiro de tudo meu ambiente é um linux configurado em inglês por isso as telas aqui estão em inglês, então pode ser que precise adaptar os detalhes das telas para o seu ambiente. Aqui eu uso tanto MySQL quanto PostgreSQL, mas nesse tutorial vou assumir que existe um MySQL instalado com um banco de dados criado de nome “curso” com um usuário “javadb” (e a senha você precisa saber qual configurou aí.) Infelizmente a configuração do MySQL não está no nosso escopo, mas qualquer banco de dados relacional serve (só precisa mudar durante a configuração conforme vou mostrar mais a frente.) Finalmente a última definição é usar o Netbeans 6.7, já temos o 6.8 disponível, mas por questões de projeto ainda não migrei nem testei ele, já a versão 6.7.1 tem alguns problemas com detalhes de web e CVS então sugiro ficar com o 6.7 por enquanto, e pode ser encontrado aqui.

Então agora vamos começar!

Primeiro precisamos entender do que estamos falando, isso costuma ajudar muito no desenvolvimento de qualquer coisa na vida. JPA é a sigla para Java Persistence Api, ou seja, uma especificação de persistência para Java. Isso significa que depois de anos de trabalho tentando mapear sistemas orientados a objetos em bancos de dados relacionais aprendemos quais são os problemas recorrentes e as soluções foram sendo catalogadas. O resultado disso ao longo dos anos foi a construção de ferramentas que ofereciam soluções parcialmente automáticas. Com a chegada do EJB3 a Sun mudou os Entity Beans (entidades do sistema) para marcar seus relacionamentos via anotações, e além disso incorporou os mecanismos das diversas ferramentas de persistência. Como implementação de referência a Oracle disponibilizou gratuitamente o TopLink, na época Oracle ainda não tinha comprado a Sun.

É claro que usar uma ferramenta de persistência pode sacrificar um pouco o desempenho da aplicação, mas tenha em mente o seguinte, nem todas as partes do sistema precisam ser extremamente rápidas. Quando alguma das partes do sistema não estiver satisfatória podemos deixar de lado a ferramenta e prover alguma solução construída manualmente. Mas por experiência própria, são poucas as vezes que isso é necessário em sistemas de informação.

Então para fechar a parte teórica e começarmos a meter a mão na massa. A Sun já tinha proposto anteriormente o JDBC que é a especificação que permite que os fornecedores de bancos de dados disponibilizem os drivers para acessar seus produtos, agora com o JPA temos o papel de provedor de persistência, neste caso temos Hibernate, TopLink, EclipseLink e assim por diante. Entre estes eu não usei ainda o eclipse link.

Agora então temos uma nova camada entre a aplicação e o banco de dados tentando tornar a aplicação cada vez mais independente de tecnologias de infraestrutura. Para o nosso exemplo vamos usar o TopLink que já vem com o Netbeans simplesmente porque o Hibernate requer que a aplicação seja gerenciada por um container, se a ideia fosse uma aplicação web isso seria mais fácil, mas vou usar aqui uma aplicação desktop.

Vamos começar então criando um projeto Java no Netbeans. Escolha Java e Aplicação Java como na figura a seguir.

Agora precisamos dar um nome ao projeto, sugiro TutorialJPA, uma coisa que o Netbeans sempre faz é perguntar se você quer criar uma classe main, pode desabilitar essa opção. E vamos escolher finalizar.

Agora que temos um projeto para trabalhar fica tudo um pouco mais fácil. Para entender melhor o que vamos fazer, a ideia e criar uma aplicação que grave as informações de uma classe Livro no banco de dados. Então precisamos de uma entidade Livro, e vou usar os atributos título, autor, isbn e número de páginas. Para isso vamos criar um pacote java de nome “domain” para guardar todas as entidades do nosso pequeno sistema.

E em seguida indique o nome do pacote, domain.

Certo, agora vamos criar a classe de entidade, para isso temos a opção criar nova classe de entidade que já considera que você vai usar as facilidades de JPA.

Agora precisamos escolher o nome da entidade, Livro.

Note que usamos o tipo Long para o id dos objetos, além disso o Netbeans no diz que não tem uma unidade de persitência configurada, agora começa a mágica do negócio. Antes de criar essa unidade de persistência, vamos entender do que se trata, para que a nossa aplicação tenha tantas indepedências precisamos configurar em algum lugar onde está o banco, e que tipo de banco estamos usando. Isso é feito em um xml que fica embutido no projeto, se você quiser mudar alguma coisa do banco, basta mexer nesse xml sem compilar nada! Aqui escolhemos Toplink, damos um nome para referenciar dentro da aplicação e precisamos escolher também qual a conexão com o banco de dados. Além disso podemos escolher o comportamento do JPA, se deve criar; remover e criar, ou não tomar ações em relação as tabelas, sim! O JPA pode criar as tabelas para nós no banco de ddaos!

Uma facilidade que o Netbeans nos oferece é criar a conexão durante este processo, é claro que se você já tiver conexões de banco de dados (até porque o Netbeans permite conectar no banco e executar comandos SQL) você pode simplesmente escolher. É claro que aqui eu vou mostrar como criar.

E agora configurar a conexão, colocando driver, endereço, nome do banco de dados, login e senha, escolhi também para lembrar a senha.

Terminando esse processo voltamos para a tela de criação da unidade de persistência e clicamos em criar.

O resultado é uma tela que nos permite visualizar de forma amigável o conteúdo do arquivo xml.

Agora vamos retomar nossa classe de Entidade, é claro que se fossemos criar várias classes de entidade, apenas na primeira vez seria necessário. Bom podemos ver que a classe Livro foi criada apenas com o atributo id, e vamos colocar agora 4 novos atributos que estão marcados na figura a seguir.

Pela especificação de java beans (já bem antiga) devemos criar os métodos acessores (get/set) para esses atributos, mas calma! O Netbeans ajuda a gente nisso. Para isso vamos clicar com o botão direito do lado de qualquer um dos atributos e aparecerá um menu no qual vamos escolher Refatorar.

Depois disso aparecerá outro menu no qual vamos escolher Encapsular Campos.

Com isso aparecerá uma nova tela na qual vamos escolher quais campos (atributos) queremos encapsular. Vamos escolher os quatro atributos que acabamos de criar.

Agora temos um detalhe, quando a classe foi criada o Netbeans gerou para a gente automanticamente dois métodos importantes o equals e o hashCode, esses métodos são fundamentais para conseguir comparar corretamente dois objetos, só que como criamos atributos novos precisamos recriar esses métodos, e novamente vamos ter uma ajuda. Podemos remover os métodos gerados.

Agora podemos recriar os métodos clicando novamente com o botão direito na tela, dentro da classe e escolhendo inserir código.

E uma nova janela aparece onde escolhemos equals e hashCode.

Agora, surgirá uma nova tela onde podemos escolher os atributos que serão usados para comparar dois objetos.

Antes de continuar, vamos dar uma pausa para uma outra configuração, precisamos importar para o nosso projeto a biblioteca do MySQL, como esse passo é bem simples é um bom momento para descansar a cabeça Então agora vamos clicar com o botão direito sobre o projeto e vamos escolher propriedades.

Isso nos abre uma outra tela na qual vamos escolher a opção bibliotecas. E agora vamos escolher adicionar bibliotecas.

Com isso vai aparecer a opção para escolhermos quais as bibliotecas queremos adicionar, neste caso a do MySQL.

Fim dos comerciais, agora podemos voltar ao nosso projeto. Vamos agora criar um pacote java chamado app onde ficará nossa classe de “aplicação” que vai representar o que seria uma interface gráfica por exemplo. Isso já está explicado aí em cima né ? Então vamos seguir para criar uma classe Java tradicional.

E basta agora dar o nome de Aplicacao e colocar a classe no pacote app. Vamos deixar essa classe em banho-maria por enquanto. Vamos seguir agora para uma outra parte mágica do JPA, o Netbeans permite criar um tipo de classe chamado JPAController, aplicando o padrão de projetos Controller, ele permite fazer a ponte entre a classe de entidade e o banco de dados efetivamente. Quando criada, está classe já vem com as operações básicas, e que muitas vezes são suficientes para alguns cadastros. Algumas vezes o tipo de recurso que queremos criar não está disponível no menu, basta ir até “outros”.

E em seguida escolher em persistência, JPAController.

Agora uma nova tela surgirá para que escolhamos para qual Entidade vamos criar o JPAController, sim, para cada entidade teremos um controller diferente.

Em nosso projeto só existe uma entidade, e portanto fica fácil de escolher, basta clicar na classe domain.Livro e clicar em adicionar, depois vamos para a próxima tela onde vamos escolher em que pacote as classes vão ser criadas.

Neste momento estamos com toda a infraestrutura do nosso projeto criada e podemos retomar a nossa classe de aplicação que vai utilizar todos esses mecanismos. Para conferir a estrutura e as classes criadas segue a próxima figura.

Agora retomando nossa classe de aplicação, o que queremos fazer com um banco de dados ? Persistir os dados de nossa aplicação! Então precisamos criar objetos, preencher os valores, criar uma instância de JPAController e chamar os métodos para realizar as ações desejadas. Nesta figura temos todos os usos das chamadas, criar, buscar, editar e remover. Esse código precisa ser colocado no método main da nossa classe Aplicacao.

É isso, é claro que até aqui só temos o suficiente para criar um pequeno projeto, mas podemos ampliar os estudos com alguns livros importantes, mais para frente vou colocar aqui umas resenhas de livros importantes para esse tópico.

O truque é puramente matemático e precisamos entender uma propriedade dos números inteiros (tenhamos em mente que os índices de arrays são normalmente números inteiros…) relacionada ao resto da divisão. Quando dividimos um número inteiro por outro, pode acontecer de sobrar um resto, de forma que o resultado mais esse resto é igual ao número dividido, assim temos:

a/ b = q + r

onde “q” é o resultado de a/b e “r” o resto da divisão.

e para achar o número dividio original basta operar: b * q + r

por exemplo: 4/3 = 1 com resto 1 e (1 * 3 ) + 1 = 4

Quem estiver muito interessado nisso pode procurar mais material referente as Classes de Números Inteiros (na matemática, não é nenhuma classe Java não!)

Bom, mas porque essa matemática toda? Porque essa propriedade é fundamental para convertermos um número em dois! Isso mesmo, como o array é indexado por um único número temos que conseguir uma relação que nos permita transformar esse número em um par de números para indexar uma matriz (que na verdade não existe, está sendo representada no array.)

Vamos pensar em uma matriz 3×3 seu array correspondente deve ter tamanho 9 (= 3 * 3) para conseguir comportar todos os elementos da matriz. Dessa maneira nossos índices (considerando as linguagens C, Java, C++, C# e outras que começam a contar em 0) são: 0, 1, 2, 3, 4, 5, 6, 7, 8, porém os índices da matriz são (0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2). Pelo menos temos a mesma quantidade de índices e pares de índices, já é uma dica do que esta acontecendo aqui

Vamos começar a analisar primeiro do ponto de vista de entrada, o usuário quer acessar um elemento em sua “matriz” e para isso vai informar dois valores digamos “i” e “j” que serão (1,1) respectivamente. Basta aqui multiplicar “i” pela ordem da matriz (3 nesse caso) e somar o valor de “j” e assim (1 * 3) + 1 = 4. Nossa primeira fórmula:

(i,j) = (i * N) + j (onde N é a ordem da matriz)

Essa foi fácil! Mas ainda não falamos sobre o porque de ter entrado aquela explicação toda sobre resto de divisão… Isso é porque para fazer a operação inversa teremos que converter um único número em dois!

Imaginemos então que o próximo passo seja imprimir a matriz na tela ou em um arquivo em disco, então vamos percorrer nosso array com um único for já que só temos uma dimensão, no entanto para imprimir precisaremos colocar os valores que o usuário conhece que são os pares (i,j), mas como?

Bom, lembrando das propriedades que falamos temos o seguinte, consideremos a posição 4 que já sabemos que equivale ao par (1,1), se dividirmos 4 pela ordem da matriz, 3 neste caso, teremos 1, agora isso é o “i” ou o ” j” ? Vamos explorar outros casos, se pegarmos o 5 por exemplo e dividirmos por 3 também teremos 1 como resultado, se o 4 e o 5 estão na mesma linha então a divisão inteira de números nos dá o componente “i”! Como vamos conseguir então com uma mesma operação e 3 valores distintos conseguir resultados que acessem as colunas? Sim, porque o valor de “j” deve ser crescente para os índices 3, 4 e 5 do array, porém é sempre o mesmo em cada uma das linhas. A resposta está na operação de módulo ou resto da divisão.  Vamos considerar esses valores abaixo:

3 % 3 = 0

4 % 3 = 1

5 % 3 = 2

Então esta é nossa segunda fórmula mágica, o resto da divisão do array pela ordem da matriz nos da o componente “j” do par.

Resumindo temos o seguinte:

dados (i,j) devemos guardar o valor na posição array[(i*N)+j]

dado o valor (idx) o seu valor corresponde ao elemento (i,j) tal que i = idx / N e j = idx % N

Como exemplo de correspondências temos:

array[0] = matriz[0][0]
array[1] = matriz[0][1]
array[2] = matriz[0][2]
array[3] = matriz[1][0]
array[4] = matriz[1][1]
array[5] = matriz[1][2]
array[6] = matriz[2][0]
array[7] = matriz[2][1]
array[8] = matriz[2][2]

A mágica das Classes de Números Inteiros está (muito resumidamente) no fato de que os números apresentam certas propriedades que os relacionam, assim podemos pensar em formato de tabela da seguinte forma (agora para um exemplo maior):

0     1   2   3    4

5     6   7   8    9

10 11 12 13 14

15 16 17 18 19

20 21 22 23 24

Com essa tabela podemos ver que se uma matriz tem ordem 5×5 então ela tem 25 elementos, além disso, podemos perceber que todos os múltiplos de 5 estão na coluna 0, todos os que tem resto de divisão 1 estão na coluna 1, e assim sucessivamente até a coluna 4 onde o próximo número será múltiplo de 5 e por isso voltará para a coluna 0 (mas com o índice de linha incrementado.)

A seguir um código Java para ilustrar o uso dessas fórmulas:

public class ArrayMatriz {
    public static void main(String[] args) {
        int N = 3;
        float matriz[][] = new float[N][N];
        float array[] = new float[(N*N)];

        for (int i = 0; i < array.length; i++) {
            array[i] = i;
            System.out.println("array["+i+"]="+array[i]);
        }
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                matriz[i][j] = (i * N) + j;
                System.out.print("matriz["+i+"]["+j+"]="+
                         (matriz[i][j])+"   ");
            }
            System.out.println("");
        }

        for (int i = 0; i < array.length; i++) {
            array[i] = i;
            int mi = i / N;
            int mj = i % N;
            System.out.println("array["+i+"]="+array[i]+
                     " matriz["+mi+"]["+mj+"]="+matriz[mi][mj]);
        }
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                matriz[i][j] = (i * N) + j;
                System.out.print("matriz["+i+"]["+j+"]="+(matriz[i][j])+
                    " / array["+((i * N) + j)+"]="+array[(i * N) + j]+"   ");
            }
            System.out.println("");
        }
    }
}

Hora de fazer um resumo ! Comece assim:

baixe os arquivos da nVidia

atualize o driver de vídeo

instale o SDK

vá até o diretório /usr/lib e faça um link simbólico para o arquivo do libcuda.so.xxx como libcuda.so

no diretório NVIDIA_CUDA_SDK execute o make como root (ou com sudo)

Pronto! Agora já tem um ambiente funcionando, no meu caso o openGL não está funcionando, mas não é bem o meu objetivo então isso não foi um grande problema. Minha placa tem apenas um multiprocessador com 8 núcleos e 512MB acredito que seja possível realizar os testes necessários, mas se tudo funcionar vou precisar providenciar um ambiente mais forte com mais núcleos.

Em breve vou postar aqui alguns exemplos de codificação e como configurar o Netbeans para trabalhar com o CUDA.

A grande surpresa veio quando, sem conseguir me conformar com a falta do suporte bluetooth (já que o controle do Wii é um dispositivo bluetooth com o qual tenho trabalhado,) resolvi mais uma vez procurar alguma coisa e, mudando os parâmetros de busca no google, cheguei até uma página que sugeria desinstalar completamente os pacotes do bluez versão 4.x e fazer um downgrade para a versão 3.x, sugeria ainda instalar os pacotes a partir de um repositório independente que já tinha os pacotes compilados. Infelizmente um dos repositórios sugeridos não tem mais os pacotes.

Após pensar um pouco tive a ideia de baixar os fontes do site do BlueZ e compilar localmente, não haveria o RPM mas havia uma chance de funcionar. Bom, após compilar e instalar o pacote, voltei ao tutorial e instalei a parte de utilitários bluez3-test, bluez3-utils e bluez-hcidump através do segundo repositório que ainda está disponível. Optei por não compilar essa parte porque existem mais dependências de compilação. Além disso instalei também o libbluetooth2 e o kbluetooth. Resultado funcionamento completo de bluetooth no openSuSE 11.1 com direito a tray-icon e busca por dipositivos com o suporte do KDE!

Bom para resumir os passos devemos fazer o seguinte:

1. Remover todos os pacotes de bluetooh do sistema
2. Baixar o pacote bluez-libs-3.36.tar.gz e descompactar o pacote para uma pasta em sua máquina local
3. Executar “./configure –prefix=/usr” na pasta onde foi descompactado o arquivo
4. Executar “make && make install” como root
5. Instalar o repositório “http://download.opensuse.org/repositories/home:/enzokiel:/bluez3/openSUSE_11.1_Update/” no Yast
6. Instalar os pacotes:
   1. bluez-audio (3.36.x)
   2. bluez-hcidump (1.42.x)
   3. bluez-utils (3.36.x)
   4. kdebluetooth (1.0_beta8)
   5. kdebluetooth-lang (1.0_beta8)
   6. libbluetooth2 (3.36.x)

Pronto agora basta plugar a antena (caso seja usb) e o ícone já aparece na barra de trabalho! Ainda é necessário configurar o adaptador para selecionar se o computador deve ser encontrado ou não por dispositivos. Como teste tentei procurar dipositivos de entrada e coloquei o Wiimote em modo de sincronia, achou e guardou a configuração! Ainda não testei sincronizar o Nokia N73, mas acredito que funcionará porque na versão anterior (openSuSE 11.0 com KDE 3.5.x e bluetooth BlueZ 3.x) a sincronia com o telefone funcionava sem problemas.

Pretendo em breve gerar uma versão em RPM de ambos os pacotes BlueZ 3.36.x e disponibilizar aqui, mas infelizmente isso não esta com prioridade alta na lista de tarefas.