Aplicação utilizando Struts 2

Olá tudo bem ?
Nesse post irei criar uma aplicação simples utilizando o framework Struts 2.
Struts 2 é um framework baseado no padrão Front Controller e MVC (Model-View-Controller);

Antes de começar baixe as bibliotecas do Struts no site download faça o download do arquivo em seguida descompacte.

As bibliotecas obrigatória para utilização do Struts são:
• commons-io
• commons-fileupload
• commons-lang
• commons-logging
• commons-logging-api
• struts2-core
• xwork-core
• javassist
• ognl
• freemarker

Depois de baixar as bibliotecas do Struts segue os passos;

Crie um projeto Dynamic Web Project chamado Cadastro
Adicione as bibliotecas do Struts na basta lib dentro no diretório do projeto, selecione todas as bibliotecas, clique com botão direito Build Path > Add Build Path. Feito isso as bibliotecas ja estarão configurada para o projeto.

1.1 Crie um class PessoaAction dentro do package br.com.vejajava.actions

package br.com.vejajava.actions;

import com.opensymphony.xwork2.ActionSupport;

public class PessoaAction extends ActionSupport {

 private String nome;
 private int idade;

 @Override
 public String execute() throws Exception {
  if (this.idade >= 18 && this.nome.equals("Jardel")) {
   return PessoaAction.SUCCESS;
  } else {
   return PessoaAction.ERROR;
  }
 }
          // getters e setters
}

Para definimos uma classe Action temos veja que herdamos a classe ActionSupport, em seguida criamos dois atributos nome e idade e um metodo chamado execute que é da propria classe ActionSupport, no metodo colocamos uma condição só será possível fazer o cadastro se o nome da pessoa for Jardel (modifique para seu nome) e se a idade dele for maior ou igual a 18, no final retornamos SUCESS em casa de sucesso ou ERROR em casa de erro, essas constantes elas são herdadas da interface Action que a classe ActionSupport implementa. Esse tipo de abordagem é para não haver erros de digitação quando retornamos algum valor.

1.2 No seu arquivo web.xml adicione o filter do Struts

  struts2
  org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
 
 
  struts2
  /*
 

1.3 Crie um arquivo chamado struts.xml dentro do package src.

 
 
 
 /dados.jsp
 /erro.jsp
 
 
 

Apontamos no arquivos struts.xml nossa classe PessoaAction com o nome Pessoa, esse nome será usado nos formulário das view para que ela identifique para qual action está se relacionando. Em seguida temos dois result, em caso de success ela retornará a pagina dados.jsp e em caso de error retornará erro.jsp

1.4 Crie suas View JSP

Não esqueça de importa a taglib do struts

<%@ taglib prefix="s" uri="/struts-tags" %>

cadastro.jsp

Criamos um formulário para inserir o nome e a idade da pessoa no final temos um botão para enviar os valores inseridos

dados.jsp

 
Cadastrado com sucesso!

Se tudo ocorrer como o método espera em caso de success ele retorna a pagina dados.jsp

erro.jsp

 
ERROR

Em caso de error retorna a pagina erro.jsp

Antes de finalizar nossa aplicação crie outra view chamada index.jsp nessa view adicione o seguinte

< meta http-equiv="refresh" content="0;URL=cadastro.jsp" >

Quando rodarmos a aplicação diretamente do projeto ela direciona para a pagina cadastro.jsp
não esqueça de adicionar no web.xml o seguinte

  index.jsp
 

É isso pessoal esse foi meu primeiro post sobre struts logo mais irei postar algo mais avançado com acesso ao banco.

Obrigado pela visita = D

Instalando e Configurando o Maven

Ciclo de vida

process-resources (processar recursos)
compile (compilar)
process-test-resources (processar recursos de teste)
test-compile (testar compilação)
test (testar)
package (empacotar)
install (instalar)
deploy (implantar)

Instalação
Para instalar o Maven acesse o site http://maven.apache.org/download.cgi
baixe o arquivo apache-maven-3.0.5-bin.zip, ap ós concluir a instalação descompacte o arquivo.
Mova a pasta descompactada para dentro da pasta "Arquivos de Programas" (opcional);

Configurando as Variavéis de Ambiente
1. Clique com o botão direito no ícone "Meu Computador" > Propriedades".
2. Clique em Configuracões avançadas dos sistemas", na nova aba clique em Avançada" > Clique no botão "Variáveis de Ambiente";
3. Na lista, vari avéis do sistema clique no botão Novo "para criar uma nova vari ável".
4. Digite no campo "Nome da vari ável" MAVEN_HOME e no campo 'Valor da variável' digite o diretório do seu arquivo C:/Arquivos de programas/apachemaven-3.0.4 - "OK";
5. Crie outra variável com nome M2 e no valor adicione %MAVEN_HOME%\bin
5. Selecione a vari avel "Path" na lista de "Vari áveis do Sistema"e clique no botão "Editar";
6. No final do Valor da variável Digite > ;%M2%
7. Clique no botão "OK > "OK".

Testando no Prompt de comando
Abra o Prompt digite mvn --version | Se sua configuração estiver correta vai aparecer a versão do Maven que foi instalado no windows.

Possível ERRO:
\'mvn' não e reconhecido como um comando interno ou externo, um programa operável ou um arquivo em lotes" verifique a configuração das variáveis se estão correta de acordo com o seu diretório do apache-maven.

Instalando o Maven no Eclipse
Acesse o menu do Eclipse, Help > Eclipse MarketPlace > no campo Find digite \Maven" > \GO". Aparecer a varias opções de Maven para downloads procure pelo o Maven "Maven Integration for Eclipse" clique no botão Install para fazer a instalação, depois de concluí da a instala cão, o eclipse vai pedir para reiniciar.

Obrigado pela visita = D

Certificacao OCJP

Olá tudo bem ?

Venho compartilhar com vocês o meu estudo para certificação OCJP (Oracle Certified Java Programmer) meu objetivo é tirar a certificação em Dezembro de 2013. Comecei os estudos mais precisamente na Terça-Feira dia 17/09 e para compartilhar o conteúdo criei um repositório no github.com quem se interessar para ver todo material é só fazer o fork do projeto, todos as classes estão comentada explicando cada assunto, se houver alguma dúvida é só postar nos comentário ou enviar um email, meu email: jardelrodrigues93@gmail.com quem tem esse objetivo podemos fazer uma "parceria" e dividi os assuntos a ser estudado, seria bem bacana =D;

Segue o link do projeto: Certificação OCJP

Obrigado a todos!

Vídeo Aula, Aplicação simples utlizando JSF+JPA+Hibernate

Criando repositório GitHub + Git + Eclipse

Olá tudo bem?

Segue o link abaixo da vídeo aula sobre como criar um repositório no GitHub importar para o Eclipse e depois fazer o clone com Git Bash, e atraves do Git Bash enviar os commit para o GitHub.

Obrigado pela visita = D

Mapeamento de entidade ManyToMany

Olá tudo bem ?

Para concluir o post de mapeamento de entidade com hibernate, relacionamento ManyToMany (Muitos para Muitos).

Como exemplo vamos fazer um relacionamento entre Cliente e Produto.
Vários Cliente pode ter vários Produtos e vários Produto pode ter vários Clientes.

Crie um database no banco de dados chamada manytomany.
Crie um projeto Dynamic Web Project chamado MapeamentoManyToMany adicione as lib do hibernate no projeto e configure o arquivo persistence.xml para se comunicar com a database.

persistence.xml

1.1 Crie uma classe chamada Cliente dentro do package br.com.vejajava.entidades

@Entity
@Table(name="cliente")
public class Cliente {

@Id
@GeneratedValue(strategy= GenerationType.AUTO)
private Long codigo;

private String nome;

@ManyToMany
@JoinTable(name = "cliente_produto", joinColumns = {@JoinColumn(name = "cod_cliente")}, 
inverseJoinColumns ={@JoinColumn(name = "cod_produto")})
private List produtos = new ArrayList();

//getters e setters
}

Observe que no mapeamento com a classe produto temos a anotação @JoinTable essa anotação é opcional, caso você não declare ela criará o nome da classe seguida de "_" mais um novo da classe que está sendo mapeada.

Veja que temos também a anotação @JoinColumns e @InverseJoinColumns elas define o quais colunas fazem parte da chave primaria.

1.2 Crie uma classe chamada Produto dentro do package br.com.vejajava.entidades

@Entity
@Table(name = "produto")
public class Produto {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long codigo;

private String descricao;

@Column(scale = 2, precision = 4)
private double preco;

//getters e setters
}

Observe a anotação @Column seguida de scale e precision.
A anotação scale: define a quantidade de casas decimais e anotação.
A anotação precision: define a quantidade de digitos que serão armazenados.

Como estamos mostrando um relacionamento Uniderecional a classe Produto nao terá o mapeamento para a classe Cliente.

1.3 Crie uma classe ManyToMany dentro do package br.com.vejajava.principal

Vamos adicionar alguns produtos e fazer o relacionamento com os clientes.

EntityManagerFactory factory = Persistence.createEntityManagerFactory("MapeamentoManyToMany");
EntityManager manager = factory.createEntityManager();

manager.getTransaction().begin();

Produto p1 = new Produto();
p1.setDescricao("Açucar");
p1.setPreco(1.50);

Produto p2 = new Produto();
p2.setDescricao("Macarrão Favorita");
p2.setPreco(1.50);

Cliente c1 = new Cliente();
c1.setNome("Maria");
c1.getProdutos().add(p1);
c1.getProdutos().add(p2);

Cliente c2 = new Cliente();
c2.setNome("José");
c2.getProdutos().add(p2);

manager.persist(p1);
manager.persist(p2);
manager.persist(c1);
manager.persist(c2);

manager.getTransaction().commit();

manager.close();
factory.close();

Verifique no banco de dados que foi criado três tabelas
Cliente: Temos dois cliente cadastrado.
Produto: Temos dois produtos cadastro
Cliente_Produto: Aonde o codigo do cliente se referencia ao codigo do produto, observe que no cliente Maria adicionamos dois produtos por isso na tabela ele faz o relacionamentos para os dois produtos cadastrado.

mysql> select * from cliente;
+--------+-------+
| codigo | nome |
+--------+-------+
| 1 | Maria |
| 2 | José |
+--------+-------+

mysql> select * from produto;
+--------+--------------------+-------+
| codigo | descricao | preco |
+--------+--------------------+-------+
| 1 | Açucar | 1.5 |
| 2 | Macarrão Favorita | 1.5 |
+--------+--------------------+-------+

mysql> select * from cliente_produto;
+-------------+-------------+
| cod_cliente | cod_produto |
+-------------+-------------+
| 1 | 1 |
| 1 | 2 |
| 2 | 2 |
+-------------+-------------+


Obrigado pela visita = D

Primeiros passos utilizando Controle de Versão Git

Olá tudo bem ?

Nesse post irei falar um pouco sobre o controle de versão Git, o objetivo desse post é mostrar alguns comandos básico para começar a utilizar git.

Instalação

Windows:
https://code.google.com/p/msysgit/downloads/list?can=3

Baixe o arquivo Git Preview e siga os passo a passo da instalação.

Next >
Escolha o local pra ser instalado >
Marque a opção Context menu entries para que ele gere o Git Bash e Git Gui >
Next >
Marque a terceira opção Run Git And inclued unix... para que o git possa ser utilizado tambem no prompt de comando >
Marque a terceira opção Checkout as-is commit as-is >
Instalação concluida.


Geração de chaves públicas

//Gerar par de chave
ssh-keygen

//Cria no diretório do seu usario dus chaves id_rsa e id_rsa.pub
//Arquivo id_rsa é a chave privada a chave privada garante que só voce pode abrir algum arquivo especifico, 
//já a chave publica id_rsa.pub pode ser compartilhada com outros desenvolvedores.

//Depois de criar as chaves publica voce pode escolher uma senha para quando for utilzar uma chave pública (opcional)

//Para gerar sua chave publica execute
cat ~/.ssh/id_rsa.pub

Irá gerar algo como:

ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEApWFJ+ChIJB1LrWRWECFhCbPI/crhCcT6cpZaiTkuibMO
/vteUWO3uk3laX/8/Oya7jEEILLFaUAVGStoAOJbhXA2GjAnV4SiuNHDGQHEyzZ8T4z5FF5KtA2cswTl
Ve64QZm+rnzMQ6EuI2g7WrgP+X+seqdi8i5561NOZ0fg5tFsnVtIOpX9Pp6yVYJmXRuxgzDpZ8ZNwgcv
1+WXNMrIINUuojDNG92aee9BwXDPzw6DX1umPSojNv6thsyivxAqeHBejO9QSRxSJgimoGVPHxEtR4SV
tLKGpmlz9bsxGJTiUMjjAA9llV0zI4YURrA8QKGAxUBHlGwmPwg1tMYdbw== JardelJava@JARDEL-J

//A chave publica é utilizada para adicionar em uma conta no github, repositório remoto usa ssh para se comunicar.

Alguns comandos básico do git:

//É preciso definir nome e email para poder utilizar o git
git config --global user.name 'seunome'
git config --global user.email 'seuemail@email.com'

//Criar um novo repositório 
git init

//Verifica todos os arquivos que já foi colocado no índice ou que ainda não foram colocados.
//Arquivos verde: Foi adicionado no índice
//Arquivos vermelho: Não foi adicionado no índice
git status

//Clonar um repositorio
https:/github.com/caminho/repositorio.git

//Adiciona repositório local do github
git remote add origin git@github.com:nome/repositorio.git

- Repositório

- Índice

- Working Area

//Adiciona os arquivos para dentro do índice
git add (arquivo)

//Adiciona todos os arquivos para dentro do índice
git add .

//Pega o que está dentro do índice e joga para o repositório
git commit -m 'mensagem'

//Retira arquivo novo do índice
git rm --cached

//Retira arquivo modificado do índice
git reset HEAD

//Ver arquivo alterado que ainda nao foi selecionado
git diff

//Ver o que selecionou para ser commitado
git diff --cached

//Descarta arquivos que ainda não foi adicionado no índice
git clean -f

//Retira arquivo que já existia no repositório que estava no índice
git checkout

//Histórico de todos commit
git log

//Adiciona os arquivos no commit anterior
git commit -m 'mesmocommit' --amend

//Apaga o último commit
git reset HEAD~1 --hard

//Guarda todos os arquivos apagados
git reflog

ex:
76fk2c 
11bd4h
34g6hb

//Recupera commit apagado
git merge 76fk2c

//Para enviar alterações feitas ao seu repositorio remoto
git push origin master

//Atualiza arquivos do repositório
git pull

//Pega os arquivos do projeto que ainda nao foi adicionado no servidor remoto origin
git fetch origin 

//interface gráfica
gitk

Obrigado pela visita =D

Mapeamento de Herança com Hibernate

Olá tudo bem ?

Nesse post irei falar sobre Mapeamento de Herança com Hibernate.

As três estratégia que pode ser feita para realizar o mapeamento de herança:

1.1 SINGLE TABLE
1.2 JOINED
1.3 TABLE PER CLASS

Antes de começar a apresentar cada um, irei mostrar qual exemplo iremos fazer para testar cada estratégia.

Vamos fazer um exemplo com Pessoa, Professor e Aluno.
Pessoa será a super classe seguidas das sub classe Professor e Aluno.

1.1 Single Table: Essa estratégia é a mais utilizada e possibilita um maior desempenho para realizar consultas no banco de dados.

Pessoa.java

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public abstract class Pessoa {
 
 @Id
 @GeneratedValue
 private Long codigo;
 
 @Column(name="nome")
 private String nome;
        
          //getters e setters
}

Professor.java

@Entity
public class Professor extends Pessoa {

 private String disciplina;
 
 @Column(name="carga_horaria")
 private int cargaHoraria;

          //getters e setters
}

Aluno.java

@Entity
public class Aluno extends Pessoa{
 
 private String turma;

         //getters e setters
}

Todas as classe tem anotação @Entity para que seja criada as tabelas no banco de dados. Como estamos usando a estratégia SINGLE_TABLE só será criada uma única tabela com todos os campos de todas as classes que extends da classe Pessoa.
A classe Pessoa foi criada como classe abstract para que ela não possa ser instanciada, porque não faz sentido instanciar uma classe do tipo Pessoa, sendo que não temos um tipo Pessoa definido.
Ex: O mesmo seria um exemplo de uma super Classe Animal aonde é seguida por suas sub classe Cachorro, Gato etc.. Não faz sentido instanciar uma classe do tipo animal, que tipo de animal é esse?

Observe a anotação @Inheritance seguida por (strategy = InheritanceType.SINGLE_TABLE) essa anotação serve para definir o tipo Single_Table.

Faça o teste:

public class Principal {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Herança");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Professor professor1 = new Professor();
  professor1.setNome("Rafael Braga");
  professor1.setDisciplina("Programação para Internet");
  professor1.setCargaHoraria(20);
  
  Aluno aluno1 = new Aluno();
  aluno1.setNome("Jardel");
  aluno1.setTurma("ADS");
  
  manager.persist(professor1);
  manager.persist(aluno1);
  
  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Verifique no banco de dados a tabela criada e seus valores.

Veja que foi criado uma coluna do tipo DTYPE, ela é utilizada para identificar qual tipo de objeto se refere a qual classe.

Desvantagem: A desvantagem desse tipo de estratégia é que consumo de espaço desnecessário na tabela.
Quando cadastramos o Professor veja que o campo turma da classe Aluno também está na tabela e não tem nenhum valor. Ou seja ele está ocupando espaço e não vai ser utilizado.
O mesmo acontece quando cadastramos Aluno, os campos da classe Professor também aparece na tabela ocupando espaço e não vai ser utilizado.

1.2 JOINED: Essa estratégia ela cria um tabela para cada classe que extends da classe principal.
No nosso exemplo será criado as tabelas da classe Pessoa, Professor e Aluno.

@Entity
@Inheritance(strategy = InheritanceType.JOINED)

Desvantagem: As consultas para esse tipo de estratégia são lentas, será necessário utilizar operação de join, para pegar os dados cadastrado nas tabelas.
Informações sobre consultas utilizando Join, Inner Join, Left Join no link clique aqui

1.3 TABLE PER CLASS: Essa estratégia uma tabela para as classes concreta é criada.

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)

Modifique também o tipo de valor gerado que está sendo utilizado na tabela Pessoa.

@Id
@GeneratedValue(strategy = GenerationType.TABLE)
private Long codigo;
 

Desvantagem: Não existe informações de uma tabela para outra. Veja que temos agora a anotação @GeneratedValue(strategy = GenerationType.TABLE) não podemos mais utilizar geração automática de chave primária.


Obrigado pela visita =D

Duvidas, Críticas e Sugestões, só comentar ;)

Mapeamento de entidade com Hibernate

Olá tudo bem ?

Nesse post vou falar sobre mapeamento de entidades com hibernate.

Primeiramente crie um projeto Dynamic Web Project na IDE, adicione os jar do hibernate, tambem nao esqueça de adicionar o jar do banco de dados.

Configure o arquivo persistence.xml, para adicionar ao seu projeto (alt + enter) em cima do projeto > Project Facets > marque a opção JPA > Aplly > OK.

Crie uma database mapeamento

persistence.xml

Verifique o usuario e a senha do seu banco se corresponde com a mesma utilizada.

1.1 OneToOne
1.2 OneToMany
1.3 ManyToOne
1.4 ManyToMany

Vamos começar com relacionamento OneToOne (Um para Um).

1.1 OneToOne

No relacionamento OneTone (Um para Um), irei fazer como exemplo um relacionamento entre País e Presidente se "em caixa" perfeitamente nessa condição, aonde um País pode ter apenas um Presidente e um Presidente só pode administrar um País.

1.1.1 Vamos criar uma classe chamada País dentro do package br.com.vejajava.entidades

@Entity
@Table(name="pais")
public class Pais {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 private String capital;
 
 @OneToOne
 private Presidente presidente;
 
 
 @Column(name="lingua_oficial")
 private String linguaOficial;
 
 private String populacao;

         // getters e setters
}

Podemos ver que na nossa classe País temos a anotação @OneToOne isso faz com que o relacionamento entre Pais e Presidente aconteça no banco de dados.
Observe que o tipo de dado que é feita no relacionamento com Presidente é do tipo Presidente e não um tipo primitivo.

1.1.2 Vamos criar uma classe chamada Presidente dentro do package br.com.vejajava.entidades

@Entity
@Table(name="presidente")
public class Presidente {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 @OneToOne
 private Pais pais;

         // getters e setters

Observe que temos o mesmo tipo referenciado na classe Presidente, com anotação @OneToOne isso faz com que o relacionamento entre Pais e Presidente aconteça no banco de dados.

Temos que definir qual classe mandará no relacionamento.

Para resolver esse problema temos um elemento chamado mappedBy que é um relacionamento bidirecional, significa que tanto na classe Pais como na classe Presidente podemos carregar-lás.
Lembrando que toda a classe que faz um relacionamento e tenha essa função (mappedBy) ela nao mandará no relacionamento.

O relacionamento na classe Presidente ficará assim:

@OneToOne(mappedBy= "presidente")
private Pais pais;

No exemplo feito teria a foreing key presidente_id na tabela Pais, para modificar o nome desse campo existe uma anotação chamada @JoinColumn.

Ex:

@JoinColumn(name="pres_id")

1.1.3 Vamos criar uma classe chamada TesteOneToOne dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteOneToOne {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Presidente presidente = new Presidente();
  presidente.setNome("Dilma R");
  
  Pais pais = new Pais();
  pais.setNome("Brasil");
  pais.setCapital("Brasília");
  pais.setLinguaOficial("Português");
  pais.setPopulacao(193.946886);
  
  pais.setPresidente(presidente);
  
  manager.persist(pais);
  manager.persist(presidente);
  
  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Podemos observa que criamos uma instancia de Presidente e Pais e passamos os valores para eles.
Observe que pais.setPresidente(presidente) ele pega o valor passado quando criamos um novo Presidente.
Nao podemos fazer o mesmo para Presidente pois quem manda no relacionamento é classe País.

Observe que temos que persistir os dois objetos

manager.persist(pais);
manager.persist(presidente);

Com o elemento (Cascade = CascadeType.PERSIST) na classe Pais so bastaria persist o objeto do tipo Pais.

Veja como ficaria o elemento Cascade.

@OneToOne(cascade = CascadeType.PERSIST)
private Presidente presidente;

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from pais;
+----+-----------+----------------+--------+------------+---------------+
| id | capital | lingua_oficial | nome | populacao | presidente_id |
+----+-----------+----------------+--------+------------+---------------+
| 1 | Brasília | Português | Brasil | 193.946886 | 1 |
+----+-----------+----------------+--------+------------+---------------+
mysql> select * from presidente;
+----+---------+
| id | nome |
+----+---------+
| 1 | Dilma R |
+----+---------+

1.2 OneToMany

No relacionamento OneToMany(Um para Muitos), irei fazer como exemplo um relacionamento entre Escola e Aluno se "em caixa" perfeitamente nessa condição, aonde uma Escola pode ter vários Alunos.

1.2.1 Vamos criar uma classe chamada Escola dentro do package br.com.vejajava.entidades

@Entity
@Table(name="escola")
public class Escola {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;

        @OneToMany(cascade = CascadeType.PERSIST)
 private Collection alunos = new ArrayList();
 
       //getters e setters
}

Observe que na classe Escola só temos 2 atributos, coloquei apenas esses dois pra entender melhor o relacionamento.
Temos uma Coleção de Alunos seguido da anotação @OneToMany, (Um para Muitos) aonde uma Escola pode ter varios alunos, temos também o elemento cascade = CascadeType.PERSIST faz com que quando o objeto escola for persistido ele automaticamente persist todos os campos que está fazendo o relacionamento entre escola e aluno. Esse relacionamento so pode ser carregado na classe Escola pois nao é um relacionamento bidirecional, para que seja um relacionamento bidirecional seria necessário adicionar o mappedyBy no relacionamento @OneToMany.

1.2.2 Vamos criar uma classe chamada Aluno dentro do package br.com.vejajava.entidades

Nessa classe vamos aprofundar mais um pouco e entender a anotação @Embedded

@Entity
@Table(name="aluno")
public class Aluno {
 
 @Id
 @GeneratedValue
 private Long id;
 
 private String nome;
 
 @Embedded
 private Endereco endereco;
         
         //getters e setters
}

Observe que na classe Aluno temos a anotação @Embedded essa anotação faz com que eu possa criar uma classe com as informações do endereço do aluno, sem a necessidade de criar outra tabela. Ela pega todos os atributos da classe endereco que será criada e coloca dentro da propria tabela aluno, essa é uma maneira muito interessante para organização do seu sistema.
Criando uma classe para colocar todas as informações de endereço para organizar, caso houver que mudar algum campo que referencia o endereco do aluno só precisaria alterar a classe endereco;

1.2.3 Vamos criar uma classe chamada Endereco dentro do package br.com.vejajava.entidades

@Embeddable
public class Endereco {

 private String rua;
 
 private int numero;
 
 private String cep;
      
         //getters e setters
}

Observe que no lugar da anotação @Entity temos a anotação @Embeddable isso faz com que nao seja criado uma tabela endereco no banco de dados e todos os campos dessa classe será criado na tabela Aluno, veja também que não precisamos definir uma primary key para essa classe.

1.2.4 Vamos criar uma classe chamada TesteOneToMany dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteOneToMany {
 
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Endereco endereco = new Endereco();
  endereco.setRua("Rua 27");
  endereco.setCep("65364-972");
  endereco.setNumero(444);
  
  Aluno aluno = new Aluno();
  aluno.setNome("Maria Eduarda");
  aluno.setEndereco(endereco);
  
  Escola escola = new Escola();
  escola.setNome("São Francisco das Chagas");
  escola.getAlunos().add(aluno);
  
  manager.persist(escola);
  manager.getTransaction().commit();
  manager.close();
  factory.close();
  
 }

Criamos uma instancia de endereco e passamos os valores nos campos.
Observe que a partir de aluno conseguimos pegar todos os valores passado na classe endereco com aluno.setEnderco(endereco).
Fizemos o mesmo para escola, instanciamos a classe passamos os valores e adicionamos na coleção o objeto aluno para que o id do aluno seja referenciado na tabela.

Observe no banco de dados que foi criado uma terceira tabela chamada escola_aluno aonde é passado o id da escola e o id de aluno.

Veja tambem que nao foi preciso persistir o objeto aluno, o elemento cascade = CascadeType.PERSIST como foi explicado anteriormente ele persist todos os objetos que se referencia a classe escola e aluno.

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from aluno;
+----+-----------+--------+--------+---------------+
| id | cep | numero | rua | nome |
+----+-----------+--------+--------+---------------+
| 1 | 65364-972 | 444 | Rua 27 | Maria Eduarda |
+----+-----------+--------+--------+---------------+

mysql> select * from escola;
+----+---------------------------+
| id | nome |
+----+---------------------------+
| 1 | São Francisco das Chagas |
+----+---------------------------+

mysql> select * from escola_aluno;
+-----------+-----------+
| escola_id | alunos_id |
+-----------+-----------+
| 1 | 1 |
+-----------+-----------+


1.3 ManyToOne

No relacionamento ManyToOne (Muitos para UM), irei fazer como exemplo um relacionamento entre Filme e Categoria se "em caixa" perfeitamente nessa condição, aonde muitos Filme pode ter uma Categoria.

1.3.1 Vamos criar uma classe chamada Filme dentro do package br.com.vejajava.entidades

@Entity
@Table(name = "filme")
public class Filme {

 @Id
 @GeneratedValue
 private Long id;

 private String nome;

 @Temporal(TemporalType.DATE)
 @Column(name="data_cadastro")
 private Date dataCadastro;

 @ManyToOne
 private Categoria categoria;

           //getters e setters
}

Observe que temos uma anotação que ainda nao foi usada no projeto. @Temportal(TemporalType.DATE) no campo dataCadastro. A anotação TemporalType.DATE faz com que seja salvo no banco de dados a seguite data 2013-08-28.
Tambem temos anotação @ManyToOne que faz com que mais de um filme pode ter uma categoria.

Outros tipos de TemporalType:
TemporalType.DATE = data (dia, mês e ano).
TemporalType.TIME = Horário (hora, minuto e segundo)
TemporalType.TIMESTAMP (Padrão) = Data e Horário

1.3.2 Vamos criar uma classe chamada Categoria dentro do package br.com.vejajava.entidades

@Entity
@Table(name="categoria")
public class Categoria {
  
 @Id
 @GeneratedValue
 private Long id;
 
 private String descricao;

           //getters e setters
}

Na classe categoria temos apenas o campo id que se refere a primary key da tabela e a descricao que será o nome categoria.

1.3.3 Vamos criar uma classe chamada TesteManyToOne dentro do package br.com.vejajava.principal para fazer o teste do nosso relacionamento.

public class TesteManyToOne {
 public static void main(String[] args) {
  
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("Mapeamento");
  EntityManager manager = factory.createEntityManager();
  
  manager.getTransaction().begin();
  
  Categoria categoria = new Categoria();
  categoria.setDescricao("Infantil");
  
  Filme filme = new Filme();
  filme.setNome("Pokémon");
  filme.setDataCadastro(new Date());
  filme.setCategoria(categoria);
  
  manager.persist(filme);
  manager.persist(categoria);

  manager.getTransaction().commit();
  
  manager.close();
  factory.close();
 }
}

Instanciamos a classe categoria e passamos o valor no campo descricao.
O mesmo foi feito na classe Filme o campo data ao ser salvo no banco registrará a data atual do máquina.
Veja também que passamos o valores da Categoria para o objeto filme.
Persistimos os dois objetos e depois fizemos o commit.

Se tudo ocorrer bem no seu banco de dados vai ter os seguintes valores:

mysql> select * from filme;
+----+---------------+----------+--------------+
| id | data_cadastro | nome | categoria_id |
+----+---------------+----------+--------------+
| 1 | 2013-08-28 | Pokémon | 1 |
+----+---------------+----------+--------------+

mysql> select * from categoria;
+----+-----------+
| id | descricao |
+----+-----------+
| 1 | Infantil |
+----+-----------+

o tópico 1.4 ManyToMany vou explicar criando o projeto exclusivo para esse mapeamento em outro post.

Obrigado pela visita.

Duvidas, Criticas e Sugestões ?

=D

Projeto simples Hibernate + JPA + MySQL

Olá tudo bem ?

Nesse post iremos ver alguns comandos para manipular entidades.

Vamos criar um projeto simples utilizando Hibernate + JPA + MySQL.

1.1 Crie um projeto Java Project chamado Pessoa

Criado o projeto primeiramente crie uma pasta chamada lib para adicionar os jar do hibernate e o driver MySQL.
Dentro do arquivo lib coloque os jar e lembrando novamente nao esqueça de adicionar o jar do banco que irá utilizar.

Abra o arquivo persistence e adicione as seguintes configurações.
Dica: Adicione JbossTools na IDE que facilita a configuração.

1.2 Abra o MySql e crie a database Aula1

create database Aula1

1.3 Crie uma classe Pessoa dentro de um package chamado br.com.vejajava.entidades

@Entity
@Table(name="pessoa")
public class Pessoa {
 
 @Id
 @GeneratedValue
 private Long id;
 
 @Column(name="nome", length=50, nullable=false)
 private String nome;
 
 @Column(name="idade")
 private Integer idade;

 //get e set

dica para gerar get e set mais rapido.
Ctrl + 3 digite gg select getters and setters >select all > ok.

Se voce tiver adicionado o JPA no project, veja que está dando um erro na classe, isso porque temos que adicionar no arquivo persistence a classe que está sendo mapeada. Para isso adicione antes de propreties

br.com.vejajava.entidades.Pessoa

@Entity funciona para que a classe que está sendo mapeada seja criada no banco de dados.
@Table no meu caso nao era necessaria, se nao tivesse ela criaria a tabela pessoa automaticamente com p 'minusculo', coloquei so para melhor entendimento, poderia modificar o nome da classe para "tb_pessoa".
@Id O atributo que tem essa anotação sera a chave primária da tabela.
@GeneratedValue esse campo será um auto incremente. por padrão ele utiliza Auto incremente. Mas você pode modificar para identity basta passar a seguinte anotação (strategy = GenerationType.IDENTITY).
@Column foi passado 3 valores name que vai representar qual nome que esse atributo vai ter na minha classe, length o tamanho dele e nullable que nao permite valor null.

1.4 Crie uma classe PessoaMain dentro do package br.com.vejajava.principal

Persistindo

public class PessoaMain {
 public static void main(String[] args) {

  EntityManagerFactory fabrica = Persistence.createEntityManagerFactory("Aula1");
  EntityManager manager = fabrica.createEntityManager();

  manager.getTransaction().begin();
  
  Pessoa p1 = new Pessoa();
  p1.setNome("José");
  p1.setIdade(50);
  
  manager.persist(p1);
  manager.getTransaction().commit();
  
  manager.close();
  fabrica.close();
 }
}

Criamos uma fabrica de entityManager depois pegamos a configuração do banco de dados que está no arquivo persistence e passamos no parametro o nome persistence-unit que identifica o arquivo.

Depois iniciamos uma transação com begin;
criarmos um objeto p1 do tipo Pessoa;
passamos alguns valores para eles;
persistimos esses valores;
commitamos para o banco de dados;
fechamos a conexão do manager.

Verifique no banco de dados a tabela pessoa criada.
Faça um Select * from Pessoa para verificar todos os campos cadastrado.

Buscando

Utilizando método find para buscar dado cadastrado.

Pessoa p1 = manager.find(Pessoa.class, 1L);  
System.out.println(p1.getNome());

Veja na saída do console o nome da pessoa cadastrada no banco de dados, no meu exemplo: José

Estamos utilizamos apenas o find, mas poderiamos buscar os dados utilizando o getReference. Lembrando que no getReference voce deve passar uma referencia ao objeto, no caso p1. String nome = p1.getNome();
Vamos ver em outros post a diferença entre find & getReference e ver quando eles passa para um estado Managed e o tipo do seu comportamento. (EAGER E LAZY)

Alterando

Pessoa p1 = manager.find(Pessoa.class, 1L);  
p1.setNome("Carlos");
p1.setIdade(22);

Alteramos o nome da Joao para Carlos e a sua idade.

Podemos também utilizar uma funcionalidade muito poderosa do hibernate que é a chamada Query.
Com a Query podemos realizar consultas ao banco de dados.

Listando

Query query = manager.createQuery("select p From Pessoa p");
List pessoas = query.getResultList();
for (Pessoa pessoa : pessoas) {
System.out.println("Nome: " + pessoa.getNome() + "\nIdade: " + pessoa.getIdade());
}

Podemos tambem limitar o numero de resultado cadastrado no banco.
OBS: Insira mais pessoas no banco de dados para fazer o teste.
Vamos supor que temos 10 pessoas cadastrada no banco de dados e que nao gostariamos de buscar todos eles e sim apenas os 3 primeiros.
Utilizando o metodo setMaxResults voce consegue capturar quantos objetos voce quiser do banco.

A vantagem de utilizar esse tipo de consulta é que o hibernate ele contem sua propria linguagem de consulta chamada JPQL, que serve para buscar os dados de qualquer tipo de linguagem de banco de dados, entao nao importa se voce está utilizando o banco MySQL, SQL, Oracle, que ele consegue atraves da sua propria JPQL buscar os dados cadastrado no banco de dados.

Query query = manager.createQuery("Select p From Pessoa p order by p.nome asc");
query.setMaxResults(3);
List pessoas = query.getResultList();
for (Pessoa pessoa : pessoas) {
System.out.println("Nome: " + pessoa.getNome() + " \nIdade: " + pessoa.getIdade());

Veja que passamos no parametro createQuery a consulta que queremos realizar, buscar todos o dados cadastrado no banco de dados e utilizando o ordey by para que ele ordene por nome os dados cadastro para fazer a consulta. Lembrando que o metodo setMaxResult ele busca os primeiro dados cadastro.

Removendo

Pessoa p1 = manager.find(Pessoa.class, 3L);
manager.remove(p1);

Verifique no banco que foi removido o objeto que tinha a ID 3;

É isso galera, espero que tenham entendido. Q
Qualquer duvida só postar nos comentários.

Obrigado, até a proxíma!

Criticas e Sugestões são bem vindas para melhorar o blog ;)

Obrigado pela a visita. =D