Questões sobre DAOs

Assuntos Gerais
#1

Olá,

Criei uma tabela no banco chamada Pessoas, que tem um relacionamento muitos para um com a tabela
Bairros, para testar os JPAControllers gerados pelo Netbeans, a partir de classes de entidade.

Bom, o PessoaJpaController, na inserção, funciona perfeitamente se e somente se o a instância de Pessoa
passada para o método tiver um nome (not null), e tiver um bairro (já cadastrado no banco). Não tendo esses requisitos,
é disparada uma Exception.

Perguntas:

  1. Um DAO deve tratar exceções, como violações de constraints, se o registro não existe (edição ou deleção), ou apenas
    lançá-las para quem usar o DAO?
  2. Tenho uma aplicação pequena, com umas 7 tabelas. Seriam então 7 DAOs, obviamente. Devo criar uma interface para cada DAO
    com os métodos da classe DAO concreta, e usar somente a interface?

Outra Questão: Vejam só o tamanho do método create de um JPAController gerado pelo Netbeans, de uma classe Diaria, que tem os vínculos:
muitos para um com tabela Funcionario
um para muitos com tabela Documento Fiscal
um para muitos com tabela Certificados
muitos para um com tabela Cidade

public void create(Diaria diaria)
    {
        if (diaria.getDocumentoFiscalCollection() == null)
        {
            diaria.setDocumentoFiscalCollection(new ArrayList<DocumentoFiscal>());
        }

        if (diaria.getCertificadoCollection() == null)
        {
            diaria.setCertificadoCollection(new ArrayList<Certificado>());
        }

        EntityManager em = null;

        try
        {
            em = getEntityManager();
            em.getTransaction().begin();
            Funcionario funcionario = diaria.getFuncionario();

            if (funcionario != null)
            {
                funcionario = em.getReference(funcionario.getClass(),
                        funcionario.getId());
                diaria.setFuncionario(funcionario);
            }

            Cidade cidade = diaria.getCidade();

            if (cidade != null)
            {
                cidade = em.getReference(cidade.getClass(), cidade.getId());
                diaria.setCidade(cidade);
            }

            Collection<DocumentoFiscal> attachedDocumentosFiscaisCollection = 
                    new ArrayList<DocumentoFiscal>();

            for (DocumentoFiscal documentosFiscaisCollectionDocumentoFiscalToAttach :
                diaria.getDocumentoFiscalCollection())
            {
                documentosFiscaisCollectionDocumentoFiscalToAttach = em.getReference(
                        documentosFiscaisCollectionDocumentoFiscalToAttach.getClass(),
                        documentosFiscaisCollectionDocumentoFiscalToAttach.getId());
                attachedDocumentosFiscaisCollection.add(
                        documentosFiscaisCollectionDocumentoFiscalToAttach);
            }

            diaria.setDocumentoFiscalCollection(
                    attachedDocumentosFiscaisCollection);
            Collection<Certificado> attachedCertificadosCollection = new ArrayList<Certificado>();

            for (Certificado certificadosCollectionCertificadoToAttach :
                diaria.getCertificadoCollection())
            {
                certificadosCollectionCertificadoToAttach = em.getReference(
                        certificadosCollectionCertificadoToAttach.getClass(),
                        certificadosCollectionCertificadoToAttach.getId());
                attachedCertificadosCollection.add(
                        certificadosCollectionCertificadoToAttach);
            }

            diaria.setCertificadoCollection(attachedCertificadosCollection);

            em.persist(diaria);

            if (funcionario != null)
            {
                funcionario.getDiariaCollection().add(diaria);
                funcionario = em.merge(funcionario);
            }

            if (cidade != null)
            {
                cidade.getDiariaCollection().add(diaria);
                cidade = em.merge(cidade);
            }

            for (DocumentoFiscal documentosFiscaisCollectionDocumentoFiscal :
                diaria.getDocumentoFiscalCollection())
            {
                Diaria oldDiariaOfDocumentosFiscaisCollectionDocumentoFiscal =
                        documentosFiscaisCollectionDocumentoFiscal.getDiaria();
                documentosFiscaisCollectionDocumentoFiscal.setDiaria(diaria);
                documentosFiscaisCollectionDocumentoFiscal = em.merge(
                        documentosFiscaisCollectionDocumentoFiscal);

                if (oldDiariaOfDocumentosFiscaisCollectionDocumentoFiscal != null)
                {
                    oldDiariaOfDocumentosFiscaisCollectionDocumentoFiscal.getDocumentoFiscalCollection().remove(
                            documentosFiscaisCollectionDocumentoFiscal);
                    oldDiariaOfDocumentosFiscaisCollectionDocumentoFiscal = em.merge(
                            oldDiariaOfDocumentosFiscaisCollectionDocumentoFiscal);
                }
            }

            for (Certificado certificadosCollectionCertificado : diaria.getCertificadoCollection())
            {
                Diaria oldDiariaOfCertificadosCollectionCertificado =
                        certificadosCollectionCertificado.getDiaria();
                certificadosCollectionCertificado.setDiaria(diaria);
                certificadosCollectionCertificado = em.merge(
                        certificadosCollectionCertificado);

                if (oldDiariaOfCertificadosCollectionCertificado != null)
                {
                    oldDiariaOfCertificadosCollectionCertificado.getCertificadoCollection().remove(
                            certificadosCollectionCertificado);
                    oldDiariaOfCertificadosCollectionCertificado = em.merge(
                            oldDiariaOfCertificadosCollectionCertificado);
                }
            }

            em.getTransaction().commit();
        }
        finally
        {
            if (em != null)
            {
                em.close();
            }
        }
    }

Que método inserir enorme, não? O método editar é maior ainda :smiley:

  1. Pergunta: isso é o mínimo necessário para inserir uma Diaria corretamente? Pode-se reduzir esse método?
  2. Nunca encontrei um site com exemplos de DAOs JPA/Hibernate com tabelas com chaves estrangeiras, somente
    com tabelas simples. Sabem alguns sites?

obrigado pela atenção

Juliano

#2

Voce pode criar uma INTERFACE e um DAO genérico estendendo desta interface…

por ex.:

INTERFACE


public interface InterfaceDAO<T> {
	
	void salvar(T obj) throws Exception;
	void atualizar(T obj) throws Exception;
	void deletar(T obj) throws Exception;
}

DAO Genérico


public class HibernateDAO<T> implements InterfaceDAO<T> {

	protected Session session;
	protected Transaction tx;
	protected Criteria c;
	protected Query query;
	
	
	public void salvar(T obj) throws Exception {
		
		session = HibernateUtil.getSessionFactory().openSession();
		
		tx = session.getTransaction();
		
		try{
			tx.begin();
			session.persist(obj);
			tx.commit();
			
		}catch(Exception e){
			System.out.println("Ocorreu um erro durante a transação: "+e.getMessage());
			tx.rollback();
			
		}finally{
			
			if(tx.isActive()){
				tx.rollback();
			}
			
			session.close();
		}
		
				
	}
#3