Java Examples for org.springframework.transaction.support.TransactionSynchronizationManager
The following java examples will help you to understand the usage of org.springframework.transaction.support.TransactionSynchronizationManager. These source code samples are taken from different open source projects.
Example 1
| Project: btpka3.github.com-master File: DataSourceKeyAdvice.java View source code |
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
@SuppressWarnings("unchecked") Stack<String> keyStack = (Stack<String>) TransactionSynchronizationManager.getResource(RoutingDataSourceImpl.DATASOURCE_RSC_KEY);
if (keyStack == null) {
keyStack = new Stack<String>();
TransactionSynchronizationManager.bindResource(RoutingDataSourceImpl.DATASOURCE_RSC_KEY, keyStack);
}
Method targetMethod = invocation.getMethod();
String key = keyResolver.resolveKey(invocation.getThis(), targetMethod, invocation.getArguments());
if (keyMapper != null) {
key = keyMapper.mapping(key);
}
// 防æ¢è·¨æ•°æ?®åº“进行事务
if (key != null && throwExceptionWhenCrossDb) {
for (int i = 0; i < keyStack.size(); i++) {
String iKey = keyStack.get(i);
if (iKey != null && !iKey.equals(key)) {
throw new CrossDbTransNotSupportedException();
}
}
}
if (key == null && !allowNullKey) {
throw new DataSouceKeyNotFoundException("Could not determin data source key for method : " + targetMethod);
}
if (logger.isDebugEnabled()) {
logger.debug("using '{}' as data source key for method : {}", key, targetMethod);
}
keyStack.push(key);
try {
return invocation.proceed();
} finally {
keyStack.pop();
}
}Example 2
| Project: geoserver-old-master File: HibUtil.java View source code |
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
if (clearActiveTX) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
try {
TransactionSynchronizationManager.unbindResource(sessionFactory);
} catch (IllegalStateException e) {
}
TransactionSynchronizationManager.clearSynchronization();
}
}
setUpSession(sessionFactory);
}Example 3
| Project: geoserver_trunk-master File: HibUtil.java View source code |
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
if (clearActiveTX) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
try {
TransactionSynchronizationManager.unbindResource(sessionFactory);
} catch (IllegalStateException e) {
}
TransactionSynchronizationManager.clearSynchronization();
}
}
setUpSession(sessionFactory);
}Example 4
| Project: apollo-master File: EntityManagerUtil.java View source code |
/**
* close the entity manager.
* Use it with caution! This is only intended for use with async request, which Spring won't
* close the entity manager until the async request is finished.
*/
public void closeEntityManager() {
EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(getEntityManagerFactory());
if (emHolder == null) {
return;
}
logger.debug("Closing JPA EntityManager in EntityManagerUtil");
EntityManagerFactoryUtils.closeEntityManager(emHolder.getEntityManager());
}Example 5
| Project: bbs.newgxu.cn-master File: JPAEmlookupRegister.java View source code |
public EntityManager lookupEntityManager() {
EntityManagerFactory emf = lookupEntityManagerFactory(event.getServletContext());
if (TransactionSynchronizationManager.hasResource(emf)) {
EntityManagerHolder holder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(emf);
EntityManager s = holder.getEntityManager();
return s;
} else {
// return lookupEntityManagerFactory(event.getServletContext()).createEntityManager();
return null;
}
}Example 6
| Project: com.revolsys.open-master File: Transaction.java View source code |
public static void afterCommit(final Runnable runnable) {
if (runnable != null) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
final RunnableAfterCommit synchronization = new RunnableAfterCommit(runnable);
TransactionSynchronizationManager.registerSynchronization(synchronization);
} else {
runnable.run();
}
}
}Example 7
| Project: geoserver-master File: HibUtil.java View source code |
public static void setUpSession(SessionFactory sessionFactory, boolean clearActiveTX) {
if (clearActiveTX) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
try {
TransactionSynchronizationManager.unbindResource(sessionFactory);
} catch (IllegalStateException e) {
}
TransactionSynchronizationManager.clearSynchronization();
}
}
setUpSession(sessionFactory);
}Example 8
| Project: lemon-master File: SpringSessionContext.java View source code |
public Session currentSession() throws HibernateException {
Object value = TransactionSynchronizationManager.getResource(this.sessionFactory);
if (value instanceof Session) {
return (Session) value;
} else if (value instanceof SessionHolder) {
SessionHolder sessionHolder = (SessionHolder) value;
Session session = sessionHolder.getSession();
if (TransactionSynchronizationManager.isSynchronizationActive() && !sessionHolder.isSynchronizedWithTransaction()) {
TransactionSynchronizationManager.registerSynchronization(new SpringSessionSynchronization(sessionHolder, this.sessionFactory));
sessionHolder.setSynchronizedWithTransaction(true);
// Switch to FlushMode.AUTO, as we have to assume a thread-bound Session
// with FlushMode.MANUAL, which needs to allow flushing within the transaction.
FlushMode flushMode = session.getFlushMode();
if (FlushMode.isManualFlushMode(flushMode) && !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
session.setFlushMode(FlushMode.AUTO);
sessionHolder.setPreviousFlushMode(flushMode);
}
}
return session;
} else {
throw new HibernateException("No Session found for current thread");
}
}Example 9
| Project: pedal-tx-master File: JPATransactionWrapper.java View source code |
@Override
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
super.prepareSynchronization(status, definition);
if (status.isNewTransaction()) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterData());
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterTask());
}
}Example 10
| Project: spring-amqp-master File: RabbitTransactionManager.java View source code |
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
throw new InvalidIsolationLevelException("AMQP does not support an isolation level concept");
}
RabbitTransactionObject txObject = (RabbitTransactionObject) transaction;
RabbitResourceHolder resourceHolder = null;
try {
resourceHolder = ConnectionFactoryUtils.getTransactionalResourceHolder(getConnectionFactory(), true);
if (logger.isDebugEnabled()) {
logger.debug("Created AMQP transaction on channel [" + resourceHolder.getChannel() + "]");
}
// resourceHolder.declareTransactional();
txObject.setResourceHolder(resourceHolder);
txObject.getResourceHolder().setSynchronizedWithTransaction(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getResourceHolder().setTimeoutInSeconds(timeout);
}
TransactionSynchronizationManager.bindResource(getConnectionFactory(), txObject.getResourceHolder());
} catch (AmqpException ex) {
if (resourceHolder != null) {
ConnectionFactoryUtils.releaseResources(resourceHolder);
}
throw new CannotCreateTransactionException("Could not create AMQP transaction", ex);
}
}Example 11
| Project: zk-master File: SpringTransactionSynchronizationListener.java View source code |
//-- utilities --//
private void getThreadLocals() {
try {
Class cls = Classes.forNameByThread("org.springframework.transaction.support.TransactionSynchronizationManager");
_threadLocals = new Object[7];
_threadLocals[0] = getThreadLocal(cls, "resources").get();
_threadLocals[1] = getThreadLocal(cls, "synchronizations").get();
_threadLocals[2] = getThreadLocal(cls, "currentTransactionName").get();
_threadLocals[3] = getThreadLocal(cls, "currentTransactionReadOnly").get();
_threadLocals[4] = getThreadLocal(cls, "actualTransactionActive").get();
//20070907, Henri Chen: bug 1785457, hibernate3 might not used
try {
cls = Classes.forNameByThread("org.springframework.orm.hibernate3.SessionFactoryUtils");
_threadLocals[5] = getThreadLocal(cls, "deferredCloseHolder").get();
} catch (ClassNotFoundException ex) {
}
cls = Classes.forNameByThread("org.springframework.transaction.interceptor.TransactionAspectSupport");
//1.2.8 currentTransactionInfo
try {
_threadLocals[6] = getThreadLocal(cls, "transactionInfoHolder").get();
} catch (SystemException ex) {
if (ex.getCause() instanceof NoSuchFieldException) {
_threadLocals[6] = getThreadLocal(cls, "currentTransactionInfo").get();
} else {
throw ex;
}
}
} catch (ClassNotFoundException ex) {
throw UiException.Aide.wrap(ex);
}
}Example 12
| Project: effectivejava-master File: DataSourceUtils.java View source code |
/**
* Actually obtain a JDBC Connection from the given DataSource.
* Same as {@link #getConnection}, but throwing the original SQLException.
* <p>Is aware of a corresponding Connection bound to the current thread, for example
* when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
* if transaction synchronization is active (e.g. if in a JTA transaction).
* <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
* @param dataSource the DataSource to obtain Connections from
* @return a JDBC Connection from the given DataSource
* @throws SQLException if thrown by JDBC methods
* @see #doReleaseConnection
*/
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}
// Else we either got no holder or an empty thread-bound holder here.
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
} else {
holderToUse.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
return con;
}Example 13
| Project: spring-framework-2.5.x-master File: DataSourceUtils.java View source code |
/**
* Actually obtain a JDBC Connection from the given DataSource.
* Same as {@link #getConnection}, but throwing the original SQLException.
* <p>Is aware of a corresponding Connection bound to the current thread, for example
* when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
* if transaction synchronization is active (e.g. if in a JTA transaction).
* <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
* @param dataSource the DataSource to obtain Connections from
* @return a JDBC Connection from the given DataSource
* @throws SQLException if thrown by JDBC methods
* @see #doReleaseConnection
*/
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}
// Else we either got no holder or an empty thread-bound holder here.
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
} else {
holderToUse.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
return con;
}Example 14
| Project: 1ed-master File: SpringUtil.java View source code |
/**
* Deixa a Session viva nesta Thread. Mesma coisa que uma Thread de uma
* requisição web utilizando o filtro "OpenSessionInViewFilter"
*/
public Session openSession() {
if (ctx != null) {
txManager = (HibernateTransactionManager) ctx.getBean("transactionManager");
SessionFactory sessionFactory = txManager.getSessionFactory();
session = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
return session;
}Example 15
| Project: Broadleaf-eCommerce-master File: IdentityExecutionUtils.java View source code |
private static void activateSession() {
Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
}
}
}Example 16
| Project: BroadleafCommerce-master File: IdentityExecutionUtils.java View source code |
private static void activateSession() {
Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
}
}
}Example 17
| Project: commerce-master File: IdentityExecutionUtils.java View source code |
private static void activateSession() {
Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
if (entry.getKey() instanceof EntityManagerFactory && entry.getValue() instanceof EntityManagerHolder) {
((HibernateEntityManager) ((EntityManagerHolder) entry.getValue()).getEntityManager()).getSession();
}
}
}Example 18
| Project: cosmo-master File: AbstractHibernateDaoTestCase.java View source code |
/**
* Override onteadDownAfterTransaction.
* @throws Exception - if something is wrong this exception is thrown.
*/
@AfterTransaction
public void onTearDownAfterTransaction() throws Exception {
// Get a reference to the Session and bind it to the TransactionManager
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
TransactionSynchronizationManager.unbindResource(sessionFactory);
// s.clear();
// clearSession();
SessionFactoryUtils.closeSession(s);
}Example 19
| Project: openmentor-master File: BaseDAOTestCase.java View source code |
protected void endTestTransaction() {
if (log.isDebugEnabled()) {
log.debug("Ending test transaction: session: " + session);
}
try {
session.flush();
} catch (Exception e) {
}
;
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.releaseSession(session, sessionFactory);
session = null;
}Example 20
| Project: Phynixx-master File: JtaConnectionHolderSupportAspect.java View source code |
@Before("@annotation(org.csc.phynixx.spring.jta.JtaConnectionHolderSupport)")
public void before() throws Throwable {
System.out.println("Actual Transaction Active for JtaConnectionHolderSynchronization" + TransactionSynchronizationManager.isActualTransactionActive());
if (!TransactionSynchronizationManager.isActualTransactionActive()) {
return;
}
Object connectionFactory = this.getConnectionFactory();
if (TransactionSynchronizationManager.hasResource(connectionFactory)) {
return;
}
ResourceHolder connectionHolder = this.getConnectionHolder();
TransactionSynchronizationManager.bindResource(connectionFactory, connectionHolder);
/**
* support die LifeCycle of then binding
*/
JtaConnectionHolderSynchronization<H, K> synchronization = new JtaConnectionHolderSynchronization(connectionHolder, connectionFactory);
TransactionSynchronizationManager.registerSynchronization(synchronization);
// Hole aktuelle Connection
System.out.println("*************************");
}Example 21
| Project: retry-master File: RetryOperationsInterceptorTests.java View source code |
public void doTansactional() throws Exception {
if (TransactionSynchronizationManager.isActualTransactionActive() && !enteredTransaction) {
transactionCount++;
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
public void beforeCompletion() {
enteredTransaction = false;
}
});
enteredTransaction = true;
}
count++;
if (count == 1) {
throw new RuntimeException("Rollback please");
}
}Example 22
| Project: spring-boot-starter-batch-web-master File: BatchMetricsImpl.java View source code |
@Override
public void increment(String metricName, Long value) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
initializeMetricContainerAndRegisterTransactionSynchronizationIfNecessary();
metricContainer.get().metrics.add(Pair.of(metricName, value));
} else {
incrementNonTransactional(metricName, value);
}
}Example 23
| Project: spring-framework-issues-master File: BookServiceImpl.java View source code |
@Override
public void triggerCreatePostCommit(final Book book) {
// Lookup book to make sure we are using the enitity manager/repository
lookupBookById(book.getId());
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
if (status == TransactionSynchronization.STATUS_COMMITTED) {
BookServiceHelper.getInstance().getBookService().createBookWithoutTx(book);
}
}
});
}Example 24
| Project: spring-framework-master File: DataSourceUtils.java View source code |
/**
* Actually obtain a JDBC Connection from the given DataSource.
* Same as {@link #getConnection}, but throwing the original SQLException.
* <p>Is aware of a corresponding Connection bound to the current thread, for example
* when using {@link DataSourceTransactionManager}. Will bind a Connection to the thread
* if transaction synchronization is active (e.g. if in a JTA transaction).
* <p>Directly accessed by {@link TransactionAwareDataSourceProxy}.
* @param dataSource the DataSource to obtain Connections from
* @return a JDBC Connection from the given DataSource
* @throws SQLException if thrown by JDBC methods
* @see #doReleaseConnection
*/
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}
// Else we either got no holder or an empty thread-bound holder here.
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
} else {
holderToUse.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
return con;
}Example 25
| Project: spring-modules-master File: Jsr94Template.java View source code |
/**
* Executes a stateful rule session. If called in a transaction, the session will be closed upon
* transaction completion; otherwise it will be closed when the callback returns.
* @param uri The ruleset uri
* @param properties The properties for the stateful rule session
* @param callback The callback
* @return The result of the callback execution
*/
public Object executeStateful(final String uri, final Map properties, final StatefulRuleSessionCallback callback) {
// get the session
boolean synchronize = TransactionSynchronizationManager.isSynchronizationActive();
if (!synchronize) {
logger.debug("Not running in transaction; the session will be closed when the callback returns.");
}
StatefulRuleSession session = (StatefulRuleSession) TransactionSynchronizationManager.getResource(getRuleSource());
if (session == null) {
logger.debug("Opening StatefulRuleSession");
session = (StatefulRuleSession) createRuleSession(uri, properties, RuleRuntime.STATEFUL_SESSION_TYPE);
if (synchronize)
TransactionSynchronizationManager.bindResource(getRuleSource(), session);
}
try {
return callback.execute(session);
} catch (InvalidRuleSessionException ex) {
throw new Jsr94InvalidRuleSessionException(ex);
} catch (RemoteException ex) {
throw new Jsr94RemoteException(ex);
} catch (InvalidHandleException ex) {
throw new Jsr94InvalidHandleException(ex);
} finally {
if (!synchronize) {
releaseStatefulSession(session);
logger.debug("Closed session");
}
}
}Example 26
| Project: spring-retry-master File: RetryOperationsInterceptorTests.java View source code |
public void doTansactional() throws Exception {
if (TransactionSynchronizationManager.isActualTransactionActive() && !enteredTransaction) {
transactionCount++;
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
public void beforeCompletion() {
enteredTransaction = false;
}
});
enteredTransaction = true;
}
count++;
if (count == 1) {
throw new RuntimeException("Rollback please");
}
}Example 27
| Project: camel-master File: EntityManagers.java View source code |
/**
* Fetches {@link javax.persistence.EntityManager} bound to the current Spring transaction or creates new manager.
*
* @param entityManagerFactory {@link javax.persistence.EntityManagerFactory} used either as a key for a Spring
* transaction resource lookup or as a factory to create new
* {@link javax.persistence.EntityManager}.
* @return {@link javax.persistence.EntityManager} bound to the existing Spring transaction or new manager instance.
*/
public static EntityManager resolveEntityManager(EntityManagerFactory entityManagerFactory) {
EntityManagerHolder entityManagerHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(entityManagerFactory);
if (entityManagerHolder != null) {
return entityManagerHolder.getEntityManager();
}
return entityManagerFactory.createEntityManager();
}Example 28
| Project: cms-ce-master File: IndexTransactionJournal.java View source code |
public void registerUpdate(Collection<ContentKey> contentKeys, boolean updateMetadataOnly) {
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
return;
}
for (ContentKey contentKey : contentKeys) {
final IndexTransactionJournalEntry indexTransactionJournalEntry = new IndexTransactionJournalEntry(UPDATE, contentKey, updateMetadataOnly);
changeHistory.add(indexTransactionJournalEntry);
}
}Example 29
| Project: db-util-master File: OptimisticConcurrencyControlAspect.java View source code |
private Object proceed(ProceedingJoinPoint pjp, Retry retryAnnotation) throws Throwable {
int times = retryAnnotation.times();
Class<? extends Throwable>[] retryOn = retryAnnotation.on();
Assert.isTrue(times > 0, "@Retry{times} should be greater than 0!");
Assert.isTrue(retryOn.length > 0, "@Retry{on} should have at least one Throwable!");
if (retryAnnotation.failInTransaction() && TransactionSynchronizationManager.isActualTransactionActive()) {
throw new IllegalTransactionStateException("You shouldn't retry an operation from withing an existing Transaction." + "This is because we can't retry if the current Transaction was already rollbacked!");
}
LOGGER.info("Proceed with {} retries on {}", times, Arrays.toString(retryOn));
return tryProceeding(pjp, times, retryOn);
}Example 30
| Project: droolsjbpm-integration-master File: KieSpringTransactionManager.java View source code |
public void commit(boolean transactionOwner) {
if (transactionOwner) {
try {
// if we didn't begin this transaction, then do nothing
this.ptm.commit(currentTransaction);
currentTransaction = null;
if (TransactionSynchronizationManager.hasResource(KieSpringTransactionManager.RESOURCE_CONTAINER)) {
TransactionSynchronizationManager.unbindResource(KieSpringTransactionManager.RESOURCE_CONTAINER);
}
} catch (Exception e) {
logger.warn("Unable to commit transaction", e);
throw new RuntimeException("Unable to commit transaction", e);
}
}
}Example 31
| Project: ef-orm-master File: CrudMethodMetadataPostProcessor.java View source code |
/*
* (non-Javadoc)
* @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
*/
public Object invoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod();
CrudMethodMetadata metadata = (CrudMethodMetadata) TransactionSynchronizationManager.getResource(method);
if (metadata != null) {
return invocation.proceed();
}
CrudMethodMetadata methodMetadata = metadataCache.get(method);
if (methodMetadata == null) {
methodMetadata = new DefaultCrudMethodMetadata(method);
CrudMethodMetadata tmp = metadataCache.putIfAbsent(method, methodMetadata);
if (tmp != null) {
methodMetadata = tmp;
}
}
TransactionSynchronizationManager.bindResource(method, methodMetadata);
try {
return invocation.proceed();
} finally {
TransactionSynchronizationManager.unbindResource(method);
}
}Example 32
| Project: FiWare-Template-Handler-master File: SpringTransactionContext.java View source code |
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
if (transactionState.equals(TransactionState.COMMITTING)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCommit(boolean readOnly) {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.COMMITTED)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCompletion() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
transactionListener.execute(commandContext);
}
});
}
}Example 33
| Project: iwethey-master File: HibernateTestHarness.java View source code |
public void setUp() throws Exception {
SessionFactory sf = (SessionFactory) this.context.getBean("sessionFactory");
//Session s = SessionFactoryUtils.getSession(sessionFactory, true);
// open and bind the session for this test thread.
Session s = sf.openSession();
TransactionSynchronizationManager.bindResource(sf, new SessionHolder(s));
}Example 34
| Project: javaconfig-ftw-master File: SpringTransactionContext.java View source code |
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
if (transactionState.equals(TransactionState.COMMITTING)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCommit(boolean readOnly) {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.COMMITTED)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCompletion() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
transactionListener.execute(commandContext);
}
}
});
}
}Example 35
| Project: jboss-seam-2.3.0.Final-Hibernate.3-master File: SpringTransaction.java View source code |
public void begin() throws NotSupportedException, SystemException {
log.debug("beginning Spring transaction");
if (TransactionSynchronizationManager.isActualTransactionActive()) {
throw new NotSupportedException("A Spring transaction is already active.");
}
currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
getSynchronizations().afterTransactionBegin();
}Example 36
| Project: jdbi-master File: JdbiUtil.java View source code |
/**
* Obtain a Handle instance, either the transactionally bound one if we are in a transaction,
* or a new one otherwise.
* @param db the Jdbi instance from which to obtain the handle
*
* @return the Handle instance
*/
public static Handle getHandle(Jdbi db) {
Handle bound = (Handle) TransactionSynchronizationManager.getResource(db);
if (bound == null) {
bound = db.open();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.bindResource(db, bound);
TransactionSynchronizationManager.registerSynchronization(new Adapter(db, bound));
TRANSACTIONAL_HANDLES.add(bound);
}
}
return bound;
}Example 37
| Project: jenkow-plugin-master File: SpringTransactionContext.java View source code |
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
if (transactionState.equals(TransactionState.COMMITTING)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCommit(boolean readOnly) {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.COMMITTED)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCompletion() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
transactionListener.execute(commandContext);
}
}
});
}
}Example 38
| Project: owsi-core-parent-master File: TransactionSynchronizationTaskManagerServiceImpl.java View source code |
protected void addSynchronizationIfNeeded() {
if (!TransactionSynchronizationManager.isActualTransactionActive()) {
throw new IllegalStateException(EXCEPTION_MESSAGE_NO_ACTUAL_TRANSACTION_ACTIVE);
}
if (!isTaskSynchronizationActive()) {
// Initialize the list of tasks that will be executed later
bindContext(new TransactionSynchronizationTasks());
// Register the synchronization adapter (that will transmit events to this service)
TransactionSynchronizationManager.registerSynchronization(new TaskTransactionSynchronizationAdapter());
}
}Example 39
| Project: seam-2.2-master File: SpringTransaction.java View source code |
public void begin() throws NotSupportedException, SystemException {
log.debug("beginning Spring transaction");
if (TransactionSynchronizationManager.isActualTransactionActive()) {
throw new NotSupportedException("A Spring transaction is already active.");
}
currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
getSynchronizations().afterTransactionBegin();
}Example 40
| Project: seam-revisited-master File: SpringTransaction.java View source code |
public void begin() throws NotSupportedException, SystemException {
log.debug("beginning Spring transaction");
if (TransactionSynchronizationManager.isActualTransactionActive()) {
throw new NotSupportedException("A Spring transaction is already active.");
}
currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
getSynchronizations().afterTransactionBegin();
}Example 41
| Project: seam2jsf2-master File: SpringTransaction.java View source code |
public void begin() throws NotSupportedException, SystemException {
log.debug("beginning Spring transaction");
if (TransactionSynchronizationManager.isActualTransactionActive()) {
throw new NotSupportedException("A Spring transaction is already active.");
}
currentTransaction = getPlatformTransactionManagerRequired().getTransaction(definition);
getSynchronizations().afterTransactionBegin();
}Example 42
| Project: spring-batch-master File: TransactionAwareProxyFactory.java View source code |
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
if (!TransactionSynchronizationManager.isActualTransactionActive()) {
return invocation.proceed();
}
T cache;
if (!TransactionSynchronizationManager.hasResource(this)) {
cache = begin(target);
TransactionSynchronizationManager.bindResource(this, cache);
TransactionSynchronizationManager.registerSynchronization(new TargetSynchronization(this, cache));
} else {
@SuppressWarnings("unchecked") T retrievedCache = (T) TransactionSynchronizationManager.getResource(this);
cache = retrievedCache;
}
Object result = invocation.getMethod().invoke(cache, invocation.getArguments());
if (appendOnly) {
String methodName = invocation.getMethod().getName();
if ((result == null && methodName.equals("get")) || (Boolean.FALSE.equals(result) && (methodName.startsWith("contains")) || (Boolean.TRUE.equals(result) && methodName.startsWith("isEmpty")))) {
// in the cache...
return invocation.proceed();
}
if (result instanceof Collection<?>) {
HashSet<Object> set = new HashSet<Object>((Collection<?>) result);
set.addAll((Collection<?>) invocation.proceed());
result = set;
}
}
return result;
}Example 43
| Project: spring-cloud-aws-master File: RdbmsRetryOperationsInterceptorTest.java View source code |
@Test
public void testRetryContextWithoutTransaction() throws Throwable {
this.expectedException.expect(RetryException.class);
this.expectedException.expectMessage("An active transaction was found");
TransactionSynchronizationManager.setActualTransactionActive(true);
try {
RdbmsRetryOperationsInterceptor operationsInterceptor = new RdbmsRetryOperationsInterceptor();
MethodInvocation methodInvocation = mock(MethodInvocation.class);
operationsInterceptor.invoke(methodInvocation);
} finally {
TransactionSynchronizationManager.setActualTransactionActive(false);
}
}Example 44
| Project: spring-data-jpa-master File: CrudMethodMetadataPostProcessor.java View source code |
/*
* (non-Javadoc)
* @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
*/
public Object invoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod();
CrudMethodMetadata metadata = (CrudMethodMetadata) TransactionSynchronizationManager.getResource(method);
if (metadata != null) {
return invocation.proceed();
}
CrudMethodMetadata methodMetadata = metadataCache.get(method);
if (methodMetadata == null) {
methodMetadata = new DefaultCrudMethodMetadata(method);
CrudMethodMetadata tmp = metadataCache.putIfAbsent(method, methodMetadata);
if (tmp != null) {
methodMetadata = tmp;
}
}
TransactionSynchronizationManager.bindResource(method, methodMetadata);
try {
return invocation.proceed();
} finally {
TransactionSynchronizationManager.unbindResource(method);
}
}Example 45
| Project: spring-ldap-master File: ContextSourceTransactionManagerTest.java View source code |
@Before
public void setUp() throws Exception {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.clearSynchronization();
}
contextSourceMock = mock(ContextSource.class);
contextMock = mock(DirContext.class);
transactionDefinitionMock = mock(TransactionDefinition.class);
transactionDataManagerMock = mock(CompensatingTransactionOperationManager.class);
renamingStrategyMock = mock(TempEntryRenamingStrategy.class);
tested = new ContextSourceTransactionManager();
tested.setContextSource(contextSourceMock);
tested.setRenamingStrategy(renamingStrategyMock);
}Example 46
| Project: spring-modules-jcr-master File: OpenSessionInViewTests.java View source code |
public void testOpenSessionInViewInterceptor() throws Exception {
MockControl sfControl = MockControl.createControl(SessionFactory.class);
SessionFactory sf = (SessionFactory) sfControl.getMock();
MockControl sessionControl = MockControl.createControl(Session.class);
Session session = (Session) sessionControl.getMock();
OpenSessionInViewInterceptor interceptor = new OpenSessionInViewInterceptor();
MockServletContext sc = new MockServletContext();
MockHttpServletRequest request = new MockHttpServletRequest(sc);
MockHttpServletResponse response = new MockHttpServletResponse();
sfControl.expectAndReturn(sf.getSession(), session);
SessionHolder holder = new SessionHolder(session);
sfControl.expectAndReturn(sf.getSessionHolder(session), holder);
sfControl.replay();
sessionControl.replay();
interceptor.setSessionFactory(sf);
interceptor.afterPropertiesSet();
interceptor.preHandle(request, response, "handler");
assertTrue(TransactionSynchronizationManager.hasResource(sf));
assertSame(holder, TransactionSynchronizationManager.getResource(sf));
// check that further invocations simply participate
interceptor.preHandle(request, response, "handler");
interceptor.preHandle(request, response, "handler");
interceptor.postHandle(request, response, "handler", null);
interceptor.afterCompletion(request, response, "handler", null);
interceptor.postHandle(request, response, "handler", null);
interceptor.afterCompletion(request, response, "handler", null);
interceptor.preHandle(request, response, "handler");
interceptor.postHandle(request, response, "handler", null);
interceptor.afterCompletion(request, response, "handler", null);
sfControl.verify();
sessionControl.verify();
sfControl.reset();
sessionControl.reset();
sfControl.replay();
sessionControl.replay();
interceptor.postHandle(request, response, "handler", null);
assertTrue(TransactionSynchronizationManager.hasResource(sf));
assertSame(holder, TransactionSynchronizationManager.getResource(sf));
sfControl.verify();
sessionControl.verify();
sfControl.reset();
sessionControl.reset();
session.logout();
sessionControl.setVoidCallable(1);
sfControl.replay();
sessionControl.replay();
interceptor.afterCompletion(request, response, "handler", null);
assertFalse(TransactionSynchronizationManager.hasResource(sf));
sfControl.verify();
sessionControl.verify();
}Example 47
| Project: summerb-master File: TransactionBoundCache.java View source code |
/**
* Get for write purpose
*/
private LoadingCache<K, V> get() {
String curTranName = TransactionSynchronizationManager.getCurrentTransactionName();
if (transactionBoundCacheEntries.get() != null) {
if (log.isTraceEnabled()) {
log.trace(cacheName + ": Using transaction-local (assumming active transaction) cache tran=" + curTranName);
}
return transactionBoundCacheEntries.get().transactionBound;
}
boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
if (!synchronizationActive) {
if (log.isTraceEnabled()) {
log.trace(cacheName + ": Using global cache");
}
return actual;
}
if (log.isTraceEnabled()) {
log.trace(cacheName + ": Constructing transaction-local cache, tran=" + curTranName);
}
TransactionSynchronizationManager.registerSynchronization(synchronization);
TransactionBoundCacheEntry newCache = new TransactionBoundCacheEntry<K, V>();
newCache.transactionBound = CacheBuilder.newBuilder().removalListener(localRemovalListener).build(loader);
newCache.transactionBound.putAll(actual.asMap());
newCache.transactionBoundRemovals = new HashSet<K>();
transactionBoundCacheEntries.set(newCache);
return newCache.transactionBound;
}Example 48
| Project: abiquo-master File: AbstractGeneratorTest.java View source code |
protected void tearDown(final String... entities) {
EntityManager em = getEntityManager();
rollbackActiveTransaction(em);
em.getTransaction().begin();
for (String entity : entities) {
em.createNativeQuery("delete from " + entity).executeUpdate();
}
em.getTransaction().commit();
em.close();
// Avoid having closed EntityManagers bound to the thread
TransactionSynchronizationManager.unbindResource(getEntityManagerFactory());
}Example 49
| Project: compass-fork-master File: SpringSyncTransaction.java View source code |
public void begin(PlatformTransactionManager transactionManager, InternalCompassSession session, boolean commitBeforeCompletion) {
this.session = session;
this.transactionManager = transactionManager;
// the factory called begin, so we are in charge, if we were not, than
// it would not call begin (we are in charge of the COMPASS transaction,
// the spring one is handled later)
controllingNewTransaction = true;
if (transactionManager != null) {
DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
transactionDefinition.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED);
int timeout = session.getSettings().getSettingAsInt(CompassEnvironment.Transaction.TRANSACTION_TIMEOUT, -1);
if (timeout != -1) {
transactionDefinition.setTimeout(timeout);
}
transactionDefinition.setReadOnly(session.isReadOnly());
status = transactionManager.getTransaction(transactionDefinition);
}
session.getSearchEngine().begin();
SpringTransactionSynchronization sync;
if (transactionManager != null) {
if (log.isDebugEnabled()) {
if (status.isNewTransaction()) {
log.debug("Beginning new Spring transaction, and a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
} else {
log.debug("Joining Spring transaction, and starting a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
}
}
sync = new SpringTransactionSynchronization(session, status.isNewTransaction(), commitBeforeCompletion, transactionFactory);
} else {
if (log.isDebugEnabled()) {
log.debug("Joining Spring transaction, and starting a new compass transaction on thread [" + Thread.currentThread().getName() + "]");
}
sync = new SpringTransactionSynchronization(session, false, commitBeforeCompletion, transactionFactory);
}
TransactionSynchronizationManager.registerSynchronization(sync);
setBegun(true);
}Example 50
| Project: droolsjbpm-master File: DroolsSpringTransactionManager.java View source code |
/**
* Borrowed from Seam
* @author Michael Youngstrom
*/
public int getStatus() {
if (ptm == null) {
return TransactionManager.STATUS_NO_TRANSACTION;
}
logger.debug("Current TX name (According to TransactionSynchronizationManager) : " + TransactionSynchronizationManager.getCurrentTransactionName());
if (TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionStatus transaction = null;
try {
if (currentTransaction == null) {
transaction = ptm.getTransaction(td);
if (transaction.isNewTransaction()) {
return TransactionManager.STATUS_COMMITTED;
}
} else {
transaction = currentTransaction;
}
logger.debug("Current TX: " + transaction);
// then we must be in the middle of committing
if (transaction.isCompleted()) {
if (transaction.isRollbackOnly()) {
return TransactionManager.STATUS_ROLLEDBACK;
}
return TransactionManager.STATUS_COMMITTED;
} else {
if (transaction.isRollbackOnly()) {
return TransactionManager.STATUS_ROLLEDBACK;
}
return TransactionManager.STATUS_ACTIVE;
}
} finally {
if (currentTransaction == null) {
ptm.commit(transaction);
}
}
}
return TransactionManager.STATUS_NO_TRANSACTION;
}Example 51
| Project: easyooo-framework-master File: RoutingSynchronizationManager.java View source code |
public static void initSynchronization(TransactionDefinition definition) throws IllegalStateException {
if (isSynchronizationActive()) {
throw new IllegalStateException("Cannot activate transaction synchronization - already active");
}
if (logger.isDebugEnabled()) {
logger.debug("Initializing transaction synchronization");
}
synchronizations.set(new LinkedHashMap<DataSource, ConnectionHolder>());
definitions.set(definition);
// åˆ?始化Springå?Œæ¥äº‹åŠ¡ç®¡ç?†å™¨ï¼Œè¿™ä½¿å¾—Mybatis让SpringæŽ¥ç®¡äº‹åŠ¡æ—¶ï¼Œæœ‰ä¸€ä¸ªåˆ¤æ–æ ‡å‡†ï¼Œ
// ä¸?会é‡?å¤?打开Session,也ä¸?会直接关é—Session
// 具体请�看 org.mybatis.spring.SqlSessionUtils#getSqlSession
// org.mybatis.spring.SqlSessionTemplate.SqlSessionInterceptor#invoke
TransactionSynchronizationManager.initSynchronization();
}Example 52
| Project: ganshane-master File: SpringSessionManagerImpl.java View source code |
@Override
public void threadDidCleanup() {
if (!participate) {
// single session mode
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
closeSession(sessionHolder.getSession(), sessionFactory);
}
}Example 53
| Project: hq-master File: GalertProcessorImpl.java View source code |
/**
* Called when primitive information has been updated which doens't
* require a reload of the entire definition.
*/
public void alertDefUpdated(GalertDef def, final String newName) {
final Integer defId = def.getId();
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
public void suspend() {
}
public void resume() {
}
public void flush() {
}
public void beforeCompletion() {
}
public void beforeCommit(boolean readOnly) {
}
public void afterCompletion(int status) {
}
public void afterCommit() {
synchronized (cfgLock) {
MemGalertDef memDef = (MemGalertDef) _alertDefs.get(defId);
if (memDef != null)
memDef.setName(newName);
}
}
});
}Example 54
| Project: jcr-springextension-master File: LocalTransactionManagerTest.java View source code |
@Test
public void testTransactionCommit() throws Exception {
final SessionFactory sessionFactory = createMock(SessionFactory.class);
final XASession xaSession = createMock(XASession.class);
// create nice mock
XAResource xaResource = createMock(XAResource.class);
expect(sessionFactory.getSession()).andReturn(xaSession);
expect(xaSession.getXAResource()).andReturn(xaResource);
xaSession.save();
xaSession.logout();
Xid xidMock = new XidMock();
xaResource.start(xidMock, XAResource.TMNOFLAGS);
expect(xaResource.prepare(xidMock)).andReturn(0);
xaResource.commit(xidMock, false);
xaResource.end(xidMock, XAResource.TMSUCCESS);
replay(sessionFactory, xaSession, xaResource);
PlatformTransactionManager tm = new LocalTransactionManager(sessionFactory);
TransactionTemplate tt = new TransactionTemplate(tm);
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sessionFactory));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
tt.execute(new TransactionCallbackWithoutResult() {
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sessionFactory));
JcrTemplate template = new JcrTemplate(sessionFactory);
template.save();
}
});
assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sessionFactory));
assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
verify(sessionFactory, xaResource, xaSession);
}Example 55
| Project: m3s-master File: AbstractServiceTest.java View source code |
/**
* One time setup which keeps a session open for the duration of the tests.
*/
protected void onSetUp() throws Exception {
//logger.trace("onSetup(): entered method.");
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
Session session = sessionFactory.openSession();
SessionHolder holder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(sessionFactory, holder);
}Example 56
| Project: narayana-master File: PlatformTransactionManagerImple.java View source code |
public void resumed(Transaction transaction) {
SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
if (holder != null) {
TransactionSynchronizationManager.setActualTransactionActive(true);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
TransactionSynchronizationManager.initSynchronization();
for (TransactionSynchronization synchronization : holder.getSuspendedSynchronizations()) {
synchronization.resume();
TransactionSynchronizationManager.registerSynchronization(synchronization);
}
}
}Example 57
| Project: riot-master File: ThreadBoundHibernateTemplate.java View source code |
@Override
protected Object doExecute(HibernateCallback action, boolean enforceNewSession, boolean enforceNativeSession) throws DataAccessException {
Assert.notNull(action, "Callback object must not be null");
Session oldSession = null;
Session session = (enforceNewSession ? SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());
boolean existingTransaction = !enforceNewSession && (!isAllowCreate() || (sessionHolder != null && sessionHolder.containsSession(session)));
if (existingTransaction) {
log.debug("Found thread-bound Session for LongConversationTemplate");
} else {
if (sessionHolder != null) {
oldSession = sessionHolder.getSession();
sessionHolder.addSession(session);
} else {
TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
}
}
FlushMode previousFlushMode = null;
try {
previousFlushMode = applyFlushMode(session, existingTransaction);
enableFilters(session);
Session sessionToExpose = (enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
Object result = action.doInHibernate(sessionToExpose);
flushIfNecessary(session, existingTransaction);
return result;
} catch (HibernateException ex) {
throw convertHibernateAccessException(ex);
} catch (SQLException ex) {
throw convertJdbcAccessException(ex);
} catch (RuntimeException ex) {
throw ex;
} finally {
if (existingTransaction) {
log.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
disableFilters(session);
if (previousFlushMode != null) {
session.setFlushMode(previousFlushMode);
}
} else {
SessionFactoryUtils.closeSession(session);
if (oldSession != null) {
sessionHolder.addSession(oldSession);
} else {
TransactionSynchronizationManager.unbindResource(getSessionFactory());
}
}
}
}Example 58
| Project: spring-data-jdbc-ext-master File: AqJmsFactoryBeanFactory.java View source code |
@Override
public java.sql.Connection getConnection() throws SQLException {
java.sql.Connection con = DataSourceUtils.getConnection(getTargetDataSource());
java.sql.Connection conToUse = con;
if (!(con instanceof OracleConnection)) {
if (logger.isDebugEnabled()) {
logger.debug("Unwrapping JDBC Connection of type:" + con.getClass().getName());
}
try {
conToUse = nativeJdbcExtractor.getNativeConnection(con);
} catch (SQLException e) {
throw new NonTransientDataAccessResourceException("Error unwrapping the Oracle Connection: " + e.getMessage(), e);
}
}
if (TransactionSynchronizationManager.isActualTransactionActive()) {
if (logger.isDebugEnabled()) {
logger.debug("Using Proxied JDBC Connection [" + conToUse + "]");
}
return getCloseSuppressingConnectionProxy(conToUse);
} else {
if (con instanceof OracleConnection) {
if (logger.isDebugEnabled()) {
logger.debug("Using Native JDBC Connection [" + conToUse + "]");
}
return conToUse;
} else {
if (logger.isDebugEnabled()) {
logger.debug("Using Closeable Proxy fo JDBC Connection [" + conToUse + "]");
}
return getCloseDelegatingConnectionProxy(conToUse, con);
}
}
}Example 59
| Project: springboot-dubbox-master File: DynamicPlugin.java View source code |
@Override
public Object intercept(Invocation invocation) throws Throwable {
boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
//如果没有事务
if (!synchronizationActive) {
Object[] objects = invocation.getArgs();
MappedStatement ms = (MappedStatement) objects[0];
DynamicDataSourceGlobal dynamicDataSourceGlobal;
if ((dynamicDataSourceGlobal = CACHE_MAP.get(ms.getId())) == null) {
dynamicDataSourceGlobal = getDynamicDataSource(ms, objects[1]);
LOGGER.warn("设置方法[{}] use [{}] Strategy, SqlCommandType [{}]..", ms.getId(), dynamicDataSourceGlobal.name(), ms.getSqlCommandType().name());
CACHE_MAP.put(ms.getId(), dynamicDataSourceGlobal);
}
DynamicDataSourceHolder.putDataSource(dynamicDataSourceGlobal);
}
return invocation.proceed();
}Example 60
| Project: starflow-master File: DefaultUniqueTableApp.java View source code |
public CacheValue getCacheValue(int cacheNum, String name) {
Assert.isTrue(TransactionSynchronizationManager.isSynchronizationActive(), "Transaction must be running");
CacheValue cache = null;
try {
cache = getCurrCode(name);
if (cache == null) {
insert(name);
cache = getCurrCode(name);
}
update(cacheNum, name);
cache.setMaxVal(cache.getMinVal() + cacheNum);
} catch (Exception e) {
logger.error("获�主键失败", e);
}
return cache;
}Example 61
| Project: tapestry5-spring-tx-master File: SpringHibernateSessionManagerImpl.java View source code |
private void startNewTransaction() {
sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());
existingTransaction = (sessionHolder != null && sessionHolder.containsSession(session));
if (existingTransaction) {
logger.debug("Found thread-bound Session for HibernateInterceptor");
} else {
if (sessionHolder != null) {
sessionHolder.addSession(session);
} else {
TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
}
}
this.previousFlushMode = applyFlushMode(session, existingTransaction);
enableFilters(session);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
this.status = txManager.getTransaction(definition);
}Example 62
| Project: uPortal-master File: OpenEntityManagerAspect.java View source code |
@Around("anyPublicMethod() && @annotation(openEntityManager)")
public Object openEntityManager(ProceedingJoinPoint pjp, OpenEntityManager openEntityManager) throws Throwable {
final EntityManagerFactory emf = getEntityManagerFactory(openEntityManager);
EntityManager em = getTransactionalEntityManager(emf);
boolean isNewEm = false;
if (em == null) {
logger.debug("Opening JPA EntityManager in OpenEntityManagerAspect");
em = createEntityManager(emf);
isNewEm = true;
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
} else {
logger.debug("Using Existing JPA EntityManager in OpenEntityManagerAspect");
}
try {
return pjp.proceed();
} finally {
if (isNewEm) {
logger.debug("Closing JPA EntityManager in OpenEntityManagerAspect");
TransactionSynchronizationManager.unbindResource(emf);
EntityManagerFactoryUtils.closeEntityManager(em);
}
}
}Example 63
| Project: Activiti-master File: SpringTransactionContext.java View source code |
public void addTransactionListener(final TransactionState transactionState, final TransactionListener transactionListener) {
if (transactionState.equals(TransactionState.COMMITTING)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCommit(boolean readOnly) {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.COMMITTED)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
CommandExecutor commandExecutor = commandContext.getProcessEngineConfiguration().getCommandExecutor();
CommandConfig commandConfig = new CommandConfig(false, TransactionPropagation.REQUIRES_NEW);
commandExecutor.execute(commandConfig, new Command<Void>() {
public Void execute(CommandContext commandContext) {
transactionListener.execute(commandContext);
return null;
}
});
}
});
} else if (transactionState.equals(TransactionState.ROLLINGBACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCompletion() {
transactionListener.execute(commandContext);
}
});
} else if (transactionState.equals(TransactionState.ROLLED_BACK)) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
if (TransactionSynchronization.STATUS_ROLLED_BACK == status) {
CommandExecutor commandExecutor = commandContext.getProcessEngineConfiguration().getCommandExecutor();
CommandConfig commandConfig = new CommandConfig(false, TransactionPropagation.REQUIRES_NEW);
commandExecutor.execute(commandConfig, new Command<Void>() {
public Void execute(CommandContext commandContext) {
transactionListener.execute(commandContext);
return null;
}
});
}
}
});
}
}Example 64
| Project: aries-master File: AriesPlatformTransactionManager.java View source code |
public void threadAssociated(Transaction transaction) {
try {
if (transaction.getStatus() == Status.STATUS_ACTIVE) {
SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
if (holder != null && holder.getSuspendedSynchronizations() != null) {
TransactionSynchronizationManager.setActualTransactionActive(true);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
TransactionSynchronizationManager.initSynchronization();
for (Iterator<?> it = holder.getSuspendedSynchronizations().iterator(); it.hasNext(); ) {
TransactionSynchronization synchronization = (TransactionSynchronization) it.next();
synchronization.resume();
TransactionSynchronizationManager.registerSynchronization(synchronization);
}
}
}
} catch (SystemException e) {
return;
}
}Example 65
| Project: BlackboardVCPortlet-master File: OpenEntityManagerAspect.java View source code |
@Around("anyPublicMethod() && @annotation(openEntityManager)")
public Object openEntityManager(ProceedingJoinPoint pjp, OpenEntityManager openEntityManager) throws Throwable {
final EntityManagerFactory emf = getEntityManagerFactory(openEntityManager);
EntityManager em = getTransactionalEntityManager(emf);
boolean isNewEm = false;
if (em == null) {
logger.debug("Opening JPA EntityManager in OpenEntityManagerAspect");
em = createEntityManager(emf);
isNewEm = true;
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em));
} else {
logger.debug("Using Existing JPA EntityManager in OpenEntityManagerAspect");
}
try {
return pjp.proceed();
} finally {
if (isNewEm) {
logger.debug("Closing JPA EntityManager in OpenEntityManagerAspect");
TransactionSynchronizationManager.unbindResource(emf);
EntityManagerFactoryUtils.closeEntityManager(em);
}
}
}Example 66
| Project: EasyTransaction-master File: EasyTransSynchronizer.java View source code |
/**
* create LogContext.<br>
* pass in busCode and trxId will help about the execute efficient and the debug and statistics<br>
* so I demand to pass in busCode and trxId to generate a global unique bus key
* @param busCode the unique busCode in AppId
* @param trxId the unique trxId in appId+busCode
*/
public void startSoftTrans(String busCode, String trxId) {
Assert.notNull(busCode);
Assert.notNull(trxId);
//hook to TransactionSynchronizer
TransactionSynchronizationManager.registerSynchronization(new TransactionHook());
LogProcessContext logProcessContext = new LogProcessContext(config.getAppId(), busCode, trxId, writer, transStatusLogger);
TransactionSynchronizationManager.bindResource(LOG_PROCESS_CONTEXT, logProcessContext);
transStatusLogger.writeExecuteFlag(config.getAppId(), busCode, trxId);
}Example 67
| Project: felix-master File: GeronimoPlatformTransactionManager.java View source code |
public void threadAssociated(Transaction transaction) {
try {
if (transaction.getStatus() == Status.STATUS_ACTIVE) {
SuspendedResourcesHolder holder = suspendedResources.remove(transaction);
if (holder != null && holder.getSuspendedSynchronizations() != null) {
TransactionSynchronizationManager.setActualTransactionActive(true);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(holder.isReadOnly());
TransactionSynchronizationManager.setCurrentTransactionName(holder.getName());
TransactionSynchronizationManager.initSynchronization();
for (Iterator<?> it = holder.getSuspendedSynchronizations().iterator(); it.hasNext(); ) {
TransactionSynchronization synchronization = (TransactionSynchronization) it.next();
synchronization.resume();
TransactionSynchronizationManager.registerSynchronization(synchronization);
}
}
}
} catch (SystemException e) {
return;
}
}Example 68
| Project: graniteds-master File: TideDataPublishingWrapper.java View source code |
public <T> T execute(DataEnabled dataEnabled, ThrowableCallable<T> action) throws Throwable {
boolean shouldRemoveContextAtEnd = DataContext.get() == null;
boolean shouldInitContext = shouldRemoveContextAtEnd || DataContext.isNull();
boolean onCommit = false;
if (shouldInitContext) {
DataContext.init(gravity, dataEnabled.topic(), dataEnabled.params(), dataEnabled.publish());
if (dataUpdatePostprocessor != null)
DataContext.get().setDataUpdatePostprocessor(dataUpdatePostprocessor);
}
DataContext.observe();
try {
if (dataEnabled.publish().equals(PublishMode.ON_COMMIT) && !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
boolean registered = false;
for (Object resource : TransactionSynchronizationManager.getResourceMap().values()) {
if (syncsMap.containsKey(resource.getClass().getName())) {
registered = syncsMap.get(resource.getClass().getName()).registerSynchronization(resource, shouldRemoveContextAtEnd);
break;
}
}
if (!registered)
TransactionSynchronizationManager.registerSynchronization(new DataPublishingTransactionSynchronization(shouldRemoveContextAtEnd));
else if (shouldRemoveContextAtEnd)
TransactionSynchronizationManager.registerSynchronization(new DataContextCleanupTransactionSynchronization());
onCommit = true;
} else if (TransactionSynchronizationManager.isActualTransactionActive()) {
log.error("Could not register synchronization for ON_COMMIT publish mode, check that the Spring PlatformTransactionManager supports it " + "and that the order of the TransactionInterceptor is lower than the order of TideDataPublishingInterceptor");
if (shouldRemoveContextAtEnd)
DataContext.remove();
} else {
// No transaction, clear data context and wait for a possible manual transactions
if (shouldRemoveContextAtEnd)
DataContext.remove();
}
}
T ret = action.call();
DataContext.publish(PublishMode.ON_SUCCESS);
return ret;
} finally {
if (shouldRemoveContextAtEnd && !onCommit)
DataContext.remove();
}
}Example 69
| Project: graphity-core-master File: OpenSessionInViewTests.java View source code |
@After
public void tearDown() throws Exception {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
}Example 70
| Project: haze-master File: HazelcastTransactionManager.java View source code |
/**
* Returns the transaction context for the given Hazelcast instance bounded to the current thread.
*
* @throws NoTransactionException if the transaction context cannot be found
*/
public static TransactionContext getTransactionContext(HazelcastInstance hazelcastInstance) {
TransactionContextHolder transactionContextHolder = (TransactionContextHolder) TransactionSynchronizationManager.getResource(hazelcastInstance);
if (transactionContextHolder == null) {
throw new NoTransactionException("No TransactionContext with actual transaction available for current thread");
}
return transactionContextHolder.getContext();
}Example 71
| Project: hazelcast-master File: HazelcastTransactionManager.java View source code |
/**
* Returns the transaction context for the given Hazelcast instance bounded to the current thread.
*
* @throws NoTransactionException if the transaction context cannot be found
*/
public static TransactionContext getTransactionContext(HazelcastInstance hazelcastInstance) {
TransactionContextHolder transactionContextHolder = (TransactionContextHolder) TransactionSynchronizationManager.getResource(hazelcastInstance);
if (transactionContextHolder == null) {
throw new NoTransactionException("No TransactionContext with actual transaction available for current thread");
}
return transactionContextHolder.getContext();
}Example 72
| Project: jeffaschenk-commons-master File: SpringAccessor.java View source code |
/**
* Obtain the Current Session.
*
* @return Session which is Current Active Session or newly created Session.
*/
public static Session getCurrentSession() {
try {
SessionFactory sessionFactory = (SessionFactory) getBean(sessionFactoryBeanName);
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
if (holder == null) {
return getSession();
}
// **********************************
// Obtain Session within Holder.
Session session = holder.getSession();
if (session != null) {
return session;
} else {
return getSession();
}
} catch (Exception e) {
log.error("Exception encountered while Obtaining Current Session:" + e.getMessage(), e);
throw new java.lang.RuntimeException("Exception encountered while Obtaining Current Session Encountered", e);
}
}Example 73
| Project: lutece-core-master File: ChainedTransactionManager.java View source code |
/**
* Begin a transaction for all transaction managers {@inheritDoc}
*/
public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
if (_transactionManagers.isEmpty()) {
return null;
}
MultiTransactionStatus mts = new MultiTransactionStatus(_transactionManagers.get(0));
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.initSynchronization();
mts.setNewSynchonization();
if (_log.isDebugEnabled()) {
_log.debug("Begin transaction : " + mts.toString());
}
}
for (PlatformTransactionManager transactionManager : _transactionManagers) {
mts.getTransactionStatuses().put(transactionManager, transactionManager.getTransaction(definition));
}
return mts;
}Example 74
| Project: molgenis-master File: IndexActionRegisterServiceImpl.java View source code |
@Transactional
@Override
public synchronized void register(String entityFullName, String entityId) {
String transactionId = (String) TransactionSynchronizationManager.getResource(TRANSACTION_ID_RESOURCE_NAME);
if (transactionId != null) {
LOG.debug("register(entityFullName: [{}], entityId: [{}])", entityFullName, entityId);
final int actionOrder = indexActionsPerTransaction.get(transactionId).size();
if (actionOrder >= LOG_EVERY && actionOrder % LOG_EVERY == 0) {
LOG.warn("Transaction {} has caused {} IndexActions to be created. Consider streaming your data manipulations.", transactionId, actionOrder);
}
IndexAction indexAction = indexActionFactory.create().setIndexActionGroup(indexActionGroupFactory.create(transactionId)).setEntityFullName(entityFullName).setEntityId(entityId).setIndexStatus(PENDING);
indexActionsPerTransaction.put(transactionId, indexAction);
} else {
LOG.error("Transaction id is unknown, register of entityFullName [{}] dataType [{}], entityId [{}]", entityFullName, entityId);
}
}Example 75
| Project: mybatis-shards-master File: MultiDataSourcesTransactionManager.java View source code |
@Override
public TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
MultiDataSourcesTransactionStatus transactionStatus = new MultiDataSourcesTransactionStatus();
log.debug("Operation '" + definition.getName() + "' starting transaction.");
for (DataSource dataSource : dataSources) {
DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(definition);
defaultTransactionDefinition.setName(definition.getName());
PlatformTransactionManager txManager = this.transactionManagers.get(dataSource);
TransactionStatus status = txManager.getTransaction(defaultTransactionDefinition);
TransactionSynchronizationManager.setCurrentTransactionName(defaultTransactionDefinition.getName());
transactionStatus.put(dataSource, status);
}
return transactionStatus;
}Example 76
| Project: perecoder-master File: TransactionalIndexWriterAccessor.java View source code |
@Override
public IndexWriter retrieveWriter(Directory directory) throws IOException {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
// Получаем адаптер Ñ?инхронизации из менеджера
IndexWriterTransactionSynchronization synchronization = (IndexWriterTransactionSynchronization) TransactionSynchronizationManager.getResource(directory);
if (synchronization == null) {
synchronization = new IndexWriterTransactionSynchronization(new IndexWriter(directory, indexWriterConfig.clone()));
TransactionSynchronizationManager.bindResource(directory, synchronization);
}
// ВыполнÑ?ем перерегиÑ?трацию адаптера
TransactionSynchronizationManager.registerSynchronization(synchronization);
// Возвращаем актуальный Ñ?ервиÑ? запиÑ?и
return synchronization.getWriter();
} else {
return createIndexWriter(directory);
}
}Example 77
| Project: ranger-master File: RangerTransactionSynchronizationAdapter.java View source code |
public void executeOnTransactionCompletion(Runnable runnable) {
if (LOG.isDebugEnabled()) {
LOG.debug("Submitting new runnable {" + runnable + "} to run after completion");
}
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
LOG.info("Transaction synchronization is NOT ACTIVE. Executing right now runnable {" + runnable + "}");
runnable.run();
return;
}
List<Runnable> threadRunnables = RUNNABLES.get();
if (threadRunnables == null) {
threadRunnables = new ArrayList<Runnable>();
RUNNABLES.set(threadRunnables);
// Register a new transaction synchronization for the current thread.
// TransactionSynchronizationManage will call afterCompletion() when current transaction completes.
TransactionSynchronizationManager.registerSynchronization(this);
}
threadRunnables.add(runnable);
}Example 78
| Project: spring-data-neo4j-master File: OpenSessionInViewInterceptor.java View source code |
@Override
public void preHandle(WebRequest request) throws DataAccessException {
String participateAttributeName = getParticipateAttributeName();
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
if (asyncManager.hasConcurrentResult()) {
if (applyCallableInterceptor(asyncManager, participateAttributeName)) {
return;
}
}
if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {
// Do not modify the Session: just mark the request accordingly.
Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
int newCount = (count != null ? count + 1 : 1);
request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
} else {
logger.debug("Opening Neo4j OGM Session in OpenSessionInViewInterceptor");
Session session = sessionFactory.openSession();
SessionHolder sessionHolder = new SessionHolder(session);
TransactionSynchronizationManager.bindResource(getSessionFactory(), sessionHolder);
AsyncRequestInterceptor interceptor = new AsyncRequestInterceptor(getSessionFactory(), sessionHolder);
asyncManager.registerCallableInterceptor(participateAttributeName, interceptor);
asyncManager.registerDeferredResultInterceptor(participateAttributeName, interceptor);
}
}Example 79
| Project: spring-data-orientdb-master File: OrientTransactionManager.java View source code |
/* (non-Javadoc)
* @see org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, org.springframework.transaction.TransactionDefinition)
*/
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
OrientTransaction tx = (OrientTransaction) transaction;
ODatabase<?> db = tx.getDatabase();
if (db == null || db.isClosed()) {
db = dbf.openDatabase();
tx.setDatabase(db);
TransactionSynchronizationManager.bindResource(dbf, db);
}
log.debug("beginning transaction, db.hashCode() = {}", db.hashCode());
db.begin();
}Example 80
| Project: spring-db4o-master File: Db4oTransactionManager.java View source code |
protected void doBegin(Object transaction, TransactionDefinition transactionDefinition) throws TransactionException {
if (transactionDefinition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
throw new InvalidIsolationLevelException("Db4o does not support an isolation level concept");
}
ObjectContainer container = null;
try {
Db4oTransactionObject txObject = (Db4oTransactionObject) transaction;
if (txObject.getObjectContainerHolder() == null) {
// use the given container
container = getObjectContainer();
logger.debug("Using given objectContainer [{}] for the current thread transaction", container);
txObject.setObjectContainerHolder(new ObjectContainerHolder(container));
}
ObjectContainerHolder containerHolder = txObject.getObjectContainerHolder();
containerHolder.setSynchronizedWithTransaction(true);
// Register transaction timeout.
if (transactionDefinition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getObjectContainerHolder().setTimeoutInSeconds(transactionDefinition.getTimeout());
}
// Bind the session holder to the thread.
TransactionSynchronizationManager.bindResource(getObjectContainer(), containerHolder);
} catch (Exception ex) {
throw new CannotCreateTransactionException("Could not start db4o object container transaction", ex);
}
}Example 81
| Project: spring-hadoop-master File: HdfsItemWriter.java View source code |
@SuppressWarnings({ "unchecked", "rawtypes" })
private List<? extends T> getCurrentBuffer() {
if (!TransactionSynchronizationManager.hasResource(bufferKey)) {
TransactionSynchronizationManager.bindResource(bufferKey, new ArrayList());
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void beforeCommit(boolean readOnly) {
List items = (List) TransactionSynchronizationManager.getResource(bufferKey);
if (!CollectionUtils.isEmpty(items)) {
if (!readOnly) {
doWrite(items);
}
}
}
@Override
public void afterCompletion(int status) {
if (TransactionSynchronizationManager.hasResource(bufferKey)) {
TransactionSynchronizationManager.unbindResource(bufferKey);
}
}
});
}
return (List) TransactionSynchronizationManager.getResource(bufferKey);
}Example 82
| Project: spring-integration-master File: RedisStoreMessageSource.java View source code |
/**
* Returns a Message with the view into a {@link RedisStore} identified
* by {@link #keyExpression}
*/
@Override
@SuppressWarnings("unchecked")
public Message<RedisStore> receive() {
String key = this.keyExpression.getValue(this.evaluationContext, String.class);
Assert.hasText(key, "Failed to determine the key for the collection");
RedisStore store = this.createStoreView(key);
Object holder = TransactionSynchronizationManager.getResource(this);
if (holder != null) {
Assert.isInstanceOf(IntegrationResourceHolder.class, holder);
((IntegrationResourceHolder) holder).addAttribute("store", store);
}
if (store instanceof Collection<?> && ((Collection<Object>) store).size() < 1) {
return null;
} else {
return this.getMessageBuilderFactory().withPayload(store).build();
}
}Example 83
| Project: spring-master File: SqlSessionTemplateTest.java View source code |
@Test
public void testExecutorType() {
SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
assertThat(template.getExecutorType()).isEqualTo(ExecutorType.BATCH);
DataSourceTransactionManager manager = new DataSourceTransactionManager(dataSource);
TransactionStatus status = null;
try {
status = manager.getTransaction(new DefaultTransactionDefinition());
// will synchronize the template with the current tx
template.getConnection();
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sqlSessionFactory);
assertThat(holder.getExecutorType()).isEqualTo(ExecutorType.BATCH);
} finally {
// rollback required to close connection
txManager.rollback(status);
}
}Example 84
| Project: spring-xd-master File: JobLaunchingJobRepositoryFactoryBean.java View source code |
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
throw new IllegalStateException("Existing transaction detected in JobRepository. " + "Please fix this and try again (e.g. " + "remove @Transactional annotations from " + "client).");
}
return invocation.proceed();
}Example 85
| Project: tcc-master File: EasyTransSynchronizer.java View source code |
/**
* create LogContext.<br>
* pass in busCode and trxId will help about the execute efficient and the debug and statistics<br>
* so I demand to pass in busCode and trxId to generate a global unique bus key
* @param busCode the unique busCode in AppId
* @param trxId the unique trxId in appId+busCode
*/
public void startSoftTrans(String busCode, String trxId) {
Assert.notNull(busCode);
Assert.notNull(trxId);
//hook to TransactionSynchronizer
TransactionSynchronizationManager.registerSynchronization(new TransactionHook());
LogProcessContext logProcessContext = new LogProcessContext(config.getAppId(), busCode, trxId, writer, transStatusLogger);
TransactionSynchronizationManager.bindResource(LOG_PROCESS_CONTEXT, logProcessContext);
transStatusLogger.writeExecuteFlag(config.getAppId(), busCode, trxId);
}Example 86
| Project: spring-data-gemfire-master File: GemfireTransactionManager.java View source code |
/**
* @inheritDoc
*/
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
try {
CacheTransactionObject cacheTransaction = (CacheTransactionObject) transaction;
GemFireCache cache = getCache();
if (logger.isDebugEnabled()) {
logger.debug(String.format("Acquired GemFire Cache [%s] for local cache transaction", cache));
}
CacheTransactionManager cacheTransactionManager = getCacheTransactionManager();
// begin GemFire local cache transaction
cacheTransactionManager.begin();
TransactionId transactionId = cacheTransactionManager.getTransactionId();
if (transactionId != null) {
TransactionSynchronizationManager.bindResource(cache, cacheTransaction.setAndGetHolder(newCacheHolder(transactionId)));
}
} catch (IllegalStateException e) {
throw new CannotCreateTransactionException(String.format("%1$s; %2$s", "An existing, ongoing transaction is already associated with the current thread", "are multiple transaction managers present?"), e);
}
}Example 87
| Project: claudia-master File: InitDbCloudProviders.java View source code |
@Transactional
public void loadTestBedBCN() {
LOGGER.info(" ");
assert TransactionSynchronizationManager.isActualTransactionActive();
List<CloudProvider> list = cloudProviderDao.findAll();
LOGGER.info(" size of current cloudProviders: " + list.size());
if (list.size() != 0) {
LOGGER.info(" ALREADY LOADED!! ");
return;
}
/**
VEE vee1cp1 = new VEE();
vee1cp1.setName("VEE1 EMOTIVE1");
vee1cp1.setCost(10);
MemoryConf mc=new MemoryConf();
mc.setMemoryUnit(MemoryUnit.GB);
mc.setQuantity(128);
vee1cp1.setMemoryConf(mc);
CloudProvider cp1 = new CloudProvider();
cp1.setUri("http://84.21.173.26:8080/DRP");
cp1.setName("EMOTIVE1");
cp1.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp1})));
vee1cp1.setCloudProvider(cp1);
VEE vee1cp2 = new VEE();
vee1cp2.setName("VEE1 EMOTIVE2");
vee1cp2.setCost(20);
CloudProvider cp2 = new CloudProvider();
cp2.setUri("http://84.21.173.27:8080/DRP");
cp2.setName("EMOTIVE2");
cp2.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp2})));
vee1cp2.setCloudProvider(cp2);
VEE vee1cp3 = new VEE();
vee1cp3.setName("VEE1 ONE");
vee1cp3.setCost(30);
CloudProvider cp3 = new CloudProvider();
cp3.setUri("http://84.21.173.28:4567");
cp3.setName("ONE");
cp3.setVees(new HashSet<VEE>(Arrays.asList(new VEE[] {vee1cp3})));
vee1cp3.setCloudProvider(cp3);
// * ----------- temporal ------------------- *
try {
XMLEncoder encoder=new XMLEncoder(
new BufferedOutputStream(new FileOutputStream("/tmp/mf.xml")));
encoder.writeObject(cp1);
encoder.writeObject(vee1cp1);
encoder.writeObject(cp2);
encoder.writeObject(vee1cp2);
encoder.writeObject(cp3);
encoder.writeObject(vee1cp3);
encoder.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// * ----------- fin temporal ------------------- *
cloudProviderDao.save(cp1);
cloudProviderDao.save(cp2);
cloudProviderDao.save(cp3);
LOGGER.info("loadTestBedBCN load end");
**/
/**/
XmlCloudProviderHelper x = XmlCloudProviderHelper.getInstance();
try {
Set<CloudProvider> newcps = x.decode();
for (CloudProvider cp : newcps) {
System.out.println("cn.nombre: " + cp.getName());
for (VEE vee : cp.getVees()) {
System.out.println("....vee.nombre: " + vee.getName() + " --> " + vee.getCost());
}
System.out.flush();
cloudProviderDao.save(cp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedDataTypeException e) {
e.printStackTrace();
}
/**/
}Example 88
| Project: droolsbook-master File: JPAKnowledgeSessionTemplate.java View source code |
private void execute(KnowledgeSessionCallback action, StatefulKnowledgeSession session) {
LocalHTWorkItemHandler hTHandler = new LocalHTWorkItemHandler(localTaskService, session, true);
try {
registerWorkItemHandlers(session, hTHandler);
action.execute(session);
} finally {
TransactionSynchronizationManager.registerSynchronization(new SessionCleanupTransactionSynchronisation(session, hTHandler));
}
}Example 89
| Project: egovframe.rte.3.5-master File: AbstractLobTypeHandler.java View source code |
/**
* This implementation delegates to setParameterInternal,
* passing in a transaction-synchronized LobCreator for the
* LobHandler of this type.
* @see #setParameterInternal
*/
public final void setParameter(PreparedStatement ps, int i, Object parameter, String jdbcType) throws SQLException {
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
throw new IllegalStateException("Spring transaction synchronization needs to be active for " + "setting values in iBATIS TypeHandlers that delegate to a Spring LobHandler");
}
final LobCreator lobCreator = this.lobHandler.getLobCreator();
try {
setParameterInternal(ps, i, parameter, jdbcType, lobCreator);
} catch (IOException ex) {
throw new SQLException("I/O errors during LOB access: " + ex.getMessage());
}
TransactionSynchronizationManager.registerSynchronization(new LobCreatorSynchronization(lobCreator));
}Example 90
| Project: Gorm-master File: HibernateCriteriaBuilder.java View source code |
@Override
protected void createCriteriaInstance() {
{
if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
participate = true;
hibernateSession = ((SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory)).getSession();
} else {
hibernateSession = sessionFactory.openSession();
}
criteria = hibernateSession.createCriteria(targetClass);
cacheCriteriaMapping();
criteriaMetaClass = GroovySystem.getMetaClassRegistry().getMetaClass(criteria.getClass());
}
}Example 91
| Project: iaf-master File: DestinationFactoryUtils.java View source code |
/** * Obtain a JMS String that is synchronized with the current transaction, if any. * @param sapSystem the JMS SapSystem to bind for * (used as TransactionSynchronizationManager key) * @param resourceFactory the ResourceFactory to use for extracting or creating * JMS resources * @param startDestination whether the underlying JMS JCoDestination approach should be * started in order to allow for receiving messages. Note that a reused JCoDestination * may already have been started before, even if this flag is <code>false</code>. * @return the transactional String, or <code>null</code> if none found * @throws JCoException in case of failure */ public static String doGetTransactionalTid(SapSystem sapSystem, ResourceFactory resourceFactory) throws JCoException { Assert.notNull(sapSystem, "SapSystem must not be null"); Assert.notNull(resourceFactory, "ResourceFactory must not be null"); JcoResourceHolder resourceHolder = (JcoResourceHolder) TransactionSynchronizationManager.getResource(sapSystem); if (resourceHolder != null) { String tid = resourceFactory.getTid(resourceHolder); if (tid != null) { return tid; } if (resourceHolder.isFrozen()) { return null; } } if (!TransactionSynchronizationManager.isSynchronizationActive()) { return null; } JcoResourceHolder resourceHolderToUse = resourceHolder; if (resourceHolderToUse == null) { resourceHolderToUse = new JcoResourceHolder(sapSystem); } JCoDestination destination = resourceFactory.getDestination(resourceHolderToUse); String tid = null; boolean isExistingDestination = (destination != null); if (!isExistingDestination) { destination = resourceFactory.createDestination(); resourceHolderToUse.addDestination(destination); } tid = resourceFactory.createTid(destination); resourceHolderToUse.addTid(tid, destination); if (resourceHolderToUse != resourceHolder) { TransactionSynchronizationManager.registerSynchronization(new JcoResourceSynchronization(sapSystem, resourceHolderToUse, resourceFactory.isSynchedLocalTransactionAllowed())); resourceHolderToUse.setSynchronizedWithTransaction(true); TransactionSynchronizationManager.bindResource(sapSystem, resourceHolderToUse); } return tid; }
Example 92
| Project: jrails-master File: OpenSessionInViewFilter.java View source code |
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
SessionFactory sessionFactory = lookupSessionFactory(request);
boolean participate = false;
if (isSingleSession()) {
// single session mode
if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
// Do not modify the Session: just set the participate flag.
participate = true;
} else {
logger.debug("Opening single Hibernate Session in OpenSessionInViewFilter");
Session session = getSession(sessionFactory);
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
} else {
// deferred close mode
if (SessionFactoryUtils.isDeferredCloseActive(sessionFactory)) {
// Do not modify deferred close: just set the participate flag.
participate = true;
} else {
SessionFactoryUtils.initDeferredClose(sessionFactory);
}
}
try {
filterChain.doFilter(request, response);
} finally {
if (!participate) {
if (isSingleSession()) {
// single session mode
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
closeSession(sessionHolder.getSession(), sessionFactory);
} else {
// deferred close mode
SessionFactoryUtils.processDeferredClose(sessionFactory);
}
}
}
}Example 93
| Project: opennms_dashboard-master File: TransactionAwareEventForwarder.java View source code |
/**
* <p>requestPendingEventsList</p>
*
* @return a {@link java.util.List} object.
*/
public List<Log> requestPendingEventsList() {
PendingEventsHolder eventsHolder = (PendingEventsHolder) TransactionSynchronizationManager.getResource(m_eventForwarder);
if (eventsHolder != null && (eventsHolder.hasPendingEvents() || eventsHolder.isSynchronizedWithTransaction())) {
eventsHolder.requested();
if (!eventsHolder.hasPendingEvents()) {
eventsHolder.setPendingEventsList(new LinkedList<Log>());
}
return eventsHolder.getPendingEvents();
}
List<Log> pendingEvents = new LinkedList<Log>();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
PendingEventsHolder holderToUse = eventsHolder;
if (holderToUse == null) {
holderToUse = new PendingEventsHolder(pendingEvents);
} else {
holderToUse.setPendingEventsList(pendingEvents);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(new PendingEventsSynchronization(holderToUse, m_eventForwarder));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != eventsHolder) {
TransactionSynchronizationManager.bindResource(m_eventForwarder, holderToUse);
}
}
return pendingEvents;
}Example 94
| Project: rapid-framework-master File: MockOpenSessionInViewFilter.java View source code |
public void endFilter() {
if (!participate) {
if (isSingleSession()) {
// single session mode
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
logger.debug("Closing single Hibernate Session in OpenSessionInViewFilter");
closeSession(sessionHolder.getSession(), sessionFactory);
} else {
// deferred close mode
SessionFactoryUtils.processDeferredClose(sessionFactory);
}
}
}Example 95
| Project: unitils-master File: HibernateModule.java View source code |
@Override
protected Session doGetActivePersistenceContext(Object testObject) {
SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getPersistenceUnit(testObject));
if (sessionHolder != null && sessionHolder.getSession() != null && sessionHolder.getSession().isOpen()) {
return sessionHolder.getSession();
}
return null;
}Example 96
| Project: zenoss-zep-master File: DaoCacheImpl.java View source code |
private <T> int getIdFromName(final DaoTableCache<T> cache, final T name) {
Integer cached = cache.getCache().getIdFromName(name);
if (cached == null) {
final int id = cache.insertOrSelect(name);
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCommit() {
cache.getCache().cache(name, id);
}
});
cached = id;
}
return cached;
}Example 97
| Project: Fudan-Sakai-master File: DbGlossary.java View source code |
protected void updateCache(GlossaryEntry entry, boolean remove) {
if (useCache) {
GlossaryTxSync txSync = new GlossaryTxSync(entry, remove);
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.registerSynchronization(txSync);
} else {
txSync.afterCompletion(GlossaryTxSync.STATUS_COMMITTED);
}
}
}Example 98
| Project: Katari-master File: TrailsModuleApplicationServlet.java View source code |
/** Processes the request.
*
* This method implements the open session in view, opening a new hibernate
* session when the request starts and closing the session on end.
*
* {@inheritDoc}
*/
public void service(final ServletRequest request, final ServletResponse response) throws ServletException, IOException {
SessionFactory sessionFactory;
sessionFactory = (SessionFactory) beanFactory.getBean("sessionFactory");
Session session = null;
// True if there was a previous hibernate session active. In that case, we
// just leave it alone, efectively 'participating' in the existing session.
boolean participate = false;
// True if this is the first time we call this servlet in the current
// request.
boolean firstCall = false;
// The name of the attribute to check if the request has already been
// handled by this servlet. We open the hibernate session the first time
// only.
String alreadyHandled = getServletName() + ".SESSION_OPENED";
// Check if we have already entered this servlet in the current request.
if (null == request.getAttribute(alreadyHandled)) {
request.setAttribute(alreadyHandled, "filtered");
if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
// Do not modify the Session: just set the participate flag.
participate = true;
} else {
log.debug("Opening single Hibernate Session in open session in view");
session = getSession(sessionFactory);
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
firstCall = true;
}
/* This is due to a bug in tapestry 4.1.5: when rendenig the exception
* page, tapestry iterates recursively over all request attributes. Katari
* puts for convenience, an atribute named 'request' that contains the
* servlet request. This makes tapestry iterate infinitely through the
* attributes, causing a stack trace exception.
*
* The bug is in tapestry HttpServletRequestStrategy.describeObject.
*/
Object savedRequest = request.getAttribute("request");
request.removeAttribute("request");
try {
super.service(request, response);
} finally {
request.setAttribute("request", savedRequest);
if (firstCall) {
if (!participate) {
TransactionSynchronizationManager.unbindResource(sessionFactory);
log.debug("Closing single Hibernate session in open session in view");
closeSession(session, sessionFactory);
}
request.removeAttribute(alreadyHandled);
}
}
}Example 99
| Project: openmicroscopy-master File: SessionHandlerMockHibernateTest.java View source code |
@Override
@BeforeMethod
protected void setUp() throws Exception {
super.setUp();
newDataSource();
newConnection();
newSession();
newSessionFactory();
handler = new SessionHandler(factory);
// As of r2677 (ticket:1013) session close is delayed
// to servicehandler cleanup. We are simulating this.
handler.setApplicationContext(context);
context.addApplicationListener(new ApplicationListener() {
public void onApplicationEvent(ApplicationEvent arg0) {
if (arg0 instanceof RegisterServiceCleanupMessage) {
cleanups.add((RegisterServiceCleanupMessage) arg0);
}
}
});
// must call newXInvocation in test
// these are reused unless otherwise noted
newStateful();
newStateless();
// Things should always be cleaned up by handler/interceptor
assertFalse(TransactionSynchronizationManager.hasResource(factory));
if (!TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.initSynchronization();
}
}Example 100
| Project: openmrs-maven-master File: HibernateContextDAO.java View source code |
public void openSession() {
log.debug("HibernateContext: Opening Hibernate Session");
if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
if (log.isDebugEnabled())
log.debug("Participating in existing session (" + sessionFactory.hashCode() + ")");
participate = true;
} else {
if (log.isDebugEnabled())
log.debug("Registering session with synchronization manager (" + sessionFactory.hashCode() + ")");
Session session = SessionFactoryUtils.getSession(sessionFactory, true);
session.setFlushMode(FlushMode.MANUAL);
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
}Example 101
| Project: sakai-cle-master File: DbGlossary.java View source code |
protected void updateCache(GlossaryEntry entry, boolean remove) {
if (useCache) {
GlossaryTxSync txSync = new GlossaryTxSync(entry, remove);
if (TransactionSynchronizationManager.isSynchronizationActive()) {
TransactionSynchronizationManager.registerSynchronization(txSync);
} else {
txSync.afterCompletion(GlossaryTxSync.STATUS_COMMITTED);
}
}
}