Dao Genérico, Transações diferentes e Rollback

17 de junho de 2013 12 respostas

fdiaz2011 17 de junho de 2013

Olá

Hoje tenho um dao generico dessa forma

abstract class GenericDAO<T> implements Serializable {

    public GenericDAO(Class<T> entityClass) { 
        this.entityClass = entityClass; 
    }

    public Session getSession() {
		if (session == null || !session.isOpen()) {
			session = sessionFactory.openSession();
		}
		return session;
	}
}

Dessa forma eu preciso criar um dao específico para cada entidade do sistema.

public class TesteDAO extends GenericDAO<Teste> { 
  
    public TesteDAO() { 
        super(Teste.class); 
    } 
  
}

Isso está funcionando, mas eu me peguei em uma situação ruim.
Tem um momento em q eu tenho 3 entidades relacionadas e preciso salvar as 3.
Se eu salvar duas delas e der problema na terceira, ele mantém as duas salvas.
Eu preciso fazer rollback nas duas salvas, mas isso não está tão fácil assim.

Não ta facil pq eu faço o seguinte: salvo uma entidade e commito para poder pegar a referencia e relacionar na outra entidade.
Se eu não commitar ele dá erro na hora de relacionar a entidade salva (e não commitada) na que não foi salva ainda.
Isso pq (acredito eu) estão em EntityManager e transações diferentes e uma não enxerga a outra.

Poderiam me sugerir uma espécie de Dao genérico que não caia nesse problema ?
Ou uma forma para resolver esse problema neste tipo de Dao.

Obrigado

12 Respostas

drsmachado 17 de jun. de 2013

Mas você não precisa fazer essa barbaridade toda.
Você deve confirmar a transação (commit) apenas ao fim da execução de todas as alterações no banco.
Quando você faz:

session.save(obj);

A referência permanece e, dependendo de como você gerencia a PK no banco, ele já recebe a PK e está pronto para uso. O próprio hibernate faz isso por você (já que usa Session).

fdiaz2011 17 de jun. de 2013

Mas é isso q eu qria e oq fui fazer, mas não rolou.

Com o dao dessa forma eu preciso fazer o seguinte.

EntidadeUmDao entidadeUmDao = new EntidadeUmDao();

entidadeUmDao.beginTransaction();

entidadeUmDao.save(entidadeUm);

entidadeUmDao.commit();

Se eu não fizer o commit, dá erro qd eu faço isso:

EntidadeDoisDao entidadeDoisDao = new EntidadeDoisDao();

entidadeDois.setEntidadeUm(entidadeUm);

entidadeDoisDao.save(entidadeDois);

Exception in thread "main" org.hibernate.exception.GenericJDBCException: could not insert: [Teste]
	at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:103)
	at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:91)
	at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
	at org.hibernate.id.insert.AbstractReturningDelegate.performInsert(AbstractReturningDelegate.java:40)
	at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2158)
	at org.hibernate.persister.entity.AbstractEntityPersister.insert(AbstractEntityPersister.java:2638)
	at org.hibernate.action.EntityIdentityInsertAction.execute(EntityIdentityInsertAction.java:48)
	at org.hibernate.engine.ActionQueue.execute(ActionQueue.java:250)
	at org.hibernate.event.def.AbstractSaveEventListener.performSaveOrReplicate(AbstractSaveEventListener.java:298)
	at org.hibernate.event.def.AbstractSaveEventListener.performSave(AbstractSaveEventListener.java:181)
	at org.hibernate.event.def.AbstractSaveEventListener.saveWithGeneratedId(AbstractSaveEventListener.java:107)
	at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.saveWithGeneratedOrRequestedId(DefaultSaveOrUpdateEventListener.java:187)
	at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.entityIsTransient(DefaultSaveOrUpdateEventListener.java:172)
	at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.performSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:94)
	at org.hibernate.event.def.DefaultSaveOrUpdateEventListener.onSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:70)
	at org.hibernate.impl.SessionImpl.fireSaveOrUpdate(SessionImpl.java:507)
	at org.hibernate.impl.SessionImpl.saveOrUpdate(SessionImpl.java:499)
	at org.hibernate.impl.SessionImpl.saveOrUpdate(SessionImpl.java:495)
	at GenericDAO.save(GenericDAO.java:76)
	at TesteDAO.save(TesteDAO.java:1)
	at JpaMain.main(JpaMain.java:31)
Caused by: java.sql.SQLException: Got error -1 from storage engine
	at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1075)
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3566)
	at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3498)
	at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1959)
	at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2113)
	at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2568)
	at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2113)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2409)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2327)
	at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2312)
	at org.hibernate.id.IdentityGenerator$GetGeneratedKeysDelegate.executeAndExtract(IdentityGenerator.java:73)
	at org.hibernate.id.insert.AbstractReturningDelegate.performInsert(AbstractReturningDelegate.java:33)
	... 17 more

drsmachado 17 de jun. de 2013

Você provavelmente está fazendo lambança com isso.
Como estão mapeadas as entidades relacionadas?

fdiaz2011 17 de jun. de 2013

Pode ser, porém eu fiz um exemplo bem simples aqui.

@Entity
@Table(name="EntidadeUm")
public class EntidadeUm implements Serializable {

	@Id @GeneratedValue
	private Long id;
	
	private String nome;
	
	@OneToOne
	@JoinColumn(name = "entidadeDois_id")
	private EntidadeDois entidadeDois;
	
}

@Entity
@Table(name="EntidadeDois")
public class EntidadeDois implements Serializable {

	@Id @GeneratedValue
	private Long id;
	
	@Column(nullable = false)
	private String nome;
}

Desta forma que dá o erro:

public static void main(String[] args) {
		
		EntidadeDois entidadeDois = new EntidadeDois();
		entidadeDois.setNome("EntidadeDois");
		
		//DAO
		EntidadeDoisDAO entidadeDoisDAO = new EntidadeDoisDAO();
		entidadeDoisDAO.beginTransaction();
		//SAVE
		entidadeDoisDAO.save(entidadeDois);
		
		EntidadeUm entidadeUm = new EntidadeUm();
		entidadeUm.setNome("EntidadeUm");
		entidadeUm.setEntidadeDois(entidadeDois);
		
		//DAO
		EntidadeUmDAO entidadeUmDAO = new EntidadeUmDAO();
		entidadeUmDAO.beginTransaction();
		//SAVE
		entidadeUmDAO.save(entidadeUm);
		
		//COMMITS
		entidadeDoisDAO.commit();
		entidadeUmDAO.commit();
		
	}

Mas se eu fizer o commit() logo após o save() não dá erro algum e tudo é salvo de boa.
Acredito q esse erro aconteça pelo fato de serem transações diferentes e um não enxerga o outro já que não teve o commit.

kdoigor 17 de jun. de 2013

entenda como funciona UserTransaction e ContainerTransaction e analise qual delas se adequa mais ao seu cenário.

drsmachado 17 de jun. de 2013

Quando você invoca

entidadeDoisDAO.beginTransaction();

E depois

entidadeUmDAO.beginTransaction();

Você está criando duas transações diferentes. Isso não deve ocorrer. As referências irão existir dentro da mesma transação, até que um commit seja executado.
Você tem um DAO genérico, por que não faz uso dele?
Faça o DAO genérico gerenciar as transações.

drsmachado 17 de jun. de 2013

Ele obviamente não está trabalhando com um app server…

kdoigor 17 de jun. de 2013

Ele obviamente não está trabalhando com um app server…

jta independe de app server. ja usei UserTransaction em sistema desktop.

drsmachado 17 de jun. de 2013

Ele obviamente não está trabalhando com um app server…

jta independe de app server. ja usei UserTransaction em sistema desktop.
Mas desktop, por padrão, é UserTransaction…

kdoigor 17 de jun. de 2013

drsmachado:

Mas desktop, por padrão, é UserTransaction…

ah tá, então não precisa implementar no DAO ?

fdiaz2011 17 de jun. de 2013

Então, é oq eu falei das duas transações.
Eu uso o GenericDao, porém eu faço isso devido a forma do GenericDao.

abstract class GenericDAO<T> implements Serializable {

	private static SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
	
	private Session session;
	
	private Class<T> entityClass; 
	
	public GenericDAO(Class<T> entityClass) { 
            this.entityClass = entityClass; 
        }

public Session getSession() {
		if (session == null || !session.isOpen()) {
			session = sessionFactory.openSession();
		}
		return session;
	}

    //demais metodos

}

public class EntidadeUmDAO extends GenericDAO<EntidadeUm> { 
  
    public EntidadeUmDAO() { 
        super(EntidadeUm.class); 
    } 
  
}

public class EntidadeDoisDAO extends GenericDAO<EntidadeDois> { 
  
    public EntidadeDoisDAO() { 
        super(EntidadeDois.class); 
    } 
  
}

Pelo q estou vendo preciso deixar o GenericDao mais genérico.

fdiaz2011 18 de jun. de 2013

Vi q oq preciso fazer é para resolver isso é um joinTransaction(), mas ainda não achei como fazer isso no hibernate.
Com JPA é fácil, mas eu uso Session do hibernate.

public void joinTransaction() {
        em = emf.createEntityManager();
        em.joinTransaction();
    }

Criado 17 de junho de 2013

Ultima resposta 18 de jun. de 2013

Respostas 12

Participantes 3

12 Respostas

Topicos relacionados