Teilen von Codebeispielen für den gleichzeitigen Zugriff auf mehrere verschiedene Datenbanken in Java Spring

Bei der Entwicklung von Unternehmensanwendungen stoßen wir häufig auf das Problem, auf mehrere verschiedene Datenbanken gleichzeitig zuzugreifen. Manchmal müssen die Daten in einer Art Data Warehouse archiviert werden, und manchmal müssen Datenänderungen in eine Datenbank eines Drittanbieters übertragen werden. Wenn Sie das SpringFramework verwenden, ist es sehr einfach, eine einzelne Datenbank zu verwenden, aber wenn Sie gleichzeitig auf mehrere Datenbanken zugreifen möchten, werden die Ereignisse viel komplizierter.

In diesem Artikel wird die Entwicklung eines SpringMVC-Programms unter dem Spring-Framework als Beispiel verwendet, um eine Methode zum gleichzeitigen Zugriff auf mehrere Datenbanken zu demonstrieren und Konfigurationsänderungen so weit wie möglich zu vereinfachen.

Erstellen Sie eine Datenbank

Es wird empfohlen, auch zwei Datenbanken gleichzeitig einzurichten, um unserem Beispiel zu folgen. In diesem Artikel haben wir PostgreSQL und MySQL verwendet.

Der folgende Skriptinhalt ist der Befehl zum Erstellen von Tabellen und zum Einfügen von Daten in zwei Datenbanken.

PostgreSQL

CREATE TABLE usermaster ( 
   id integer, 
   name character varying, 
   emailid character varying, 
   phoneno character varying(10), 
   location character varying
) 

INSERT INTO usermaster(id, name, emailid, phoneno, location)
VALUES (1, 'name_postgres', 'email@email.com', '1234567890', 'IN');

MySQL

CREATE TABLE `usermaster` (
   `id` int(11) NOT NULL, 
   `name` varchar(255) DEFAULT NULL, 
   `emailid` varchar(20) DEFAULT NULL, 
   `phoneno` varchar(20) DEFAULT NULL, 
   `location` varchar(20) DEFAULT NULL, 
   PRIMARY KEY (`id`) 
)

INSERT INTO `kode12`.`usermaster` 
  (`id`, `name`, `emailid`, `phoneno`, `location`)
VALUES
  ('1', 'name_mysql', 'test@tset.com', '9876543210', 'IN');

Erstellen Sie das Projekt

Wir verwenden Spring Tool Suite (STS) zum Erstellen dieses Beispiels:

• Klicken Sie auf Datei ->

• Geben Sie den Projektnamen, die Maven-Koordinaten, die Beschreibung und die Paketinformationen in das Dialogfeld ein und klicken Sie auf „Weiter“.

• Wählen Sie Web in der Boot-Abhängigkeit aus und klicken Sie auf Weiter.

• Klicken Sie auf Fertig stellen. STS lädt die erforderlichen Inhalte entsprechend den Projektabhängigkeiten automatisch aus dem Spring Warehouse herunter.

Das erstellte Projekt wird unten angezeigt:

Als nächstes schauen wir uns jedes verwandte Element im genauer an Projektdatei Inhalt.

pom.xml

pom enthält alle erforderlichen Abhängigkeiten und Plug-In-Zuordnungsbeziehungen.

Code:

<?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>

    <groupId>com.aegis</groupId>
    <artifactId>MultipleDBConnect</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>MultipleDB</name>
    <description>MultipleDB with Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.5.RELEASE</version>
        <relativePath />
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Erklärung:

Die Details verschiedener Abhängigkeiten werden im Folgenden ausführlich erläutert:

• Frühling- boot -starter-web: Bietet Unterstützung für Webentwicklung und MVC.

• spring-boot-starter-test: Bietet JUnit, Mockito und andere Testabhängigkeiten.

• spring-boot-starter-jdbc: Bietet JDBC-Unterstützung.

• postgresql: JDBC-Treiber für die PostgreSQL-Datenbank.

• mysql-connector-java: JDBC-Treiber für MySQL-Datenbank .

application.properties

enthält alle vom Programm benötigten Konfigurationsinformationen. In der alten Version von Spring mussten wir diese Konfigurationsinformationen über mehrere XML-Dateien bereitstellen.

server.port=6060
spring.ds_post.url =jdbc:postgresql://localhost:5432/kode12
spring.ds_post.username =postgres
spring.ds_post.password =root
spring.ds_post.driverClassName=org.postgresql.Driver
spring.ds_mysql.url = jdbc:mysql://localhost:3306/kode12
spring.ds_mysql.username = root
spring.ds_mysql.password = root
spring.ds_mysql.driverClassName=com.mysql.jdbc.Driver

Erklärung:

„server.port=6060“ erklärt, dass Ihr eingebetteter Server nach dem Start Port 6060 verwenden wird (port.server.port ist der Standard-Standardport von Boot).

Andere Attribute:

• Die mit dem Präfix „spring.ds_*“ sind benutzerdefinierte Attribute.

• Die Eigenschaften mit dem Präfix „spring.ds_post.*“ sind Eigenschaften, die für die PostgreSQL-Datenbank definiert sind.

• Die Eigenschaften mit dem Präfix „spring.ds_mysql.*“ sind Eigenschaften, die für die MySQL-Datenbank definiert sind.

MultipleDbApplication.java

package com.aegis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public MultipleDbApplication {

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

Diese Datei enthält die Hauptfunktion , die unser Boot-Programm startet. Die Annotation „@SpringBootApplication“ ist eine Kombination aus allen anderen Spring-Annotationen und der Java-Annotation , einschließlich:

@Configuration
@EnableAutoConfiguration
@ComponentScan
@Target(value={TYPE})
@Retention(value=RUNTIME)
@Documented
@Inherited

Andere Annotationen:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Das Obige Anmerkungen sorgen dafür, dass der Container unsere Konfiguration über diese Klasse lädt.

MultipleDBConfig.java

package com.aegis.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class MultipleDBConfig {
    @Bean(name = "mysqlDb")
    @ConfigurationProperties(prefix = "spring.ds_mysql")
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "mysqlJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) {
        return new JdbcTemplate(dsMySQL);
    }

    @Bean(name = "postgresDb")
    @ConfigurationProperties(prefix = "spring.ds_post")
    public DataSource postgresDataSource() {
        return  DataSourceBuilder.create().build();
    }

    @Bean(name = "postgresJdbcTemplate")
    public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb") 
                                              
    DataSource dsPostgres) {
        return new JdbcTemplate(dsPostgres);
    }
}

Erklärung:

Dies ist eine annotierte Konfigurationsklasse, die das Laden unserer PostgreSQL- und MySQL-Datenbankkonfigurationsfunktionen und Annotationen enthält . Dieser ist auch für die Erstellung von JDBC-Vorlagenklassen für jede Datenbank verantwortlich.

Werfen wir einen Blick auf diese vier Funktionen:

@Bean(name = "mysqlDb")
@ConfigurationProperties(prefix = "spring.ds_mysql")
public DataSource mysqlDataSource() {
return DataSourceBuilder.create().build();
}

Die erste Zeile des obigen Codes erstellt die mysqlDb-Bean.

Die zweite Zeile hilft @Bean beim Laden aller Eigenschaften mit dem Präfix spring.ds_mysql.
Die vierte Zeile erstellt und initialisiert die DataSource-Klasse und erstellt das mysqlDb DataSource-Objekt.

@Bean(name = "mysqlJdbcTemplate")
public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) {
     return new JdbcTemplate(dsMySQL);
}

Die erste Zeile erstellt eine neue Bean vom Typ JdbcTemplate mit dem Namen mysqlJdbcTemplate.

Die zweite Zeile übergibt den neuen Parameter des in der ersten Zeile erstellten DataSource-Typs an die Funktion und verwendet mysqlDB als Qualifikationsmerkmal.
Die dritte Zeile initialisiert die JdbcTemplate-Instanz mit dem DataSource-Objekt.

@Bean(name = "postgresDb")
@ConfigurationProperties(prefix = "spring.ds_post")
public DataSource postgresDataSource() {
   return  DataSourceBuilder.create().build();
}

Die erste Zeile erstellt die DataSource-Instanz postgresDb.

Die zweite Zeile hilft @Bean beim Laden aller Konfigurationen mit dem Präfix spring.ds_post.
Die vierte Zeile erstellt und initialisiert die DataSource-Instanz postgresDb.

@Bean(name = "postgresJdbcTemplate")
public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb")
DataSource dsPostgres) {
  return new JdbcTemplate(dsPostgres);
}

Die erste Zeile erstellt eine neue Bean vom Typ JdbcTemplate mit dem Namen postgresJdbcTemplate.

Die zweite Zeile akzeptiert Parameter vom Typ DataSource und verwendet postgresDb als Qualifikationsmerkmal.
Die dritte Zeile initialisiert die JdbcTemplate-Instanz mit dem DataSource-Objekt.

DemoController.java

package com.aegis.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @Autowired
    @Qualifier("postgresJdbcTemplate")
    private JdbcTemplate postgresTemplate;

    @Autowired
    @Qualifier("mysqlJdbcTemplate")
    private JdbcTemplate mysqlTemplate;

    @RequestMapping(value = "/getPGUser")
    public String getPGUser() {
        Map<String, Object> map = new HashMap<String, Object>();
        String query = " select * from usermaster";
        try {
            map = postgresTemplate.queryForMap(query);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "PostgreSQL Data: " + map.toString();
    }

    @RequestMapping(value = "/getMYUser")
    public String getMYUser() {
        Map<String, Object> map = new HashMap<String, Object>();
        String query = " select * from usermaster";
        try {
            map = mysqlTemplate.queryForMap(query);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "MySQL Data: " + map.toString();
    }
}

Erklärung:

Die Klassenanmerkung @RestController gibt an, dass alle in dieser Klasse definierten Funktionen standardmäßig an Responding gebunden sind .

上面代码段创建了一个JdbcTemplate实例。@Qualifier用于生成一个对应类型的模板。代码中提供的是postgresJdbcTemplate作为Qualifier参数，所以它会加载MultipleDBConfig实例的jdbcTemplate(…)函数创建的Bean。

这样Spring就会根据你的要求来调用合适的JDBC模板。在调用URL “/getPGUser”时Spring会用PostgreSQL模板，调用URL “/getMYUser”时Spring会用MySQL模板。

@Autowired
@Qualifier("postgresJdbcTemplate")
private JdbcTemplate postgresTemplate;

这里我们用queryForMap(String query)函数来使用JDBC模板从数据库中获取数据，queryForMap(…)返回一个map，以字段名为Key，Value为实际字段值。

演示

执行类MultipleDbApplication中的main (…)函数就可以看到演示效果。在你常用的浏览器中点击下面URL：

URL: http://localhost:6060/getMYUser

上面的URL会查询MySQL数据库并以字符串形式返回数据。

Url: http://localhost:6060/getPGUser

上面的URL会查询PostgreSQL数据库并以字符串形式返回数据。

Das obige ist der detaillierte Inhalt vonTeilen von Codebeispielen für den gleichzeitigen Zugriff auf mehrere verschiedene Datenbanken in Java Spring. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!