Java hibernate，spring-事务

我在Spring有一个项目，我有两个数据库连接。两个，因为一个用于只读连接，另一个用于读写连接

我的问题是，当我尝试调用只读方法时，我得到：

没有绑定到线程的Hibernate会话，并且配置不允许在此创建非事务会话

现在我不知道如何准确地配置我的连接

下面我插入了我的服务类文件。问题是，当我尝试使用

sessionFactoryr

调用方法时，当我使用

sessionFactory

时，一切都正常

我的配置是：

hibernate-context.xml：

     <?xml version="1.0" encoding="UTF-8"?>
    <beans  xmlns="http://www.springframework.org/schema/beans" 
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:p="http://www.springframework.org/schema/p" 
            xmlns:tx="http://www.springframework.org/schema/tx"
            xmlns:context="http://www.springframework.org/schema/context"
            xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/tx 
                http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context-3.0.xsd
                ">

        <context:property-placeholder location="/WEB-INF/spring.properties" />

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

        <!-- Declare the Hibernate SessionFactory for retrieving Hibernate sessions -->
        <!-- See http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/orm/hibernate3/annotation/AnnotationSessionFactoryBean.html -->                           
        <!-- See http://docs.jboss.org/hibernate/stable/core/api/index.html?org/hibernate/SessionFactory.html -->
        <!-- See http://docs.jboss.org/hibernate/stable/core/api/index.html?org/hibernate/Session.html -->

<!-- First Connection -->

        <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
                     p:dataSource-ref="dataSource"
                     p:configLocation="${hibernate.config}"
                     p:packagesToScan="com.esb.scs"/>

        <!-- 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.hibernate3.HibernateTransactionManager" 
                    p:sessionFactory-ref="sessionFactory" />

<!-- Second connection (read only)  -->                     

        <bean id="sessionFactoryr" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
                     p:dataSource-ref="dataSourcer"
                     p:configLocation="${hibernate.config}"
                     p:packagesToScan="com.esb.scs"/>

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

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



    </beans>

服务类别：

    package com.esb.scs.service;


import static java.lang.System.out;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.UUID;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.security.authentication.encoding.Md5PasswordEncoder;
import org.springframework.security.authentication.encoding.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.esb.scs.domain.User;
import com.esb.scs.domain.UserReference;

@Service("userService")
@Transactional
public class UserService {

    protected static Logger logger = Logger.getLogger("service");

//  @Resource(name="sessionFactoryr")
//  private SessionFactory sessionFactoryr;

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

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


    public void addUser(HttpServletRequest request){

        logger.info("test");

        Session session = sessionFactory.getCurrentSession();

        PasswordEncoder encoder = new Md5PasswordEncoder();
        String hashedPassword = encoder.encodePassword(request.getParameter("password"), null);

        String login = request.getParameter("login");
        String password = hashedPassword;
        //String role = request.getParameter("role");
        String role = "normal";
        String ip = request.getParameter("ip");
        int active = 1;

        String referenceAddress = request.getParameter("referer");
        String sex = request.getParameter("sex");
        int age = Integer.parseInt(request.getParameter("age"));
        String country = request.getParameter("country");
        String city = request.getParameter("city");
        String education = request.getParameter("education");
        String profession = request.getParameter("profession");
        String branch = request.getParameter("branch");


        Transaction transaction = session.beginTransaction();

        User user = new User();

        UserReference userReference = new UserReference();

        Date dateCreate = new Date();

        user.setEmail(login);
        user.setPassword(password);
        user.setRole(role);
        user.setIp(ip);
        user.setDateCreate(dateCreate);
        user.setLastLoginDate(dateCreate);
        user.setActive(active);
        user.setToken("");

        userReference.setReferenceAddress(referenceAddress);
        userReference.setSex(sex);
        userReference.setAge(age);
        userReference.setCountry(country);
        userReference.setCity(city);
        userReference.setEducation(education);
        userReference.setProfession(profession);
        userReference.setBranch(branch);
        userReference.setSite(referenceAddress);
        userReference.setUser(user);



        userReference.setUser(user);
        user.getUserReferences().add(userReference);

        session.save(user);
        session.save(userReference);

        transaction.commit();

    }

    public List<User> getUser(String name, String password){

        Session session = sessionFactoryr.getCurrentSession();

        String sqlQuery = "FROM User WHERE email='"+name+"' AND password = '" +password+ "'" ;

        Query query = session.createQuery(sqlQuery).setMaxResults(1);

        return query.list();

    }


    public void updateUUID(String uuid, String login, String password){

        Session session = sessionFactory.getCurrentSession();

        Transaction transaction = session.beginTransaction();

        String hql = "update User set token = :token where email = :login and password = :password";

        Query query = session.createQuery(hql);

        query.setString("token", uuid);
        query.setString("login", login);
        query.setString("password", password);

        query.executeUpdate();

        transaction.commit();

    }





}

包com.esb.scs.service；
导入静态java.lang.System.out；
导入java.text.simpleDataFormat；
导入java.util.Date；
导入java.util.List；
导入java.util.UUID；
导入javax.annotation.Resource；
导入javax.servlet.http.HttpServletRequest；
导入org.apache.log4j.Logger；
导入org.hibernate.Query；
导入org.hibernate.Session；
导入org.hibernate.SessionFactory；
导入org.hibernate.Transaction；
导入org.springframework.security.authentication.encoding.Md5PasswordEncoder；
导入org.springframework.security.authentication.encoding.PasswordEncoder；
导入org.springframework.stereotype.Service；
导入org.springframework.transaction.annotation.Transactional；
导入com.esb.scs.domain.User；
导入com.esb.scs.domain.UserReference；
@服务（“用户服务”）
@交易的
公共类用户服务{
受保护的静态记录器=Logger.getLogger（“服务”）；
//@Resource（name=“sessionFactoryr”）
//私人会话工厂会话工厂；
@资源（name=“sessionFactory”）
私人会话工厂会话工厂；
@资源（name=“sessionFactoryr”）
私人会话工厂会话工厂；
public void addUser（HttpServletRequest）{
logger.info（“测试”）；
Session Session=sessionFactory.getCurrentSession（）；
PasswordEncoder=新的Md5PasswordEncoder（）；
字符串hashedPassword=encoder.encodePassword（request.getParameter（“密码”），null）；
字符串login=request.getParameter（“login”）；
字符串密码=哈希密码；
//字符串角色=request.getParameter（“角色”）；
字符串role=“正常”；
字符串ip=request.getParameter（“ip”）；
int-active=1；
字符串referenceAddress=request.getParameter（“referer”）；
字符串sex=request.getParameter（“sex”）；
int age=Integer.parseInt（request.getParameter（“age”）；
字符串country=request.getParameter（“国家”）；
字符串city=request.getParameter（“city”）；
字符串教育=request.getParameter（“教育”）；
字符串profession=request.getParameter（“profession”）；
String branch=request.getParameter（“branch”）；
事务=会话。beginTransaction（）；
用户=新用户（）；
UserReference UserReference=新的UserReference（）；
Date dateCreate=新日期（）；
user.setEmail（登录）；
user.setPassword（密码）；
user.setRole（角色）；
user.setIp（ip）；
user.setDateCreate（dateCreate）；
user.setLastLoginDate（日期创建）；
user.setActive（活动）；
user.setToken（“”）；
setReferenceAddress（referenceAddress）；
userReference.setSex（性别）；
userReference.setAge（年龄）；
userReference.setCountry（国家）；
userReference.setCity（城市）；
userReference.setEducation（教育）；
userReference.setProfession（profession）；
userReference.setBranch（分行）；
userReference.setSite（referenceAddress）；
userReference.setUser（用户）；
userReference.setUser（用户）；
user.getUserReferences（）.add（userReference）；
session.save（用户）；
session.save（userReference）；
commit（）；
}
公共列表getUser（字符串名称、字符串密码）{
Session Session=sessionFactoryr.getCurrentSession（）；
String sqlQuery=“FROM User WHERE email=”“+name+”，password=”“+password+”；
Query Query=session.createQuery（sqlQuery）.setMaxResults（1）；
返回query.list（）；
}
public void updateuid（字符串uuid、字符串登录、字符串密码）{
Session Session=sessionFactory.getCurrentSession（）；
事务=会话。beginTransaction（）；
String hql=“更新用户设置令牌=：令牌，其中电子邮件=：登录名和密码=：密码”；
Query=session.createQuery（hql）；
query.setString（“token”，uuid）；
query.setString（“login”，login）；
query.setString（“密码”，password）；
query.executeUpdate（）；
commit（）；
}
}

此外，我有

<filter>
        <filter-name>hibernateFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>hibernateFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>

冬眠过滤器
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
冬眠过滤器
/*

在myweb.xml中

---

根据您的建议，如果我将

@Transactional（“transactionManagerr”）

添加到我的方法中，它不会改变任何东西，我仍然会得到错误。

我认为您必须在

@Transactional

注释中指定事务管理器名称（例如

@Transactional（“transactionManagerr”）

）。阅读

---

我认为您必须在

@Transactional

（例如

@Transactional（“transactionManagerr”）

）注释中指定事务管理器名称。阅读

---

和

如果使用事务注释，则不需要在服务类中手动创建事务

您已指定类为transactiona

<bean id="transactionManagerr" class="org.springframework.orm.hibernate3.HibernateTransactionManager"                p:sessionFactory-ref="sessionFactoryr">
    <qualifier value="transactionManagerr"/>            
</bean>

@Transactional(value = "transactionManagerr")