Projeto Java Desktop com Maven 3º Post

Olá galera,

Para este post estarei criando nossas entidades para damos inicio a parte legal do projeto.

Bom como disse é sistema vai ser algo bem simples e por se tratar de algo que servirá de estudos para iniciantes em programação vamos fazer um cadastro de cidades e estados.

Particularmente não faço este tipo de cadastro em nenhum de meus sistemas, deixar com que o usuário efetue tal tipo de cadastro pode gerar inconsistência no banco de dados, pois, damos ao o usuário o poder de cadastrar cidades e estados que não existem, além de cidades em estados errados. Exemplo claro, o usuário por engano cadastrar Porto Alegre no estado de São Paulo, isto seria um problema e tanto não dando nenhuma credibilidade a informações que nosso sistema fornecerá. Neste caso prefiro inserir cidades e estados diretamente no banco evitando este tipo de problema. Pense pelo seguinte é muito difícil surgir estados e cidades novas do dia pra noite e caso surgir, não é nada fora do comum inserir diretamente no banco um estado e cidade nova. Lembrando opinião particular todo caso gera exceções, por isso analisem bem sua regra de negocio antes de sair criando classes e programando.

Dando sequencia e começando pela entidade estado.

No pacote br.com.meuprimeroprojeto.modelo, vamos criar uma nova classe Java e dar nome a ela de Estado.

Primeiro passo e o mais importante, definir os atributos que nosso estado irá ter. No nosso caso, nome e sigla ficando conforme abaixo.


package br.com.meuprimeiroprojeto.modelo;

/**
*
* @author Fernado
*/

public class Estado {
private Long idEstado;
private String nome;
private String sigla;
}

Feito isso criaremos uma nova classe Java e daremos o nome a ela de Cidade. No caso, somente o nome, porém aqui entra uma coisa interessante. Java é uma linguagem orientada a objetos, para quem não intende orientação a objetos lei este POST, acredito que irá ajudar. Neste caso já possuímos um objeto Estado e se formos pensar, toda cidade fica dentro de um Estado certo?

Neste caso nossa classe cidade ficará da seguinte forma.

package br.com.meuprimeiroprojeto.modelo;

/**
*
* @author Fernado
*/

public class Cidade {
private Long idCidade;
private String nome;
private Estado estado;
}

Bem como o post não ficou extenso vamos fazer o mapeamento objeto relacional das classes pra que o Hibernate crie as tabelas de nosso banco de dados.

Para fazer o mapeamento usaremos algumas Annotations.

Vamos lá:

@Entity: Informa que a classe mapeada é persistente

@Id: Definição de chave primária.

@GeneratedValue: Permite a geração de forma automática para o valor identificador baseados nos mecanismos de geração automática que existem no Hibernate. @GeneratedValue(strategy=”GenerationType.IDENTITY”)  Para este estou utilizando o mecanismo de geranção IDENTITY que é utilizada pra criar colunas identidades na maioria dos bancos de dados, porém existem outros, como SEQUENCE, INCREMENT, AUTO e TABLE, basta escolher o que melhor se aplica ao seu caso.

@ManyToOne: Informa a cardinalidade de muitos para um ao banco de dados. Para mapearmos quando inserimos um objeto dentro de outro é necessário que se informe tal Annotation. Em nosso caso, temos um objeto Estado dentro do objeto Cidade, ao se utilizá-la estamos informando que existem muitas Cidades dentro de um Estado.

Obs: Fiz um breve comentário sobre as Annotations utilizadas neste post, caso queira saber mais recomendo pesquisar algo, existem deversas annotations criadas para facilitar o mapeamento objeto relacional entre outras coisas.

Feito isso basta irmos ao HibernateUtility que se no pacote útil e informar as classes que queremos que o Hibenate mapie para nós deixando o arquivo conforme abaixo.


package br.com.meuprimeiroprojeto.util;

import br.com.meuprimeiroprojeto.modelo.Cidade;
import br.com.meuprimeiroprojeto.modelo.Estado;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateUtility {

private static final SessionFactory factory;
private static final ThreadLocal sessionThread = new ThreadLocal();
private static final ThreadLocal transactionThread = new ThreadLocal();

public static Session getSession() {
Session session = (Session) sessionThread.get();
if ((session == null) || (!(session.isOpen()))) {
session = factory.openSession();
sessionThread.set(session);
}
return ((Session) sessionThread.get());
}

public static void closeSession() {
Session session = (Session) sessionThread.get();
if ((session != null) && (session.isOpen())) {
sessionThread.set(null);
session.close();
}
}

public static void beginTransaction() {
Transaction transaction = getSession().beginTransaction();
transactionThread.set(transaction);
}

public static void commitTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.commit();
transactionThread.set(null);
}
}

public static void rollbackTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.rollback();
transactionThread.set(null);
}
}

static {
try {
factory = new Configuration()
/***POSTGRESQL***/
//                    .setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect")
//                    .setProperty("hibernate.connection.driver_class", "org.postgresql.Driver")
//                    .setProperty("hibernate.connection.url", "jdbc:postgresql://localhost/meuprimeiroprojeto")
//                    .setProperty("hibernate.connection.username", "postgres")
//                    .setProperty("hibernate.connection.password", "postgres")
/***MYSQL***/
.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect")
.setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver")
//CONFIGURAÇÃO DA BASE DE DADOS ** Verificar sempre Username e Password caso necessario alterar.
.setProperty("hibernate.connection.url", "jdbc:mysql://localhost/meuprimeiroprojeto")
.setProperty("hibernate.connection.username", "root")
.setProperty("hibernate.connection.password", "root")

//                    .setProperty("hibernate.connection.datasource", "jdbc/dbSGC") //data source (so pra aplicacao web e tem q configurar no tomcat)
.setProperty("hibernate.hbm2ddl.auto", "update")
.setProperty("hibernate.c3p0.max_size", "10")
.setProperty("hibernate.c3p0.min_size", "2")
.setProperty("hibernate.c3p0.timeout", "5000")
.setProperty("hibernate.c3p0.max_statements", "10")
.setProperty("hibernate.c3p0.idle_test_period", "3000")
.setProperty("hibernate.c3p0.acquire_increment", "2")
.setProperty("show_sql", "true")
.setProperty("use_outer_join", "true")
.setProperty("hibernate.generate_statistics", "true")
.setProperty("hibernate.use_sql_comments", "true")
.setProperty("hibernate.format_sql", "true")
//CLASSES PARA MAPEAMENTO
.addAnnotatedClass(Cidade.class)
.addAnnotatedClass(Estado.class)

.buildSessionFactory();
} catch (RuntimeException e) {
e.printStackTrace();
throw e;
}
}

public static void main(String [] args) {

}

}

Ao termino temos nossas classes com as devidas annotations ficarma da seguinte forma:

Classe Estado


package br.com.meuprimeiroprojeto.modelo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
*
* @author Fernado
*/
@Entity
public class Estado {

@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long idEstado;
private String nome;
private String sigla;

//GETTERS E  SETTERS OMITIDOS

}
<pre>

Classe Cidade


package br.com.meuprimeiroprojeto.modelo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

/**
*
* @author Fernado
*/
@Entity
public class Cidade {

@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long idCidade;
private String nome;
@ManyToOne
private Estado estado;

//GETTERS E  SETTERS OMITIDOS
}

Para concluir, basta abrir MySQL e criarmos um novo schema dando a ele o nome dele de meuprimeiroprojeto.

Com isso termino por aqui e até o próximo post.

Fiz algumas alterações no arquivo POM.xml estarei deixando disponivel o código no GITHUB

Orientação a Objetos – OO

Neste post, tentarei explicar de uma maneira fácil o que é a orientação a objetos.

Basicamente orientação a objetos ou OO é a técnica que tem por finalidade aproximar o mundo real de um mundo que os programadores estão familiarizados, ou seja, um mundo virtual. No começo é um pouco confuso mais vou simplificar. Pense nas coisas que existem no mundo real, temos pessoas, casas, carros e inúmeras outras coisas. Em OO tudo isso é tratado como objeto, desta forma temos um objeto pessoa, um objeto casa, um objeto carro e assim por diante. Partindo deste ponto fica fácil entender o que seria um objeto em OO, agora o ponto mais importante em OO é que cada objeto obrigatoriamente tem uma identificação e esta identificação precisa ser única e independente do conteúdo do objeto. Com isto um programador pode criar coleções de objetos, que ao fim também vem a se tornar um objeto em si.

Agora que compreendemos o que é um objeto em OO, vamos aprofundar mais um pouco.  A grosso modo objetos parados não servem pra nada. Então entra o nosso grande amigo “Programador” que no mundo virtual seria uma espécie de “Deus”. A ele cabe ha função de moldar e ditar o comportamento dos objetos, ou seja, o programador é o cara que da vida aos objetos do mundo virtual. Como no mundo real, os objetos precisam comunicar-se, o programador volta a agir nesta questão. Os objetos se comunicam por mensagens e o programador é quem vai especificar quais mensagens o objeto vai enviar e a ação que vai tomar. Os programadores com certeza se sentiram valorizados agora, sendo comparados com “Deus”. Mais é isso ai mesmo, temos que dar valor a nossa profissão, afinal estudamos para isso e não é nada fácil descrever uma situação real para uma situação virtual.

Agora já sabemos também qual a função do programador, voltaremos a falar de objetos.

A estrutura de um objeto é formatada por atributos, e seu comportamento é representado pelos métodos que ele pode realizar. Objetos são agrupados por classes que é uma abstração de um tipo de objeto. Confuso não é? Vou exemplificar utilizando um conceito biológico que achei na internet e por ele achei muito simples exemcplificar e quando o cara faz um trabalho deste nível temos que dar o crédito a ele, afinal ninguém quer reinventar a roda.

Vamos ao exemplo:

“Um animal é uma classe, e tem suas características: é um ser vivo capaz de pensar, precisa se alimentar para viver, etc, etc. O Ser Humano é uma subclasse dos animais. Ele tem todas as características de um animal, mas também têm algumas peculiaridades suas não encontradas nas outras subclasses de animais. Os pássaros também são animais, mas possuem características próprias. Note que uma Classe não tem vida, é só um conceito. Mas os Objetos (animais, serem humanos, pássaros, etc.) possuem vida. O seu cachorro rex é um Objeto (ou instância) da classe Cachorro. A classe Cachorro não pode latir, não pode fazer xixi no poste, ela apenas especifica e define o que é um cachorro. Mas Objetos do tipo Cachorro, estes sim podem latir, enterrar ossos, ter um nome próprio, etc. [Marcio Frayze David – 2007].

Creio que ficou fácil entender o que é uma classe com o exemplo e como o exemplo está fresquinho na mente de todos, vamos falar de herança.

Basicamente herança é um mecanismo que permite compartilhar atributos e métodos entre classes relacionadas. Desta forma podemos utilizar o exemplo acima. Vamos pegar a classe Animal e Ser Humano novamente. Em OO como sabemos todo ser humano já herda as características da classe animal, se parássemos por ai o ser humano simplesmente seria um animal, então como ser humano já é uma animal não precisamos implementar novamente todas características de um animal vamos nos preocupar em implementar somente o que o ser humano possui de diferente. Por exemplo, o ser humano: fala, trabalha, compra, e etc. Ou seja, animal seria a superclasse e ser humano uma subclasse de animal.  Todo mundo agora pensou em sair criando códigos e fazendo herança de todas classes, se você foi um destes esta completamente errado. A herança ajuda muito um programador mais também pode se tornar uma arma quando não se sabe utiliza-la corretamente, pois se você for herdando uma classe de outra classe chegará a um ponto que não se sabe mais o que herda o que, você não saberá qual classe é pai de qual classe e terá feito uma verdadeira bagunça. Digo isso por que quando comecei aprender herança pensei desta forma e meu amigo Altieres que acaba de entrar pra turma da galera que tem o certificado OCJP (Oracle Certified Java Programer 6.0) me disse isto: “A herança pode ser uma arma se utilizada de forma incorreta”. E realmente ele estava certo, tanto que normalmente as linguagens de programação permitem apenas uma classe pai, a única que eu conheço que permite herança múltipla é C++, e por sinal não é um exemplo de OO a ser seguido.

Pra quem leu até aqui muito bem, então vamos para o assunto que eu não tenho até medo de falar, pois eu acho um tanto quanto complicado, vamos falar de Polimorfismo.

Bom, que polimorfismo que é complicado todo mundo já deve imaginar, o próprio nome já deixa isso claro.  Vamos lá, Polimorfismo significa que um objeto pode ter formas diferentes. Pense no seu Objeto pessoa tendo varias formas. Como assim? Eu tenho um objeto Pessoa, Como ele pode ter diversas formas diferentes? Complicado não?  Vou tentar exemplificar isto de uma forma que acho funcional e que diversas vezes topamos em programação. Pessoa física e jurídica.

Quem desenvolve sistema sabe que quando isto aparece em um diagrama até causa um arrepio na coluna. Mais vamos lá temos uma classe Pessoa, até ai tudo bem, mais minha regra de negocio agora apresenta dois tipos de pessoa, uma física e uma jurídica. O que fazer? Bom, primeira coisa é pensar no que difere uma pessoa da outra, exemplo obvio CPF e CNPJ, certamente existem mais coisas que diferem mais neste caso nossa regra de negocio exige somente isto. Muito bem temos uma classe abstrata Pessoa e nela vamos informar os atributos que uma pessoa teria, como exemplo nome e endereço. Partindo dai temos uma pessoa jurídica que possui CNPJ e uma jurídica que possui CPF. Ficaria assim.

Classe Pessoa:

public abstract class Pessoa {

 public String nome = "Pessoa";
 public String endereço = "Endereço de pessoa";

}
 

Classe Fisica

 public class Fisica extends Pessoa {

 protected String cpf = "000.000.000-00";

 public String toString() {
 return "Nome: " + nome + ", Endereço: " + endereço + ", Documento: " + cpf;
 }

 }
 

Classe Juridica:

 public class Juridica extends Pessoa {

 protected String cnpj = "00.000.000/000-00";

 public String toString() {
 return "Nome: " + nome + ", Endereço: " + endereço + ", Documento: " + cnpj;
 }

 }
 

Para o exemplo eu acima usei protected em algunss atributos, bom protected é um modificador de acesso mais isto não será explicado neste post, deixarei para um próximo. Além disto, eu atribui um valor direto para cada atributo, mais isto foi para simplificar o resultado.

Executando:

public static void main(String[] args) {

 System.out.println("Executando pessoa fisica");
 Pessoa f = new Fisica();
 System.out.println(f);

 System.out.println("Executando pessoa juriica");
 Pessoa j = new Juridica();
 System.out.println(j);

 }

Agora pergunto a vocês qual será o resultado?

———————————————————————————————————————

Executando pessoa fisica

Nome: Pessoa, Endereço: Endereço de pessoa, Documento: 000.000.000-00

 
Executando pessoa juridica

Nome: Pessoa, Endereço: Endereço de pessoa, Documento: 00.000.000/000-00

———————————————————————————————————————-

Pra quem pensou nisto:

Acertou, você entendeu completamente isto que escrevi acima.

Pra quem não entendeu.

Leia este post. Nele você  encontra mais alguns exemlos.

Bom, encerro por aqui este post espero ter ajudado.

Até o próximo.