Открытие / закрытие Hibernate, правильный подход для DAO - PullRequest
Новая
       26

Открытие / закрытие Hibernate, правильный подход для DAO

3 голосов
/ 12 января 2012

Я написал этот объект Hibernate DAO, однако с этим подходом он использует подход сеанса к обновлению (что я не думаю, что это правильно).

Причина, по которой я не думаю, что это правильно, потому что у меня проблемы с моим классом User, который содержит коллекции, которые лениво выбираются.Поскольку при извлечении каждого пользователя из DAO, сеанс закрывается.Поэтому я не могу получить свои коллекции.

Время от времени он также выполняет множество ненужных обновлений таблицы, потому что объект отсоединен.

Так что есть ли способы исправить моюDAO, например, с использованием getCurrentSession () ? 

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import org.test.util.DataAccessLayerException;
import org.test.util.HibernateUtil;

public abstract class AbstractDao {
    protected Session session;
    protected Transaction tx;
    public AbstractDao() {
        HibernateUtil.buildIfNeeded();
    }
    protected void saveOrUpdate(Object obj) {
        try {
            startOperation();
            session.saveOrUpdate(obj);
            tx.commit();
        } catch (HibernateException e) {
            handleException(e);
        } finally {
            HibernateUtil.close(session);
        }
    }
    protected void delete(Object obj) {
        try {
            startOperation();
            session.delete(obj);
            tx.commit();
        } catch (HibernateException e) {
            handleException(e);
        } finally {
            HibernateUtil.close(session);
        }
    }
    protected Object find(Class clazz, Long id) {
        Object obj = null;
        try {
            startOperation();
            obj = session.load(clazz, id);
            tx.commit();
        } catch (HibernateException e) {
            handleException(e);
        } finally {
            HibernateUtil.close(session);
        }
        return obj;
    }
    protected List findAll(Class clazz) {
        List objects = null;
        try {
            startOperation();
            Query query = session.createQuery("from " + clazz.getName());
            objects = query.list();
            tx.commit();
        } catch (HibernateException e) {
            handleException(e);
        } finally {
            HibernateUtil.close(session);
        }
        return objects;
    }
    protected void handleException(HibernateException e) throws DataAccessLayerException {
        HibernateUtil.rollback(tx);
        throw new DataAccessLayerException(e);
    }
    protected void startOperation() throws HibernateException {
        session = HibernateUtil.openSession();
        tx = session.beginTransaction();
    }
}

HibernateUtil 

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static Log log = LogFactory.getLog(HibernateUtil.class);
    private static SessionFactory sessionFactory;

    private static SessionFactory configureSessionFactory()
            throws HibernateException {
        Configuration configuration = new Configuration();
        configuration.configure();
        sessionFactory = configuration.buildSessionFactory();
        return sessionFactory;
    }

    public static SessionFactory buildIfNeeded()
            throws DataAccessLayerException {
        if (sessionFactory != null) {
            return sessionFactory;
        }
        try {
            return configureSessionFactory();
        } catch (HibernateException e) {
            throw new DataAccessLayerException(e);
        }
    }

    public static SessionFactory buildSessionFactory()
            throws HibernateException {
        if (sessionFactory != null) {
            closeFactory();
        }
        return configureSessionFactory();
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static Session openSession() throws HibernateException {
        buildIfNeeded();
        return sessionFactory.openSession();
    }

    public static void closeFactory() {
        if (sessionFactory != null) {
            try {
                sessionFactory.close();
            } catch (HibernateException ignored) {
                log.error("Couldn't close SessionFactory", ignored);
            }
        }
    }

    public static void close(Session session) {
        if (session != null) {
            try {
                session.close();
            } catch (HibernateException ignored) {
                log.error("Couldn't close Session", ignored);
            }
        }
    }

    public static void rollback(Transaction tx) {
        try {
            if (tx != null) {
                tx.rollback();
            }
        } catch (HibernateException ignored) {
            log.error("Couldn't rollback Transaction", ignored);
        }
    }
}

Ответы [ 2 ]

1 голос
/ 30 мая 2014

Хороший подход - добавить метод close к вашему DAO (AbstractDao) и назвать его концом вашей "единицы работы".

И, пожалуйста, никаких статических ссылок на сессию, сессия не является поточно-безопасной

Вот блестящее объяснение с примером: Ссылка

0 голосов
/ 13 января 2012

Вы можете хранить статический член Session в HibernateUtil. Ленивый инициализирован. Закрывайте сессию в любое время, но пока она не будет закрыта, вы продолжите ее использовать.

...