Hibernate ouverture/fermeture de session, l'approche correcte pour DAO
J'ai écrit ce Hibernate objet DAO, cependant, avec cette approche, c'est à l'aide de session par approche de mise à jour (que je ne pense pas que c'est à droite).
La raison pour laquelle je ne pense pas que son droit parce que je suis en cours d'exécution dans des problèmes avec ma classe User, qui contient des collections qui sont paresseusement par les cheveux. Depuis lors de la récupération de chaque Utilisateur à partir de la DAO, la fermeture de la session. Donc je ne peux pas obtenir mes collections.
De temps en temps, c'est aussi faire beaucoup de mises à jour inutiles à la table parce que l'objet est détaché.
Donc est-il possible de fixer mon DAO, comme l'utilisation de 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);
}
}
}
OriginalL'auteur HeavenAgain | 2012-01-12
Vous devez vous connecter pour publier un commentaire.
Bonne approche est d'ajouter de la méthode close pour votre DAO(AbstractDao) et de l'appeler à la fin de votre "unité de travail".
Et, s'il vous plaît, pas de références statiques de la session, la session n'est pas thread-safe
Ici est une brillante explication de l'échantillon: Lien
OriginalL'auteur aleks.n.fedorov
Vous pouvez tenir un statique membre de Session dans HibernateUtil. Paresseux initialisé.
Une fermeture de la session à chaque fois que vous voulez, mais jusqu'à ce qu'il n'est pas fermé, vous pourrez continuer à l'utiliser.
Comme vous utilisez startOperation() pour obtenir une nouvelle session, vous pouvez utiliser closeOperation() pour fermer la session, et de les utiliser quand vous le souhaitez..
si vous faites de la session statique, ce schéma d'interaction n'est pas thread-safe.
OriginalL'auteur AAaa