JGroups - Compartilhando Objetos entre aplicações Java

A um tempo atrás a equipe de desenvolvimento a qual faço parte deparou-se com um problema interessante para resolver. Imagine o seguinte cenário:

Uma aplicação foi dividida em diversas aplicações menores, rodando em desktop/Swing. Essas aplicações foram instaladas nas máquinas dos usuários, eles podem acessar cada diferente aplicação clicando em um ícone no Desktop (Cada aplicação roda em uma VM diferente). Na solução original a arquitetura era mais complexa utilizando-se Java Web Start e outras coisas, aqui foi simplificado para apresentar o propósito do uso do JGroups.

Na versão atual da aplicação, o usuário loga e tem acesso a um determinado Perfil (Administrador, Gerente). Ocorreu uma mudança nos requisitos e agora um usuário pode ter mais de um perfil. O perfil corrente pode ser selecionado em um combobox na aplicação, até aqui nenhum problema. Agora, imagine que o usuário tenha duas aplicações abertas, logadas com o mesmo usuário e muda o Perfil em uma das aplicações. Na especificação de requisitos diz que o perfil deve ser alterado "automagicamente" em todos as aplicações abertas com o mesmo usuário. Como implementar essa mudança sem modificar drasticamente a arquitetura?


A solução adotada for JGroups e está em produção, funcionando muito bem a algum tempo.

JGroups é um toolkit para comunicações multicast. Simplificando pode-se dizer que ele permite que um Objeto (qualquer objeto Serializable Java) seja compartilhando entre aplicações rodando em máquinas diferentes em uma rede, o que permite a criação de Clusters de aplicações de maneira simples. Algo interessante é que diferente de arquiteturas cliente/servidor, um cluster, não precisa de um servidor para "repassar" a informação para os outros clientes "conectados". Dentro do cluster uma das máquinas assume a responsabilidade de gerenciar as possiveis mudanças nos dados (no caso no Objeto Serializable) e avisar os outros clientes sobre elas. Caso esse cliente seja fechado outro cliente assume mantendo tudo funcionando.

O que fizemos na nossa aplicação foi integrar as aplicações em um cluster que compartilha o objeto o qual representa o perfil atual do usuário. Configuramos o JGroups para trabalhar apenas localmente de maneira que ele não procure nós (outras aplicações) do cluster em rede, apenas no ip local e VOIALÁ ... Uma solução para o nosso problema de maneira que não foi necessário mexer na arquitetura original da aplicação.

Espero que Seja útil.

Picanha Quatro Queijos

É galera, já a um tempo sem postar nada, vou recomeçar em grande estilo. Vai ai uma receita de picanha que é garantia de sucesso. Os ingredientes são simples:

Uma picanha show de bola
Quatro tipo de queijos. Eu particularmente gosto de queijo com gosto forte, então sugiro: Parmesão, Gorgonzola, Mussarela e Provolone;
Orégano;
Sal grosso. Pode ser desses temperados, mas se for o normal também fica muito bom;
Um pedaço grande de papel laminado (o suficiente para enrolar duas vezes a picanha);
Linha e agulha de costura;

Faça um buraco na parte grossa da picanha com a ponta da faca, e vá abrindo até formar tipo um saco dentro da picanha (se você não tiver as manhas pode pedir para o açougueiro para abrir a picanha e explica que você vai fazer recheada que ele sabe como preparar)
Corte o queijo em pedaços como na foto.
Coloque todos os queijos + orégano dentro da picanha e lembre de ir "socando" para caber mais
No fim, use a linha/agulha para costurar o buraco usado para colocar o queijo.
Coloque a picanha no papel laminado (conforme a foto), um pouco de vinho tinto seco para dar "liga" e depois jogue sal a vontade
Feche o papel laminado, coloque em uma grelha e deixei na churrasqueira por uns 40 min. Lembrando de virar de vez em quando para "cozinhar" por igual.
Tire o papel laminado, e deixe no fogo até pegar uma cor boa.
Obs: tem gente que gosta da picanha mais mal passada, tem gente que gosta passada, e tem gente que gosta torrada, então deixe no fogo conforme o gosto.
Depois é só cortar em "bifões" e servir

Google Web ToolKit

De tempos em tempos alguma tecnologia torna-se a queridinha dos desenvolvedores. A mais ou menos 1 ano a tecnologia abençoada foi o AJAX (Asynchronous Javascript And XML). Simplificando o papo, ajax é simplesmente uma maneira de você navegar em um browser sem ficar enviando parâmetros ao servidor e por consequencia refazendo a página o tempo todo. Esse processo além de trazer uma série de complicações técnicas (quem já programou WEB sabe bem ... ) não é tão agradável ao usuário como uma aplicação desktop.

O AJAX em sí não é nada muito complexo, você tem a possibilidade de criar uma função javascript que permite chamar uma página web (servlet, php, asp), tratar seu retorno e utilizar DHTML para redesenhar a tela web sem que seja necessário executar um reload. Entretanto, a manipulação manual de javascript e DHTML para montar uma aplicação complexa (e que funcione em vários browsers) é extramamente tediosa. Para resolver essa questão foram criados diversos frameworks que auxiliam o desenvolvimento de aplicações baseadas em AJAX e DHTML.

Aqui, vou falar um pouco do Google Web ToolKit, que a meu ver, destacou-se das demais ferramentas de sua categoria por apresentar uma visão (arquitetura, paradigma ou o que seja) inovadora.

Considero GWT inovador pois diferente das outras ferramentas ele permite que você escreva a sua aplicação inteiramente em JAVA (sem escrever uma linha de HTML). A mágica funciona de uma maneira muito inteligente.

Primeiro, a equipe do Google Labs portou (construiu as mesmas classes com os mesmos métodos) uma boa parte dos pacotes java.lang e java.util para javascript e chamou de JRE Emulation Library. Nestas bibliotecas estão contidas classes como Object e String que são essenciais para qualquer aplicação Java. Em um segundo momento foram desenvolvidos uma série de classes (componentes visuais, chamadas a servetls, manipulação de XML entre outros) que também foram portados para javascript.

Em um segundo momento foi desenvovido um compilador que converte uma aplicação desenvolvida em Java para Javascript denominado GWT Java-to-JavaScript Compiler. Então com essas duas ferramentas a mágica tornou-se possível. Você desenvolve a aplicação inteiramente em Java e depois utiliza o compilador para transformá-la em javascript.

Uma outra característica muito interessante foi o desenvolvimento de um Browser próprio. Esse browser intercepta as execuções em javascript e redireciona para a máquina virtual Java. Isto permite que em tempo de desenvolvimento seja possível debbugar a aplicação.

E é assim que toda a mágica funciona. Eu andei olhando o código do compilador e também os códigos gerados e a única palavra que achei para descrever foi mágica.

Agora vamos a prática, vou descrever abaixo os passos para fazer a primeira aplicação utilizando-se GWT e Netbeans.

1. Baixe o plugin para o netbeans aqui.
2. Utilize o Netbeans 5.5 (neste eu tenho certeza que funciona).
3. Baixe o GWT aqui (Esta é a versão para Windows, mas tem pra Linux e Mac).
4. Instale o plugin no Netbeans utilizando a seguinte sequência: Tools > Update Center > Install Manually Downloaded Modules (.nbm Files) > Next > Add (Adicione o arquivo baixado no item 1) > Next > Confirme todas as telas seguintes ;)

Para criar um novo projeto baseado no GWT você deve utilizar a seguinte sequência: File > New Project > Web > Google Web ToolKit Application. A primeira vez que você criar um projeto será necessário informar o lugar onde você descompactou o arquivo baixado no item 3.

O Netbeans irá criar toda a estrutura de arquivos e uma classe que implementa EntryPoint. Esta classe possui o método onModuleLoad(). Dentro deste módulo você deverá incluir os componentes de sua aplicação. O código abaixo cria uma aplicação simples com dois campos textos e um botão. O Botão copia o texto digitado em um TextField para o outro.

final TextBox texto1 = new TextBox();
final TextBox texto2 = new TextBox();

Button botao = new Button("Clique", new ClickListener() {
public void onClick(Widget sender) {
texto2.setText(texto1.getText());
}
});

RootPanel.get().add(texto1);
RootPanel.get().add(texto2);
RootPanel.get().add(botao);

Para Executar ou Debuggar basta utilizar as funcionalidades padrões do NetBeans.

É isso ai pessoal, espero que tenham gostado. A ferramenta GWT permite que você crie aplicações WEB complexas de maneira simples e bem organizada. Em um próxima entrada explicarei como enviar e receber objetos para o servidor web (Tomcat) utilizando-se o recurso Remote Procedure Call, assim será possível persistir objetos no bando de dados por exemplo.

[]s

Controle Transacional utilizando EJB 3.0

Olá pessoal, demorei um pouco para postar .. sabem como é o final do ano. Muita festa, muita cerveja, e pouco trabalho. ;)

Este tópico vai ser um pouco diferente dos outros, vou abordar um pouco da teoria sobre transações. Uma transação é basicamente um conjunto de operações executadas em um ambiente transacional como por exemplo: Gravação de Dados em um Banco de Dados ou Envio de Mensagens utilizando-se providers JMS, etc.

Segundo a própria especificação Enterprise JavaBeans 3.0 o suporte a transações é uma das features chave do JEE. O objetivo principal de utilizar transações é possibilitar diminuir a complexidade no desenvolvimento de softwares de grande porte.

A especificação EJB 3.0 permite uma transação possa envolver dois ou mais ambientes transacionados utilizando-se um ou mais SessionBeans ou Message Driven Beans.

As figuras abaixo demostram alguns cenários possiveis:

1. Atualizar multiplos bancos de dados/MDBs em um ou Session Bean.
2. Atualizar multiplos bancos de dados/MDBs em mais de um Session Bean.
3. Atualizar multiplos bancos de dados/MDBs em mais de um EJB Container.

A idéia básica é evitar problemas com inconsistencia de dados. Uma transação deve ser necessáriamente completada por inteiro ou caso aconteça algum erro todas as alterações devem ser desfeitas.

Você pode optar por duas formas de controle transacional, Bean Managed Transactional ou Container Managed Transactional. O primeiro caso você faz o controle na "unha", ou seja, você informa no código onde quer iniciar uma transação, onde quer terminar, no segundo caso, o próprio container controla quando uma transação deve ser aberta ou fechada.

Exemplo de parte do código de um Session Bean com Bean Managed Transactional:

@Stateless
@TransactionManagement(BEAN)
public class MySessionBean implements MySession {
@Resource javax.transaction.UserTransaction ut;
@Resource javax.sql.DataSource database1;
@Resource javax.sql.DataSource database2;
...

ut.begin();
stmt1.executeQuery(...);
stmt1.executeUpdate(...);
stmt2.executeQuery(...);
stmt2.executeUpdate(...);
stmt1.executeUpdate(...);
stmt2.executeUpdate(...);
ut.commit();

...

Lembre-se que você pode utilizar tanto Stateless Session Beans como Stateful Session Beans para fazer transações, a diferença básica é que em um Stateless você deve fechar a transação antes do business método retornar e no Statefull você pode mas não é obrigado. Neste caso pode-se chamar um método do cliente que inicia a transação, chamar diversos métodos que utilizem a mesma transação e depois chamar um método que fecha a transação (Isso porque o Stateful Session Bean mantem estado. O caso 1 é um exemplo onde pode-se utilizar Bean Managed Transactional.

Os casos que envovam mais de um Session Bean Caso 2 e Caso 3 são casos clássicos de uso de Container Managed Transactional. Para você poder especificar como o container deverá tratar a execução de uma transação envolvendo mais de um Bean você deve utilizar as anotações de tipo de Managed Transaction que são as seguintes:

Mandatory: Só pode ser chamado a partir de um Bean com transação, caso contrário dispara uma Exception.

Required: Se existe transação no Bean anterior o container usa a transação, se não existir cria uma nova, essa nova transação é passada para novos Beans que possam ser chamados a partir do Bean marcado como Required.

Requires_new: Sempre cria uma nova transação, essa transação é finalizada no fim do método, ou seja, em todos os casos é apenas utilizada dentro do Bean marcado como Requires_New.

Suports: Se existir transação utiliza, se não existir ignora.

Not_Supported: Se você chama um Session Bean marcado como Not_Supported a partir de um Bean com uma transação ativa o container simplesmente ignora a transação.

Never: Só pode ser chamado a partir de um Bean sem transação, caso contrário dispara uma Exception.

Abaixo o exemplo de um Session Bean utilizando Managed Transactional:

@Stateless public class MySessionBean implements MySession {
...
@TransactionAttribute(REQUIRED)

public void someMethod(...) {
java.sql.Connection con1;
...
stmt1.executeQuery(...);
stmt1.executeUpdate(...);

...

Note que não deve-se declarar inicio de transação, nem fim.

Outra informação importante sobre transações é que qualquer serviço que seja compativel com a especificação JTA (Java Transactional API) pode ser utilizado nas transações. Os mais comuns e citados acima são Banco de Dados e Sistemas de Mensageria (JMS), mas isso não impede por exemplo de existir outros tipos de serviços como um sistema de email que armazene a msg e só envie realmente quando a transação acabar (Apesar de ficar estranho você controlar a chegada dele no cliente pois email é assincrono, isso deixaria a transação aberta por muito tempo. Mas enfim, é só um exemplo de serviço conhecido rs).

É isso ai.

[]s a todos

Genesis - Desenvolvendo Aplicações Desktop de maneira simples e organizada

Olá a todos,

Quem aqui já desenvolveu aplicações desktop em qualquer linguagem (Delphi, C++, VB, Java) sabe que existem duas partes que tendem a transformarem-se no famoso "código macarronico" se você não possuir um padrão de desenvolvimento ou uma boa capacidade de organização.

1. Ligação dos campos com as variáveis que os representam.
2. Controle de Habilitação e Desabilitação de campos baseados em regras de Negócio.

Para resolver esse tipo de problema diversos modelos foram criados, entre eles pode-se citar o MVC utilizado hoje em dia no Swing (É uma das mais conhecidas APIs para desenvolvimento Desktop em Java). Apesar do MVC do swing proporcionar uma organização no código o que acaba padronizando tudo, ele sempre foi criticado por ser muito complexo, assim, tornando o desenvolvimento caro pois você sempre precisa de desenvolvedores experientes.

Seguindo nesta mesma linha surgiu o Genesis que é uma ferramenta OpenSource (disponivel em sua totalidade e com manual em Português) desenvolvida pela Summa Technologies do Brasil sendo que os principais culpados pela criança são Michael Nascimento e Allan Jones . A idéia básica do Genesis é permitir que programadores com pouca experiência conseguiam desenvolver aplicações Desktop com suporte a conexão a EJBs transparentemente. O Genesis pode ser divido em duas partes: client e shared.

O lado client é conhecido como binding, essa parte da API vincula todos os elementos de uma Interface (Construida em Swing, SWT ou Thinlet) a um Pojo (Plain Old Java Object). Imagine que você tenha uma interface como na figura.

O Genesis Client permite que você crie uma classe java simples sem herança nem dependencias de nenhum tipo contendo os campos relacionados a interface/métodos e vincule a interface com essa classe (Esta classe é chamada de Form). Além disso ainda possibilita constrolar a ativação e desativação dos botões, validação de campos etc.
Outro bônus é que como a interface é totalmente separada do "negócio" é possivel construir Unit Tests (outra hora faço um post sobre isso) o que permite testar a aplicação inteira sem interação humana.

O lado shared é assim chamado pois utiliza Aspectos (falo disso outra hora tb) para executar um conjunto de operações dentro de um EJB Container de maneira transparente, assim pode-se dizer que as classes estão entre (shared) a parte cliente e servidora, entretando neste post não vou entrar em detalhes.

Um bom começo seria assistir o vídeo que mostra como fazer binding simples: dois campos texto e um botão. É importante salientar que como no exemplo foi utilizadas anotações, é necessária a utilização do jdk1.5, entretando, o genesis também pode ser utilizado com jdk1.4, maiores informações podem ser encontradas na página da API.

Continuando o exemplo apresentado no vídeo, imagine que você deseja colocar um ComboBox na interface, basta para isso utilização a anotação @DataProvider, que pode ser utilizado para Combos, Listas e Tabelas. Para utilizar esta funcionalidade você deve criar um método qualquer que retorna uma lista de Objetos e informar qual a propriedade na classe que irá receber o objeto selecionando:

@DataProvider(objectField="sistema", widgetName="sistemas")
public List populaSistema() {
List sistemas = new ArrayList();
sistemas.add(new Sistema("JPA","JPA"));
sistemas.add(new Sistema("EJB","EJB"));
return sistemas;
}

Neste exemplo, o campo ComboBox com o nome sistemas será populado com a lista retornada e quando um item do combo for selecionado ele estará disponível na propriedade sistema do form.
Outra configuração importante é informar ao Genesis qual propriedade (do objeto Sistema) será apresentadas na tela, para isso deve-se adicionar as seguintes linhas na inicialização da inteface:

sistemas.putClientProperty(SwingBinder.KEY_PROPERTY, "sigla");
sistemas.putClientProperty(SwingBinder.VALUE_PROPERTY, "nome");
sistemas.setRenderer(new KeyValueListCellRenderer(sistemas));

Neste caso, a propriedade que será mostrada na lista será NOME.

Outra funcionalidade interessante é a utilização de Formatadores. Imagine que você possui um campo de um tipo qualquer mas deseja que o texto para o usuário seja formatado de uma maneira especifica, por exemplo, você quer que o nome apresentado no combo acima seja iniciado com -- e finalizado com --, basta você adicionar o seguinte código na inicialização da interface:

Formatter f = new Formatter() {
public String format(Object o) {
return "--"+o+"--";
}
};

e registrar o Formatador após fazer o Binder

binder.registerFormatter("sistema.nome", f);

Toda vez que a propriedade nome for inserida no list o Genesis irá chamar o formatador definido. Obviamente esse exemplo não tem muito sentido pratico, foi feito apenas para demostração. Um exemplo mais prático poderia envolver formatação de números, datas, códigos etc. Salienta-se que os formatadores podem ser utilizados com qualquer tipo de campo.

No exemplo passo a passo foi demostrado como vincular um botão a um método utilizando-se a anotação @Action, agora imagine que você precisar ativar esse botão apenas em uma determinada condição. Em nosso exemplo poderiamos ativar o botão apenas se todos os campos estiverem selecionados, para isso deve-se utilizar a anotação @Condition.

Primeiro você cria a condição (você pode utilizar diversas sintaxes para criá-la, vou utilizar aqui a que considero mais simples):

@Condition("loginSenhaOk=
genesis.isNotEmpty('form:usuario') &&
genesis.isNotEmpty('form:senha') &&
genesis.isNotEmpty('form:sistema')")

Criamos aqui uma condição denominada loginSenhaOk que será verdadeira quando todos os campos da inteface estiverem selecionados. Está anotação deverá ser feita no inicio do Pojo, e poderá ser utilizada em quaisquer campos ou ações utilizando-se as anotações @VisibledWhen, @EnabledWhen entre outras.

Como os próprios nomes dizem @VisibledWhen fará com que o botão fique visivel quando a condição for verdadeira e o @EnabledWhen deve ser utilizado para habilitar o botão. Estas anotações devem estar antes do método a ser controlado:

@Action
@VisibledWhen("loginSenhaOk")
public void limpar() {
setUsuario(null);
setSenha(null);
setSistema(null);
}

Outras anotações de controle podem ser utilizadas, no site do Genesis você pode encontrar uma lista completa.

Agora, imagine que você queira apresentar uma tela de confirmação antes de executar uma ação. Para isso você pode utilizar a anotação @BeforAction, ela permite que um método seja executado antes de uma ação, este método pode retornar void ou boolean, caso retornar void a ação será sempre executada, caso retornar boolean a ação será executada se o retorno for true.

No nosso caso vamos criar um método que apresenta uma tela perguntando se o usuário deseja limpar realmente a tela e executar este método antes da ação limpar.

@BeforeAction
public boolean limpar()
{
if ( JOptionPane.showConfirmDialog(null,"Limpar?", "Limpar?" ,JOptionPane.YES_NO_OPTION) == 0 )
return true;
return false;
}

O método deverá possui o mesmo nome do método da ação, entretando deverá ser declado na interface e não no Pojo ou Form.

O exemplo completo pode ser baixado aqui.

Aconselho a quem está iniciando um projeto com Swing, Thinlet ou SWT a fazer um exemplo de tela o mais complexa possível utilizando-se as APIs acima em sua maneira original e depois a mesma interface utilizando o Genesis, vocês perceberam que o código utilizando o genesis fica mais simples e organizado com pouco esforço.

[]s

Listagem e Edição de 2 Tabelas com Relacionamento em 2 min

Ae pessoal, lá vou eu para mais uma entrada no blog. Agora vou falar um pouquinho sobre JPA, da mesma maneira que antes não vou ficar entrando em muitos detalhes apenas o suficiente para que vocês consigam fazer uma implementação básica.

A idéia básica é mostrar como se utilizar JPA (Java Persistence Api). JPA é o que se pode chamar de o novo Entity Beans que faz parte da especificação Java EE.

Mas não precisa ficar chateado, é muito, muito melhor que o Entity Bean. Quem conhece hibernate (que apesar de não fazer parte da especificação do J2EE acabou virando padrão de mercado devido a uma série de vantagens sobre o Entity Bean) vai achar o JPA muito parecido e não vai ter dificuldades em utilizá-lo. Em minha opinião sempre se deve utilizar padrões a não ser que a qualidade de uma ferramenta não padrão seja muito superior como foi o caso do Hibernate.

Para quem não sabe o que é Entity Bean e nunca ouviu falar em Hibernate não fique preocupado, siga lendo que você já vai entender, mas basicamente estas duas ferramentas fazem parte de um grupo de apis denominadas de Object/Relational que possibilitam que o programador crie Classes java as quais podem ser persistidas diretamente no banco de dados com o mínimo de uso de SQL o que possibita a utilização de Orientação a Objetos de uma maneira mais completa pois você não precisa quebrar o paradigma no momento da gravação dos dados.

JPA provê um tipo de "Interface" entre o programador e o que chama-se de Provider. O Interessante é que funcionando dessa maneira você poderia teóricamente modificar além do banco de dados o Provider sem nenhum impacto no código. O provider é a api que realmente persiste os dados no banco de dados como o topLink, Hibernate entre outros.

Como havia dito antes a arquitetura do JPA é muito semelhante a do Hibernate, diferente do Entity Bean que deveria obrigatoriamente ser rodado dentro do EJB Container, o JPA pode ser rodado dentro do servlet Container como o Tomcat. Você deverá utilizar um componente denominado Entity Manager que é semelhante do Session do Hibernate e para recuperar e modificar dados.

Basicamente uma Entidade JPA contém a seguinte sintaxe:

@Entity
@Table(name = "pessoa")
public class Pessoa implements Serializable {

@Id
@Column(name = "identificador", nullable = false)
private Integer identificador;

@Column(name = "nome", nullable = false)
private String nome;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "identificadorPessoa")
private Collection telefoneCollection;

...

Você também vai precisar de um .xml contendo as informações de seu banco de dados e provider. No nosso exemplo o xml é criado transparentemente.

Para obter o EntityManager você simplesmente cria um Factory que lê o XML e cria o EntityManager.

EntityManagerFactory emf = Persistence.createEntityManagerFactory("WebApplication3PU");

EntityManager em = emf.createEntityManager();

Agora você já pode manipular os dados utilizando diretamente as classes:

em.getTransaction().begin();
em.persist(pessoa);
em.getTransaction().commit();
...
Pessoa o = (Pessoa) em.find(Pessoa.class, id);

Utilizando-se JPA você aumenta em muito a produtividade (comparando a utilizar JDBC na mão), entrentando existe uma maneira de aumentar ainda mais a produtividade. O Netbeans versão 5.5 vem com uma série de recursos que permite você construir praticamente tudo utilizando-se o "Pattern Next Next Next ;)". Server para fazer cruds rapidamente e também para construir a base de um sistema.

Aqui você pode acompanhar a criação de um crud para manipuação das entidades: Pessoa e Telefone.

Qualquer banco de dados pode ser utilizado desde que exista um driver JDBC compatível e que você possa criar Foreign Keys, entretando sugiro a utilização do Mysql 5 já que foi o utilizado para fazer o exemplo aqui disponivel. Você pode seguir os passos abaixo para instalar da maneira mais simples possível.

1. Baixe o Mysql em formato msi (Instalador Windows) e instale deixando todas as opções como padrão, apenas lembre-se de no momento da requisição de senha optar por criar um usuário anonimo (não é a maneira politicamente correta, mas é a mais simples).

2. Baixe O GUI Tools que é um grupo de ferramentas para gráficas para manutenção do banco e Instale. A imagem acima foi criada utilizando-se a ferramenta MySql Workbench.

3. Também será necessário baixar o Connector/J que contém o driver JDBC.

Após instalar utilize a ferramenta Mysql Query Browser para criar as tabelas. Como você criou um usuário anonimo apenas use o login anonymous sem senha com o schema test que já vem criado no mysql. Você deve clicar com o botão direito no schema e optar por criar tabela.

Os scripts abaixo também podem ser utilizados:

CREATE TABLE `test`.`pessoa` ( `identificador` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `nome` VARCHAR(45) NOT NULL, PRIMARY KEY(`identificador`) ) ENGINE = InnoDB;

CREATE TABLE `test`.`telefone` ( `identificador` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `numero` VARCHAR(45) NOT NULL, `identificador_pessoa` INTEGER UNSIGNED NOT NULL, PRIMARY KEY(`identificador`), CONSTRAINT `FK_telefone` FOREIGN KEY `FK_telefone` (`identificador_pessoa`) REFERENCES `pessoa` (`identificador`) ON DELETE RESTRICT ON UPDATE RESTRICT ) ENGINE = InnoDB;

Entrentando a GUI é bem simples e eficiente. Você deverá criar as tabelas Pessoa e Telefone. Não esquecendo de criar a Foreign Key na tabela telefone referenciando a tabela Pessoa.

Depois que você tiver criado o banco você assista o passo a passo da criação do crud.

Você pode baixar o projeto aqui.

É isso ai. Espero que tenham gostado.

Acabe com a sua Tese antes que ela acabe com você

Ontem acabei de escrever a minha Tese, já envei para o meu orientador e estou esperando para fazer as correções necessárias e defender essa pesquisa de uma vez. Apenas para citar, o título é Intersecção das Técnicas de Term Extration e Query Expansion aplicadas a Recuperação de Documentos Textuais. A idéia básica é construir uma Engine de Busca Textual que consiga usar semântica. Utilizei na construção do prototótipo o Lucene e o Jena. O Lucene pra quem não conhece é uma ótima ferramenta para indexação e busca de textos e o Jena é uma ferramenta para criação e utilização de ontologias.