Java TransactionConfig类代码示例

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
public JEConnection getConnection(String jeRootDir,
			      EnvironmentConfig envConfig,
			      TransactionConfig transConfig)
throws JEException {

JEConnection dc = null;
	JERequestInfo jeInfo =
	    new JERequestInfo(new File(jeRootDir), envConfig, transConfig);
try {
    dc = (JEConnection) manager.allocateConnection(factory, jeInfo);
} catch (ResourceException e) {
    throw new JEException("Unable to get Connection: " + e);
}

return dc;
   }
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * Begins a new transaction for this environment and associates it with
 * the current thread.  If a transaction is already active for this
 * environment and thread, a nested transaction will be created.
 *
 * @param config the transaction configuration used for calling
 * {@link Environment#beginTransaction}, or null to use the default
 * configuration.
 *
 * @return the new transaction.
 *
 * @throws DatabaseException if the transaction cannot be started, in which
 * case any existing transaction is not affected.
 *
 * @throws IllegalStateException if a transaction is already active and
 * nested transactions are not supported by the environment.
 */
public final Transaction beginTransaction(TransactionConfig config)
    throws DatabaseException {

    Trans trans = (Trans) localTrans.get();
    if (trans != null) {
        if (trans.txn != null) {
            if (!DbCompat.NESTED_TRANSACTIONS) {
                throw new IllegalStateException(
                        "Nested transactions are not supported");
            }
            Transaction parentTxn = trans.txn;
            trans = new Trans(trans, config);
            trans.txn = env.beginTransaction(parentTxn, config);
            localTrans.set(trans);
        } else {
            trans.txn = env.beginTransaction(null, config);
            trans.config = config;
        }
    } else {
        trans = new Trans(null, config);
        trans.txn = env.beginTransaction(null, config);
        localTrans.set(trans);
    }
    return trans.txn;
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * Mappings are flushed to disk at close, and at checkpoints.
 */
public void flushToDatabase(Durability useDurability) {
   
    TransactionConfig config = new TransactionConfig();
    config.setDurability(useDurability);
    Txn txn = Txn.createLocalTxn(envImpl, config);
    boolean success = false;
    try {
        flushToDatabase(txn);
        txn.commit();
        success = true;
    } finally {
        if (!success) {
            txn.abort();
        }
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
public void testReadUncommittedTransaction()
    throws Exception {

    TransactionRunner runner = new TransactionRunner(env);
    TransactionConfig config = new TransactionConfig();
    config.setReadUncommitted(true);
    runner.setTransactionConfig(config);
    assertNull(currentTxn.getTransaction());
    runner.run(new TransactionWorker() {
        public void doWork() throws Exception {
            assertNotNull(currentTxn.getTransaction());
            doReadUncommitted(map);
        }
    });
    assertNull(currentTxn.getTransaction());
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * A non-zero mandatedId is specified only by subtypes which arbitrarily
 * impose a transaction id value onto the transaction. This is done by
 * implementing a version of Locker.generateId() which uses the proposed
 * id.
 */
protected Txn(EnvironmentImpl envImpl,
              TransactionConfig config,
              ReplicationContext repContext,
              long mandatedId)
    throws DatabaseException {

    /*
     * Initialize using the config but don't hold a reference to it, since
     * it has not been cloned.
     */
    super(envImpl, config.getReadUncommitted(), config.getNoWait(),
          mandatedId);
    initTxn(config);
    this.repContext = repContext;
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
static Txn createUserTxn(EnvironmentImpl envImpl,
                         TransactionConfig config) {

    Txn ret = null;
    try {
        ret = envImpl.isReplicated() ?
              envImpl.createRepUserTxn(config) :
              createLocalTxn(envImpl, config);
    } catch (DatabaseException DE) {
        if (ret != null) {
            ret.close(false);
        }
        throw DE;
    }
    return ret;
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
private void openMappingDatabase(String mappingDbName)
    throws DatabaseException {

    final Locker locker =
        Txn.createLocalAutoTxn(envImpl, new TransactionConfig());

    try {
        DbTree dbTree = envImpl.getDbTree();
        DatabaseImpl db = dbTree.getDb(locker,
                                       mappingDbName,
                                       null /* databaseHandle */);
        if (db == null) {
            if (envImpl.isReadOnly()) {
                /* This should have been caught earlier. */
                throw EnvironmentFailureException.unexpectedState
                   ("A replicated environment can't be opened read only.");
            }
            DatabaseConfig dbConfig = new DatabaseConfig();
            dbConfig.setReplicated(false);
            db = dbTree.createInternalDb(locker, mappingDbName, dbConfig);
        }
        mappingDbImpl = db;
    } finally {
        locker.operationEnd(true);
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
public JEConnection getConnection(String jeRootDir,
                                  EnvironmentConfig envConfig,
                                  TransactionConfig transConfig)
    throws JEException {

    JEConnection dc = null;
     JERequestInfo jeInfo =
         new JERequestInfo(new File(jeRootDir), envConfig, transConfig);
    try {
        dc = (JEConnection) manager.allocateConnection(factory, jeInfo);
    } catch (ResourceException e) {
        throw new JEException("Unable to get Connection: " + e);
    }

    return dc;
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * The entry just read is a prepare record. Setup a PrepareTxn that will
 * exempt any of its uncommitted LNs from undo. Instead, uncommitted LNs
 * that belong to a PrepareTxn are redone.
 * @throws DatabaseException
 */
private void handlePrepare(LNFileReader reader)
    throws DatabaseException {

    long prepareId = reader.getTxnPrepareId();
    Long prepareIdL = Long.valueOf(prepareId);
    if (!committedTxnIds.containsKey(prepareIdL) &&
        !abortedTxnIds.contains(prepareIdL)) {
        TransactionConfig txnConf = new TransactionConfig();
        PreparedTxn preparedTxn = PreparedTxn.createPreparedTxn
            (envImpl, txnConf, prepareId);

        /*
         * There should be no lock conflicts during recovery, but just in
         * case there are, we set the locktimeout to 0.
         */
        preparedTxn.setLockTimeout(0);
        preparedTxns.put(prepareIdL, preparedTxn);
        preparedTxn.setPrepared(true);
        envImpl.getTxnManager().registerXATxn
            (reader.getTxnPrepareXid(), preparedTxn, true);
        LoggerUtils.logMsg(logger, envImpl, Level.INFO,
                           "Found unfinished prepare record: id: " +
                           reader.getTxnPrepareId() +
                           " Xid: " + reader.getTxnPrepareXid());
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * Verifies that consistency requirements are met before allowing the
 * transaction to proceed.
 */
@Override
protected void txnBeginHook(TransactionConfig config)
    throws ReplicaConsistencyException, DatabaseException {

    if (!envImpl.isReplicated()) {
        return;
    }
    checkConsistency((RepImpl) envImpl, config.getConsistencyPolicy());
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
   * Create a new transaction.
   * @param parent for nested transactions, not yet supported
   * @param txnConfig specifies txn attributes
   * @return the new txn
   */
  public Txn txnBegin(Transaction parent, TransactionConfig txnConfig)
      throws DatabaseException {

      if (parent != null) {
          throw new DatabaseException
("Nested transactions are not supported yet.");
      }

      return new Txn(env, txnConfig);
  }
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
    * Create a transaction from Environment.txnBegin.
    */
   public Txn(EnvironmentImpl envImpl, TransactionConfig config)
       throws DatabaseException {

       /*
        * Initialize using the config but don't hold a reference to it, since
        * it has not been cloned.
        */
       super(envImpl, config.getReadUncommitted(), config.getNoWait());
init(envImpl, config);
   }
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * Used when creating ReplayTxns at recovery. No ActiveTxns map is
 * available.
 */
public ReplayTxn(EnvironmentImpl envImpl,
                 TransactionConfig config,
                 long txnId,
                 Logger logger)
    throws DatabaseException {

    super(envImpl,
          config,
          null,      // ReplicationContext set later
          txnId);    // mandatedId
    /* Preempt reader transactions when a lock conflict occurs. */
    setImportunate(true);
    this.logger = logger;
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
/**
 * Causes the transaction to wait until we have sufficient replicas to
 * acknowledge the commit.
 */
@Override
@SuppressWarnings("unused")
protected void txnBeginHook(TransactionConfig config)
    throws DatabaseException {

    RepImpl repImpl = (RepImpl) envImpl;
    try {
        repImpl.txnBeginHook(this);
    } catch (InterruptedException e) {
        throw new ThreadInterruptedException(envImpl, e);
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入依赖的package包/类
public JERequestInfo(File rootDir,
		 EnvironmentConfig envConfig,
		 TransactionConfig transConfig) {
this.rootDir = rootDir;
this.envConfig = envConfig;
this.transConfig = transConfig;
   }