class JdbcTemplateStorageAccessor extends AbstractStorageAccessor {
    private final NamedParameterJdbcTemplate jdbcTemplate;
    private final TransactionTemplate transactionTemplate;
    private final Configuration configuration;
    private SqlStatementsSource sqlStatementsSource;

    JdbcTemplateStorageAccessor(@NonNull Configuration configuration) {
        requireNonNull(configuration, "configuration can not be null");
        this.jdbcTemplate = new NamedParameterJdbcTemplate(configuration.getJdbcTemplate());
        this.configuration = configuration;
        PlatformTransactionManager transactionManager = configuration.getTransactionManager() != null
                ? configuration.getTransactionManager()
                : new DataSourceTransactionManager(
                        configuration.getJdbcTemplate().getDataSource());

        this.transactionTemplate = new TransactionTemplate(transactionManager);
        this.transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

        if (configuration.getIsolationLevel() != null) {
            this.transactionTemplate.setIsolationLevel(configuration.getIsolationLevel());
        }
    }

    @Override
    public boolean insertRecord(@NonNull LockConfiguration lockConfiguration) {
        try {
            String sql = sqlStatementsSource().getInsertStatement();
            return execute(sql, lockConfiguration);
        } catch (DuplicateKeyException | ConcurrencyFailureException | TransactionSystemException e) {
            logger.debug("Duplicate key", e);
            return false;
        } catch (DataIntegrityViolationException | BadSqlGrammarException | UncategorizedSQLException e) {
            if (configuration.isThrowUnexpectedException()) {
                throw e;
            }
            logger.error("Unexpected exception", e);
            return false;
        }
    }

    @Override
    public boolean updateRecord(@NonNull LockConfiguration lockConfiguration) {
        String sql = sqlStatementsSource().getUpdateStatement();
        try {
            return execute(sql, lockConfiguration);
        } catch (ConcurrencyFailureException e) {
            logger.debug("Serialization exception", e);
            return false;
        } catch (DataIntegrityViolationException | TransactionSystemException | UncategorizedSQLException e) {
            if (configuration.isThrowUnexpectedException()) {
                throw e;
            }
            logger.error("Unexpected exception", e);
            return false;
        }
    }

    @Override
    public boolean extend(@NonNull LockConfiguration lockConfiguration) {
        String sql = sqlStatementsSource().getExtendStatement();

        logger.debug("Extending lock={} until={}", lockConfiguration.getName(), lockConfiguration.getLockAtMostUntil());
        return execute(sql, lockConfiguration);
    }

    @Override
    public void unlock(@NonNull LockConfiguration lockConfiguration) {<FILL_FUNCTION_BODY>}

    private void doUnlock(LockConfiguration lockConfiguration) {
        String sql = sqlStatementsSource().getUnlockStatement();
        execute(sql, lockConfiguration);
    }

    @SuppressWarnings("ConstantConditions")
    private boolean execute(String sql, LockConfiguration lockConfiguration) throws TransactionException {
        return transactionTemplate.execute(status -> jdbcTemplate.update(sql, params(lockConfiguration)) > 0);
    }

    @NonNull
    private Map<String, Object> params(@NonNull LockConfiguration lockConfiguration) {
        return sqlStatementsSource().params(lockConfiguration);
    }

    private SqlStatementsSource sqlStatementsSource() {
        synchronized (configuration) {
            if (sqlStatementsSource == null) {
                sqlStatementsSource = SqlStatementsSource.create(configuration);
            }
            return sqlStatementsSource;
        }
    }
}

        for (int i = 0; i < 10; i++) {
            try {
                doUnlock(lockConfiguration);
                return;
            } catch (ConcurrencyFailureException | TransactionSystemException e) {
                logger.info("Unlock failed due to TransactionSystemException - retrying attempt {}", i + 1);
            }
        }
    
<methods>public non-sealed void <init>() <variables>protected final Logger logger