Désactiver la connexion dans SpringBoot

Il semble que Springboot se configure automatiquement pour utiliser Logback avec Tomcat. Je voudrais désactiver cela et utiliser celui que je fournis dans mon chemin de classe.

Le message d'erreur ci-dessous.

LoggerFactory n'est pas un Logback LoggerContext mais Logback est sur le chemin de classe. Supprimez Logback ou l'implémentation concurrente (classe org.slf4j.impl.SimpleLoggerFactory) L'objet de la classe [org.slf4j.impl.SimpleLoggerFactory] doit être une instance de la classe ch.qos.logback.classic.LoggerContext

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>1.0.1.RELEASE</version>
    </parent>

    <groupId>com.fe</groupId>
    <artifactId>cloudapp</artifactId>
    <version>1.0.0</version>
    <name>Withinet-PaaS</name>
    <description>Develop your web applications in on our infrastructure and we will worry about administration and scalability of your app.</description>

    <properties>
        <java.version>1.7</java.version>
        <guava.version>16.0.1</guava.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

    <dependencies>
    <dependency>
        <groupId>com.sun.jersey</groupId>
        <artifactId>jersey-client</artifactId>
        <version>1.8</version>
    </dependency>
        <dependency>
        <groupId>com.withinet.cloudapp</groupId>
    <artifactId>slave</artifactId>
    <version>1.0.0</version>    
        </dependency>
        <dependency>
            <groupId>org.apache.wicket</groupId>
            <artifactId>wicket-core</artifactId>
            <version>6.15.0</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.0.Final</version>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.2.4</version>
        </dependency>

        <!-- Spring Boot -->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Hibernate validator -->

        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>1.1.0.Final</version>


        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator-annotation-processor</artifactId>
            <version>4.1.0.Final</version>
        </dependency>

        <!-- Guava -->

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>

        <!-- Java EE -->

        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>

        <!--  Search -->
        <dependency>
            <groupId>org.apache.lucene</groupId>
            <artifactId>lucene-queryparser</artifactId>
            <version>4.8.0</version>
        </dependency>

        <!--  Security 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>

        <plugins>

            <!-- Spring Boot Maven -->

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.withinet.cloud.Application</mainClass>
                    <layout>JAR</layout>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>
</project>

Ajoutez une exclusion à la fois au spring-boot-starter et au spring-boot-starter-web pour résoudre le conflit.

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <exclusions>
    <exclusion>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
    </exclusion>
  </exclusions>
</dependency>

Pour ajouter une solution meilleure et plus générique dans Gradle (toutes les instances seront exclues):

configurations {
    all*.exclude module : 'spring-boot-starter-logging'
}

Depuis https://docs.gradle.org/current/userguide/dependency_management.html

Pour ajouter une solution dans gradle.

dependencies {
    compile ('org.springframework.boot:spring-boot-starter') {
        exclude module : 'spring-boot-starter-logging'
    }
    compile ('org.springframework.boot:spring-boot-starter-web') {
        exclude module : 'spring-boot-starter-logging'
    }
}

J'ai trouvé que l'exclusion du spring-boot-starter-loggingmodule complet n'est pas nécessaire. Il suffit d'exclure le org.slf4j:slf4j-log4j12module.

L'ajout de ceci à un fichier de construction Gradle résoudra le problème:

configurations {
    runtime.exclude group: "org.slf4j", module: "slf4j-log4j12"
    compile.exclude group: "org.slf4j", module: "slf4j-log4j12"
}

Consultez cette autre réponse StackOverflow pour plus de détails.

J'aime ça pour résoudre mon problème

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Pour gradle,

Vous pouvez voir cette solution sur: http://www.idanfridman.com/how-to-exclude-libraries-from-dependcies-using-gradle/

Juste besoin d' ajouter excludedans configurations:

configurations {
    providedRuntime
    compile.exclude(group: 'ch.qos.logback')
}

Recherchez spring-boot-starter-test dans votre pom.xml et modifiez-le comme suit:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <exclusions>
            <exclusion>
                <artifactId>commons-logging</artifactId>
                <groupId>commons-logging</groupId>
            </exclusion>
        </exclusions>
        <scope>test</scope>
    </dependency>

Il a corrigé une erreur comme:

_Caused by: java.lang.IllegalArgumentException:_ **LoggerFactory** is not a **Logback LoggerContext** but *Logback* is on the classpath.

Either remove **Logback** or the competing implementation

(_class org.apache.logging.slf4j.Log4jLoggerFactory_
loaded from file: 

**${M2_HOME}/repository/org/apache/logging/log4j/log4j-slf4j-impl/2.6.2/log4j-slf4j-impl-2.6.2.jar**).

If you are using WebLogic you will need to add **'org.slf4j'** to prefer-application-packages in WEB-INF/weblogic.xml: **org.apache.logging.slf4j.Log4jLoggerFactory**

Suivre des oeuvres pour moi

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

Il peut être utile de dire quel est votre enregistreur préféré et ce que vous avez fait pour essayer de l'installer. Quoi qu'il en soit, Spring Boot essaie de travailler avec tout ce qui se trouve dans le chemin de classe, donc si vous ne voulez pas de connexion, supprimez-le du chemin de classe. Il y a des instructions pour log4j dans la documentation , mais la même chose s'appliquerait aux autres systèmes de journalisation pris en charge (tout ce qui concerne slf4j, log4j ou java util).

J'ai résolu mon problème ci-dessous:

compile('org.mybatis.spring.boot:mybatis-spring-boot-starter:1.3.0'){
    exclude module: 'log4j-slf4j-impl'
    exclude module: 'logback-classic'
}
compile('org.springframework.boot:spring-boot-starter-web'){
    exclude module: 'log4j-slf4j-impl'
    exclude module: 'logback-classic'
}

Cela a très bien fonctionné pour moi

configurations {
    all*.exclude module : 'spring-boot-starter-logging'
}

Mais cela ne fonctionnerait pas pour les utilisateurs de maven . Toutes mes dépendances étaient dans libs.gradle et je ne les voulais pas dans d'autres fichiers. Donc , ce problème a été résolu en ajoutant exclude module : 'spring-boot-starter-loggingdans spring-boot-starter-data-jpa, spring-boot-starter-testet pratiquement tout avec le mot de démarrage.

METTRE À JOUR

Mon nouveau projet avait besoin d'une mise à jour, il s'avère que la version spring-boot-starter-test1.5 et les versions antérieures ne l'avaient pas été spring-boot-starter-logging. 2.0 l'a

Dans mon cas, il était seulement nécessaire d'exclure l' spring-boot-starter-loggingartefact de celui- spring-boot-starter-securityci.

Il s'agit d'un projet Spring Boot 2.2.6.RELEASE nouvellement généré comprenant les dépendances suivantes:

• ressort-boot-starter-security
• validation-démarrage-ressort
• ressort-boot-starter-web
• test de démarrage à ressort

J'ai découvert en courant mvn dependency:treeet en cherchant ch.qos.logback.

La botte à ressort liée <dependencies>à mon pom.xmlressemble à ceci:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>           
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-test</artifactId>
        <scope>test</scope>
    </dependency>



</dependencies>

Ajoutez ceci dans votre build.gradle

configurations.all {
    exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
    exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
    exclude group: 'org.springframework.boot', module: 'logback-classic'
}

Si cette erreur s'est produite dans SpringBoot lorsque vous essayez d'utiliser log4j2, procédez comme suit:

• Supprimez le fichier jar lors de l'emballage en ajoutant ce "excludeGroupIds log4j-slf4j-impl / excludeGroupIds"
• Découvrez quelle bibliothèque dépend de "logback-classic" en utilisant la commande "mvn dependecy: tree"
• Partout où vous le trouvez, excluez-le de la dépendance.

Cette erreur s'est produite car la journalisation remplace les modifications de log4j2. Donc, si vous souhaitez utiliser log4j2, vous devez supprimer la bibliothèque logback et les dépendances.

J'espère que cela aidera quelqu'un.

Méthode correcte pour exclure la journalisation par défaut et configurer log4j pour la journalisation.

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 <exclusions>
     <exclusion>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-logging</artifactId>
     </exclusion>
 </exclusions>
</dependency>

Reportez-vous à Spring Logging - How To .

Pour ajouter une exclusion pour la connexion à partir de l'EDI Netbeans

1. Accédez à la section> Explorateur de projets pour votre projet
2. Passez à> Dépendances comme indiqué ci-dessous
3. Tracez 'spring-boot-starter-logging-XXXjar'

4. Cliquez avec le bouton droit sur le pot et sélectionnez Exclure la dépendance comme indiqué ci-dessous. Ceci exclut le jar de connexion sur le pom.xml comme ceci;

     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       <exclusions>
           <exclusion>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-logging</artifactId>
           </exclusion>
       </exclusions>
   </dependency>
   

Dans mon cas ci-dessous, l'exclusion fonctionne !!

    <dependency>
        <groupId>com.xyz.util</groupId>
        <artifactId>xyz-web-util</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

L'ajout d'exclusions ne me suffisait pas. J'ai dû fournir un faux pot:

    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <scope>system</scope>
        <systemPath>${project.basedir}/empty.jar</systemPath>
    </dependency>

La raison en est que spring boot est livré avec logback comme configuration de journal par défaut, tandis que camel utilise log4j. C'est la raison du conflit. Vous avez deux options, soit supprimer le logback de Spring Boot comme mentionné dans les réponses ci-dessus, soit supprimer log4j de camel.

<dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-spring-boot-starter</artifactId>
            <version>${camel.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

Ajoutez simplement la configuration logback.xml dans votre chemin de classe et ajoutez toute votre configuration avec l'ajout de root appender. Une fois que le démarrage de Spring a terminé le chargement du bean, il commencera la journalisation en fonction de votre configuration.