Example usage for org.springframework.transaction.support TransactionSynchronizationManager isCurrentTransactionReadOnly

Introduction

In this page you can find the example usage for org.springframework.transaction.support TransactionSynchronizationManager isCurrentTransactionReadOnly.

Prototype

public static boolean isCurrentTransactionReadOnly() 

Source Link

Document

Return whether the current transaction is marked as read-only.

Usage

From source file:org.makersoft.shards.strategy.ShardStrategyImpl.java

@Override
public ShardAccessStrategy getShardAccessStrategy() {

    return TransactionSynchronizationManager.isCurrentTransactionReadOnly() ? shardAccessStrategy
            : transactionShardReduceStrategy;
}

---

From source file:org.grails.datastore.mapping.jpa.JpaSession.java

public static boolean hasTransaction() {
    return TransactionSynchronizationManager.isActualTransactionActive()
            && !TransactionSynchronizationManager.isCurrentTransactionReadOnly();
}

---

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

@After
public void verifyTransactionSynchronizationManagerState() {
    assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertNull(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
}

---

From source file:com.github.rholder.spring.transaction.TransactionBindingSupport.java

/**
 * @return      Returns the read-write state of the current transaction
 * @since 2.1.4//from   w  w w  . j  ava  2  s. c  o m
 */
public static TxnReadState getTransactionReadState() {
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        return TxnReadState.TXN_NONE;
    }
    // Find the read-write state of the txn
    if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
        return TxnReadState.TXN_READ_ONLY;
    } else {
        return TxnReadState.TXN_READ_WRITE;
    }
}

---

From source file:com.github.rholder.spring.transaction.TransactionBindingSupport.java

/**
 * Checks the state of the current transaction and throws an exception if a transaction
 * is not present or if the transaction is not read-write, if required.
 * // ww  w.j a  va  2 s.c  om
 * @param requireReadWrite          <tt>true</tt> if the transaction must be read-write
 * 
 * @since 3.2
 */
public static void checkTransactionReadState(boolean requireReadWrite) {
    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        throw new IllegalStateException("The current operation requires an active "
                + (requireReadWrite ? "read-write" : "") + "transaction.");
    }
    if (TransactionSynchronizationManager.isCurrentTransactionReadOnly() && requireReadWrite) {
        throw new IllegalStateException("The current operation requires an active read-write transaction.");
    }
}

---

From source file:org.apache.servicemix.transaction.GeronimoPlatformTransactionManager.java

protected void registerTransactionAssociationListener() {
    addTransactionAssociationListener(new TransactionManagerMonitor() {
        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);
                        }//from  w  w  w  . j  a va 2 s. c  o m
                    }
                }
            } catch (SystemException e) {
                return;
            }
        }

        public void threadUnassociated(Transaction transaction) {
            try {
                if (transaction.getStatus() == Status.STATUS_ACTIVE) {
                    if (TransactionSynchronizationManager.isSynchronizationActive()) {
                        List<?> suspendedSynchronizations = TransactionSynchronizationManager
                                .getSynchronizations();
                        for (Iterator<?> it = suspendedSynchronizations.iterator(); it.hasNext();) {
                            ((TransactionSynchronization) it.next()).suspend();
                        }
                        TransactionSynchronizationManager.clearSynchronization();
                        String name = TransactionSynchronizationManager.getCurrentTransactionName();
                        TransactionSynchronizationManager.setCurrentTransactionName(null);
                        boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
                        TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
                        TransactionSynchronizationManager.setActualTransactionActive(false);
                        SuspendedResourcesHolder holder = new SuspendedResourcesHolder(null,
                                suspendedSynchronizations, name, readOnly);
                        suspendedResources.put(transaction, holder);
                    }
                }
            } catch (SystemException e) {
                return;
            }
        }
    });
}

---

From source file:org.grails.orm.hibernate.GrailsSessionContext.java

private Session createSession(Object resource) {
    LOG.debug("Opening Hibernate Session");

    SessionHolder sessionHolder = (SessionHolder) resource;

    Session session = sessionFactory.openSession();

    // Use same Session for further Hibernate actions within the transaction.
    // Thread object will get removed by synchronization at transaction completion.
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        // We're within a Spring-managed transaction, possibly from JtaTransactionManager.
        LOG.debug("Registering Spring transaction synchronization for new Hibernate Session");
        SessionHolder holderToUse = sessionHolder;
        if (holderToUse == null) {
            holderToUse = new SessionHolder(session);
        } else {//from  w w  w. j av a2 s  .com
            // it's up to the caller to manage concurrent sessions
            // holderToUse.addSession(session);
        }
        if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
            session.setFlushMode(FlushMode.MANUAL);
        }
        TransactionSynchronizationManager
                .registerSynchronization(createSpringSessionSynchronization(holderToUse));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != sessionHolder) {
            TransactionSynchronizationManager.bindResource(sessionFactory, holderToUse);
        }
    } else {
        // No Spring transaction management active -> try JTA transaction synchronization.
        registerJtaSynchronization(session, sessionHolder);
    }

    /*        // Check whether we are allowed to return the Session.
            if (!allowCreate && !isSessionTransactional(session, sessionFactory)) {
               closeSession(session);
               throw new IllegalStateException("No Hibernate Session bound to thread, " +
      "and configuration does not allow creation of non-transactional one here");
            }
    */
    return session;
}

---

From source file:com._4dconcept.springframework.data.marklogic.datasource.IsolationLevelContentSourceAdapter.java

/**
 * Determine the current read-only flag: by default,
 * the transaction's read-only hint.// w w w . j  a  v  a  2 s.co  m
 * @return whether there is a read-only hint for the current scope
 * @see TransactionSynchronizationManager#isCurrentTransactionReadOnly()
 */
protected Boolean getCurrentReadOnlyFlag() {
    boolean txReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
    return (txReadOnly ? Boolean.TRUE : null);
}

---

From source file:org.grails.orm.hibernate.GrailsHibernateTemplate.java

protected boolean shouldPassReadOnlyToHibernate() {
    if ((passReadOnlyToHibernate || osivReadOnly)
            && TransactionSynchronizationManager.hasResource(getSessionFactory())) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            return passReadOnlyToHibernate && TransactionSynchronizationManager.isCurrentTransactionReadOnly();
        } else {/*from   w  ww.j a v a  2 s. com*/
            return osivReadOnly;
        }
    } else {
        return false;
    }
}

---

• «
• 1
• 2
• 3
• »