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.

TCC – Ferramentas e Frameworks

Neste post estarei falando um pouco sobre as ferramentas e frameworks escolhidos para o desenvolvimento deste trabalho.

A princípio, na segunda etapa deste trabalho foi feito o levantamento de requisitos. Nesta etapa diversos requisitos não funcionais foram analisados, entre estes requisitos estão quais ferramentas deveriam ser utilizadas para o desenvolvimento deste software.

Por se tratar de um software para desktop em que uma pequena parte será desenvolvida para web, diversos nomes de ferramentas foram listados, sendo elas: IDEs, banco de dados, frameworks, ferramentas de modelagem entre outros.

De inicio, diversas delas chamam atenção de todo desenvolvedor por apresentar uma inteface bonita, parecer de fácil implementação ou até mesmo por que alguém falou muito bem de tal ferramenta. Como todo mundo sabe, nem tudo é o que parece ser, algumas vezes escolher uma ferramenta sem conhece-la pode se torna um problema e por isso existe o estudo de viabilidade.

No estudo de viabilidade estas ferramentas listadas precisam ser bem estudas, pois pode-se comprometer todo um projeto simplesmente por ter feito a escolha da ferramenta errada. Outro requisito que deve ser levado em consideração é a escolha de ferramentas que necessitam a aquisição de licenças para uso.

Atualmente no mercado podemos encontrar diversas ferramentas gratuitas, com um poder igual ou até mesmo superior ao de ferramentas pagas, oferecendo mais agilidade se aplicadas de maneira correta e na área certa. Com esta afirmação não estou defendendo que todos os projetos devam utilizar ferramentas gratuitas. Cada projeto possui suas características e em alguns casos é inevitável que seja necessária aquisição ferramentas especificas. A ideia é escolher a melhor ferramenta sendo ela paga ou gratuita, levando-se em consideração a complexidade do software que se esta desenvolvendo. Caso seja necessária uma ferramenta paga, de alguma forma alguém terá que pagar pela licença, portanto cuidado com este requisito, pois é necessário que se tenha uma atenção especial, se esta parte passa sem analise pode-se encarecer o projeto e o tornar inviável financeiramente.

Bom, se você nunca pensou em nada disso antes de um projeto espero ter levantado uma duvida. Neste caso, como escolher a melhor ferramenta?

Muitos requisitos devem ser levados em consideração, dentre eles, verifique se esta ferramenta possui fóruns ativos na internet, uma vez que em todo projeto chega-se a um momento em que se encontra um problema para a implementação de algum método, e é nestes fóruns que se vai encontrar a ajuda necessária para se solucionar tal problema. Verifique a quantidade de profissionais que utilizam a ferramenta e analise qual a opinião deles sobre tal ferramenta, e o principal, a que área aplicar e como aplicar o uso tal ferramenta no projeto. Pode-se perdem tempo analisando estas informações? Sim, porém é um tempo necessário, para que seu projeto seja bem executado e não tire suas horas de sono.

Para o meu projeto foram escolhidas algumas ferramentas que achei interessantes. Confesso que algumas delas ainda estou aprendendo como é seu funcionamento, e escolhi por motivos próprios por não se tratar de uma aplicação o comercial e sim de um trabalho de conclusão de curso. Neste caso testar algumas ferramentas e frameworks novos se torna interessante, uma vez que entre estas que escolhi,  existem algumas que estão em alta no mercado, e um profissional que esta se formando agora como eu, precisa de um conhecimento amplo para se preparar para o mercado de trabalho. Vou da uma breve descrição de algumas ferramentas que estarei utilizando neste projeto.

Ferramentas aplicadas neste projeto nas áreas Desktop e Web.

Apache Maven: Apache Maven ou simplesmente Maven esta atualmente na sua versão 3,  é uma ferramenta de automação de projetos em Java. Desenvolvido em cima da ferramenta Ant, o Maven se tornou uma ferramenta bastante utilizada por sua configuração serem mais simples, uma vez que sua configuração é baseada em XML. Por se tratar de uma ferramenta de automação de projeto, ele é quem descreve todo o processo de construção de um software. O Maven gerencia as dependências de um projeto, seus módulos e componentes e sequencia de construção através de uma estrutura conhecida como POM (Project Object Model).  Uma característica marcante do Maven é a possibilidade de trabalhar em rede onde seu núcleo pode baixar as dependências diretamente de um repositório.

Mais informações:  http://maven.apache.org/

Subverison: O Subversion é uma ferramenta de controle de versão, ou seja, ele gerencia arquivos e diretórios salvando todas as modificações feitas no projeto com o tempo. Com isso pode se recuperar versões mais antigas do projeto ou examinar o histórico de alterações. O Subversion pode funcionar em rede, com isso permite-se que varias pessoas trabalhem no mesmo projeto estando em computadores diferentes. Em grandes projetos ganha se em produtividade, pois e sempre que um profissional envolvido termine determinada tarefa, pode submetê-la e outro profissional que ao atualizar seu projeto estará com a versão atualiza em sua maquina.

Mais informações:  http://svnbook-pt-br.googlecode.com/svn/snapshots/1.4/svn.intro.whatis.html

Hibernate: O Hibernate é um framework para mapeamento objeto-relacional que tem como objetivo diminuir a complexidade entre programas Java que utilizam o modelo de programação orientada a objetos e banco de dados modelo objeto relacional.  Sua principal característica e transformar classes em Java em tabelas de banco de dados, além de gerar todo o SQL da aplicação liberando o programador desta tarefa.

Mais Informações: http://www.hibernate.org/

Ferramentas para Web:

Spring: Spring é um framework que trabalha com Inversão de Controle e Injeção de Dependência. Possui sua arquitetura baseada em POJOS (Plain Old Java Object) e oferece a eles a eles a possibilidade de alcançar coisas que somente eram possíveis com EJBs.  No Spring o container se encarrega de instanciar as classes e definir quais são suas dependências através de um arquivo de configuração no formato XML permitindo o baixo acoplamento entre classes.

Spring Security: O Spring Security trabalha com segurança baseada em roles. Com isso não é necessário chamar nenhum método para realizar autenticação ou autorização de acesso a usuários em um sistema. Com os roles definidos informamos a aplicação quais recursos podem ser acessados por um usuário que acessou uma área restrita.

Mais informações:  http://www.springsource.org/

JSF: Sobre o Java Server Faces (JSF) não falarei aqui para que o post não fique muito extenso. Fiz um post sobre JSF há algum tempo, então segue o link  Fernando Godoy – JSF.

PrimeFaces: O Primefaces é uma biblioteca de componentes de código aberto para JSF e citada por muitos como uma das melhores bibliotecas do mercado, possuindo cerca de 100 componentes.

Mais informações: http://www.primefaces.org/

Estas são as ferramenta mais interessantes e que estarei utilizando, dentre outras tenho o Astah, Ireport, DbDesigner, DbWrenchapp, PostGreSQL que será meu banco de dados e o NetBeans que será minha IDE.

Estas são algumas das ferramentas e frameworks escolhidas, postei junto com cada descrição o link que contem mais informações caso interesse a mais alguém. Não me aprofundei muito nas explicações para o post não ficar muito extenso, mais sem duvida vale a pena estudar cada uma delas.

Em breve estarei postando códigos e tutorias de configuração de cada uma das ferramentas listadas acima.

Espero que gostem e até o próximo.