/**
* Get a TopLink Session for the given SessionFactory. Is aware of and will return any existing
* corresponding Session bound to the current thread, for example when using
* TopLinkTransactionManager. Will create a new Session otherwise, if allowCreate is true.
*
* <p>Same as <code>getSession</code>, but throwing the original TopLinkException.
*
* @param sessionFactory TopLink SessionFactory to create the session with
* @param allowCreate if a non-transactional Session should be created when no transactional
* Session can be found for the current thread
* @return the TopLink Session
* @throws TopLinkException if the Session couldn't be created
* @throws IllegalStateException if no thread-bound Session found and allowCreate false
* @see #releaseSession
* @see TopLinkTemplate
*/
public static Session doGetSession(SessionFactory sessionFactory, boolean allowCreate)
throws TopLinkException, IllegalStateException {
Assert.notNull(sessionFactory, "No SessionFactory specified");
SessionHolder sessionHolder =
(SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
if (sessionHolder != null) {
return sessionHolder.getSession();
}
if (!allowCreate && !TransactionSynchronizationManager.isSynchronizationActive()) {
throw new IllegalStateException(
"No TopLink Session bound to thread, "
+ "and configuration does not allow creation of non-transactional one here");
}
logger.debug("Creating TopLink Session");
Session session = sessionFactory.createSession();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering new Spring transaction synchronization for new TopLink Session");
// Use same Session for further TopLink actions within the transaction.
// Thread object will get removed by synchronization at transaction completion.
sessionHolder = new SessionHolder(session);
sessionHolder.setSynchronizedWithTransaction(true);
TransactionSynchronizationManager.registerSynchronization(
new SessionSynchronization(sessionHolder, sessionFactory));
TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);
}
return session;
}
public void testInterceptorWithThreadBoundAndFlushAlways() {
MockControl sfControl = MockControl.createControl(SessionFactory.class);
SessionFactory sf = (SessionFactory) sfControl.getMock();
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
session.getSessionFactory();
sessionControl.setReturnValue(sf, 1);
session.isOpen();
sessionControl.setReturnValue(true, 1);
session.getFlushMode();
sessionControl.setReturnValue(FlushMode.AUTO, 1);
session.setFlushMode(FlushMode.ALWAYS);
sessionControl.setVoidCallable(1);
session.setFlushMode(FlushMode.AUTO);
sessionControl.setVoidCallable(1);
sfControl.replay();
sessionControl.replay();
TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
HibernateInterceptor interceptor = new HibernateInterceptor();
interceptor.setSessionFactory(sf);
interceptor.setFlushMode(HibernateInterceptor.FLUSH_ALWAYS);
try {
interceptor.invoke(new TestInvocation(sf));
} catch (Throwable t) {
fail("Should not have thrown Throwable: " + t.getMessage());
} finally {
TransactionSynchronizationManager.unbindResource(sf);
}
sfControl.verify();
sessionControl.verify();
}
@Test
public void testTransactionRollback() {
final ODB odb = Mockito.mock(ODB.class);
Mockito.when(odb.store(Mockito.isNull())).thenThrow(new RuntimeException());
PlatformTransactionManager tm = new NeoDatisTransactionManager(odb);
TransactionTemplate tmpl = new TransactionTemplate(tm);
Assert.assertFalse(
"Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
Assert.assertFalse(
"There should no active synchronizations",
TransactionSynchronizationManager.isSynchronizationActive());
try {
tmpl.execute(
new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
Assert.assertTrue(TransactionSynchronizationManager.hasResource(odb));
NeoDatisTemplate neoDatisTemplate = new NeoDatisTemplate(odb);
neoDatisTemplate.store(null);
}
});
} catch (RuntimeException e) {
// is ok
}
Assert.assertFalse(
"Should not have a resource", TransactionSynchronizationManager.hasResource(odb));
Assert.assertFalse(
"There should no active synchronizations",
TransactionSynchronizationManager.isSynchronizationActive());
Mockito.verify(odb, Mockito.times(1)).rollback();
}
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
boolean existingTransaction = false;
PersistenceManager pm =
PersistenceManagerFactoryUtils.getPersistenceManager(getPersistenceManagerFactory(), true);
if (TransactionSynchronizationManager.hasResource(getPersistenceManagerFactory())) {
logger.debug("Found thread-bound PersistenceManager for JDO interceptor");
existingTransaction = true;
} else {
logger.debug("Using new PersistenceManager for JDO interceptor");
TransactionSynchronizationManager.bindResource(
getPersistenceManagerFactory(), new PersistenceManagerHolder(pm));
}
try {
Object retVal = methodInvocation.proceed();
flushIfNecessary(pm, existingTransaction);
return retVal;
} finally {
if (existingTransaction) {
logger.debug("Not closing pre-bound JDO PersistenceManager after interceptor");
} else {
TransactionSynchronizationManager.unbindResource(getPersistenceManagerFactory());
PersistenceManagerFactoryUtils.releasePersistenceManager(
pm, getPersistenceManagerFactory());
}
}
}
public void testInterceptorWithThreadBoundAndFilters() {
MockControl sfControl = MockControl.createControl(SessionFactory.class);
SessionFactory sf = (SessionFactory) sfControl.getMock();
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
session.getSessionFactory();
sessionControl.setReturnValue(sf, 1);
session.isOpen();
sessionControl.setReturnValue(true, 1);
session.enableFilter("myFilter");
sessionControl.setReturnValue(null, 1);
session.enableFilter("yourFilter");
sessionControl.setReturnValue(null, 1);
session.disableFilter("myFilter");
sessionControl.setVoidCallable(1);
session.disableFilter("yourFilter");
sessionControl.setVoidCallable(1);
sfControl.replay();
sessionControl.replay();
TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
HibernateInterceptor interceptor = new HibernateInterceptor();
interceptor.setSessionFactory(sf);
interceptor.setFilterNames(new String[] {"myFilter", "yourFilter"});
try {
interceptor.invoke(new TestInvocation(sf));
} catch (Throwable t) {
fail("Should not have thrown Throwable: " + t.getMessage());
} finally {
TransactionSynchronizationManager.unbindResource(sf);
}
sfControl.verify();
sessionControl.verify();
}
@Override
protected Object doGetTransaction() {
EntityManagerHolder holder =
(EntityManagerHolder)
TransactionSynchronizationManager.getResource(getEntityManagerFactory());
boolean isNew = false;
if (holder == null) {
EntityManager em = _jpaContext.getEm(getEntityManagerFactory());
holder = new EntityManagerHolder(em);
TransactionSynchronizationManager.bindResource(getEntityManagerFactory(), holder);
isNew = true;
}
JdbcTransactionObjectSupport transactionObj =
(JdbcTransactionObjectSupport) super.doGetTransaction();
if (isNew) {
_newTransactionObjects.put(transactionObj, holder.getEntityManager());
LOGGER.debug(
"doGetTransaction() bound EntityManagerHolder [{}] and saved transactionObj [{}]",
holder,
transactionObj);
} else {
LOGGER.debug(
"doGetTransaction() existing EntityManagerHolder, ignoring transactionObj: {}",
holder,
transactionObj);
}
return transactionObj;
}
private boolean unbindEntityManager(EntityManager em) {
if (TransactionSynchronizationManager.hasResource(entityManagerFactory)) {
TransactionSynchronizationManager.unbindResource(entityManagerFactory);
return true;
}
return false;
}
@Override
protected Object doGetTransaction() {
JpaTransactionObject txObject = new JpaTransactionObject();
txObject.setSavepointAllowed(isNestedTransactionAllowed());
EntityManagerHolder emHolder =
(EntityManagerHolder)
TransactionSynchronizationManager.getResource(getEntityManagerFactory());
if (emHolder != null) {
if (logger.isDebugEnabled()) {
logger.debug(
"Found thread-bound EntityManager ["
+ emHolder.getEntityManager()
+ "] for JPA transaction");
}
txObject.setEntityManagerHolder(emHolder, false);
}
if (getDataSource() != null) {
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(getDataSource());
txObject.setConnectionHolder(conHolder);
}
return txObject;
}
public static List<String> bindAndGetEventLog(EventLogSender eventLogSender) {
if (!TransactionSynchronizationManager.hasResource(EVENT_LOG_KEY)) {
TransactionSynchronizationManager.bindResource(EVENT_LOG_KEY, new ArrayList<String>());
TransactionSynchronizationManager.registerSynchronization(
new EventLogSynchronization(eventLogSender));
}
return (List<String>) TransactionSynchronizationManager.getResource(EVENT_LOG_KEY);
}
public void testOpenPersistenceManagerInViewInterceptor() throws Exception {
MockControl pmfControl = MockControl.createControl(PersistenceManagerFactory.class);
PersistenceManagerFactory pmf = (PersistenceManagerFactory) pmfControl.getMock();
MockControl pmControl = MockControl.createControl(PersistenceManager.class);
PersistenceManager pm = (PersistenceManager) pmControl.getMock();
OpenPersistenceManagerInViewInterceptor interceptor =
new OpenPersistenceManagerInViewInterceptor();
interceptor.setPersistenceManagerFactory(pmf);
MockServletContext sc = new MockServletContext();
MockHttpServletRequest request = new MockHttpServletRequest(sc);
pmf.getPersistenceManager();
pmfControl.setReturnValue(pm, 1);
pmfControl.replay();
pmControl.replay();
interceptor.preHandle(new ServletWebRequest(request));
assertTrue(TransactionSynchronizationManager.hasResource(pmf));
// check that further invocations simply participate
interceptor.preHandle(new ServletWebRequest(request));
interceptor.preHandle(new ServletWebRequest(request));
interceptor.postHandle(new ServletWebRequest(request), null);
interceptor.afterCompletion(new ServletWebRequest(request), null);
interceptor.postHandle(new ServletWebRequest(request), null);
interceptor.afterCompletion(new ServletWebRequest(request), null);
interceptor.preHandle(new ServletWebRequest(request));
interceptor.postHandle(new ServletWebRequest(request), null);
interceptor.afterCompletion(new ServletWebRequest(request), null);
pmfControl.verify();
pmControl.verify();
pmfControl.reset();
pmControl.reset();
pmfControl.replay();
pmControl.replay();
interceptor.postHandle(new ServletWebRequest(request), null);
assertTrue(TransactionSynchronizationManager.hasResource(pmf));
pmfControl.verify();
pmControl.verify();
pmfControl.reset();
pmControl.reset();
pm.close();
pmControl.setVoidCallable(1);
pmfControl.replay();
pmControl.replay();
interceptor.afterCompletion(new ServletWebRequest(request), null);
assertFalse(TransactionSynchronizationManager.hasResource(pmf));
pmfControl.verify();
pmControl.verify();
}
public void testLoggingAutoActivate() throws Throwable {
assertFalse(
"Auto-logging of misuse of the wrapper should be off",
BorrowedConnectionProxy.isCallStackTraced());
UserTransaction txn = transactionService.getUserTransaction();
Connection connection;
try {
txn.begin();
// Dig the proxy out of ... somewhere
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
connection = conHolder.getConnection();
txn.commit();
} catch (Throwable e) {
try {
txn.rollback();
} catch (Throwable ee) {
}
throw e;
}
// Now mess with the connection, which is protected by the Hibernate wrapper
try {
connection.commit();
fail("Use case should have generated a HibernateException");
} catch (HibernateException e) {
// Expected
}
assertTrue(
"Auto-logging of misuse of the wrapper should now be on",
BorrowedConnectionProxy.isCallStackTraced());
// Now start a new transaction and we should see logging
txn = transactionService.getUserTransaction();
try {
txn.begin();
// Dig the proxy out of ... somewhere
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
connection = conHolder.getConnection();
txn.commit();
} catch (Throwable e) {
try {
txn.rollback();
} catch (Throwable ee) {
}
throw e;
}
// Now mess with the connection, which is protected by the Hibernate wrapper
try {
connection.commit();
fail("Use case should have generated a HibernateException");
} catch (HibernateException e) {
// Expected
}
// Check for error logs
}
@Override
protected void doResume(Object transaction, Object suspendedResources) {
SuspendedResourcesHolder resourcesHolder = (SuspendedResourcesHolder) suspendedResources;
TransactionSynchronizationManager.bindResource(
getEntityManagerFactory(), resourcesHolder.getEntityManagerHolder());
if (getDataSource() != null && resourcesHolder.getConnectionHolder() != null) {
TransactionSynchronizationManager.bindResource(
getDataSource(), resourcesHolder.getConnectionHolder());
}
}
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
if (methodInvocation.getMethod().getName().equals("setSomething")) {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
} else {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
}
return methodInvocation.proceed();
}
@After
public void tearDown() throws Exception {
if (this.transactionStatus != null && !this.transactionStatus.isCompleted()) {
endTransaction();
}
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
}
@Override
protected Session getSession() {
SessionHolder sessionHolder =
(SessionHolder) TransactionSynchronizationManager.getResource(jpaDatastore);
if (sessionHolder == null) {
Session session = jpaDatastore.connect();
sessionHolder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(jpaDatastore, sessionHolder);
return session;
}
return sessionHolder.getSession();
}
/**
* Prepare a transaction on the given EntityManager, if possible.
*
* @param em the EntityManager to prepare
* @param emf the EntityManagerFactory that the EntityManager has been created with
* @return an arbitrary object that holds transaction data, if any (to be passed into
* cleanupTransaction)
* @see JpaDialect#prepareTransaction
*/
private static Object prepareTransaction(EntityManager em, EntityManagerFactory emf) {
if (emf instanceof EntityManagerFactoryInfo) {
EntityManagerFactoryInfo emfInfo = (EntityManagerFactoryInfo) emf;
JpaDialect jpaDialect = emfInfo.getJpaDialect();
if (jpaDialect != null) {
return jpaDialect.prepareTransaction(
em,
TransactionSynchronizationManager.isCurrentTransactionReadOnly(),
TransactionSynchronizationManager.getCurrentTransactionName());
}
}
return null;
}
public static void doBeforeCommit(final InvokationCallback invokationCallback) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronizationAdapter() {
public void beforeCommit(boolean readOnly) {
invokationCallback.invoke();
}
});
} else {
// invoke now
invokationCallback.invoke();
}
}
public static void afterCommit(final Runnable action) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
action.run();
}
});
} else {
action.run();
}
}
/**
* Process a message received from the provider.
*
* <p>Executes the listener, exposing the current JMS Session as thread-bound resource (if
* "exposeListenerSession" is "true").
*
* @param message the received JMS Message
* @param session the JMS Session to operate on
* @see #executeListener
* @see #setExposeListenerSession
*/
protected void processMessage(Message message, Session session) {
boolean exposeResource = isExposeListenerSession();
if (exposeResource) {
TransactionSynchronizationManager.bindResource(
getConnectionFactory(), new LocallyExposedJmsResourceHolder(session));
}
try {
executeListener(session, message);
} finally {
if (exposeResource) {
TransactionSynchronizationManager.unbindResource(getConnectionFactory());
}
}
}
private boolean bindSession() {
if (sessionFactory == null) {
throw new IllegalStateException("No sessionFactory property provided");
}
final Object inStorage = TransactionSynchronizationManager.getResource(sessionFactory);
if (inStorage != null) {
((SessionHolder) inStorage).getSession().flush();
return false;
} else {
Session session = SessionFactoryUtils.getSession(sessionFactory, true);
session.setFlushMode(FlushMode.AUTO);
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
return true;
}
}
/**
* this method checks if there is a transaction active and registers an afterCommit invokation of
* the InvokationCallback. if there is no transaction active it invokes the InvokationCallback
* immediately.
*
* @param invokationCallback
*/
public static void doAfterCommit(final InvokationCallback invokationCallback) {
// currentlly supports spring synchronization
if (TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
invokationCallback.invoke();
}
});
} else {
// invoke now
invokationCallback.invoke();
}
}
public Object intercept(Invocation invocation) throws Exception {
try {
Session session = sessionFactory.openSession();
session.setFlushMode(FlushMode.MANUAL);
SessionHolder sessionHolder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);
return invocation.invoke();
} catch (Exception e) {
throw e;
} finally {
SessionHolder sessionHolder =
(SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
sessionHolder.getSession().close();
}
}
@Override
protected Object doSuspend(Object transaction) {
JpaTransactionObject txObject = (JpaTransactionObject) transaction;
txObject.setEntityManagerHolder(null, false);
EntityManagerHolder entityManagerHolder =
(EntityManagerHolder)
TransactionSynchronizationManager.unbindResource(getEntityManagerFactory());
txObject.setConnectionHolder(null);
ConnectionHolder connectionHolder = null;
if (getDataSource() != null && TransactionSynchronizationManager.hasResource(getDataSource())) {
connectionHolder =
(ConnectionHolder) TransactionSynchronizationManager.unbindResource(getDataSource());
}
return new SuspendedResourcesHolder(entityManagerHolder, connectionHolder);
}
@Test
public void testCreate() {
OrgPerson person = new OrgPerson();
person.setId(new Integer(2));
person.setDescription("some description");
person.setFullname("Some testperson");
person.setLastname("testperson");
person.setCountry("Sweden");
person.setCompany("company1");
try {
this.dummyDao.create(person);
} catch (CannotCreateTransactionException expected) {
assertTrue(expected.getCause() instanceof CommunicationException);
}
// Make sure there is no transaction synchronization
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
try {
this.dummyDao.create(person);
} catch (CannotCreateTransactionException expected) {
assertTrue(expected.getCause() instanceof CommunicationException);
}
}
public void testInterceptorWithThreadBoundEmptyHolder() {
MockControl sfControl = MockControl.createControl(SessionFactory.class);
SessionFactory sf = (SessionFactory) sfControl.getMock();
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
sf.openSession();
sfControl.setReturnValue(session, 1);
session.getSessionFactory();
sessionControl.setReturnValue(sf, 1);
session.flush();
sessionControl.setVoidCallable(1);
session.close();
sessionControl.setReturnValue(null, 1);
sfControl.replay();
sessionControl.replay();
SessionHolder holder = new SessionHolder("key", session);
holder.removeSession("key");
TransactionSynchronizationManager.bindResource(sf, holder);
HibernateInterceptor interceptor = new HibernateInterceptor();
interceptor.setSessionFactory(sf);
try {
interceptor.invoke(new TestInvocation(sf));
} catch (Throwable t) {
fail("Should not have thrown Throwable: " + t.getMessage());
}
sfControl.verify();
sessionControl.verify();
}
private void bindEntityManager(EntityManager em) {
if (log.isDebugEnabled()) {
log.debug("Binding conversation's entityManager: " + em.hashCode());
}
TransactionSynchronizationManager.bindResource(
entityManagerFactory, new EntityManagerHolder(em));
}
@Override
public void afterCompletion(int status) {
try {
switch (status) {
case TransactionSynchronization.STATUS_COMMITTED:
connection.exec();
break;
case TransactionSynchronization.STATUS_ROLLED_BACK:
case TransactionSynchronization.STATUS_UNKNOWN:
default:
connection.discard();
}
} finally {
if (log.isDebugEnabled()) {
log.debug("Closing bound connection after transaction completed with " + status);
}
connHolder.setTransactionSyncronisationActive(false);
connection.close();
TransactionSynchronizationManager.unbindResource(factory);
}
}
@Override
protected void tearDown() throws Exception {
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.releaseSession(session, sessionFactory);
super.tearDown();
}
/**
* Gets a Redis connection. Is aware of and will return any existing corresponding connections
* bound to the current thread, for example when using a transaction manager. Will create a new
* Connection otherwise, if {@code allowCreate} is <tt>true</tt>.
*
* @param factory connection factory for creating the connection
* @param allowCreate whether a new (unbound) connection should be created when no connection can
* be found for the current thread
* @param bind binds the connection to the thread, in case one was created
* @param enableTransactionSupport
* @return an active Redis connection
*/
public static RedisConnection doGetConnection(
RedisConnectionFactory factory,
boolean allowCreate,
boolean bind,
boolean enableTransactionSupport) {
Assert.notNull(factory, "No RedisConnectionFactory specified");
RedisConnectionHolder connHolder =
(RedisConnectionHolder) TransactionSynchronizationManager.getResource(factory);
if (connHolder != null) {
if (enableTransactionSupport) {
potentiallyRegisterTransactionSynchronisation(connHolder, factory);
}
return connHolder.getConnection();
}
if (!allowCreate) {
throw new IllegalArgumentException("No connection found and allowCreate = false");
}
if (log.isDebugEnabled()) {
log.debug("Opening RedisConnection");
}
RedisConnection conn = factory.getConnection();
if (bind) {
RedisConnection connectionToBind = conn;
if (enableTransactionSupport && isActualNonReadonlyTransactionActive()) {
connectionToBind = createConnectionProxy(conn, factory);
}
connHolder = new RedisConnectionHolder(connectionToBind);
TransactionSynchronizationManager.bindResource(factory, connHolder);
if (enableTransactionSupport) {
potentiallyRegisterTransactionSynchronisation(connHolder, factory);
}
return connHolder.getConnection();
}
return conn;
}
/**
* Determine whether the given JMS Session is transactional, that is, bound to the current thread
* by Spring's transaction facilities.
*
* @param session the JMS Session to check
* @param cf the JMS ConnectionFactory that the Session originated from
* @return whether the Session is transactional
*/
public static boolean isSessionTransactional(Session session, ConnectionFactory cf) {
if (session == null || cf == null) {
return false;
}
JmsResourceHolder resourceHolder =
(JmsResourceHolder) TransactionSynchronizationManager.getResource(cf);
return (resourceHolder != null && resourceHolder.containsSession(session));
}
