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

Projeto Java Desktop com Maven 2º Post

Boa tarde galera,

Para este segundo post estarei disponibilizando 3 arquivos, sendo estes um Interface denominada DAOGENERICO, uma classe que implementa essa interface denominada DAOGENERICOIMPL  tais arquivos são genéricos contendo tudo que é necessário para a persistência de dados de nossa aplicação, além de outra classe denominada HibernateUtility responsável por gerenciar todas transações entre aplicação e banco de dados. Estes arquivos não são de minha autoria, foram arquivos que peguei na internet e estarei somente fazendo alguns comentários sobre eles.

Abaixo à Interface DaoGenerico:


import java.io.Serializable;
import java.util.List;
import java.util.Map;

public interface DaoGenerico<T, ID extends Serializable> {

public Class<T> getObjectClass();

public T save(T objeto);

public void delete(T objeto);

public void deleteItem(T objeto);

public List<T> list();

public List<T> listCriterio(String subClazz, Map<String, Object> filtrosConsulta, int tipoConsulta);

public T getById(Serializable id);

public T getById(Serializable id, boolean lock);

public List<T> consultaHQL(String consulta);

public void cancel();
}
<pre>

Abaixo segue a classe DaoGenericoImpl:


import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockOptions;
import org.hibernate.criterion.Restrictions;

public class DaoGenericoImpl<T, ID extends Serializable> implements DaoGenerico<T, ID> {

private final Class<T> oClass;

public DaoGenericoImpl() {
this.oClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}

@Override
public Class<T> getObjectClass() {
return this.oClass;
}

@Override
public T save(T objeto) {
try {
Object obj = null;
HibernateUtility.beginTransaction();
obj = HibernateUtility.getSession().merge(objeto);
HibernateUtility.commitTransaction();
HibernateUtility.closeSession();
return (T) obj;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public void delete(T objeto) {
try {
HibernateUtility.beginTransaction();
HibernateUtility.getSession().flush();
HibernateUtility.getSession().clear();
HibernateUtility.getSession().delete(objeto);
HibernateUtility.commitTransaction();
HibernateUtility.closeSession();
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public void deleteItem(T objeto) {
try {
HibernateUtility.beginTransaction();
HibernateUtility.getSession().delete(objeto);
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public List<T> list() {
try {
List list = HibernateUtility.getSession().createCriteria(oClass).list();
//HibernateUtility.closeSession();
return (List<T>) list;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public T getById(Serializable id) {
try {
return (T) HibernateUtility.getSession().get(oClass, id);
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public T getById(Serializable id, boolean lock) {
try {
if (lock) {
return (T) HibernateUtility.getSession().get(oClass, id, LockOptions.UPGRADE);
} else {
return (T) HibernateUtility.getSession().get(oClass, id);
}
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public List<T> listCriterio(String subClazz, Map<String, Object> filtrosConsulta, int tipoConsulta) {
List<T> lista = new ArrayList<T>();
Set entradas = filtrosConsulta.entrySet();

try {
Criteria crit = HibernateUtility.getSession().createCriteria(oClass);
if (subClazz == null) {
for (Iterator it = entradas.iterator(); it.hasNext();) {
Entry object = (Entry) it.next();
if (object.getValue() instanceof Enum) {
crit.add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 0) {
crit.add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
} else if (tipoConsulta == 1) {
crit.add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.add(Restrictions.gt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 3) {
crit.add(Restrictions.ge(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 4) {
crit.add(Restrictions.lt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 5) {
crit.add(Restrictions.le(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.add(Restrictions.ne(object.getKey().toString(), object.getValue()));
}
}
} else {
for (Iterator it = entradas.iterator(); it.hasNext();) {
Entry object = (Entry) it.next();
//crit.createCriteria(subClazz).add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
if (object.getValue() instanceof Enum) {
} else if (tipoConsulta == 0) {
crit.createCriteria(subClazz).add(Restrictions.ilike(object.getKey().toString(), "%" + object.getValue() + "%"));
} else if (tipoConsulta == 1) {
crit.createCriteria(subClazz).add(Restrictions.eq(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.createCriteria(subClazz).add(Restrictions.gt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 3) {
crit.createCriteria(subClazz).add(Restrictions.ge(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 4) {
crit.createCriteria(subClazz).add(Restrictions.lt(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 5) {
crit.createCriteria(subClazz).add(Restrictions.le(object.getKey().toString(), object.getValue()));
} else if (tipoConsulta == 2) {
crit.createCriteria(subClazz).add(Restrictions.ne(object.getKey().toString(), object.getValue()));
}
}
}
crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
crit.setMaxResults(20);
lista = (List<T>) crit.list();
//HibernateUtility.closeSession();
return lista;
} catch (HibernateException hibernateException) {
cancel();
throw hibernateException;
}
}

@Override
public List<T> consultaHQL(String consulta) {
return (List<T>) HibernateUtility.getSession().createQuery(consulta).list();
}

@Override
public void cancel() {
HibernateUtility.rollbackTransaction();
HibernateUtility.closeSession();
}
}
<pre>

Sobre esses dois arquivos não há o que comentar, dificilmente precisará ser feita alguma alteração neles.

Abaixo o HibernateUtility:


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")
.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) {

}

}

Nossa aplicação possui o Maven que é responsável pelo gerenciamento das dependências  e como disse no post anterior o Maven possui um arquivo de configuração denominado POM.xml, para agilizar um pouco fiz algumas alterações já inserindo as dependências básicas para o desenvolvimento deste projeto fincando o POM desta forma:


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>br.com.meuprimeiroprojeto</groupId>
<artifactId>MeuPrimeiroProjeto</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>MeuPrimeiroProjeto</name>
<url>http://maven.apache.org</url>
<repositories>
<repository>
<id>java.net2</id>
<name>Repository hosting the jee6 artifacts</name>
<url>http://download.java.net/maven/2</url>
</repository>
</repositories>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.swinglabs</groupId>
<artifactId>swing-layout</artifactId>
<version>1.0.3</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.6.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.6.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>3.1.0.GA</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.16</version>
</dependency>
<!--        <dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>8.4-702.jdbc4</version>
</dependency>-->
</dependencies>

</project>

Note que tanto no HibernateUtility quanto no POM existem trechos comentados, nestes trechos esta incluído o necessário para funcionar no banco de dados PostgreSQL, ficando a seu critério utilizar o banco que achar melhor, sendo necessário somente comentar a parte do MySQL e habilitar a parte do PostgreSQL.

Feio isso a estrtura de nosso projeto ficou desta forma:

Observe que ao inserir as dependências no POM.xml o Maven automaticamente irá baixa-lás para nosso projeto, os arquivos que citei no post estão no pacote UTIL e temos mais dois pacotes modelo e visão que utilizarei nos próximos post.

Com isso termino este post, para o próximo post estarei criando as classes Cidade e Estado, fazendo o mapeamento destas para o Hibernate gerar as tabelas de nosso banco de dados e incluindo alguns plugins no POM.xml.

Lembrando que os códigos estarão disponíveis no GITHUB.

Até mais.