TRABALHANDO COM JSE E SPRING FRAMEWORK

E ai galera,

Alguma vez já pensou em utilizar os Padrões de Injeção de Dependências e Inversão de Controle com Spring Framework em aplicações desenvolvidas com Java SE ?

Criei um mini tutorial explicando como fazer isso disponível neste link: Trabalhando com JSE e Spring Framework

O post foi publicado no blog da empresa onde trabalho atualmente à MATERA Systems e caso tenham curiosidade existem outros posts sobre os mais variados temas disponíveis lá, vale a pena conferir.

Espero que gostem.

Fico por aqui e até à próxima.

Projeto Java Desktop com Maven 4º Post

Olá,

Projetinho parado há algum tempo devido a falta de tempo, mais vamos dar sequência para concluir.

Pra inicio, criei um JFrame dando o nome de Principal.

Como o nome já diz, esta será nossa tela principal do sistema, ela que será aberta quando nosso sistema for inicializado.

Para ela não irei fazer nada muito difícil, inseri somente uma barra de menu com dois itens.

Ficando da seguinte forma.

Image

Para a opção Estado do menu, criei um JDialog dando o nome de EstadoForm.

Para ele também nada excepcional, dois campos de texto e um menu com as opções novo, salvar, editar e excluir.

Resumindo nosso formulário ficou da seguinte forma.

Image

Como todos sabem Java é uma linguagem que trabalha com Orientação a Objetos.

Pensando toda nossa tela se torna um objeto assim como cada item da nossa tela também se torna um objeto.

Por enquanto vamos pensar em nossos botões e por sinal temos quatro.

Se cada botão é um objeto, significa que cada um terá um comportamento.

Ps.: Se você pensou que nem todo objeto tem um comportamento, acredite ficar parado sem fazer nada por incrível que pareça é um comportamento.

Em Java, comportamentos são implementados criando-se métodos.

Passo inicial seria pensarmos nas ações que devem ocorrer quando ocorrer um click no botão Novo.

Primeiro passo seria habilitar os campos para preencher e já vamos garantir que estes campos estejam limpos para que nosso usuário preencha com os dados que quiser.

Vamos criar dois métodos separados para executar esta ação.

Se você pensou por que dois métodos separados a explicação mais simples para isto seria a seguinte.

Como estamos utilizando componentes Swing, tais componentes possuem nativos a implementação de um Listener (ouvinte) para eventos, ou seja, um click, o apertar uma tecla, etc.

Para este caso estaremos criando um evento para o click no botão que criamos.

Para fazer isto, click com botão direito do mouse sobre nosso botão > action > actionPerformed.

A ferramenta irá gerar o seguinte método.

private void jButtonActionPerformed(java.awt.event.ActionEvent evt) {  }

Nosso trabalho agora será implementar o comportamento desde método, uma vez que quando o usuário efetuar um click em nosso botão, o Listener saberá que é este método que deve ser executado.

Voltando agora na parte em que disse que criaríamos dois métodos separados para cara ação.

Para as duas ações em específicas que seria habilitar e limpar, e tais ações são bem genéricos e podem ser reutilizadas pra vários outros botões, então dentro dos métodos que indicará qual será a ação de nosso botão, apenas incluímos a chamada para nossos dois métodos, ficando da seguinte forma.

private void jButtonActionPerformed(java.awt.event.ActionEvent evt) {

habilitar(true);

limpar();

//demais métodos

}

Como o foco deste post é somente fazer um exemplo bem simples dando os conceitos básicos para quem esta iniciando com Java encerro por aqui.

Abraço e até mais.

O projeto completo ficará disponível no Git Hub.

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.

Projeto Java Desktop com Maven

Para este post estarei iniciando um projeto de aplicação desktop utilizando o Netbeans, Hibernate e o Maven.

Estarei utilizando neste projeto o padrão de persistência DAO (Data Access Object) por se tratar de algo bem simples. Ao término deste começarei um novo projeto utilizando EntityMannager e SpringFramework algo mais elegante.

Bom por que utilizar o Maven ?

O Maven é um framework que considero muito interessante, ele irá nos proporcionar um certo conforto no desenvolvimento do projeto, uma vez que ele será o responsável por gerenciar nossas dependências, e consequentemente nosso projeto inteiro. Como ele faz isso acho que ficará mais claro no andamento do projeto.
Para iniciar devemos primeiramente configurar o Maven em nossa máquina e no NetBeans, para isso recomendo ler o post do meu amigo Thiago Marques que explica passo a passo como fazer isso.

Próximo passo agora é a criação do projeto no netbeans.
Quem desenvolve projetos desktop está acostumado a criar um projeto simples, porém para utilizar o Maven temos uma pequena diferença.
No menu vamos em Arquivo > Novo Projeto.  Ou pelo atalho CTRL+SHIFT+N.
Iremos selecionar em categorias a opção MAVEN e em Projeto APLICATIVO JAVA.

Ficando como na figura abaixo.

Na próxima tela inserimos algumas informações de nosso projeto ficando da seguinte forma.

Para este projeto, por se tratar de algo bem simples estas informações acima não são de muita importância, mais para projetos futuros que envolvem um pouco mais de complexidade explicarei a importância de tais informações. Já de inicio digo que tais informações estarão incluídas no arquivo POM.xml que é nosso arquivo de configuração do Maven.

Terminado a estrutura de nosso projeto deverá ficar desta forma

Iremos excluir o pacote com.MeuPrimeroProjeto  existente no diretório Pacotes de códigos fonte e Pacote de teste, deixando nosso projeto da seguinte forma.

Ao término teremos nossa estrutura da seguinte forma:
Pacote de códigos-fonte – Onde serão inseridos os pacotes de nosso projeto, classes, interfaces e formulários e etc.
Pacote de testes – Caso utilize testes automatizados tudo relacionado a isso deve ser incluído neste pacote.
Dependências – Onde serão inseridas as bibliotecas do projeto.
Testar Dependências – Onde serão inseridas as bibliotecas de testes caso seja feitos testes automatizados.
Arquivos do Projeto – Onde fica o POM.xml que é nosso arquivo de configuração do Maven, nele serão declaradas nossas dependências do projeto, plugins para compilação e tudo mais. Entrarei em mais detalhes nos próximos posts.

Com isso termino por aqui este primeiro post de inicialização do nosso projeto, para o próximo post iniciarei a criação das classes formulários e interfaces, lembrando que disponibilizarei no GITHUB todo o código quer for gerado neste projeto.
Até mais.