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

Introduction

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

Prototype

public static void registerSynchronization(TransactionSynchronization synchronization)
        throws IllegalStateException

Source Link

Document

Usage

From source file:org.skife.jdbi.v2.spring.DBIUtil.java

/**
 * Obtain a Handle instance, either the transactionally bound one if we are in a transaction,
 * or a new one otherwise.//from  www. j  a  v a  2  s . c  om
 * @param dbi the IDBI instance from which to obtain the handle
 */
public static Handle getHandle(IDBI dbi) {
    Handle bound = (Handle) TransactionSynchronizationManager.getResource(dbi);
    if (bound == null) {
        bound = dbi.open();
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.bindResource(dbi, bound);
            TransactionSynchronizationManager.registerSynchronization(new Adapter(dbi, bound));
            TRANSACTIONAL_HANDLES.add(bound);
        }
    }
    return bound;
}

From source file:org.jdbi.v3.spring4.JdbiUtil.java

/**
 * Obtain a Handle instance, either the transactionally bound one if we are in a transaction,
 * or a new one otherwise./*  w  w w .ja  va  2 s  .c  o  m*/
 * @param jdbi the Jdbi instance from which to obtain the handle
 *
 * @return the Handle instance
 */
public static Handle getHandle(Jdbi jdbi) {
    Handle bound = (Handle) TransactionSynchronizationManager.getResource(jdbi);
    if (bound == null) {
        bound = jdbi.open();
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.bindResource(jdbi, bound);
            TransactionSynchronizationManager.registerSynchronization(new Adapter(jdbi, bound));
            TRANSACTIONAL_HANDLES.add(bound);
        }
    }
    return bound;
}

From source file:com.eclecticlogic.pedal.impl.JPATransactionWrapper.java

@Override
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
    super.prepareSynchronization(status, definition);
    if (status.isNewTransaction()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterData());
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapterTask());
    }/*from  w w  w .java  2 s .c  om*/
}

From source file:org.logicblaze.lingo.cache.impl.SpringTransactionRegistration.java

public void register(ActiveCacheManager cacheManager) {
    SpringSynchronization synchronization = (SpringSynchronization) cacheManager.getTransactionSynchronizer();
    if (synchronization == null) {
        synchronization = new SpringSynchronization(cacheManager);
        cacheManager.setTransactionSynchronizer(synchronization);
    }//from w  w w  . ja  va2 s .  c  o  m
    if (synchronization.isRequiresRegistration()) {
        TransactionSynchronizationManager.registerSynchronization(synchronization);
        synchronization.setRequiresRegistration(false);
    }
}

From source file:com.frank.search.solr.core.SolrTransactionSynchronizationAdapter.java

public void register() {
    TransactionSynchronizationManager.registerSynchronization(this);
}

From source file:org.activiti.spring.SpringTransactionContext.java

public void addTransactionListener(final TransactionState transactionState,
        final TransactionListener transactionListener) {
    if (transactionState.equals(TransactionState.COMMITTING)) {

        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override//from   www . j a v  a2 s . c  o  m
            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);
                }
            }
        });

    }

}

From source file:org.csc.phynixx.spring.jta.JtaConnectionHolderSupportAspect.java

@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;//from   w ww.  java 2 s .  co m
    }
    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("*************************");
}

From source file:org.motechproject.server.omod.sdsched.TxSyncManWrapperImpl.java

public void registerSynchronization(TransactionSynchronization sync) {
    TransactionSynchronizationManager.registerSynchronization(sync);
}

From source file:org.zenoss.zep.dao.impl.DaoCacheImpl.java

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/*from w  ww .j a  v  a  2 s.c om*/
            public void afterCommit() {
                cache.getCache().cache(name, id);
            }
        });
        cached = id;
    }
    return cached;
}

From source file:org.openvpms.component.business.dao.hibernate.im.common.Context.java

/**
 * Returns the context for the given assembler and session and current
 * thread.//from ww  w.  j av a  2  s.  c om
 * <p/>
 * If one does not exist, it will be created.
 *
 * @param assembler the assembler
 * @param session   the hibernate session
 * @return the context
 */
public static Context getContext(Assembler assembler, Session session) {
    Context context;
    ResourceKey key = new ResourceKey(session);
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        if (!TransactionSynchronizationManager.hasResource(key)) {
            context = new Context(assembler, session, true);
            TransactionSynchronizationManager.bindResource(context.getResourceKey(), context);
            TransactionSynchronizationManager.registerSynchronization(new ContextSynchronization(context));
        } else {
            context = (Context) TransactionSynchronizationManager.getResource(key);
        }
    } else {
        context = new Context(assembler, session, false);
    }
    return context;
}