sessionFactory.getCurrentSession() renvoie des sessions différentes bien que OSIV soit configuré

Question

J'ai un problème avec de printemps OpenSessionInViewFilter. Mon config web.xml ressemble à ça:

<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value> 
     WEB-INF/applicationContext.xml 
    </param-value> 
</context-param> 


<listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
</listener> 
<listener> 
    <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class> 
</listener> 

<filter> 
    <filter-name>Hibernate-OSIV pattern</filter-name> 
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class> 
    <init-param> 
     <param-name>sessionFactoryBeanName</param-name> 
     <param-value>sessionFactory</param-value> 
    </init-param> 
    <init-param> 
     <param-name>singleSession</param-name> 
     <param-value>true</param-value> 
    </init-param> 
    <init-param> 
     <param-name>flushMode</param-name> 
     <param-value>AUTO</param-value> 
    </init-param> 

</filter> 
<filter-mapping> 
    <filter-name>Hibernate-OSIV pattern</filter-name> 
    <url-pattern>/*</url-pattern> 
</filter-mapping> 

Et mon générique DAO ressemble que:

public class BasicDaoImpl implémente BasicDao {

private Class currentClass; 

private SessionFactory sessionFactory; 

public SessionFactory getSessionFactory() { 
    return sessionFactory; 
} 

public void setSessionFactory(SessionFactory sessionFactory) { 
    this.sessionFactory = sessionFactory; 
} 

@Transactional(readOnly = true) 
@Override 
public T getById(long id) { 
    Session session = getCurrentSession(); 
    return (T) session.get(getGenericClass(), id); 
} 

@Transactional(readOnly = true) 
@Override 
public List<T> getAll() { 
    Session session = getCurrentSession(); 
    return session.createCriteria(getGenericClass()).list(); 
} 

@Transactional(readOnly = false) 
@Override 
public void create(T entity) { 
    Session session = getCurrentSession(); 
    session.save(entity); 
} 

@Transactional(readOnly = false) 
@Override 
public void update(T entity) { 
    getCurrentSession().update(entity); 
} 

@Transactional(readOnly = false) 
@Override 
public void delete(T entity) { 
    Session session = getCurrentSession(); 
    session.delete(entity); 
} 

@Override 
@Transactional(readOnly = false) 
public void update(Collection<T> entities) { 
    Session session = getCurrentSession(); 
    for (T entity : entities) { 
     session.update(entity); 
    } 
} 

@Override 
@Transactional(readOnly = false) 
public void create(List<T> entities) { 
    Session session = getCurrentSession(); 
    for (T entity : entities) { 
     session.save(entity); 
    } 
} 

private Class getGenericClass() { 
    if (currentClass == null) { 
     ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass(); 
     currentClass = (Class) type.getActualTypeArguments()[0]; 
    } 
    return currentClass; 
} 

protected Session getCurrentSession() { 
    return sessionFactory.getCurrentSession(); 
} 
} 

(SessionFactory est injecté)

Je sais que ce n'est pas configuré pour une seule session (comme l'utilisation de la mise à jour au lieu de fusionner), mais d'abord je veux me débarrasser de LazyInitializationException.

Ce que je peux voir à partir du débogage sessionFactory.getCurrentSession() sur chaque demande retourne session avec un autre hashCode

Maintenant, qu'ai-je fait de mal? A partir d'Hibernate 4.1.7, vous pouvez désactiver les transactions sur les associations paresseuses en tant que propriété de configuration.

Answer 1

more details