Esquema de Transação - Hibernate

Programação Java
#1

Pessoal boa noite,

Como eu faria para criar ma “estrutura”, que para alguns metodos eu tivesse uma transação.

Eu to usando hibernate e Java 5, mas eu queira umas opniões de como “criar” esquema de transações meio generico que eu pudesse usar com ou sem um framework de persistencia!

Tipo para os metodos updates dos meus DAOs (Exemplo):

void update ( MinhaClasse minhaClasse ){ Transaction transaction = getTransaction(); try{ transaction.begin(); //executa o update session.update(minhaClasse); transaction.commit(); }catch(DaoException de){ transaction.rollback(); }finally{ session.close } }

pq eu tenho uma Interface que define metodos basicos:

Dao

public interface BasicDao <T extends Serializable>{
		
	/**
     * @param user
     * @return
     * @throws WriteDaoException
     */
    T insert(T transientObject) throws WriteDaoException;

    /**
     * @param news
     * @throws WriteDaoException
     */
    void update(T transientObject) throws WriteDaoException;

    /**
     * @param news
     * @throws WriteDaoException
     */
    void delete(T transientObject) throws WriteDaoException;

    /**
     * @param id
     * @return
     * @throws LoadDaoException
     */
    T get(Integer id) throws LoadDaoException;

    /**
     * Returns all registers in repository.
     *
     * @return
     *
     * @throws DaoException
     */
	List<T> listAll() throws DaoException;

E outras classes que definem metodos especificos de cada classe(Entidade) que é uma inteface tb, e herda os metodos dessa interface!

UserDao

public interface UserDao extends Dao {

/**
     * @param login
     * @return
     * @throws LoadDaoException
     */
    User getByLogin(String login) throws LoadDaoException;

E tenho uma implementação dessa interface.
Pergunta? Como eu poderia fazer para que nos metodos que sejam transacionais, ou que eu queira que sejam, eu posso fazer algo que chame o begin(), execute o necssario e se der tudo certo, cahme o commit(), senão rollback().

Valew pessoal!

#2

Olá.

você poderia implementar na sua interface Dao os seguintes métodos:

public void enableTransaction() throws DaoException;
public void commitTransaction() throws DaoException;
public void rollbackTransaction() throws DaoException;

Você deveria ter uma classe Abstract, algo como, HibernateDao.
Nesta classe, você poderia ter a estrutura para carregar o session da transação do hibernate em memória, e implementar os novos métodos da interface:

[code]public void enableTransaction() throws DaoException{
if (this.transaction != null) {
this.transaction.begin();
}
}
public void commitTransaction() throws DaoException {
if (this.transaction != null) {
this.transaction.commit();
}
}

public void rollbackTransaction() throws DaoException {
if (this.transaction != null) {
this.transaction.rollback();
}
}[/code]

Agora suas implementações para o Dao poderiam estender o HibernateDao e implementar o Dao.

Caso você troque de framework de persistência (JDBC, por exemplo), você cria uma classe abstrata JDBCDao (por exemplo) implementando o Dao, e escreve os métodos referentes a transação no JDBC.

Uma questão que me vem agora é que o JDBC precisa de uma conexão, então talvez seria interessante fornecer algo genérico no contrato para garantir uma conexão…

Bem, mais no geral é isso aí que você deve fazer:

  1. Contrato para transação;
  2. Abstração da implementação da transação de acordo com o seu framework;
  3. Permissão para troca de framework;

Note que o ideal não é você realizar a chamada da instância diretamente (dao usuario = new UsuarioDao());
O ideal é você implementar um factory para usar a implementação sem dependência, através do uso de XML, ResourceBundle, etc.
Acho que você já deve ter feito isso ao implementar o pattern DAO, mas em todo caso, vale repetir. :slight_smile:

Att.

#3

Particularmente eu não gosto de DAOs que tem acesso a transaction ou que saibam que estão no meio de uma.

Transaction é uma operação bem maior onde os DAOs estão inseridos e portanto não deve ser controlada de dentro dos DAOs.

Veja a documentação do hibernate e o Java Persistence API with Hibernate para ver algumas ideias de filtros(web) e controle de transactions.

Agora se você quer algo genérico, não reinvente a roda, use o gerenciamento de transaction do Spring e fique muito feliz.

#4

Embora o DAO tenha o contrato das transações, não é ele quem o faz. Quem continua fazendo é o programador, que implementa.

Os DAOs não saberão se estão em uma transação, o que acontece, no entanto, é que elas podem ser controladas internamente, e isto sim não é muito bom, baseado no que o Guilherme falou. Fazendo um HibernateDao que mantenha a transparência e ao mesmo tempo garantindo integridade no sistema (sem controle interno das operações), ficaria interessante. (Semelhante a um Adapter).

A questão de usar Spring, seria uma boa, mas as vezes o arquiteto não projetou o sistema para usar Spring, ou prefere alternativas mais simples. Mas é uma opção interessante, pois tem tudo o que você precisa.

Att.

#5