mvc - spring java hibernate

No se encontró ninguna sesión para el hilo actual(Spring 3.1.X e Hibernate 4)

Question

Estoy intentando configurar mi proyecto usando Spring 3.1 e Hibernate 4. He estado siguiendo algunos tutoriales en línea. Recibo un error extraño que, según los foros de Spring, debería haberse solucionado con Spring 3.1. Spring Bug Tracker

Cuando mi servicio llama a getCurrentSession() , getCurrentSession() la siguiente excepción:

org.hibernate.HibernateException: **No Session found for current thread**] with root cause org.hibernate.HibernateException: No Session found for current thread
at org.springframework.orm.hibernate4.SpringSessionContext.currentSession(SpringSessionContext.java:97) at
org.hibernate.internal.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:881)

**** EDITAR: actualicé mi spring-dao.xml de acuerdo con la documentación de Spring Spring 3.1 para transacciones . He intentado cambiar mi fuente de datos con un org.apache.commons.dbcp.BasicDataSource. ¿Hay alguna propiedad que falte en mi configuración que pueda estar causando esto? ****

Aquí está mi spring-dao.xml:

 <!-- Enable annotation style of managing transactions -->
<tx:annotation-driven transaction-manager="transactionManager" />   

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="hibernateProperties">
        <value>hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect</value>
    </property>
</bean>

<!-- Declare a datasource that has pooling capabilities-->   
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
            destroy-method="close"
            p:driverClass="${app.jdbc.driverClassName}"
            p:jdbcUrl="${app.jdbc.url}"
            p:user="${app.jdbc.username}"
            p:password="${app.jdbc.password}"
            p:acquireIncrement="5"
            p:idleConnectionTestPeriod="60"
            p:maxPoolSize="100"
            p:maxStatements="50"
            p:minPoolSize="10" />

<!-- Declare a transaction manager-->
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager" 
            p:sessionFactory-ref="sessionFactory" />

Mi usuario bean (User.java)

package com.foo.lystra.beans;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="users")
public class User implements Serializable {
private static final long serialVersionUID = -5527566191402296042L;

@Id
@Column(name = "idusers")
private Integer user_id;

@Column(name="login_name")
private String loginName;

@Column(name="password")
private String password;

@Column(name="role")
private String role;

@Column(name="congregation_id")
private Integer congregation_id;

public Integer getUser_id() {
    return user_id;
}
public void setUser_id(Integer user_id) {
    this.user_id = user_id;
}
public String getLoginName() {
    return loginName;
}
public void setLoginName(String loginName) {
    this.loginName = loginName;
}
public String getPassword() {
    return password;
}
public void setPassword(String password) {
    this.password = password;
}
public String getRole() {
    return role;
}
public void setRole(String role) {
    this.role = role;
}
public Integer getCongregation_id() {
    return congregation_id;
}
public void setCongregation_id(Integer congregation_id) {
    this.congregation_id = congregation_id;
}

public String toString() {
    return "user_name: " + this.loginName + " congregation_id: " + this.congregation_id.toString();
}
}

Y finalmente mi servicio ...

package com.foo.lystra.services;

import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.foo.lystra.beans.User;
import com.foo.lystra.beans.Congregation;

@Service("congregationUserService")
@Transactional
public class CongregationUserService {
protected static Log logger = LogFactory.getLog(CongregationUserService.class);

@Resource(name="sessionFactory")
private SessionFactory sessionFactory;

public List<User> getAllUsers() {
    logger.debug("getting all users");

            //Exception is thrown on this next line:
    Session session = sessionFactory.getCurrentSession();

    Query query = session.createQuery("FROM users");
    return query.list();
}
}

Me doy cuenta de que mi fuente de datos probablemente no se está utilizando. Si he olvidado incluir alguna configuración, puedo actualizar esta publicación. Además, si los registros de inicio de Tomcat son necesarios, puedo proporcionarlos también.

Answer 1

pongo

<context:component-scan base-package="com.sprhib.repo"/>  #(some class files are annotaed by @Repository,@Service,@Component)
<tx:annotation-driven transaction-manager="txManager" />
<task:annotation-driven/>

int el root.xml.

Y puse

<context:component-scan base-package="com.sprhib.web"/>  #(some class files are annotaed by @Controller)
<mvc:annotation-driven />

int el servlet-context.xml.

Funciona.

Answer 2

¿Es una aplicación web? Si es así considere utilizar OpenSessionInViewFilter. Porque creo que cuando se usa currentSession (que está vinculada al hilo actual) debe haber un punto en el código que desvincula la sesión del hilo.

No estoy seguro de si el administrador de transacciones hace esto o no.

Answer 3

Agregue un filtro OpenSessionInViewFilter en su web.xml

<filter>
    <filter-name>hibernateFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    <init-param>
        <param-name>sessionFactoryBeanName</param-name>
        <param-value>sessionFactory</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>hibernateFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>FORWARD</dispatcher>
</filter-mapping>

Answer 4

Como se indica en la Referencia de primavera (3.2.x):

En el marco de Web MVC, cada DispatcherServlet tiene su propio WebApplicationContext, que hereda todos los beans ya definidos en la raíz WebApplicationContext. Estos beans heredados se pueden anular en el ámbito específico del servlet, y puede definir nuevos beans específicos del ámbito locales para una instancia de Servlet determinada.

Por lo tanto, los Beans definidos o escaneados con <context:component-scan> serán visibles en sus controladores para que pueda @Autowired ellos, pero no será visible en otros archivos de ApplicationContext *, así que a menos que <tx:annotation-driven/> haya sido definido en la configuración de DispatcherServlet, @Transactional no funcionará.

Así que supongo que probablemente tenga un <context:component-scan> en la configuración de DispatcherServlet y la declaración de <tx:annotation-driven/> en su aplicaciónContext * .xml, por lo que @Autowired funciona bien, pero @Transactional no.

Answer 5

Creo que necesitas:

<context:component-scan base-package="com.foo.package" />

De lo contrario, el contexto Spring no encontrará su servicio, por lo tanto no envolverá sus métodos con los aspectos transaccionales.

Answer 6

He encontrado que este problema es un error de la primavera.

este enlace https://jira.springsource.org/browse/SPR-9020 informa el problema ...

para solucionarlo, he utilizado la solución alternativa de Matias Mirabelli que se puede encontrar en este enlace https://gist.github.com/seykron/4770724

Lo que está sucediendo es que los métodos anotados con Propagation.SUPPORTS admiten transacciones, pero si no hay transacciones vinculadas al hilo, en lugar de crear una nueva sesión, se lanza una HibernateException

Para configurar la solución puede usar la propiedad de hibernación:

hibernate.current_session_context_class = com.your.package.TransactionAwareSessionContext

Answer 7

No estoy seguro, pero el problema podría estar en p:packagesToScan . Su ConfigurationUserService está en el paquete com.foo.lystra.services pero p:packagesToScan tiene com.foo.lystra.beans

Answer 8

Resolví este problema al poner <tx:annotation-driven transaction-manager="miTransactionManager"/> en el dispatcher-servlet.xml en lugar de cualquier otro archivo de configuración XML.

Creo que de esta manera los frijoles pueden coexistir en el mismo contexto de primavera.

Answer 9

Su configuración no apunta a las clases anotadas. Agregalos

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
  <property name="hibernateProperties">
     <value>hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect</value>
  </property>

  <property name="annotatedClasses">
    <list>
      <value>test.package.Foo</value>
      <value>test.package.Bar</value>
    </list>
  </property>
</bean>

Es similar a AnnotationSessionFactoryBean que estaba allí anteriormente. Compruebe el Api AnnotationSessionFactoryBean .

Answer 10

Tengo el mismo problema en una aplicación web. El problema es que existen en ambos archivos de configuración: application-context.xml y webmvc-context.xml. El archivo webmvc-context.xml se carga después de application-context.xml. Creo que la clase DAO se carga primero con referencias transaccionales cuando se carga application-context.xml, pero se reemplaza con otro objeto, sin referencias transaccionales, cuando se carga webmvc-context.xml. De cualquier forma, resuelvo el problema con paquetes específicos escaneados:
<context:component-scan base-package="com.app.repository" />
para application-context.xml, y
<context:component-scan base-package="com.app.web" />
para webmvc-context.xml.

Answer 11

Tuve el mismo error que el tuyo.

Este es un error que aún no está resuelto.

https://jira.springsource.org/browse/SPR-9028

Intente cambiar los archivos jar de hibernación a 3.6. porque la primavera lo usa.

http://mvnrepository.com/artifact/org.springframework/spring-orm/3.1.0.RELEASE

Aquí primavera 3.1 artefacto y dependencias.

Answer 12

Tuve el mismo problema y probé todas las soluciones contestadas. La respuesta de Vali fue muy útil. Lo que funcionó para mí fue mover estos beans de applicationContext.xml a web-servlet.xml:

<bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation">
            <value>classpath:hibernate.cfg.xml</value>
        </property>       
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

    <tx:annotation-driven />
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

Además, necesitas agregar en web-servlet.xml:

xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"

xsi:schemaLocation="       
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    "

Answer 13

Tuve este problema con spring-4.0.6 y hibernate-4.3.6.

La solución es mover todas las directivas controladas por anotación, componente-escaneado, anotación desde root-context.xml a servlet-context.xml:

<mvc:annotation-driven />
<context:component-scan base-package="ru.dd.demo" />
<tx:annotation-driven transaction-manager="transactionManager" />

dataSource, sessionFactory y transactionManager todavía se pueden definir en root-context.xml.

Answer 14

Tuvo exactamente el mismo error y se resolvió simplemente creando una interfaz para mi servicio. Así que en tu caso, yo crearía:

public interface ICongregationUserService {
   public List<User> getAllUsers();
}

luego cambie CongregationUserService para implementarlo:

@Service("congregationUserService")
@Transactional
public class CongregationUserService implements ICongregationUserService{
   //...
}

y en el lugar en el que usted autowired CongregationUserService, autowire ICongregationUserService:

@Autowired
private ICongregationUserService congregationUserService;