Disabilita tutte le configurazioni automatiche relative al database in Spring Boot

Sto usando Spring Boot per sviluppare due applicazioni, una funge da server e l'altra è un'app client. Tuttavia, entrambi sono la stessa app che funziona in modo diverso in base al profilo attivo. Sto usando la funzione di configurazione automatica di Spring Boot per configurare le mie applicazioni.

Desidero disabilitare tutta la configurazione automatica relativa al database sull'app client, poiché non richiederà la connessione al database. L'applicazione non deve tentare di stabilire una connessione con il database, né provare a utilizzare nessuna delle funzionalità Spring Data o Hibernate. L'abilitazione o la disabilitazione della configurazione automatica del database dovrebbe essere condizionale e basata sul profilo attivo dell'app.

Posso ottenere ciò creando due diversi file application.properties per i rispettivi profili?

Ho provato ad aggiungerlo al mio file delle proprietà,

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

Tuttavia, l'applicazione tenta ancora di connettersi al database all'avvio. Queste esclusioni sono sufficienti per soddisfare il mio requisito?

Il modo in cui farei una cosa simile è:

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

Scrivine uno simile per l'app server (senza esclusioni).

L'ultimo passaggio consiste nel disabilitare la configurazione automatica dalla classe di avvio primaverile principale:

@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);
    }
}

Cambia: @SpringBootApplicationin:

@Configuration 
@ComponentScan

Questo dovrebbe fare il lavoro. Ora, le dipendenze che ho escluso nell'esempio potrebbero essere incomplete. Erano sufficienti per me, ma non sono sicuro che sia tutto per disabilitare completamente le librerie relative al database. Controlla l'elenco di seguito per essere sicuro:

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

spero che aiuti

Per disabilitare tutte le autoconfigurazioni relative al database e uscire da:

Impossibile determinare la classe del driver del database incorporato per il tipo di database NONE

1. Utilizzo dell'annotazione:

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

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

2. Utilizzo di Application.properties:

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

Sembra che tu abbia appena dimenticato la virgola per separare le classi. Quindi, in base alla configurazione, funzionerà quanto segue:

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

In alternativa potresti anche definirlo come segue:

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

C'è un modo per escludere classi di configurazione automatica specifiche utilizzando l' @SpringBootApplicationannotazione.

@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#excludeattributo è un alias per @EnableAutoConfiguration#excludeattributo e lo trovo piuttosto comodo e utile.
Ho aggiunto @Import(MyPersistenceConfiguration.class)all'esempio per dimostrare come applicare la configurazione del database personalizzato.

La via d'uscita per me era aggiungere

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

annotazione alla classe che esegue l'avvio primaverile (contrassegnata con `@SpringBootApplication).

Infine, sembra che:

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

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

Un altro modo per controllarlo tramite i profili è questo:

// 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 {

    }
}

Ho avuto lo stesso problema qui, risolto in questo modo:

Basta aggiungerne un altro application-{yourprofile}.ymldove "yourprofile" potrebbe essere "client".

Nel mio caso volevo solo rimuovere Redis in un profilo Dev, quindi ne ho aggiunto uno application-dev.ymlaccanto al main application.ymle ha funzionato.

In questo file metto:

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

questo dovrebbe funzionare anche con i file delle proprietà.

Mi piace il fatto che non sia necessario modificare il codice dell'applicazione per farlo.

Ho ricevuto questo errore anche se ho eseguito tutte le soluzioni sopra menzionate.

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

Ad un certo punto, quando cerco il POM, c'era questa dipendenza in esso

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

E la classe Pojo aveva le seguenti importazioni

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

Il che mostra chiaramente che l'applicazione si aspettava un'origine dati.

Quello che ho fatto è stato rimuovere la dipendenza JPA da pom e sostituire le importazioni per il pojo con il seguente una volta

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

Finalmente ho ottenuto una build SUCCESSFUL. Dai un'occhiata potresti aver riscontrato lo stesso problema

Aggiungo myApp.java, dopo @SpringBootApplication

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

E cambiato

@SpringBootApplication => @Configuration

Quindi, ho questo nella mia classe principale (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);
}

}

E lavora per me! =)