Comment faire pour que liquibase se connecte avec slf4j?

il y en a, mais c'est un peu obscur. Citation fixation de l'enregistrement liquibase avec SLF4J et Log4J :

il y a la voie facile , en tombant dans une dépendance:

<!-- your own standard logging dependencies -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.5</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId><!-- or log4j2 or logback or whatever-->
    <version>1.7.5</version>
</dependency>

<!-- special dependency to fix liquibase's logging fetish -->
<dependency>
    <groupId>com.mattbertolini</groupId>
    <artifactId>liquibase-slf4j</artifactId>
    <version>1.2.1</version>
</dependency>

maintenant les deux premiers sont vos cadres de journalisation quotidiens (api slf4j et mise en œuvre de log4j). Ceux-ci s'ajoutent à votre dépendance log4j standard, car tout ce qu'ils font, c'est se diriger vers le cadre de journalisation physique. Sans log4j / logback / etc. lui-même, ils ne peuvent toujours pas la route quoi que ce soit.

la dernière est cependant intéressante, car elle fournit une classe unique dans un paquet spécifique que liquibase scannera pour les implémentations Logger . C'est open source, par Matt Bertolini, donc vous pouvez le trouver sur GitHub .

Si vous voulez le faire vous-même, il y a aussi à La Dure :

package liquibase.ext.logging; // this is *very* important

import liquibase.changelog.ChangeSet;
import liquibase.changelog.DatabaseChangeLog;
import liquibase.logging.core.AbstractLogger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Liquibase finds this class by itself by doing a custom component scan (sl4fj wasn't generic enough).
 */
public class LiquibaseLogger extends AbstractLogger {
    private static final Logger LOGGER = LoggerFactory.getLogger(LiquibaseLogger.class);
    private String name = "";

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void severe(String message) {
        LOGGER.error("{} {}", name, message);
    }

    @Override
    public void severe(String message, Throwable e) {
        LOGGER.error("{} {}", name, message, e);
    }

    @Override
    public void warning(String message) {
        LOGGER.warn("{} {}", name, message);
    }

    @Override
    public void warning(String message, Throwable e) {
        LOGGER.warn("{} {}", name, message, e);
    }

    @Override
    public void info(String message) {
        LOGGER.info("{} {}", name, message);
    }

    @Override
    public void info(String message, Throwable e) {
        LOGGER.info("{} {}", name, message, e);
    }

    @Override
    public void debug(String message) {
        LOGGER.debug("{} {}", name, message);
    }

    @Override
    public void debug(String message, Throwable e) {
        LOGGER.debug("{} {}", message, e);
    }

    @Override
    public void setLogLevel(String logLevel, String logFile) {
    }

    @Override
    public void setChangeLog(DatabaseChangeLog databaseChangeLog) {
    }

    @Override
    public void setChangeSet(ChangeSet changeSet) {
    }

    @Override
    public int getPriority() {
        return Integer.MAX_VALUE;
    }
}

cette implémentation fonctionne, mais ne doit être utilisée qu'à titre d'exemple. Par exemple, je n'utilise pas les noms de Liquibase pour exiger une journalisation, mais utilise cette classe Logger à la place. Les versions de Matt font quelques null - vérifications aussi, donc c'est probablement une implémentation plus mature à utiliser, plus c'est open source.