我的客户端向使用Hibernate的服务层发送了3个请求。
每个单一请求都会导致Hibernate开始一个事务（session.beginTransaction()）。
我发现，有时，一个事务（来自2个正在运行的并发事务）与createQuery is not valid without active transaction失败。
我使用的Hibernate配置（在Tomcat 6.0.x和OC4j 10.1.3.4中运行）：
<property name="hibernate.connection.pool_size">5</property>
<!-- <property name="hibernate.current_session_context_class">thread</property> -->
<property name="hibernate.current_session_context_class">org.hibernate.context.ThreadLocalSessionContext</property>
<property name="connection.autoReconnect">true</property>
<property name="connection.autoReconnectForPools">true</property>
<property name="connection.is-connection-validation-required">true</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">false</property>
<!-- auto commit -->
<!-- <property name="connection.autocommit">true</property> -->
<!-- configuration pool via c3p0 -->
<property name="c3p0.idleConnectionTestPeriod">1000</property>
<property name="c3p0.initialPoolSize">5</property>
<property name="c3p0.maxPoolSize">10</property>
<property name="c3p0.maxIdleTime">1</property>
<property name="c3p0.maxStatements">30</property>
<property name="c3p0.minPoolSize">1</property>
<property name="cache.use_query_cache">true</property>
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<property name="cache.use_second_level_cache">true</property>
编辑：我使用以下代理来管理所有交易：
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
/**
* http://stackoverflow.com/questions/2587702
*
* @author mohammad_abdullah
*/
public class ServiceProxy implements InvocationHandler {
private Object object;
private Logger logger = Logger.getLogger(this.getClass().getSimpleName());
private static final String SESSION_FIELD = "session";
public static final Map<Long, Transaction> ACTIVE_TRANSACTIONS = new HashMap<Long, Transaction>();
private ServiceProxy(Object object) {
this.object = object;
}
public static Object newInstance(Object object) {
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), new ServiceProxy(object));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
Session session = null;
boolean joined = false;
try {
if (Modifier.isPublic(method.getModifiers())) {
session = HibernateUtil.getSessionFactory().getCurrentSession();
Field sessionField = object.getClass().getSuperclass().getDeclaredField(SESSION_FIELD);
if (sessionField == null)
throw new UPSAdminException("Service Implementation should have field named: \"" + SESSION_FIELD + "\".");
sessionField.setAccessible(true);
sessionField.set(object, session);
if (session.getTransaction().isActive()) {
joined = true;
logger.info("Using Already Active transaction" + " Method: " + method.getName() + " Thread: "
+ Thread.currentThread().getId());
ACTIVE_TRANSACTIONS.put(Thread.currentThread().getId(), session.getTransaction());
} else {
logger.info("Transaction Began" + " Method: " + method.getName() + " Thread: " + Thread.currentThread().getId());
Transaction newTnx = session.beginTransaction();
ACTIVE_TRANSACTIONS.put(Thread.currentThread().getId(), newTnx);
}
result = method.invoke(object, args);
if (!joined) {
ACTIVE_TRANSACTIONS.get(Thread.currentThread().getId()).commit();
ACTIVE_TRANSACTIONS.remove(Thread.currentThread().getId());
logger.info("Transaction Commited" + " Method: " + method.getName() + " Thread: " + Thread.currentThread().getId());
}
} else {
result = method.invoke(object, args);
}
return result;
} catch (InvocationTargetException _ex) {
Throwable cause = _ex.getCause();
logger.severe("Caller Exception: " + cause + " Method: " + method.getName() + " Thread: " + Thread.currentThread().getId());
if (!joined && session != null && session.getTransaction().isActive()) {
ACTIVE_TRANSACTIONS.get(Thread.currentThread().getId()).rollback();
ACTIVE_TRANSACTIONS.remove(Thread.currentThread().getId());
}
if (cause instanceof HibernateException) {
logger.severe("Hibernate Error. Rollbacked Back. Method: " + method.getName() + " Thread: "
+ Thread.currentThread().getId());
throw new DBException(cause.getCause().getMessage());
} else if (cause instanceof SetRollbackException) {
logger.severe("Transaction marked for Rollback. Rollbacked Back. Method: " + method.getName() + " Thread: "
+ Thread.currentThread().getId());
return result;
} else {
logger.severe("Error in Business Method : " + method + ". Rollbacked Back." + " Thread: " + Thread.currentThread().getId());
throw cause;
}
} catch (Exception ex) {
logger.severe("Error in Proxy code :" + ex + " Method :" + method + " Thread: " + Thread.currentThread().getId());
if (!joined && session != null && session.getTransaction().isActive()) {
ACTIVE_TRANSACTIONS.get(Thread.currentThread().getId()).rollback();
ACTIVE_TRANSACTIONS.remove(Thread.currentThread().getId());
}
if (ex instanceof HibernateException)
throw new DBException(ex.getCause().getMessage());
throw ex;
}
}
}
答案 0 :(得分：0)
由于您已创建大小为5的连接池，因此对于并发事务，它应该运行时没有太多问题。 createQuery（）方法更新了持久化需要在事务中运行的对象。我认为这是你错误的原因。
对于事务和连接，每个事务都必须保持连接，但由于连接是池，如果事务处于等待状态，它将释放连接回池。如果有这么多并发事务，并且连接数量较少，则会延迟处理。对于长期交易，甚至有可能出现诸如死锁等问题......
您可以在链接中找到transaction和Contextual sessions的hibernate API。
答案 1 :(得分：0)
您是否测试了beginTransaction（）成功？
您是否在关闭游戏后关闭连接而不等待它自动关闭？
来自http://docs.jboss.org/hibernate/orm/3.5/api/org/hibernate/Session.html的示例：
Session sess = factory.openSession();
Transaction tx;
try {
tx = sess.beginTransaction();
//do some work
...
tx.commit();
}
catch (Exception e) {
if (tx!=null) tx.rollback();
throw e;
}
finally {
sess.close();
}