Maison  >  Article  >  Java  >  Comment Springboot intègre-t-il mybatis pour implémenter une configuration multi-sources de données ?

Comment Springboot intègre-t-il mybatis pour implémenter une configuration multi-sources de données ?

WBOY
WBOYavant
2023-05-20 15:42:06914parcourir

Créez un nouveau projet Springboot et introduisez les dépendances Web, MySQL et mybatis

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

Configurez plusieurs sources de données dans application.properties

spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/ds0
spring .datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.secondary. jdbc-url=jdbc:mysql://localhost:3306/ds1
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com. mysql.cj.jdbc.Driver

La différence entre la configuration de plusieurs sources de données et la configuration d'une seule source de données est qu'il existe un nom de source de données supplémentaire primaire/secondaire après spring.datasource pour distinguer les différentes sources de données

Initialiser la source de données ;

Nouveau Une classe de configuration utilisée pour charger plusieurs sources de données pour terminer l'initialisation.

@Configuration
public class DataSourceConfiguration {
    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

Vous pouvez savoir grâce à @ConfigurationProperties que ces deux sources de données ont chargé les configurations de spring.datasource.primary.* et spring.datasource.secondary.* respectivement. Si la source de données n'est pas explicitement spécifiée, la source de données principale marquée par l'annotation @Primary est utilisée.

configuration mybatis

@Configuration
@MapperScan(
        basePackages = "com*.primary",
        sqlSessionFactoryRef = "sqlSessionFactoryPrimary",
        sqlSessionTemplateRef = "sqlSessionTemplatePrimary")
public class PrimaryConfig {
    private DataSource primaryDataSource;
    public PrimaryConfig(@Qualifier("primaryDataSource") DataSource primaryDataSource) {
        this.primaryDataSource = primaryDataSource;
    }
    @Bean
    public SqlSessionFactory sqlSessionFactoryPrimary() throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(primaryDataSource);
        return bean.getObject();
    }
    @Bean
    public SqlSessionTemplate sqlSessionTemplatePrimary() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactoryPrimary());
    }
}
@Configuration
@MapperScan(
        basePackages = "com.*.secondary",
        sqlSessionFactoryRef = "sqlSessionFactorySecondary",
        sqlSessionTemplateRef = "sqlSessionTemplateSecondary")
public class SecondaryConfig {
    private DataSource secondaryDataSource;
    public SecondaryConfig(@Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        this.secondaryDataSource = secondaryDataSource;
    }
    @Bean
    public SqlSessionFactory sqlSessionFactorySecondary() throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(secondaryDataSource);
        return bean.getObject();
    }
    @Bean
    public SqlSessionTemplate sqlSessionTemplateSecondary() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactorySecondary());
    }
}

L'annotation @MapperScan est utilisée sur la classe de configuration pour spécifier l'entité et le chemin du package de mappeur définis sous la source de données actuelle. Elle injecte également sqlSessionFactory et sqlSessionTemplate, et spécifie la source de données correspondante via l'annotation @Qualifier. , dont le nom correspond au nom de la fonction défini par la source de données dans la classe de configuration DataSourceConfiguration.

Entités et mappeurs sous les chemins correspondants de chaque paire de sources de données

@Data
@NoArgsConstructor
public class UserPrimary {
    private Long id;
    private String user_name;
    private Integer age;
    public UserPrimary(String name, Integer age) {
        this.user_name = name;
        this.age = age;
    }
}
public interface UserMapperPrimary {
    @Select("SELECT * FROM USER_0 WHERE USER_NAME = #{name}")
    UserPrimary findByName(@Param("name") String name);
    @Insert("INSERT INTO USER_0 (USER_NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);
    @Delete("DELETE FROM USER_0")
    int deleteAll();
}
@Data
@NoArgsConstructor
public class UserSecondary {
    private Long id;
    private String user_name;
    private Integer age;
    public UserSecondary(String name, Integer age) {
        this.user_name = name;
        this.age = age;
    }
}
public interface UserMapperSecondary {
    @Select("SELECT * FROM USER_1 WHERE USER_NAME = #{name}")
    UserSecondary findByName(@Param("name") String name);
    @Insert("INSERT INTO USER_1 (USER_NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);
    @Delete("DELETE FROM USER_1")
    int deleteAll();
}

Test

	@Test
    public void test() {
        // 往Primary数据源插入一条数据
        userMapperPrimary.insert("caocao", 20);
        // 从Primary数据源查询刚才插入的数据,配置正确就可以查询到
        UserPrimary userPrimary = userMapperPrimary.findByName("caocao");
        Assert.assertEquals(20, userPrimary.getAge().intValue());
        // 从Secondary数据源查询刚才插入的数据,配置正确应该是查询不到的
        UserSecondary userSecondary = userMapperSecondary.findByName("caocao");
        Assert.assertNull(userSecondary);
        // 往Secondary数据源插入一条数据
        userMapperSecondary.insert("sunquan", 21);
        // 从Primary数据源查询刚才插入的数据,配置正确应该是查询不到的
        userPrimary = userMapperPrimary.findByName("sunquan");
        Assert.assertNull(userPrimary);
        // 从Secondary数据源查询刚才插入的数据,配置正确就可以查询到
        userSecondary = userMapperSecondary.findByName("sunquan");
        Assert.assertEquals(21, userSecondary.getAge().intValue());
    }

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!

Déclaration:
Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer