wake-up-neo.com

Datenquelle zum Zurücksetzen des Springboots im laufenden Betrieb

Ich versuche, die Datenquelle in Spring Boot zu aktualisieren, wenn sich die DB-Eigenschaft wie DB-Name, Kennwort oder Hostname in der Spring-Konfigurationsdatei oder der benutzerdefinierten DB-Eigenschaftsdatei ändert. Wenn sich die Eigenschaft ändert, muss die Anwendung selbst aktualisieren, indem Änderungen an der Eigenschaft abgehört werden.

Ich habe Spring Actuator verwendet, um Beans neu zu starten, nachdem die DB-Konfiguration geändert wurde. Der Benutzer muss jedoch explizit eine Post-Anforderung zum Neustart stellen. Dieser Schritt muss vermieden werden, indem die Änderungen abgehört und die Datenquelle aktualisiert werden.

Kannst du mir sagen, wie das am besten im Frühjahr geht?

javaspringspring-mvcspring-bootspring-boot-actuator
5
vishnukumar

Es wurde eine Möglichkeit gefunden, die Datenquelle im laufenden Betrieb zu aktualisieren.

Ich habe der Anwendung eine externe Spring-Konfigurationsdatei übergeben, die DB-Eigenschaften enthält, und dann die Eigenschaften mit @RefreshScope für die Datenquellen-Bean aktualisiert.

Ein Thread überwacht die Dateiänderungen und ruft die refresh () -Methode des Aktors auf.

database.properties

dburl=jdbc://localhost:5432/dbname
dbusername=user1
dbpassword=userpwd

Datenquelle erstellen,

@RefreshScope
public class DBPropRefresh{
@Value("${dburl}")
private String dbUrl;

@Value("${dbusername}")
private String dbUserName;

@Value("${dbpassword}")
private String dbPassword;

@Bean
@RefreshScope
public DataSource getDatasource(){
return new DatasourceBuilder().create().url(dbUrl).username(dbUserName).password(dbPassword);
}

Externe Konfigurationsdatei an die Anwendung übergeben,

Java -jar myapplication.jar --spring.config.location=database.properties

Ich habe eine Java-Thread-Klasse erstellt, um die Dateiänderungen in database.properties zu überwachen. Followed https://dzone.com/articles/how-watch-file-system-changes Bei Änderungen wird refreshEndPoint.refresh () aufgerufen.

In pom.xml

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>1.5.6.RELEASE</version>
    </dependency>
4
vishnukumar

Sie können das dynamische Datenquellen-Routing von Spring verwenden und prüfen, ob es hilft. Es ist eine sehr alte Technik und könnte nützlich sein, wenn das Ihrem Zweck dient.

Beachten Sie jedoch, dass dies Datenquellenrouting und keine neue Datenquellenkonfiguration ist.

https://spring.io/blog/2007/01/23/dynamic-datasource-routing/

1
Karthik R

In meinem Projekt habe ich Mandantenfähigkeit verwendet. Grundsätzlich habe ich in Eigenschaften wie diesen mehrere Datenquellen definiert:

primary.datasource.url=jdbc:postgresql://localhost:5432/db_name?currentSchema=schema_name
primary.datasource.username=user
primary.datasource.password=password
primary.datasource.driverClassName=org.postgresql.Driver
primary.datasource.driver-class-name=org.postgresql.Driver

secondary.datasource.url=jdbc:postgresql://localhost:5432/other_db?currentSchema=schema
secondary.datasource.username=user
secondary.datasource.password=password
secondary.datasource.driverClassName=org.postgresql.Driver
secondary.datasource.driver-class-name=org.postgresql.Driver

default.datasource.url=jdbc:postgresql://localhost:5432/default_db?currentSchema=public
default.datasource.username=user
default.datasource.password=password
default.datasource.driverClassName=org.postgresql.Driver
default.datasource.driver-class-name=org.postgresql.Driver

dann wurden in der Konfigurationsklasse mehrere Datenquellen definiert:

@Bean
@Primary
@ConfigurationProperties(prefix="primary.datasource")
public DataSource primaryDataSource() {
    return DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties(prefix="secondary.datasource")
public DataSource secondaryDataSource() {
    return DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties(prefix="default.datasource")
public DataSource defaultDataSource(){
    return DataSourceBuilder.create().build();
}

und konfigurierte Mandantenfähigkeit basierend auf diesem und diesem Artikel.
Vorteile:

  • Einfacher Mandantenwechsel, der manuell ausgelöst oder sogar so konfiguriert werden kann, dass er auf bestimmte Header in Anfrage (Filter) ausgelöst wird.
  • Könnte so konfiguriert sein, dass zwischen Schemas oder Datenbanken gewechselt wird.
  • Passiert dynamisch (Sie müssen Ihre Beans nicht neu starten)

Nachteile:

  • Sie müssen alle DB-Möglichkeiten in der Eigenschaftendatei definieren.
  • Sie müssen die Schemaüberprüfung deaktivieren, da sie verrückt wird.
1
pokemzok

Werfen Sie einen Blick auf diesen Artikel Ich hoffe, es ist hilfreich :)

0
Montassar El Béhi