Java TransactionIsolationLevel类代码示例

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@Override
public void append(final UUID id, final UnitOfWork uow) {

    final String sql = String.format("insert into %s (id, uow_data, version) values (:id, :uow_data, :version)", tables.getUnitOfWorkTable());
	
	log.debug(sql);
	
	final String asString = toStringFunction.apply(uow);
	
	dbi.inTransaction(TransactionIsolationLevel.READ_COMMITTED, new TransactionCallback<Integer>() {
		@Override
		public Integer inTransaction(Handle conn, TransactionStatus status)
				throws Exception {
			conn.createStatement(sql)
			.bind("id", id.toString())
			.bind("uow_data", asString)
		    .bind("version", uow.getVersion())
		    .execute();
			return null;
		}
	}) ;
	
	log.debug("wrote uow");
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@Override
public String load(final Long id) {
	String result = null;
	try {
		log.info("will load {} from table {}", id.toString(), tableName);
		result = dbi.inTransaction(TransactionIsolationLevel.READ_COMMITTED,
				new TransactionCallback<String>() {
					@Override
					public String inTransaction(Handle h, TransactionStatus ts) throws Exception {
						String sql = String.format("select value from %s where id = :id", tableName);
						return h.createQuery(sql).bind("id", id).map(ClobToStringMapper.FIRST).first();
					}
				});
		if (result==null) {
			log.warn("found a null value for id {}", id.toString());
		} else {
			log.info("loaded {} {} from table {}", id.toString(), result, tableName);
		}
	} catch (Exception e) {
		log.error("error when loading {} from table {}", id.toString(), tableName);
		e.printStackTrace();
	}
	return result;
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@Override
public String load(final UUID id) {
	String result = null;
	try {
		log.debug("will load {} from table {}", id.toString(), tableName);
		result = dbi.inTransaction(TransactionIsolationLevel.READ_COMMITTED,
				new TransactionCallback<String>() {
					@Override
					public String inTransaction(Handle h, TransactionStatus ts) throws Exception {
						String sql = String.format("select aggregate_root_data from %s where id = :id", tableName);
						return h.createQuery(sql).bind("id", id.toString()).map(ClobToStringMapper.FIRST).first();
					}
				});
		// http://stackoverflow.com/questions/9779324/program-hangs-after-retrieving-100-rows-containg-clob
		if (result == null) {
			log.debug("found a null or zero length value for id {}", id.toString());
		} else {
			log.debug("loaded {} {} from table {}", id.toString(), result.replace("\n", "").substring(0, Math.min(10, result.length()-1)), tableName);
		}
	} catch (Exception e) {
		log.error("error when loading {} from table {}", id.toString(), tableName);
		e.printStackTrace();
	} finally {
	}
	return result;
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
public static void useTransaction(DBI dbi, Consumer<Handle> callback) {
    try {
        dbi.useTransaction(TransactionIsolationLevel.SERIALIZABLE, (handle, status) -> callback.accept(handle));
    } catch (CallbackFailedException e) {
        throw Throwables.propagate(e.getCause());
    }
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
public static <T> T inTransaction(DBI dbi, Function<Handle, T> callbackFn) {
    try {
        return dbi.inTransaction(TransactionIsolationLevel.SERIALIZABLE, (handle, status) -> callbackFn.apply(handle));
    } catch (CallbackFailedException e) {
        throw Throwables.propagate(e.getCause());
    }
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@Override
public void append(final K targetId, final Command command, final UnitOfWork unitOfWork) {

    checkNotNull(targetId);
    checkNotNull(command);
    checkNotNull(unitOfWork);
    checkArgument(unitOfWork.getCommandId().equals(command.getCommandId()));

    String insertUowSql = String.format("insert into %s (id, uow_data, version, inserted_on) values (:id, :uow_data, :version, :inserted_on)", dbMetadata.unitOfWorkTable);
    String insertCommandSql = String.format("insert into %s (id, cmd_data) values (:id, :cmd_data)", dbMetadata.commandTable);

    logger.debug(insertUowSql);

    logger.debug("appending uow to {} with id {}", dbMetadata.aggregateRootTable, targetId);

    try {
        dbi.inTransaction(TransactionIsolationLevel.READ_COMMITTED, (conn, status) -> {
                    int result1 = conn.createStatement(insertUowSql)
                            .bind("id", targetId.toString())
                            .bind("uow_data", uowSer.toStringFunction.apply(unitOfWork))
                            .bind("version", unitOfWork.getVersion())
                            .bind("inserted_on", unitOfWork.getCreatedOn())
                            .execute() ;
                    int result2 = conn.createStatement(insertCommandSql)
                            .bind("id", command.getCommandId().toString())
                            .bind("cmd_data", cmdSer.toStringFunction.apply(command))
                            .execute() ;
                    return result1 + result2 == 2;
                }
        );
    } catch (Exception e) {
        CommandExecutionException exception = convertFrom(e);
        logger.error(exception.getMessage());
        throw exception;
    }

}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
public void executeInTransaction(final Transaction<Void, BusinessAnalyticsSqlDao> transaction) {
    // In REPEATABLE READ, every lock acquired during a transaction is held for the duration of the transaction.
    // In READ COMMITTED the locks that did not match the scan are released after the STATEMENT completes.
    // We need to make sure to use READ COMMITTED here, to avoid MySQL deadlocks under high load. This should
    // not have any impact in these transactions as we only delete & re-insert rows on a per account basis,
    // and accounts are not updated in parallel (not enforced, but we try hard not to).
    sqlDao.inTransaction(TransactionIsolationLevel.READ_COMMITTED, transaction);
}
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery(EnabledUserRolesPermissionsBaseSelectPrefix + "users.username = :username")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<UserRolePermissionJoinRow> findEnabledUsersWithRolesAndPermissions(@Bind("username") String username);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery(UserRolesPermissionsBaseSelectPrefix + "users.username = :username")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<UserRolePermissionJoinRow> findUsersWithRolesAndPermissions(@Bind("username") String username);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery("SELECT user_Id AS id, username, password FROM users WHERE enabled AND username = :username")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<DefaultUserImpl> findEnabledUsersWithoutRoles(@Bind("username") String username);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery("SELECT user_Id AS id, username, password FROM users WHERE username = :username")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<DefaultUserImpl> findUsersWithoutRoles(@Bind("username") String username);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery(EnabledRolesPermissionsBaseSelectPrefix + "users_roles.user_id = :userId")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<UserRolePermissionJoinRow> getEnabledUserRolesAndPermissions(@Bind("userId") Long userId);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@SqlQuery(RolesPermissionsBaseSelectPrefix + "users_roles.user_id = :userId")
@MapResultAsBean
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
protected abstract Iterator<UserRolePermissionJoinRow> getUserRolesAndPermissions(@Bind("userId") Long userId);
 

import org.skife.jdbi.v2.TransactionIsolationLevel; //导入依赖的package包/类
@Override
@Transaction(value = TransactionIsolationLevel.READ_COMMITTED)
public DefaultUserImpl getUser(Long userId) {
    checkArgument(userId != null, "getUser() requires a non-null userId parameter.");
    return extractObjectGraphFromJoinResults(getUserWithRolesAndPermissions(userId));
}