A organização do projeto

8 de agosto de 2012 5 respostas

pauloglc 8 de agosto de 2012

Boa noite,

estou iniciando um novo projeto e gostaria de uma opinião sobre a maneira que pretendo organiza-lo.

primeiramente, pretendo utilizar hibernate para persistir.
todas as minhas classes de controle serão colocadas em um pacote chamado casses, e serão divididas por módulos, ex: classes.faturamento.NotaFiscal
pretendo criar um pacote dao.modulo.classe para ajudar no controle da persistencia, aqui que é minha maior dúvida: porque o hibernate ja abstrai bastante no que se diz em persistencia, porém, para que as classes de controle nao tenhao contato nenhum com o banco, achei interessante criar as “dao”. a dúvida é, vocês acham q ja posso colocar o hibernate direto nas classes de controle ou realmente é interessante o dao?
a parte visual também criarei um pacote: view.modulo
ainda não decidi a api q usarei para gerar relatórios(inclusive se alguem tiver indicações…) mas também pretendo separar por pacotes…

deixem suas opiniões

5 Respostas

luzales 8 de ago. de 2012

Sim, é uma boa prática usar o DAO (Data Access Object), um padrão de projeto que separa as regras de acesso ao banco de dados das regras de negócio do sistema, bem como de interface com o usuário. O DAO pode e deve ser utilizado mesmo no caso de utilizar o Hibernate, pois diminuirá o acoplamento entre classes com diferentes propósitos (persistência, modelo de negócio e interface), facilitando a manutenção do sistema. Além disso, um DAO bem implementado permite a utilização de diferentes bancos de dados com mínimas alterações no código.
Quanto à organização dos pacotes do projeto, não há uma receita ideal. Considerando que você deva estar utilizando o padrão MVC, vc poderia separar as classes em pacotes como:
DAO
Modelo
Controle
Visão
Resources (para imagens, etc)
Util (para classes úteis ao sistema, etc)

É apenas uma sugestão.

pauloglc 8 de ago. de 2012

hum, valeu.
veja, eu andei pensando e desenvolvi uma classe que, de inicio, parece despensar a criação de um DAO por classe… para classes simples funcionou tranquilo, imagino que para algumas classes mais complexas talvez seja necessário criar um herdeiro que seja mais especifico… veja e me diz o que acha:

public class DataSet<T> {

    public T insert(Session session, T objeto) {

        boolean inTransaction = session.getTransaction() != null;

        if (!inTransaction) {
            session.beginTransaction();
        }

        session.save(objeto);

        if (!inTransaction) {
            session.getTransaction().commit();
        }

        return objeto;
    }

    public T insert(T objeto) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        session.save(objeto);
        session.getTransaction().commit();
        session.close();
        return objeto;
    }

    public T update(Session session, T objeto) {

        boolean inTransaction = session.getTransaction() != null;

        if (!inTransaction) {
            session.beginTransaction();
        }

        session.update(objeto);

        if (!inTransaction) {
            session.getTransaction().commit();
        }

        return objeto;
    }

    public T update(T objeto) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        session.update(objeto);
        session.getTransaction().commit();
        session.close();
        return objeto;
    }

    public T insertOrUpdate(Session session, T objeto) {

        boolean inTransaction = session.getTransaction() != null;

        if (!inTransaction) {
            session.beginTransaction();
        }

        session.saveOrUpdate(objeto);

        if (!inTransaction) {
            session.getTransaction().commit();
        }

        return objeto;
    }

    public T insertOrUpdate(T objeto) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        session.saveOrUpdate(objeto);
        session.getTransaction().commit();
        session.close();
        return objeto;
    }

    public T delete(Session session, T objeto) {

        boolean inTransaction = session.getTransaction() != null;

        if (!inTransaction) {
            session.beginTransaction();
        }

        session.delete(objeto);

        if (!inTransaction) {
            session.getTransaction().commit();
        }

        return objeto;
    }

    public T delete(T objeto) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        session.delete(objeto);
        session.getTransaction().commit();
        session.close();
        return objeto;
    }

    public List<T> getList(Session session, Class classe) {
        Query query = session.createQuery("from " + getTableName(classe));
        return query.list();
    }

    public List<T> getList(Class classe) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Query query = session.createQuery("from " + getTableName(classe));
        List<T> lista = query.list();
        session.close();
        return lista;
    }

    private String getTableName(Class classe) {
        String tableName = "";
        ClassMetadata hibernateMetadata = HibernateUtil.getSessionFactory().getClassMetadata(classe);
        if (hibernateMetadata == null) {
            throw new HibernateException("Nome da tabela não encontrado");
        }
        if (hibernateMetadata instanceof AbstractEntityPersister) {
            AbstractEntityPersister persister = (AbstractEntityPersister) hibernateMetadata;
            tableName = persister.getTableName();
        }
        return tableName;
    }
}

luzales 8 de ago. de 2012

pauloglc:
hum, valeu. veja, eu andei pensando e desenvolvi uma classe que, de inicio, parece despensar a criação de um DAO por classe... para classes simples funcionou tranquilo, imagino que para algumas classes mais complexas talvez seja necessário criar um herdeiro que seja mais especifico... veja e me diz o que acha:

Sim, a ideia é essa generalizando o DAO, mas vc pode melhorar um pouco mais.
É possível criar uma interface de um DAO genérico com os principais métodos de acesso ao banco de dados, como você fez. Isso diminuirá ainda mais o acoplamento:

public interface IDAO<T>{

void save(T t);
void delete(T t);
void update(T t);
List<T> findAll();
T findById(int id);
}

Implementar a interface através de uma classe genérica:

public abstract class DaoGenerica<T> implements IDAO<T> {
 
    //inicialização
    //métodos da interface...
}

E depois utilizar:

DAO<Pessoa> pessoaDao = new DaoGenerica<Pessoa>;
pessoaDao.save(pessoa);

Para as classes que necessitem de outros métodos específicos relacionados a persistência, você poderia criar classes filhas herdando os métodos da classe GenericDAO.
Você pode melhorar ainda mais. Pesquise sobre a combinação dos padrões DAO e Facade para a camada de persistência.
Para maiores detalhes, sugiro os seguintes artigos:

[url]http://blog.caelum.com.br/ei-como-e-o-seu-dao-ele-e-tao-abstraido-quanto-o-meu/[/url]
[url]http://blog.caelum.com.br/possibilidades-de-design-no-uso-do-seu-generic-dao/[/url]

pauloglc 8 de ago. de 2012

hum, massa…
valeu mesmo, muito boa a idea

luzales 8 de ago. de 2012

pauloglc:
hum, massa…
valeu mesmo, muito boa a idea

Criado 8 de agosto de 2012

Ultima resposta 8 de ago. de 2012

Respostas 5

Participantes 2

5 Respostas

Topicos relacionados