Partage d'exemples de code pour accéder simultanément à plusieurs bases de données différentes dans Java Spring

Lors du développement d'applications d'entreprise, nous rencontrons souvent le problème de l'accès à plusieurs bases de données différentes en même temps. Parfois, les données doivent être archivées dans une sorte d'entrepôt de données, et parfois les modifications des données doivent être transférées vers une base de données tierce. Lorsque vous utilisez le framework Spring, il est très simple d'utiliser une seule base de données, mais si vous souhaitez accéder à plusieurs bases de données en même temps, les événements deviennent beaucoup plus compliqués.

Cet article prend comme exemple le développement d'un programme SpringMVC sous le framework Spring pour démontrer une méthode d'accès à plusieurs bases de données en même temps et simplifier autant que possible les changements de configuration.

Construire une base de données

Il est recommandé de configurer également deux bases de données en même temps pour suivre notre exemple. Dans cet article, nous avons utilisé PostgreSQL et MySQL.

Le contenu du script suivant est la commande permettant de créer des tables et d'insérer des données dans deux bases de données.

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');

Construire le projet

Nous utilisons Spring Tool Suite (STS) pour créer cet exemple :

• Cliquez sur Fichier -> Nouveau ->

• Entrez le nom du projet, les coordonnées Maven, la description et les informations sur le package dans la boîte de dialogue, puis cliquez sur Suivant.

• Sélectionnez Web dans la dépendance de démarrage et cliquez sur Suivant.

• Cliquez sur Terminer. STS téléchargera automatiquement le contenu requis depuis l'entrepôt Spring en fonction des dépendances du projet.

Le projet créé est présenté ci-dessous :

Ensuite, examinons de plus près chaque élément associé dans le projet Fichier contenu.

pom.xml

pom contient toutes les dépendances requises et les relations de mappage des plug-ins.

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>

Explication :

Les détails des différentes dépendances sont expliqués en détail ci-dessous :

• printemps- boot -starter-web : fournit la prise en charge du développement Web et de MVC.

• spring-boot-starter-test : fournit JUnit, Mockito et d'autres dépendances de test.

• spring-boot-starter-jdbc : fournit la prise en charge de JDBC.

• postgresql : pilote JDBC pour base de données PostgreSQL.

• mysql-connector-java : pilote JDBC pour base de données MySQL .

application.properties

contient toutes les informations de configuration requises par le programme. Dans l'ancienne version de Spring, nous devions fournir ces informations de configuration via plusieurs fichiers XML.

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

Explication :

"server.port=6060" déclare que votre serveur embarqué utilisera le port 6060 après le démarrage (port.server.port est le port standard par défaut de Boot).

Autres attributs :

• Ceux préfixés par "spring.ds_*" sont des attributs définis par l'utilisateur.

• Les propriétés préfixées par "spring.ds_post.*" sont des propriétés définies pour la base de données PostgreSQL.

• Les propriétés préfixées par "spring.ds_mysql.*" sont des propriétés définies pour la base de données MySQL.

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

Ce fichier contient la fonction principale qui démarre notre programme de démarrage. L'annotation "@SpringBootApplication" est une combinaison de toutes les autres annotations Spring et de l'annotation Java , notamment :

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

Autres annotations :

@Configuration
@EnableAutoConfiguration
@ComponentScan

Ce qui précède les annotations permettront au conteneur de charger notre configuration via cette classe.

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

Explication :

Il s'agit d'une classe de configuration annotée qui contient le chargement de nos fonctions et annotations de configuration de bases de données PostgreSQL et MySQL . Celui-ci sera également responsable de la création de classes de modèles JDBC pour chaque base de données.

Jetons un coup d'œil à ces quatre fonctions :

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

La première ligne du code ci-dessus crée le bean mysqlDb.
La deuxième ligne aide @Bean à charger toutes les propriétés avec le préfixe spring.ds_mysql.
La quatrième ligne crée et initialise la classe DataSource et crée l'objet mysqlDb DataSource.

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

La première ligne crée un nouveau Bean de type JdbcTemplate nommé mysqlJdbcTemplate.
La deuxième ligne transmet le nouveau paramètre du type DataSource créé dans la première ligne dans la fonction, et utilise mysqlDB comme qualificatif.
La troisième ligne initialise l'instance JdbcTemplate avec l'objet DataSource.

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

La première ligne crée l'instance DataSource postgresDb.
La deuxième ligne aide @Bean à charger toutes les configurations préfixées par spring.ds_post.
La quatrième ligne crée et initialise l'instance DataSource postgresDb.

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

La première ligne crée un nouveau bean de type JdbcTemplate avec le nom postgresJdbcTemplate.
La deuxième ligne accepte les paramètres de type DataSource et utilise postgresDb comme qualificatif.
La troisième ligne initialise l'instance JdbcTemplate avec l'objet DataSource.

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

Explication :

L'annotation de la classe @RestController indique que toutes les fonctions définies dans cette classe sont liées par défaut. Répondre .

上面代码段创建了一个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数据库并以字符串形式返回数据。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!