Katas para Coding Dojos

Dae gurizada...

Coding Dojo já é um a prática amplamente utilizada, há no mínimo 6 anos. Toda vez que eu quero fazer um, saio catando Katas pela internet. Então vai um post pra eu não precisar sair procurando toda vez.

Primeiramente, o catálogo do codingdojo.org já tem vários Katas interessantes.

Minha carreira no exterior: 1 ano de Europa

Dae gurizada...

Hoje resolvi contar um pouco da minha experiência morando e trabalhando com TI no exterior. Estou morando na Europa faz um pouco mais de 1 ano. Passei 8 meses em Londres e há 6 estou em  Dublin.

Vou contar mais sobre minha experiência em Dublin, pois vim pra cá "com meus próprios pés". Enquanto em Londres, fui como consultor de uma empresa gaúcha, na qual atrabalhei até Junho deste ano.

Mudei para Dublin na metade de Junho. Cheguei aqui sem nenhuma oprtunidade "pré-arranjada" e  acredtio que é essa história que vale a pena ser contada.

Scala Tour - Part 1

Dae gurizada..

Nos últimos meses tenho acompanhado algumas coisas sobre Scala, e minha idéia é criar alguns posts explicando alguns tests.

Vou usar como referência este post do Martin Odersky, pai do Scala, onde ele separa alguns "níveis" de conhecimento. (Não vou entrar no mérito se estes níveis estão certos ou não, só vou usar como referência. E quando digo referência é porque não vou seguir extatamente o que está alí.)

Seguindo a idéia do Uncle Bob Martin, vou usar TDD para estudar a linguagem. Então, cada recurso da linaguem vai ser representado com um ou vários testes unitários.

Código fonte: https://github.com/simundi/gyro/tree/master/scala-tour

Ambiente de Desenvolvimento

Eu fiz testes rápidos usando o Scala IDE no Eclipse e Eclipse + Maven. Não gostei de nehum deles. Eu encontrei alguns problemas mas não dispensei muito tempo tentando arrumar. Então, não use como base meus problemas para dizer se funciona ou não. Abaixo alguma explicação:

Arquiteto de Software: O que você espera saber?

Atualmente ando repensando os caminhos da minha carreira profissional e resolvi colocar na ponta do lápis os conhecimentos que gostaria de adquirir nos próximos meses. 

Então criei esse mapa mental sobre o que EU acredito que um Arquiteto de Software deva conhecer. 

Mas espere! É óbvio que não estou criando uma receita de bolo, até porque não tenho condições para isso. É apenas uma reflexão e AGUARDO COMENTÁRIOS.

Eclipse Fullscreen no Mac OS Lion

Dae gurizada..

Pra quem usa Mac com o Lion, segue uma o link de um Plugin para dexiar o Eclipse em Fullscreen mode.

http://alblue.bandlem.com/2011/07/full-screen-support-for-eclipse-on-osx.html

Basicamente é ir em: "Help -> Install new software" e colocar a URL: http://github.bandlem.com/

Fica a dica...

era isso..

Rode seus testes com jetty fácil..

Dae guriazada..

Eu conheço o Jetty faz algum tempo, mas nunca dei muita bola pra ele até ver como é fácil rodar uma aplicação web com ele. É perfeito pra fazer testes!!!

Este post é mais para eu mesmo lembrar do como fazer..rsrsrs


Primeiro crie uma aplicação web com maven.  Tem várias turorais por ai sobre como fazer isso.

Mas basicamente essa deve ser a estrutura do projeto:

Incluir o plugin do maven par rodar a aplicação com Jetty:

  
   
    org.mortbay.jetty
    maven-jetty-plugin
    
     /jetty-test
     
      
       8080
      
     
    
   
  
 

Acredito que esteja claro os parâmetros que o plugin recebe  (contexto e porta). Mais informações sobre o plugin aqui.


No console é só digitar:

mvn jetty:run

Depois acessar a url: http://localhost:8080/jetty-test/


E feito o carreto...


Era isso. Abraço

Primeiro contato com Node.j e mais sobre non-blocking servers

Dae gurizada..

Na sequência do meus estudos sobre non-blocking web servers vou dar uma olhada no Node.js.

Instalação: https://github.com/joyent/node/wiki/Installation

Vou utilizar como base esta apresentação do Ryan Dahl, que está disponível no site do node.js

Antes de olhar sobre Node.js é importante entender o C10K Problem e Non-blocking I/O

Node.js

Node.js nada mais é que uma biblioteca que roda em cima do virutal machine chamada v8. V8 é uma JavaScript Engine escrita pelos  engenheiros da Google e é utilizada no Google Chrome.

Node utiliza o v8 para fazer o trabalho de comunicação (networking) corretamente. 

Não existe "waiting time"

Óbvio, é isso que faze dele um non-blocking server: Não ter "waiting time".

Você não consegue mandar o node dormir (sleep). Não é que você seja encorajado a não fazer um "sleep", na verdade você não tem poder para isso. 

O que o Node faz é definir Timeouts e deixar processos em idle (ocioso), fazendo com que o consumo de CPU vá para zero.

De uma olhada nesse código:

C10K Problem. O quê Deft, Node.js, Netty e outros estão solucionando

Dae gurizada,

A idéia de olhar para esse problema surgiu depois que o Diego Pacheco me deu a missão de falar sobre Deft e Loft em um lighting talk que fizemos há algumas semanas atrás.

O grande impecílio que tive para entender o conceito dos servidores Deft e Loft foi de entender o problema. Eis a motivação do post.

O que vou tentar explicar são as limitações existetes que fazem com alguns servidores não consigam processar mais que 10mil requisições simultâneas. E (se tudo der certo) você vai entender porque servidors como Deft, Loft, Tornado, Netty, Node.js e outros tem um desempenho diferente que os sservidores normais. 

C10k Problem

C10k significa 10.000 (dez mil) conexões simultâneas. Este é a limitação de conexões silmutaneas da maioria dos servidores de aplicação.

Isso acontece devido a forma que os servidores trabalham com cada conexão recebida.

Muitas destes problemas são ocasionaos pela forma que o servidor foi impelmentado e de como o Sistema Operaciona (OS) trabalha com sockets.

Eu vou descrever algumas destas limitações abaixo.

Taskboard e Standup Meeting não é suficiente. Algumas dicas de como executar...

Trabalhei em diversos projetos que utilizavam TASK BOARD do Scrum. Ao longo do tempo conseguimos otimizar a utlização dos mesmos identificando algumas boas práticas.

Engenharia de Requisitos: todo mundo fala, poucos fazem

Hoje terminei o treinamento sobre Requisitos de Software com o Luiz Parzianello, que ao meu ver é um dos "CARAS" de requisitos no brasil.

O objetivo do post é falar um pouco do porquê resolvi estudar requisitos e algumas dicas para quem está começando a estudar sobre isso.

Motivação

• É um assunto abordado de forma muito pobre nas faculdades
• Existe muita gente(inclusive eu) definindo requisitos baseado na experiência(empírico), sem fundamento teórico.
• É nítido os problemas que requisitos errados e/ou inconsistentes geram nos projetos.

Instalar OC4j no Ubuntu

Esses tempos tive que instalar o OC4J para trabalhar.

Então resolvi fazer esse post para não sofrer novamente com algumas configurações.

Instalação

Bom a instalação foi tranquila.

Segui os passos da documentação da Oracle e não tive problemas: http://download.oracle.com/docs/cd/B25221_04/web.1013/b14432/install.htm

Atenção com os paths das variáveis de ambiente!

Spring Roo, a filosofia por trás do código...

Dae gurizada..

Esse post está guardado há uns 2 meses, então não reparem as datas... ;)

No último dia 09/Novembro fui no TDC, onde tive a satisfação de assistir a palestra do próprio Rod Johnson, sobre spring Roo.

Eu e o Rod. Os carecas.. hehehe

Desenvolverdor Java mudando de Windows para Linux(Ubuntu)

Dae guriazada...

No início do ano meu notebook estragou. Demorei uns 4meses para mandar arrumar. Mas consegui! :D:D:D

Então, resolvi mudar e largar de mão o windows vista.

Faça a mudança acontecer. Não mude.

Mudança é sempre uma palavra complicada. Nós, profissionais de TI, sempre adoramos mas organizações nem tanto.

Depios de uma certa experiência, que relaciono com as "vivências" não com o tempo, aumentamos nosso poder de obsevação e nossa análise crítica. Apartir daí, somos capazes agregar valor ao nosso trabalho de forma mais intensa.

Quando trocamos de empresa essa vontade de trazer nossas experiências a tona é dispertada. Normalmente nos deparamos com diversos pontos que podemos melhor, agregar, modificar, etc, no novo contexto. Isso acontece devido às experiências carregadas na mocihla.

Neste momento vejo o primeiro equívoco.

Trazer as crenças da empresa para nós, não trazer a nossas crenças para a Empresa

Não é bom chegar em um lugar e querar mudar diversas coisas. Apontar diversos falahs. Não e bom porque mal entendemos o ambiente, o contexto, como as coisas funcionam.

Viver a rotina da empresa para depios apontar pontos de melhoria é um bom começo. Dessa forma, é possível projetar o impacto das mudanças. Ao conseguir projetar o impacto das mudanças pode-se argumentar para que elas sejam efetuadas.

Devemos fazer parte do negócio, enteder os fluxos de trabalho, conhecer as causas e efeitos, o porquê as coisas são como são.

A partir daí...

Faça a mudança a contecer, não mude

Normalmente temos idéias que, com certeza, vão mudar o mundo. A empresa vai lucrar muito mais, eu vou ganhar uma promoção, tudo vai melhorar. Mas...

Apesar da mudança ser uma constante, ela tem que ser controlada pelas organizações. Afinal, qualquer mudança tem custo. Se cada funcionário que entra resolver mudar tudo, a empresa ta ferrada!

Por isso, para fazer com que suas idéias possam ser atendidas não proponha simplesmente mudanças. Provoque a inquietude nas pessoas. Provoque a mudança nas pessoas. Seja um agente de mudanças. Levante faíscas para que todos envolta possam acender o fogo. Isso sim que vai fazer todoas ganharem.

Ser um agente de mudanças
Acredite nas pessoas. Seja humilde. Ouça o que os outros têm a dizer.Valorize o conhecimento de quem está a sua volta.

Se você mostrar estas características ANTES de sair mudando tudo, será ouvido.


Pense fora da caixa
Um dos passos para ter idéias novas é questionar.

Não seja "palpiteiro". Questionar sem argumento é palpite. Isso não agrega nada.

Questione, entenda, reflita, então provoque a inquietude nas pessoas. Para que todos façam os mesmos questionamentos.



Resumindo, tenho três idéias principais sobre mudanças:

• Entenda o contexto. Não "jogue" tudo que você conhece propondo mudanças em tudo.
• Provoque mudanças em quem está a sua volta.
• Pense fora da caixa.Questione, entenda e refilta sobre o contexto.

Não sei porque resolvi escrever isso...

Mas... são 3h da madruga e veio a inspiração... amanhã eu leio como ficou... heheheh

Abraço!

RMI e HIbernate... lições aprendidas

Estou participando de um projeto onde decidimos utilizar RMI para conversação de dois módulos do sistema. A decisão não vem ao caso agora, mas achei interessante gurdas alguns "causos"...

RMI e Hibernate, onde tudo começou

Como falei anteriormente, decidimos utilizar RMI para integrar dois módulos do sistema. Um módulo responsável pela parte de negócio( persistência também) e outro por uma parte específica bem baixo nível (baixo nível = bytes.. 01010101...etc...).

Então, o gênio projetista teve a seguinte idéia: "Vamos utilizar as classes persistentes para trafegar via RMI".

Resultado: LazyInitializationException -LIE.

Em um determinado método de uma classe acessada via RMI o retorno era um objeto que foi buscado do Hibernate. Este objeto tinha outros objetos, que tinham outros objetos, que tinham outros objetos... blá blá blá...

Soluções:

1º) Colocar "transient"(do java não do JPA) nos atributos que não deveriam trafegar via RMI. Puramor de Deus, Nãããão!!!

Imagina ficar colocando transiente em tudo que é atributo espalhado pelo código inteiro. Loucura!!!

2º) Modificar o design

Interessante... muito interessante...

O Design... (não é de moda porr!!)

Tentei fazer algo que representasse o problema. Então abaixo estão algumas classes de domínio, mapeadas no hibernate.

OBS: Para quem não sabe, em RMI devem existir interfaces comuns nos dois lados da comunicação. Então a interface PessoaData é conhecida pelos dois módulos.


Agora, viram o que o projetista gênio fez ?!?!?!

A classe Pessoa implementa a interface PessoaData. Na imagem acima temos somente um exemplo, mas no contexto real são umas 20 classes que irão trafegar via RMI. Todas essas classes são entidades persistentes.

Observe que a interface PessoaData retorna byte[]. Isso mesmo.. o "carinha" que utiliza estas classes vai precisar dos dados convertidos em bytes. Guarde esta informação.

Confesso que o projetista gênio(agora já deve-se saber quem é o projetista... :D ) percebeu a burrada somente quando ocorreu o erro com hibernate.

O que vocês conseguem enchergar ai?

Bom, vou dizer o que eu consegui enxergar:

• Uma classe persistente implementa uma interface utilizada para comunicação entre sistemas. Acomplamento! Entidade persistente conhece uma interface onde o objetivo é comunicação de dados entre sistemas... "nada a vê"
  
• Pelo motivo acima, a entidade persistente é responsável por converter String, Integer, Date em bytes. Coesão! Tava tudo misturado, conversões com bytes em uma classe onde o objeto é enviar e obter informações do banco de dados.

Solução tomada

Utilizamos os famosos Transfer Objects. Segue o exemplo:

Matamos o problema de coesão, onde a classe PessoaTo é responsável por trabalhar os dados para comunicação.
Matamos o problema de acomplamento onde a classe Pessoa não sabe que a classe PessoaTo existe.
Matamos o LazyInitializationException. A classe TO contém apenas o que será necessário para transferência.

Lições aprendidas

• Colocar tudo em uma classe é diferente de economizar tempo
• Preguisoço trabalha em dobro... :D
• Projetos iterativos minimizam os erros. Descobrimos o problema no início e retrabalho foi de aproximadamente 5hs.
• Enviar objetos utilizados para persistência via RMI-> ... LazyInitializationException
• Spring RMI exporter facilita muito!
• Cuidar as dependências das classes

Era isso..

Abraço!

Quer aprender Adobe Flex?

Acabei de chegar de uma palestra de demonstração do Adobe Flex na T@rgetTrust.

Eu não sei nada sobre Adobe Flex, mas achei muito interessante o que vi hoje.

Segue algumas referências para quem estiver afim de iniciar os estudos:

Referências:

• Adobe TV
• Flex Developer Center
• Tour de Flex

Listas Brasileiras

• FlexBrasil
• FlexDev

Bibliotecas (outros componentes):

• Flexlib
• Flex MDI
• Flex Object Handle
• Ilog Elixir
• Degrafa

Frameworks para integração com Java:

• BlazeDS – Free
• OBS: O spring tem um projeto para integração com BlazeDS
  
• LCDS - Pago

Tutoriais:

• http://www.adobe.com/devnet/flex/flex_java.html
• http://www.javaworld.com/javaworld/jw-01-2009/jw-01-javaee-flex-1.html?page=1
• http://www.adobe.com/devnet/livecycle/articles/blazeds_gettingstarted.html
• http://blog.digows.com/integrando-adobe-flex-blazeds-springframework-hibernate-uma-soluo-opensource-para-sistemas-web-parte-1/ (Muito Bom!!!)
  

IDE

• Flex Buildes ($249)
• Flex Builder plugin para Eclipse ($249)
• Flex SDK (Gratuito)
• Flex versão para estudante

Esse post é mais para eu anotar em algum lugar os links do que qualquer outra coisa..

Abraço

Simundi

Padrões de Projeto - Gerador de Gráficos com Template Method

Dae gurizada...

Algum tempo atrás eu e um amigo, Marcos Brião, fizemos uma oficina (workshop) na Confraria do Java, grupo de estudos da Ulbra em Canoas/RS, sobre Desgin Patterns.


Esses dias tava revirando meus arquivos e encontrei essa apresentação. Nessa oficina fizemos um Gerador de Gráficos simples com alguns patterns. O sistema ficou bem interessante.

Screenshot:

Faça os downloads:

• Apresentação (PDF)
• Aplicação Exemplo

Essa aplicação basicamente gera gráficos com informações digitadas na tela. Com o uso de Design Patterns como Template Method e Facade, conseguimos ter uma aplicação fácil de fazer manutenção e entendimento.
Utilizamos o framework JFreeChart(link) para gerar os gráficos.

Esse é o diagrama de classes:




Template Method
Definição:

Definir o esqueleto de um algorítimo em uma operação, postergando (deferring) alguns passos para subclasses. Template Method (Gabaríto de Método) permite que subclasses redefinam certos passos de um algorítimo sem mudar a estrutura do mesmo.

Padroes de Projeto -GoF

Vamos imaginar um algorítimo qualquer, com esse exemplo, gerar gráficos.

Quando vamos gerar gráficos a lógica para criar o ojeto JFreeChart é sempre a mesma. A única parte que muda, de um gráfico para outro, é quando vamos adicionar os dados ao gráfico.

Nesse contexto poderíamos ter uma classe que faria a lógica para gerar o gráfico e quando fosse adicionar dados, passaria a responsabilidade para uma classe filha.

Fizemos exatamente isso. Temos uma classe abstrata chamda GraficoTemplate, que tem a lógica para gerar os gráficos.

Veja a classe:

Como vocês podem ver essa clase é bem simples.

Temos um método criarGráfico, que recebe uma lista de dados e retorna um objeto JFreeChart. Esse método esta declarado como final. Isso significa que nenhuma classe que extender esa classe poderá alterar essa lógica. Esse detalhe do método ser final não faz parte do padrão Template Method.

Dentro do método criarGrafico eu chamo dois métidos: "carregarDados" e "configurarLegenda".

O método "configurarLegenda" é implementado dentro dessa classe mesmo. Ou seja, tem uma implementação padrão, mas qualquer classe que pode sobrescrever o método e alterar essa configuração de legenda.

O método "carregarDados", muita anteção! Aqui que está o Pattern.

Viu que o método esta marcado como "abstract" e por isso não tem implemetação ?

Na linguagem java todo método declarado como "abstract" indica que esse método deverá ser implementado na primeira classe concreta que estender essa classe.

O comportamento é igual ao de uma interface. Até por que uma interface, para o compiladora java, é uma classe abstrata com métodos abstrados, mas isso é outra história.

Vamos ver uma classe que estende a GraficoTemplate.

Vamos ver a classe que gerar o grafico de Pizza:


A classe GraficoPizza estende a GraficoTemplate e, obrigatoriamente, implementa o método "carregarDados(List dados)".

É aqui, na classe filha, que é definido como será carregado o gráfico.

Simplesmente itero a lista e populo o objeto "grafico", que está definido como protected na classe GraficoTemplate.

Veja que nessa implementação eu usso o método "createPieChart3D" da classe ChartFactory.

Quando fomos implementar outra classe, como a GraficoLinha, esse método "carregarDados" será diferente.

Veja:

A implementação do método "carregarDados" na classe "GraficoLinha" está um pouco diferente.


Esse exempo é bem simples. Mas se você conseguiu entender a "lógica"do pattern com certeza irá utlizar muitas vezes esse.

O que fizemos aqui é delegar parte da lógica de gerar gráficos para suas classes filhas.

Você pode estar pensando que a lógica que está no classe GraficoTemplate é bem simples. E realmente é. Mas poderías implementar nela outros métodos como alterar as cores do gráfico, definir um padráo de tamaho, etc..

Isso seria simples e se aplicaria a todos os gráficos da aplicação.


Esse exemplo foi construído para explicar, de forma simples, a lógica de 1 padrão de projeto e como é vantajoso sua utilização.

Tem pontos da aplicação que estão "feias" quanto a Design. Como por exemplo, não ter utilizado interfaces e utlizar Array de object para transferir dos dados da View para os gráficos.


Mas, nem tudo é perfeito...heheheh

Conforme irei estudando os Design Patterns vou postando ai...

Mais uma vez: Críticas sempre são bem vindas, obrigado.

Abraço a todos!

1º dia do Curso de Spring

Acabei de chegar do meu 1º dia do curso de Spring na T@arget.

E achei ineteressante dar meu feedback aqui.

Falando primeiro da infra-estrutura da escola, só tenho um comentário: Tem que melhorar.

Depois vêm instrutor, Diego Pacheco. Esse cara é bom.

O balanço final é: O investimento, com certeza, valeu a pena. Não tenho dúvida que vou aprender bastante com ele.

Pra quem quiser ai vai o Blog do Diego Pacheco - http://diego-pacheco.blogspot.com/


Abraço!

API JavaComm é show di bola

Dea gurizada...

Esses dias fiz um esquema que achei bem interessante.

Através de um modem GSM( parecido com esse aqui) conectado a uma porta serial, dei alguns "toques" para celulares para avisar determinada ação de um usuário.

Fiz isso através de comandos AT. Pra falar a verdade nem imagnava que dava para fazer isso, até então.

Sei que você deve tar pensando: "Por que esse idiota não enviou uma mensagem?"

Reposta simples: Dar um toque não tem custo E se a pessoa atender eu termino a ligação no mesmo instante... :D

Apanhei um puco para trabalhar com o Buffer do modem. e Para fazer a ligação ser encerrada quando alguem atende o telefone. Mas consegui. Por questões éticas não vou postar o código.

Para fazer a comunicação com a porta COMM utilizei a API JavaComm, que é muito, mas muito fácil de usar.

Tinha pensando em fazer um tutorial, mas o tutorial do GUJ (link abaixo) está ótimo. Tem tudo que se precisa saber...

Links:

• API Documentation
• Reference API
• Tutorial do GUJ

Depois andei lendo pelos fóruns que tem alguns celulares que aceitam commandos AT. Isso significa que é possivel, por exemlpo, conectar o celular em um Note e controlar chamadas, enviar mensagens, etc..

Quando tiver mais informações posto por ai.


Bom fica ai a dica...


Abraço!

Criar uma aplicação com hibernate

Dae gurizada!!!

Esse é um post simples para quem quer confirguar uma aplicação para usar Hibernate com Annotations.

Eu usei o Netbeans 5.5 para montar esse exemplo. Será necessário fazer o download do Hibernate Annotations, que por sua vez precisa do Hibernate Core. Para os teste utilizei o Postgresql 8.2. Segue os links:

• Hibernate Core 3.2
• Hibernate-Annotations 3.3
• Postgresql 8.2
  

Abaixo está o link da aplicação exemplo:

• Aplicação exemplo (sem libs)
  

E só clicar nos links que irá direto para o local onde pode ser veito o download.


1º Passo: Criar o projeto

Esse artigo ainda foi feito no NetBeans 5.5. Para criar um novo projeto vá em Arquivo -> Novo Projeto. Selecione a categoria "Geral" e clique em Aplicação Java. Chamei o projeto de HibernateApp.

Crie uma pasta chamada de "lib" na raiz do seu projeto. A estrutura de diretórios vai ficar assim:


Criado o nosso projeto já criei alguns pacotes e classes. Veja:

Agora temos qu adicionar os jar necessários para a aplicação rodar. Se você notar, o hibernate tem um monte de JARs, mas nem todos são obrigatórios.

Abaixo estão quais os JARs devem estar na pasta LIB do nosso projeto. Vou separar os jars do Hibernate Core e do Hibernate Annotations, mas todos devem ser colocados na pasta LIB direto, não em subpastas.

Hibernate Core - 3.2.5GA:

• antlr.jar
• cglib.jar
• asm.jar
• asm-attrs.jars
• commons-collections.jar
• commons-logging.jar
• hibernate3.jar
• jta.jar
• dom4j.jar
• log4j.jar

Hibernate Annotations 3.3.0GA

• ejb3-persistence
• hibernate-commons-annotations
• hibernate-annotations

Postgresql 8.2

• postgresql-8.2-505.jdbc4

A minha pasta lib ficou assim:



Com os JARs na pasta lib ainda temos que adicionar ao projeto pelo Netbeans.
Para isso clique com o botão direito no nome do projeto e clieque em propriedades:

Depois clique em "Bibliotecas" e no botão "Adicionar Jar/Pasta" e localize os jars na pasta lib do nosso projeto:



2º Passo: Criar as classes - Entidades Persistentes.
É considerado "Entidade persistente" as classes que serão inseridas no banco de dados.

No nosso exemplo tenho duas classes que serão persistidas no banco de dados. A classe Pessoa e Endereco.

Veja com elas ficaram:

Explicação

@Entity: Toda classe persistente (POJO) deve user @Entity. Isso indica que a classe é uma entidade persistente(Entity Bean). Ou seja, existe uma tabela no banco de dados que representa essa classe. Por padrão o hibernate considera o nome da tabela igual ao nome da classe.

Caso sua classe possua um nome diferente ao nome da tabela, é necessário usar a anotaçao a seguir:

@Table: essa anotação é utiliza quando informamos o nome da tabela. Veja a classe Pessoa. O nome da classe é Pessoa, mas o nome da tabela no banco é TB_Pessoa.

@Id: Para o hibernate o ID é a forma de identificar o objeto (bem óbvio).
Os ID's podem ser gerados de várias formas dependendo do banco utilizado. O Postgresql, por exemplo, utiliza sequences. O MySQL tem um campo autoincrement e assim por diante.

Existem vários tipos de "generators". Veja esse link ou veja o meu outro post.

@Column: Essa anotação simplesmente indica qual coluna da tabela a propriedade irá referenciar. Por padrão todos os atributos da classe são pripriedades de tabelas.

@ManyToOne: esse atributo faz as relações entre as classes.

@JoinColumn: essa anotação indica qual coluna da classe Pessoa referencia a classe Endereço.

Agora um desenho para melhorar a compreensão:


3º Passo: Classe/Arquivo de configuração:

Você deve estar se perguntando:

- Por que esse retardado colocou "'classe/arquivo de configuração" ?

Simples! Existem as duas formas de configurar o hibernate. Na verdade são 3.. heheheh

hibernate.cfg.xml ou hibernate.properties: Até chegar o annotations e jpa o hibernate era configurado através de um arquivo xml ou .properties. Neste arquivo estão as informaões de conexão com o banco e as classes que serão mapeadas. Utiliza-se esse arquivo quando vamos utilizar somente o Hibernate Core.

persistence.xml: A especificação EJB3 definiu o arquivo padrão para configuração do mapemaneto objeto relacional. Este arquivo é semelhanto ao hibernate.cfg.xml ( e tambem foi baseado nele). Utiliza-se esse arquivo quando vamos utilizar o EntityManager.

Configuração programática (classe): Uma alternativa ao antigo hibernate.cfg.xml. Todas as configurações informadas no arquivo de configuração do hibernate, podem ser setadas em tempo de execução.

Nosso hibernate.cfg.xml

Vamos ver primeiro o arquivo de configuração.

Crie um arquivo "hibernate.cfg.xml" dentro da pasta src do seu projeto.

OBS inútil: esse arquivo do hibernate pode ter outro nome. É obrigatório o arquivo conter "cfg.xml".
Ex: "qualauernome.cfg.xml"
Mas o nome mais comum é "hibernate.cfg.xml".

Veja como fica o meu projeto no netbeans:


Criado o arquivo vamos ver a maldita configuração:
Explicação
connection.driver_class: Nome da classe do driver que será utilizado. No meu caso estou utilizando o postgresql.

connection.url: URL para conexão com o banco. connection.username: nome do usuário para conexão com o banco connection.password: senha para conexão com o banco
Até aqui são configuraçoes normais que você já deve ter usado para criar conexões com o banco via JDBC dirto.

connection.pool_size: Configuração do pool de conexão. No nosso caso o hibernate manterá sempre 1 conexão com o banco.

dialect (Importantíssimo): O hibernate gera o sql dinamicamente de acordo com o banco de dados utilizado. A forma do Hibernate saber para qual banco gerar o SQL é o "dialect". Veja aqui a tabela de "dialetos" do hibernate.
cache.provider_class: O hibernate possui um podero sistema de Cahce de objetos. Eu particularmente nunca utilizei. Se alguem quiser se aprofundar veja em:

• Second Level e query cache
• Second Level

show_sql: Com o valor "true" exibe todos os comandos SQL executados pelo hibernate no console da IDE e no arquivo de LOG, caso configurado.
Ótimo para achar erros.

hbm2ddl.auto(maravilhoso): Essa cara aqui é muito bom. Esta ferramenta do hibernate gera o schema para o banco de dados, ou seja, ele cria o banco de dados com os seus relacionados, chaves primárias, etc.. a partir das classes configuradas no hibernate. Essa ferramente é executado quando criamos o SessionFactory que veremos a seguir.

Algums valores:

create-drop: Cria as tabelas do banco quando o SessionFactory é iniciado e deleta a base de dados quao termina a executação. Muito cuidado ao usar essa configração com o banco de dados de produção..hehehehe

update: Atualizar colunas e tabelas do banco de dados. Essa configuração não deleta nenuma coluna, somente insere.

OBS: É necessário já estar criado o "database".


"mapping class":
Bom esse trecho não é bem uma configuração. Aqui estamos adicionando as classes que serão mapeadas no hibernate. Todas as classe que iremos mapear no hibernate tem que ser adicionadas na configuração.


Agora que foi entendido a configuração do hibernate vamos ver como fazer essa mesma configuração na classe:


Nessa classe criamos uma instância da classe AnnotationConfiguration que é a classe do hibernate que recebe configurações iguais ao do XML.

Veja que chamei o método "setProperty" para setar as propriedades.


4º Passo: Iniciar o Hibernate.

Eu criei uma classe chamda HibernateConfig com os métodos iniciarHibernateClasse(mostrado acima) e iniciarHibernateXML, abaixo.
A lógica para istânciar um objeto SessionFactory é a mesma com o arquivo de configuação e para a classe.

1º Criar o objto AnnotationConfiguration

2º Setar as configurações.
Classe: setar as configurações a partir do método setProperty

Arquivo cfg.xml: chamar o método configure() da classe AnnotationConfiguration. Este método irá carregar as configurações do arquivo e retornar um objeto do tipo Configuration.

3º Chamar o método
Classe: chamar o método "buildSessionFactory()" da classe AnnotationConfiguration.
Arquivo: chamar o método "buildSessionFactory()" do objeto retornado do método "configure()"


Se ficiu confuso esses passos veja a classe que vai ajudar.


Bom.. mais uma vez fica aqui meu pedido de críticas e sugestões...

No mais era isso...

Abração!