Как быть, когда блок finally нужен и как применить com.google.common.io.Closer

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
 
import static com.training.carshop.validate.object.ValidateObjectNotNull.isNullObjects;
import static com.training.carshop.validate.string.ValidateArgumentString.isBlank;
 
 
/**
 * Создан разработчиком IT
 * Дата 26.08.2018
 */
public class ConnectionPool extends Constants {
 
    private static final ConnectionPool pool = new ConnectionPool();
 
    public static ConnectionPool getPool() {
        return pool;
    }
 
 
    private DataSource dataSource;
 
    private ConnectionPool() {
        Properties properties;
        String nameJndiResource;
        try {
            if (isBlank(PATH_TO_PROPERTIES_JNDI)) {
                throw new ValidateException(MESSAGE_NOT_EMPTY_STR);
            }
 
            properties = new ClassPathPropertiesReader().getProperties(PATH_TO_PROPERTIES_JNDI);
 
        } catch (IOException e) {
            throw new ConnectionException(MESSAGE_EXCEPTION_FILE_JNDI, e);
        }
 
        isNullObjects(properties);
 
        try {
            nameJndiResource = properties.getProperty(JNDI_LINK);
            Context initContext = new InitialContext();
            Context rootContext = (Context) initContext.lookup("java:comp/env");
            dataSource = (DataSource) rootContext.lookup(nameJndiResource);
        } catch (NamingException e) {
            throw new ConnectionException(MESSAGE_LOOKUP_JNDI, e);
            /* Надо подумать, как сделать не проброс исключения и остановку программы, а
            в случае отлова ошибки подключения, выполнить переход на страницу, в которой
            будет сообщено пользователю, что база данных не работатет и нужно попробовать
            подключится позже.
             А адиминстратору выдать на косноль предупреждение, а также сформировать отправку
             сообщения на почту
             */
        }
    }
 
    public Connection getConnection() {
        try {
            dataSource.getConnection().setAutoCommit(false);
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new ConnectionException(MESSAGE_CONNECTION, e);
        }
    }
 
    /**
     * Методы для закрытия поптоков
     * Применяется принцип делегирования
     */
    public void closeDbResources(Connection connection) {
        closeDbResources(connection, null, null);
    }
 
    public void closeDbResources(ResultSet resultSet) {
        closeDbResources(null, null, resultSet);
    }
 
    public void closeDbResources(Connection connection, Statement statement) {
        closeDbResources(connection, statement, null);
    }
 
 
    private void closeDbResources(Connection connection, Statement statement, ResultSet resultSet) {
        closeResultSet(resultSet);
        closeStatement(statement);
        closeConnection(connection);
    }
 
 
    private void closeConnection(Connection connection) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                System.out.println("Error: Connection has not been closed!");
            }
        }
    }
 
    private void closeStatement(Statement statement) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                System.out.println("Error: Statement has not been closed!");
            }
        }
    }
 
    private void closeResultSet(ResultSet resultSet) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                System.out.println("Error: ResultSet has not been closed!");
            }
        }
    }
 
    /*  отменить действия с базой данных, в  текущем запросe (отменить транзакцию)
       Отмена всех изменений, внесенных в текущую транзакцию
       и освобождение всех блокировок базы данных, удерживаемые в данный момент
       текущим объектoм Connection. Этот метод должен быть
       использован только при отключенном режиме автоматической фиксации транзакций
      (auto-commit mode = disable).
     @exception SQLException - при возникновении ошибки доступа к базе данных,
     rollback() метод вызывается при участии в распределенной транзакции,
     этот метод вызывают на закрытом соединении, или когда объект connection
     находится в auto-commit mode  */
    public static void rollback(Connection conn) {
        try {
            conn.rollback();
        } catch (Exception e) {
            System.out.println("Rollback changes as a result of a transaction that failed to undo.");
        }
    }
 
 
}

/**
     * @see CarDao
     * @param carEntity - объект для хранения одной записи обрабатываемого бизнес-объекта
     */
    @Override
    public CarEntity storeCar(CarEntity carEntity) throws DaoException {
 
        isNullObjects(carEntity);
 
        Connection connection;
        PreparedStatement statement = null;
        String sql;
 
        sql = "INSERT INTO `cars` (`model`, `color`, `speed`, `fuel_consumption`, " +
                "`quantity`, `cost`, `date_delivery`,`uuid`) " +
                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
 
        connection = ConnectionPool.getPool().getConnection();
 
        try {
            statement = connection.prepareStatement(sql);
            statement.setString(ONE, carEntity.getModel());
            statement.setString(TWO, carEntity.getColor());
            statement.setInt(THREE, carEntity.getSpeed());
            statement.setInt(FOUR, carEntity.getFuelConsumption());
            statement.setInt(FIVE, carEntity.getQuantity());
            statement.setInt(SIX, carEntity.getCost());
            setDateToStatement(statement, SEVEN, carEntity.getDateDelivery());
            statement.setString(EIGHT, carEntity.getUuid());
 
            statement.executeUpdate();
            connection.commit();
 
            Integer storeId = loadStoreId(statement);
            CarEntity storeCar;
 
            if(isNotValidateArgument(storeId)){
 
                return new CarEntity();
            }
 
 
            storeCar = loadCarById(storeId);
            return storeCar;
 
        } catch (SQLException e) {
            rollback(connection);
            throw new DaoException(MESSAGE_STATEMENT,e);
        } finally {
            ConnectionPool.getPool().closeDbResources(connection, statement);
        }
    }

    private static OutputStream openOutputStream() throws IOException {
 
        return null;
    }
 
    private static void excCheck(){
 
        OutputStream stream = null;
        Throwable mainException = null;
        try {
            // что-то делаем со stream
            stream = openOutputStream();
        } catch (Throwable t) {
            mainException = t;
            // обрабатываем исключение
        } finally {
 
            try {
                stream.close();
            } catch (Throwable unused) {
                /* игнорируем, так как есть основное исключение
                 можно добавить лог исключения (по желанию)
                Лог создается, если ресурс не закрылся (например, stream = null). 
                Так как закрытие потока невозможно обработать, поэтому нет смысла что-либо
                ловить в данном случае
 
                Throwable unused - подавит вывод исключения (java.lang.NullPointerException) в StackTrace,
                если объект закрываемого
                ресурса равен null*/
            }
        }
    }

 public static void resourcesProcess() {
        OutputStream stream = null;
        Throwable mainException = null;
 
        try {
            /*
            что-то делаем со stream
             */
            String pathToFile = "c:\\driver";
            FileInputStream fileInputStream = new FileInputStream(pathToFile);
            stream = openOutputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
 
            System.out.println("Блок try");
 
        } catch (Throwable t) {
            mainException = t;
            /*
             обрабатываем исключение
              */
            System.out.println("Исключение в блоке catch");
            System.out.println("t = " + mainException);
        } finally {
 
            try {
                stream.close();
            } catch (Throwable unused) {
                System.out.println("++++++++++++++++++++++++++");
                System.out.println("Исключение в блоке finally");
            }
        }
    }
 
 
    private static OutputStream openOutputStream() throws IOException {
 
        return null;
    }

@Override
    public List<TranslitEntity> loadAllUserTranslits(Integer userId) {
 
        List<TranslitEntity> result = new ArrayList<TranslitEntity>();
 
        Connection connectionTmp = null;
 
        try (Connection connection = ConnectionPool.getPool().getConnection();
             PreparedStatement statement = connection.prepareStatement("SELECT * from translits " +
                     "WHERE user_id = ?");
 
             ) {
            connectionTmp = connection;
            statement.setInt(1, userId);
 
        try(ResultSet set = statement.executeQuery()){
            System.out.println("set - " + set);
            System.out.println();
            while (set.next()) {
                TranslitEntity entity = ResultSetConverter.createTranslitEntity(set);
                result.add(entity);
            }
        }
 
        } catch (SQLException e) {
            rollback(connectionTmp);
            throw new DaoException(e);
        }
 
        return result;
    }