Deaktivieren Sie alle Datenbank-bezogenen Autokonfigurationen in Spring Boot

Ich verwende Spring Boot, um zwei Anwendungen zu entwickeln, eine dient als Server und eine andere ist eine Client-App. Beide sind jedoch dieselbe App, die je nach aktivem Profil unterschiedlich funktioniert. Ich verwende die automatische Konfigurationsfunktion von Spring Boot, um meine Anwendungen zu konfigurieren.

Ich möchte die gesamte datenbankbezogene automatische Konfiguration in der Client-App deaktivieren, da keine Datenbankverbindung erforderlich ist. Die Anwendung sollte weder versuchen, eine Verbindung mit der Datenbank herzustellen, noch versuchen, eine der Spring Data- oder Hibernate-Funktionen zu verwenden. Das Aktivieren oder Deaktivieren der automatischen Datenbankkonfiguration sollte bedingt sein und auf dem aktiven Profil der App basieren.

Kann ich dies erreichen, indem ich zwei verschiedene application.properties-Dateien für die jeweiligen Profile erstelle?

Ich habe versucht, dies zu meiner Eigenschaftendatei hinzuzufügen.

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration\
  org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration\
  org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration

Die Anwendung versucht jedoch weiterhin, beim Start eine Verbindung zur Datenbank herzustellen. Reichen diese Ausschlüsse aus, um meine Anforderung zu erfüllen?

Die Art und Weise, wie ich ähnliche Dinge tun würde, ist:

@Configuration
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@Profile ("client_app_profile_name")
public class ClientAppConfiguration {
    //it can be left blank
}

Schreiben Sie eine ähnliche für die Server-App (ohne Ausschlüsse).

Der letzte Schritt besteht darin, die automatische Konfiguration in der Hauptfeder-Boot-Klasse zu deaktivieren:

@SpringBootApplication
public class SomeApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication.run(SomeApplication.class);
    }

    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SomeApplication.class);
    }
}

Ändern: @SpringBootApplicationin:

@Configuration 
@ComponentScan

Dies sollte den Job machen. Die Abhängigkeiten, die ich im Beispiel ausgeschlossen habe, sind möglicherweise unvollständig. Sie waren genug für mich, aber ich bin nicht sicher, ob es alles ist, um datenbankbezogene Bibliotheken vollständig zu deaktivieren. Überprüfen Sie die Liste unten, um sicherzugehen:

http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#auto-configuration-classes

hoffentlich hilft das

Zum Deaktivieren der gesamten datenbankbezogenen Autokonfiguration und zum Beenden von:

Die eingebettete Datenbanktreiberklasse für den Datenbanktyp NONE kann nicht ermittelt werden

1. Verwenden von Anmerkungen:

@SpringBootApplication
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(PayPalApplication.class, args);
    }
}

2. Verwenden von Application.properties:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration, org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Scheint, als hätten Sie gerade das Komma vergessen, um die Klassen zu trennen. Abhängig von Ihrer Konfiguration funktioniert also Folgendes:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration

Alternativ können Sie es auch wie folgt definieren:

spring.autoconfigure.exclude[0]=org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
spring.autoconfigure.exclude[1]=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
spring.autoconfigure.exclude[2]=org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
spring.autoconfigure.exclude[3]=org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration

Es gibt eine Möglichkeit, bestimmte Klassen für die automatische Konfiguration mithilfe von @SpringBootApplicationAnmerkungen auszuschließen .

@Import(MyPersistenceConfiguration.class)
@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class, 
        DataSourceTransactionManagerAutoConfiguration.class,
        HibernateJpaAutoConfiguration.class})
public class MySpringBootApplication {         
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

@SpringBootApplication#excludeAttribut ist ein Alias ​​für @EnableAutoConfiguration#excludeAttribut und ich finde es ziemlich praktisch und nützlich.
Ich @Import(MyPersistenceConfiguration.class)habe dem Beispiel hinzugefügt, um zu demonstrieren, wie Sie Ihre benutzerdefinierte Datenbankkonfiguration anwenden können.

Ausweg für mich war hinzuzufügen

@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})

Anmerkung zur Klasse, in der Spring Boot ausgeführt wird (gekennzeichnet mit `@SpringBootApplication).

Schließlich sieht es so aus:

@SpringBootApplication
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class Application{

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
 }

Eine andere Möglichkeit, es über Profile zu steuern, ist folgende:

// note: no @SpringApplication annotation here
@Import(DatabaseConfig.class)
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Configuration
@Import({DatabaseConfig.WithDB.class, DatabaseConfig.WithoutDB.class})
public class DatabaseConfig {

    @Profile("!db")
    @EnableAutoConfiguration(
            exclude = {DataSourceAutoConfiguration.class,   DataSourceTransactionManagerAutoConfiguration.class,
                HibernateJpaAutoConfiguration.class})
    static class WithoutDB {

    }

    @Profile("db")
    @EnableAutoConfiguration
    static class WithDB {

    }
}

Ich hatte das gleiche Problem hier, so gelöst:

application-{yourprofile}.ymlFügen Sie einfach eine weitere hinzu, bei der "yourprofile" "client" sein könnte.

In meinem Fall wollte ich nur Redis in einem Dev-Profil entfernen, also habe ich application-dev.ymlneben dem Main ein hinzugefügt application.ymlund es hat den Job gemacht.

In diese Datei habe ich gesetzt:

spring.autoconfigure.exclude: org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration

Dies sollte auch mit Eigenschaftendateien funktionieren.

Ich mag die Tatsache, dass es nicht notwendig ist, den Anwendungscode zu ändern, um dies zu tun.

Ich habe diesen Fehler erhalten, auch wenn ich alle oben genannten Lösungen durchgeführt habe.

 by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dataSource' defined in class path resource [org/springframework/boot/autoconfigure/jdbc/DataSourceConfig ...

Irgendwann, als ich das POM nachschlug, war diese Abhängigkeit darin

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

Und die Pojo-Klasse hatte die folgenden Importe

import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id;

Dies zeigt deutlich, dass die Anwendung eine Datenquelle erwartet hat.

Ich habe die JPA-Abhängigkeit von pom entfernt und die Importe für das Pojo einmal durch die folgenden ersetzt

import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document;

Endlich habe ich ERFOLGREICH gebaut. Überprüfen Sie, ob Sie möglicherweise auf dasselbe Problem gestoßen sind

Ich füge in myApp.java nach @SpringBootApplication hinzu

@EnableAutoConfiguration (exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})

Und verändert

@SpringBootApplication => @Configuration

Also habe ich das in meiner Hauptklasse (myApp.java)

package br.com.company.project.app;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
public class SomeApplication {

public static void main(String[] args) {
    SpringApplication.run(SomeApplication.class, args);
}

}}

Und arbeite für mich! =)