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 aplicação 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.