Introduction et méthodes de DataSourceUitls

Introduction à DataSourceUitls

La classe DataSourceUitls se trouve sous le package org.springframework.jdbc.datasource. Elle fournit de nombreuses méthodes statiques pour obtenir une connexion JDBC à partir d'un javax.sql.DataSource et assure la gestion des transactions Spring. soutien.

Dans la classe JdbcTemplate, DataSourceUtils est utilisé plusieurs fois. En fait, nous pouvons également utiliser DataSourceUitls directement dans le code pour faire fonctionner Jdbc.

DataSourceUitls obtient Connection

Méthode getConnection

Implémentation interne

    public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
        try {
            return doGetConnection(dataSource);
        }
        catch (SQLException ex) {
            throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex);
        }
        catch (IllegalStateException ex) {
            throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection: " + ex.getMessage());
        }
    }

On peut voir qu'en passant une DataSource spécifiée, une connexion peut être obtenu, le processus d'acquisition est mis en œuvre par la méthode doGetConnection. Si SQLException et IllegalStateException sont levées, enveloppez-les dans CannotGetJdbcConnectionException. En fait, seules SQLException et IllegalStateException peuvent être levées. En examinant le code source de CannotGetJdbcConnectionException, nous pouvons constater que CannotGetJdbcConnectionException est en fait une sous-classe de DataAccessException. Par conséquent, on peut dire que getConnection encapsulera uniformément l'exception levée dans DataAccessException de Spring.

Méthode doGetConnection

Implémentation interne

    public static Connection doGetConnection(DataSource dataSource) throws SQLException {
        Assert.notNull(dataSource, "No DataSource specified");

        ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
        if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
            conHolder.requested();
            if (!conHolder.hasConnection()) {
                logger.debug("Fetching resumed JDBC Connection from DataSource");
                conHolder.setConnection(fetchConnection(dataSource));
            }
            return conHolder.getConnection();
        }
        // Else we either got no holder or an empty thread-bound holder here.

        logger.debug("Fetching JDBC Connection from DataSource");
        Connection con = fetchConnection(dataSource);

        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            logger.debug("Registering transaction synchronization for JDBC Connection");
            // Use same Connection for further JDBC actions within the transaction.
            // Thread-bound object will get removed by synchronization at transaction completion.
            ConnectionHolder holderToUse = conHolder;
            if (holderToUse == null) {
                holderToUse = new ConnectionHolder(con);
            }
            else {
                holderToUse.setConnection(con);
            }
            holderToUse.requested();
            TransactionSynchronizationManager.registerSynchronization(
                    new ConnectionSynchronization(holderToUse, dataSource));
            holderToUse.setSynchronizedWithTransaction(true);
            if (holderToUse != conHolder) {
                TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
            }
        }

        return con;
    }

La méthode doGetConnection est la méthode de base pour l'opération réelle permettant d'obtenir la connexion. On peut conclure du code source que s'il n'y a pas de connexion liée au thread actuel, une nouvelle connexion sera créée. Si la synchronisation des transactions du thread actuel est active, alors la prise en charge de la gestion des transactions Spring sera simplement ajoutée à la connexion. créé ; si Si une connexion correspondante existe pour le thread actuel, alors il existe une allocation de gestion des transactions en cours.

Méthode fetchConnection

fetchConnection est une méthode privée qui n'est pas ouverte au public. Elle remplit en fait une fonction simple : créer une nouvelle connexion à partir de la DastaSource actuelle. Si la création échoue, une IllegalStateException. est lancé, indiquant qu'une nouvelle connexion ne peut pas être obtenue.

DataSourceUitls publie Connection

Méthode releaseConnection

Implémentation interne

    public static void releaseConnection(@Nullable Connection con, @Nullable DataSource dataSource) {
        try {
            doReleaseConnection(con, dataSource);
        }
        catch (SQLException ex) {
            logger.debug("Could not close JDBC Connection", ex);
        }
        catch (Throwable ex) {
            logger.debug("Unexpected exception on closing JDBC Connection", ex);
        }
    }

L'implémentation spécifique de la méthode releaseConnection est gérée par doReleaseConnection. Si une exception est levée, elle sera uniquement déboguée dans le journal et ne sera pas levée en externe. Les deux paramètres de cette méthode sont NULL
Si con est NULL, cet appel est ignoré tandis que l'autre paramètre peut être NULL.

Méthode doReleaseConnection

Implémentation interne

    public static void doReleaseConnection(@Nullable Connection con, @Nullable DataSource dataSource) throws SQLException {
        if (con == null) {
            return;
        }
        if (dataSource != null) {
            ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
            if (conHolder != null && connectionEquals(conHolder, con)) {
                // It's the transactional Connection: Don't close it.
                conHolder.released();
                return;
            }
        }
        logger.debug("Returning JDBC Connection to DataSource");
        doCloseConnection(con, dataSource);
    }

La méthode doReleaseConnection est la méthode qui libère réellement la connexion. Par rapport à la méthode releaseConnection, elle termine le traitement des deux entrants. La somme de contrôle des paramètres lève une exception de niveau inférieur. Lorsque dataSource n'est pas NULL, libérez la connexion actuelle retenue par ce ConnectionHolder afin que la connexion actuelle puisse être réutilisée, ce qui est très utile pour améliorer les performances des opérations Jdbc. Si dataSource est null, choisissez de fermer la connexion directement.

DataSourceUitls ferme la connexion

Méthode doCloseConnection

Implémentation interne

    public static void doCloseConnection(Connection con, @Nullable DataSource dataSource) throws SQLException {
        if (!(dataSource instanceof SmartDataSource) || ((SmartDataSource) dataSource).shouldClose(con)) {
            con.close();
        }
    }

Dans la méthode doReleaseConnection, nous avons appris que lorsque la source de données est NULL, elle exécutera la méthode doCloseConnection. En fait, ce n'est que lorsque le dataSource n'implémente pas l'interface org.springframework.jdbc.datasource.SmartDataSource ou lorsque le dataSource implémente l'interface org.springframework.jdbc.datasource.SmartDataSource et est autorisé à être fermé que la connexion est réellement fermée.

L'interface org.springframework.jdbc.datasource.SmartDataSource est une extension de l'interface javax.sql.DataSource et renvoie la connexion Jdbc sous une forme non enveloppée. Les classes qui implémentent cette interface peuvent demander si la connexion doit être fermée une fois l'opération terminée. Ces vérifications sont automatiquement effectuées dans Srping, DataSourceUitls et JdbcTemplate.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!