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.openvpms.hl7.impl.MessageDispatcherImpl.java

/**
 * Queues a message to a sender./*from  www .j a v  a2 s.com*/
 *
 * @param message the message
 * @param sender  the sender
 * @param user    the user responsible for the message
 * @return the queued message
 * @throws HL7Exception if the message cannot be encoded
 */
protected DocumentAct queue(Message message, final MLLPSender sender, User user) throws HL7Exception {
    DocumentAct result;
    MessageQueue queue = getMessageQueue(sender);
    if (log.isDebugEnabled()) {
        log.debug("queue() - " + sender);
    }
    result = queue.add(message, user);
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        // a transaction is in progress, so only invoke schedule() once the transaction has committed
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                schedule();
            }
        });
    } else {
        schedule();
    }
    return result;
}

From source file:org.sakaiproject.chat2.model.impl.ChatManagerImpl.java

/**
 * {@inheritDoc}//from  w  ww.j a v  a  2s.c o m
 */
public void sendDeleteMessage(ChatMessage message) {
    ChatMessageDeleteTxSync txSync = new ChatMessageDeleteTxSync(message);

    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(txSync);
    } else {
        txSync.afterCompletion(ChatMessageDeleteTxSync.STATUS_COMMITTED);
    }
}

From source file:org.sakaiproject.chat2.model.impl.ChatManagerImpl.java

/**
 * {@inheritDoc}/* www .  j  av a 2 s  .c  o m*/
 */
public void sendDeleteChannel(ChatChannel channel) {
    ChatChannelDeleteTxSync txSync = new ChatChannelDeleteTxSync(channel);

    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(txSync);
    } else {
        txSync.afterCompletion(ChatChannelDeleteTxSync.STATUS_COMMITTED);
    }
}

From source file:org.sakaiproject.chat2.model.impl.ChatManagerImpl.java

/**
 * {@inheritDoc}//from   w  ww. j  a v  a 2  s  . co m
 */
public void sendDeleteChannelMessages(ChatChannel channel) {
    ChatChannelMessagesDeleteTxSync txSync = new ChatChannelMessagesDeleteTxSync(channel);

    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(txSync);
    } else {
        txSync.afterCompletion(ChatChannelMessagesDeleteTxSync.STATUS_COMMITTED);
    }
}

From source file:org.springframework.amqp.rabbit.connection.ConnectionFactoryUtils.java

public static void bindResourceToTransaction(RabbitResourceHolder resourceHolder,
        ConnectionFactory connectionFactory, boolean synched) {
    if (TransactionSynchronizationManager.hasResource(connectionFactory)
            || !TransactionSynchronizationManager.isActualTransactionActive() || !synched) {
        return;//w  w  w  .  j  av a 2 s .c o  m
    }
    TransactionSynchronizationManager.bindResource(connectionFactory, resourceHolder);
    resourceHolder.setSynchronizedWithTransaction(true);
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(
                new RabbitResourceSynchronization(resourceHolder, connectionFactory, synched));
    }
}

From source file:org.springframework.data.document.mongodb.MongoDbUtils.java

public static DB doGetDB(Mongo mongo, String databaseName, String username, char[] password,
        boolean allowCreate) {
    Assert.notNull(mongo, "No Mongo instance specified");

    DbHolder dbHolder = (DbHolder) TransactionSynchronizationManager.getResource(mongo);
    if (dbHolder != null && !dbHolder.isEmpty()) {
        // pre-bound Mongo DB
        DB db = null;//www .  j  a v  a  2 s.  c  om
        if (TransactionSynchronizationManager.isSynchronizationActive() && dbHolder.doesNotHoldNonDefaultDB()) {
            // Spring transaction management is active ->
            db = dbHolder.getDB();
            if (db != null && !dbHolder.isSynchronizedWithTransaction()) {
                LOGGER.debug("Registering Spring transaction synchronization for existing Mongo DB");
                TransactionSynchronizationManager
                        .registerSynchronization(new MongoSynchronization(dbHolder, mongo));
                dbHolder.setSynchronizedWithTransaction(true);
            }
        }
        if (db != null) {
            return db;
        }
    }

    LOGGER.trace("Getting Mongo Database name=[" + databaseName + "]");
    DB db = mongo.getDB(databaseName);

    boolean credentialsGiven = username != null && password != null;
    if (credentialsGiven && !db.isAuthenticated()) {
        //Note, can only authenticate once against the same com.mongodb.DB object.
        if (!db.authenticate(username, password)) {
            throw new CannotGetMongoDbConnectionException("Failed to authenticate to database [" + databaseName
                    + "], username = [" + username + "], password = [" + new String(password) + "]",
                    databaseName, username, password);
        }
    }

    // Use same Session for further Mongo 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.
        LOGGER.debug("Registering Spring transaction synchronization for new Hibernate Session");
        DbHolder holderToUse = dbHolder;
        if (holderToUse == null) {
            holderToUse = new DbHolder(db);
        } else {
            holderToUse.addDB(db);
        }
        TransactionSynchronizationManager.registerSynchronization(new MongoSynchronization(holderToUse, mongo));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != dbHolder) {
            TransactionSynchronizationManager.bindResource(mongo, holderToUse);
        }
    }

    // Check whether we are allowed to return the DB.
    if (!allowCreate && !isDBTransactional(db, mongo)) {
        throw new IllegalStateException("No Mongo DB bound to thread, "
                + "and configuration does not allow creation of non-transactional one here");
    }

    return db;
}

From source file:org.springframework.data.keyvalue.redis.core.RedisConnectionUtils.java

/**
 * Gets a Redis connection. Is aware of and will return any existing corresponding connections bound to the current thread, 
 * for example when using a transaction manager. Will create a new Connection otherwise, if {@code allowCreate} is <tt>true</tt>.
 * /*from  www .  j a v  a  2s.com*/
 * @param factory connection factory for creating the connection
 * @param allowCreate whether a new (unbound) connection should be created when no connection can be found for the current thread
 * @param bind binds the connection to the thread, in case one was created
 * @return an active Redis connection
 */
public static RedisConnection doGetConnection(RedisConnectionFactory factory, boolean allowCreate,
        boolean bind) {
    Assert.notNull(factory, "No RedisConnectionFactory specified");

    RedisConnectionHolder connHolder = (RedisConnectionHolder) TransactionSynchronizationManager
            .getResource(factory);
    //TODO: investigate tx synchronization

    if (connHolder != null)
        return connHolder.getConnection();

    if (!allowCreate) {
        throw new IllegalArgumentException("No connection found and allowCreate = false");
    }

    if (log.isDebugEnabled())
        log.debug("Opening RedisConnection");

    RedisConnection conn = factory.getConnection();

    boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();

    if (bind || synchronizationActive) {
        connHolder = new RedisConnectionHolder(conn);
        if (synchronizationActive) {
            TransactionSynchronizationManager
                    .registerSynchronization(new RedisConnectionSynchronization(connHolder, factory, true));
        }
        TransactionSynchronizationManager.bindResource(factory, connHolder);
        return connHolder.getConnection();
    }
    return conn;
}

From source file:org.springframework.data.mongodb.core.MongoDbUtils.java

public static DB doGetDB(Mongo mongo, String databaseName, String username, char[] password,
        boolean allowCreate) {
    Assert.notNull(mongo, "No Mongo instance specified");

    DbHolder dbHolder = (DbHolder) TransactionSynchronizationManager.getResource(mongo);
    if (dbHolder != null && !dbHolder.isEmpty()) {
        // pre-bound Mongo DB
        DB db = null;//from  w w w .  ja  v a 2  s .c  om
        if (TransactionSynchronizationManager.isSynchronizationActive() && dbHolder.doesNotHoldNonDefaultDB()) {
            // Spring transaction management is active ->
            db = dbHolder.getDB(databaseName);
            if (db != null && !dbHolder.isSynchronizedWithTransaction()) {
                LOGGER.debug("Registering Spring transaction synchronization for existing Mongo DB");
                TransactionSynchronizationManager
                        .registerSynchronization(new MongoSynchronization(dbHolder, mongo));
                dbHolder.setSynchronizedWithTransaction(true);
            }
        }
        if (db != null) {
            return db;
        }
    }

    LOGGER.trace("Getting Mongo Database name=[" + databaseName + "]");
    DB db = mongo.getDB(databaseName);

    boolean credentialsGiven = username != null && password != null;
    if (credentialsGiven && !db.isAuthenticated()) {
        // Note, can only authenticate once against the same com.mongodb.DB object.
        synchronized (db) {
            if (!db.authenticate(username, password)) {
                throw new CannotGetMongoDbConnectionException(
                        "Failed to authenticate to database [" + databaseName + "], username = [" + username
                                + "], password = [" + new String(password) + "]",
                        databaseName, username, password);
            }
        }
    }

    // Use same Session for further Mongo 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.
        LOGGER.debug("Registering Spring transaction synchronization for new Hibernate Session");
        DbHolder holderToUse = dbHolder;
        if (holderToUse == null) {
            holderToUse = new DbHolder(databaseName, db);
        } else {
            holderToUse.addDB(databaseName, db);
        }
        TransactionSynchronizationManager.registerSynchronization(new MongoSynchronization(holderToUse, mongo));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != dbHolder) {
            TransactionSynchronizationManager.bindResource(mongo, holderToUse);
        }
    }

    // Check whether we are allowed to return the DB.
    if (!allowCreate && !isDBTransactional(db, mongo)) {
        throw new IllegalStateException("No Mongo DB bound to thread, "
                + "and configuration does not allow creation of non-transactional one here");
    }

    return db;
}

From source file:org.springframework.data.neo4j.transaction.SessionFactoryUtils.java

public static Session getSession(SessionFactory sessionFactory) throws IllegalStateException {

    Assert.notNull(sessionFactory, "No SessionFactory specified");

    SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    if (sessionHolder != null) {
        if (!sessionHolder.isSynchronizedWithTransaction()
                && TransactionSynchronizationManager.isSynchronizationActive()) {
            sessionHolder.setSynchronizedWithTransaction(true);
            TransactionSynchronizationManager
                    .registerSynchronization(new SessionSynchronization(sessionHolder, sessionFactory, false));
        }//  w w  w .j ava  2 s  .co m
        return sessionHolder.getSession();
    }

    if (!TransactionSynchronizationManager.isSynchronizationActive()) {
        return null;
    }

    Session session = sessionFactory.openSession();

    if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
        System.out.println("hitting read only txn.");
    }

    logger.debug("Registering transaction synchronization for Neo4j Session");
    // Use same Session for further Neo4j actions within the transaction.
    // Thread object will get removed by synchronization at transaction completion.

    sessionHolder = new SessionHolder(session);
    sessionHolder.setSynchronizedWithTransaction(true);
    TransactionSynchronizationManager
            .registerSynchronization(new SessionSynchronization(sessionHolder, sessionFactory, true));
    TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);

    return session;
}

From source file:org.springframework.data.redis.core.RedisConnectionUtils.java

private static void potentiallyRegisterTransactionSynchronisation(RedisConnectionHolder connHolder,
        final RedisConnectionFactory factory) {

    if (isActualNonReadonlyTransactionActive()) {

        if (!connHolder.isTransactionSyncronisationActive()) {
            connHolder.setTransactionSyncronisationActive(true);

            RedisConnection conn = connHolder.getConnection();
            conn.multi();//from w w  w  .  java2 s.co m

            TransactionSynchronizationManager
                    .registerSynchronization(new RedisTransactionSynchronizer(connHolder, conn, factory));
        }
    }
}