springboot基础学习4: mybatis多数据源

最新推荐文章于 2024-08-22 11:13:11 发布
最新推荐文章于 2024-08-22 11:13:11 发布
阅读量164 收藏
点赞数
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin9209/article/details/102826732
版权

一、在开发过程中可能我们会用到 多中数据源 有可能是mysql ，也有可能是sqlserver 这样的混合使用，还有就是主从模式或者需要连接不同的分库来支持业务。所以这些写一个简单支持处理多数据源的方式。
首先看项目结构
在这里插入图片描述
1、我们来看配置文件 application.yml

server:
  tomcat:
    uri-encoding: UTF-8
  port: 8084
spring:
  banner:
    charset: utf-8
  http:
   encoding:
     charset: UTF-8
     enabled: true
     force: true
  messages:
    encoding: UTF-8
  datasource:
    test1:
       jdbcUrl: jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=true
       username: root
       password: 123
       driver-class-name: com.mysql.cj.jdbc.Driver
    test2:
       jdbcUrl: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=true
       username: root
       password: 123
       driver-class-name: com.mysql.cj.jdbc.Driver

logging:
  level:
   com.base.mapper: debug
mybatis:
  config-location: classpath:mybatis_config.xml
  mapper-locations: classpath:mybatis/*.xml
  type-aliases-package: org.learn.boot.datasource.entity

在配置文件我们需要配置两个数据库，其中 test1 位主库，在使用的过程中必须指定主库，不然会报错。

2、数据源配置

package org.learn.boot.datasource.datasource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 * ClassName: DataSource1Config
 * Description: 数据源配置1 , 这个配置就是和spring 里面 的xml配置一样，只不过是通过java类 通过
 * Date:     2019/3/24 16:55
 * History:
 * <version> 1.0
 * @author lin
 */
@Configuration

@MapperScan(basePackages = "org.learn.boot.datasource.mapper.test1",sqlSessionTemplateRef = "test1SqlSessionTemplate")
public class DataSource1Config {

    @Autowired
    private DatasourceTest1 datasourceTest1;

    /**
     * @MapperScan 该注解指名扫描dao层，并且将dao层注入到指定的sqlSessionTemplate, 所以的@Bean都需要按照命令指定
     * prefix(前缀) = "spring.datasource.test1" 表示配置文件中那个下面的所有属性
     **/


    /**
     * @Description  1、创建dataSource，2、创建SqlSessionFactory ,3、再创建事务 ，4、最后包装到SqlSessionTemplate
     * 这里注意下 如果使用 yml 文件，那么就不能通过 这种方式来  @ConfigurationProperties(prefix = "spring.datasource.test1") 获取数据源。
     * 因为在这种方式下 会报错 ，找不到相应的配置。 如果是使用的properties 配置文件那么 就可以使用这种方式。
     * 如果要使用 yml文件配置 方式，那么需要
     * @param
     * @return javax.sql.DataSource
     * @exception   
     * @author lin
     * @Date 17:28 2019/3/24
     **/
    @Bean(name = "test1DataSource")
//    @ConfigurationProperties(prefix = "spring.datasource.test1")
    @Primary
    public DataSource testDateSource(){
        return  DataSourceBuilder.create().url(datasourceTest1.getJdbcUrl()).
                username(datasourceTest1.getUsername()).
                password(datasourceTest1.getPassword()).
                driverClassName(datasourceTest1.getDriverClassName()).
                build();
//        return DataSourceBuilder.create().build();
    }

    @Bean(name = "test1SqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/Bank1Mapper.xml"));
        return  bean.getObject();
    }

    @Bean("test1TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean("test1SqlSessionTemplate")
    @Primary
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return  new SqlSessionTemplate(sqlSessionFactory);
    }
}

这里注意注入是一层一层的注入
a、先注入dataSource，b、注入创建SqlSessionFactory , c、再创建事务test1TransactionManager ，d、最后包装到SqlSessionTemplate。并且需要知道分库的mapper文件地址。以及分库dao层代码。

@MapperScan(basePackages = "org.learn.boot.datasource.mapper.test1",sqlSessionTemplateRef = "test1SqlSessionTemplate")

这块的注解就是指明了扫描 dao 层，并且给 dao 层注入指定的 SqlSessionTemplate。所有@Bean都需要按照命名指定正确。

package org.learn.boot.datasource.datasource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 读取 yml文件配置
 * @ClassName: DatasourceConfig
 * @Description:
 * @Author: lin
 * @Date: 2019/3/24 18:11
 * History:
 * @<version> 1.0
 */

@Component
@ConfigurationProperties(prefix = "spring.datasource.test1")
public class DatasourceTest1 {

    /** 数据库连接url */
    private String jdbcUrl;
    /** 用户名 */
    private String username;
    /** 用户密码 */
    private String password;
    /** 数据库驱动 */
    private String driverClassName;

    public String getJdbcUrl() {
        return jdbcUrl;
    }

    public void setJdbcUrl(String jdbcUrl) {
        this.jdbcUrl = jdbcUrl;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
}

3、第二个数据源

package org.learn.boot.datasource.datasource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 * ClassName: DataSource2Config
 * Description: 数据源配置2
 * Date:     2019/3/24 16:55
 * History:
 * <version> 1.0
 * @author lin
 */
@Configuration
@MapperScan(basePackages = "com.base.mapper.test2",sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class DataSource2Config {

    @Autowired
    private DatasourceTest2 datasourceTest2;
    /**
     * @Description 创建DataSource
     * @param
     * @return javax.sql.DataSource
     * @exception   
     * @author lin
     * @Date 18:12 2019/3/24
     **/
    @Bean(name = "test2DataSource")
//    @Value("spring.datasource.test2")
    public DataSource test2DataSource(){
        return  DataSourceBuilder.create().url(datasourceTest2.getJdbcUrl()).
                username(datasourceTest2.getUsername()).
                password(datasourceTest2.getPassword()).
                driverClassName(datasourceTest2.getDriverClassName()).build();
//        return DataSourceBuilder.create().build();
    }


    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory test2SqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/Bank2Mapper.xml"));
        return  bean.getObject();
    }


    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager test2TransactionManager(@Qualifier("test2DataSource") DataSource dataSource){
        return  new DataSourceTransactionManager(dataSource);
    }


    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate test2SqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}


package org.learn.boot.datasource.datasource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @ClassName: DatasourceTest2
 * @Description:
 * @Author: lin
 * @Date: 2019/3/24 18:15
 * History:
 * @<version> 1.0
 */
@Component
@ConfigurationProperties(prefix = "spring.datasource.test2")
public class DatasourceTest2 {
    /** 数据库连接url */
    private String jdbcUrl;
    /** 用户名 */
    private String username;
    /** 用户密码 */
    private String password;
    /** 数据库驱动 */
    private String driverClassName;

    public String getJdbcUrl() {
        return jdbcUrl;
    }

    public void setJdbcUrl(String jdbcUrl) {
        this.jdbcUrl = jdbcUrl;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
}

这里注意 获取yml的配置有三种 ：a:使用 @Value注解，b.使用 @ConfigurationProperties注解来指定 配置文件中前缀。c.使用@Environment 注解来读取，这种方式使用的比较少。
4、上面的数据源编写好了之后 是dao层和 xml层。这两个分别编写在不同的包下面
Bank1Mapper 类

/**
 * ClassName: Bank1Mapper
 * Description: 测试多数据源配置
 * Date:     2019/3/24 17:02
 * History:
 * <version> 1.0
 * @author lin
 */
@Mapper
public interface Bank1Mapper {
    /**
     * 查询全部
     * @Description 查询全部
     * @param
     * @return java.util.List<com.base.entity.Bank>
     * @exception
     * @author lin
     * @Date 16:09 2019/3/21
     **/
    List<Bank> getAll();

    /**
     * 根据id查询
     * @Description 根据id查询
     * @param id
     * @return com.base.entity.Bank
     * @exception
     * @author lin
     * @Date 16:10 2019/3/21
     **/
    Bank getOne(Integer id);

    /**
     * 添加
     * @Description
     * @param bank
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void insert(Bank bank);

    /**
     * 更新
     * @Description
     * @param bank
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void update(Bank bank);

    /**
     * 删除
     * @Description
     * @param id
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void delete(Integer id);
}

Bank2Mapper 类

package org.learn.boot.datasource.mapper.test2;


import org.apache.ibatis.annotations.Mapper;
import org.learn.boot.datasource.entity.Bank;

import java.util.List;

/**
 * ClassName: Bank2Mapper
 * Description: 测试多数据源配置
 * Date:     2019/3/24 17:03
 * History:
 * <version> 1.0
 * @author lin
 */
@Mapper
public interface Bank2Mapper {

    /**
     * 查询全部
     * @Description 查询全部
     * @param
     * @return java.util.List<com.base.entity.Bank>
     * @exception
     * @author lin
     * @Date 16:09 2019/3/21
     **/
    List<Bank> getAll();

    /**
     * 根据id查询
     * @Description 根据id查询
     * @param id
     * @return com.base.entity.Bank
     * @exception
     * @author lin
     * @Date 16:10 2019/3/21
     **/
    Bank getOne(Integer id);

    /**
     * 添加
     * @Description
     * @param bank
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void insert(Bank bank);

    /**
     * 更新
     * @Description
     * @param bank
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void update(Bank bank);

    /**
     * 删除
     * @Description
     * @param id
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    void delete(Integer id);
}

实体类

/**
 * ClassName: Bank
 * Description: 实体类
 * Date:     2019/3/21 15:50
 * History:
 * <version> 1.0
 * @author lin
 */
@Data
public class Bank {
    private Integer id;
    private String code;
    private String name;
    private Date createTime;
}

5、xml的编写
Bank1Mapper.xml 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.learn.boot.datasource.mapper.test1.Bank1Mapper" >
     <resultMap id="BaseResultMap" type="org.learn.boot.datasource.entity.Bank">
         <id column="id" property="id" javaType="INT"/>
         <result column="name" property="name" jdbcType="VARCHAR"/>
         <result column="code" property="code" jdbcType="VARCHAR"/>
         <result column="create_time" property="createTime" jdbcType="DATE"/>
     </resultMap>

    <sql id="Base_Column_List">
        id, code, name, create_time
    </sql>

    <select id="getAll" resultMap="BaseResultMap">
        SELECT 
        <include refid="Base_Column_List"/>
             FROM c_bank
    </select>

    <select id="getOne" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
           FROM c_bank
           WHERE id=#{id}
    </select>

    <insert id="insert" parameterType="org.learn.boot.datasource.entity.Bank">
        INSERT INTO
                  c_bank
                  (name,code,create_time)
          VALUES
                  (#{name},#{code},#{createTime})
    </insert>

    <update id="update" parameterType="org.learn.boot.datasource.entity.Bank">
        UPDATE
                c_bank
        SET
         <if test="name != null">name=#{name},</if>
         <if test="code != null">code=#{code},</if>
         WHERE
              id=#{id}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
          DELETE FROM
                   c_bank
          WHERE
                   id=#{id}
    </delete>
</mapper>

Bank2Mapper.xml 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.learn.boot.datasource.mapper.test2.Bank2Mapper" >
     <resultMap id="BaseResultMap" type="org.learn.boot.datasource.entity.Bank">
         <id column="id" property="id" javaType="INT"/>
         <result column="name" property="name" jdbcType="VARCHAR"/>
         <result column="code" property="code" jdbcType="VARCHAR"/>
         <result column="create_time" property="createTime" jdbcType="DATE"/>
     </resultMap>

    <sql id="Base_Column_List">
        id, code, name, create_time
    </sql>

    <select id="getAll" resultMap="BaseResultMap">
        SELECT 
        <include refid="Base_Column_List"/>
             FROM c_bank
    </select>

    <select id="getOne" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
           FROM c_bank
           WHERE id=#{id}
    </select>

    <insert id="insert" parameterType="org.learn.boot.datasource.entity.Bank">
        INSERT INTO
                  c_bank
                  (name,code,create_time)
          VALUES
                  (#{name},#{code},#{createTime})
    </insert>

    <update id="update" parameterType="org.learn.boot.datasource.entity.Bank">
        UPDATE
                c_bank
        SET
         <if test="name != null">name=#{name},</if>
         <if test="code != null">code=#{code},</if>
         WHERE
              id=#{id}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
          DELETE FROM
                   c_bank
          WHERE
                   id=#{id}
    </delete>
</mapper>

6、编写controller来测试

package org.learn.boot.datasource.controller;

import org.learn.boot.datasource.entity.Bank;
import org.learn.boot.datasource.mapper.test1.Bank1Mapper;
import org.learn.boot.datasource.mapper.test2.Bank2Mapper;
import org.learn.boot.datasource.vo.BankVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
/**
 * ClassName: BankController
 * Description:  mybatis  xml 测试
 * Date:     2019/3/21 16:52
 * History:
 * <version> 1.0
 * @author lin
 */
@RestController
@RequestMapping(value = "bank")
public class BankController {

    @Autowired
    private Bank1Mapper bank1Mapper;

    @Autowired
    private Bank2Mapper bank2Mapper;
    /**
     * 查询全部
     * @Description 查询全部
     * @param
     * @return java.util.List<com.base.entity.Bank>
     * @exception
     * @author lin
     * @Date 16:09 2019/3/21
     **/
    @RequestMapping(value = "getBanks")
    public List<Bank> getBanks(){
        List<Bank> banks = bank1Mapper.getAll();
        return banks;
    }

    @RequestMapping(value ="getById")
    public Bank getById(Integer id){
        Bank bank = bank2Mapper.getOne(id);
        return bank;
    }

    /**
     * 添加
     * @Description
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    @RequestMapping(value = "add")
    public void save(@RequestBody BankVo bankVo){
         
        try {
           Bank bank2 = new Bank();
          bank2.setName(bankVo.getName());
          bank2.setCode(bankVo.getCode());
          Date time1;
          SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            time1 = simpleDateFormat.parse(bankVo.getCreateTime());
            bank2.setCreateTime(time1);
           bank2Mapper.insert(bank2);
        } catch (ParseException e) {
            e.printStackTrace();
        }

       
    }

    /**
     * 更新
     * @Description
     * @param bank
     * @return void
     * @exception
     * @author lin
     * @Date 16:11 2019/3/21
     **/
    @RequestMapping(value = "update")
    public void update(Bank bank){
        bank2Mapper.update(bank);
    }


    @RequestMapping(value = "delete")
    public void delete(@PathVariable("id") Integer id){
        bank1Mapper.delete(id);
    }

}

测试添加
在这里插入图片描述
查看数据库，可以看到数据库数据已经添加进去了。
在这里插入图片描述

参考：http://www.ityouknow.com/springboot/2016/11/25/spring-boot-multi-mybatis.html

lin59106
关注
专栏目录
SpringBoot第27讲：SpringBoot集成MySQL - MyBatis 多个数据源
Jet_qi的博客
06-17 3560
本文是Springboot第27讲，主要讲解哪些场景会使用多个数据源以及哪些场景会需要多个数据源的动态切换呢？本文主要介绍上述场景及SpringBoot+MyBatis实现多个数据源的方案和示例
Springboot整合mybatis多数据源
daimenglaoshi的博客
12-03 2845
场景1：一个商城网站，一个游戏网站，商城网站已经做好，游戏网站正在开发，游戏网站上的很多道具需要用到商城网站的产品数据，这种情况最好是用两个数据库，商城网站更多的是设计直接交易，涉及金钱方面较多，需要较安全的数据库和网络环境，而游戏网站一般人流量比较大，若和商城放一起占用的数据库、网络、带宽资源较大，而且更容易被攻击，这样很容易影响商城 的正常使用。而把他们独立开虽然可能成本稍高，但是能够保证其中一个网站或数据库挂掉不会影响另一个，大大降低安全风险。场景2：随着时间和业务的发展，数据库中的数据量增长是不可控
SpringBoot多数据源
大老杨的博客
04-11 5890
很多业务场景都需要使用到多数据库，本文介绍springboot对多数据源的使用。 这次先说一下application.properties文件，分别连接了2个数据库test和test1。完整代码如下： ##端口号 server.port=8888 ##数据库url spring.datasource.test.url=jdbc:mysql://localhost:3306/test?c...
Spring Boot 多数据源配置
最新发布
dream_snow2012的专栏
08-22 3771
通过以上配置，您可以在 Spring Boot 项目中成功实现多数据源的管理，分离不同的数据库操作。这样可以轻松处理不同数据源之间的事务以及数据交互，确保应用的高效性和可扩展性。
Springboot 之 Mybatis 多数据源实现
天行健，君子以自强不息；地势坤，君子以厚德载物。
09-11 839
简介上篇讲解了 JPA 多数据源实现；这篇讲解一下 Mybatis 多数据源实现 。主要采用将不同数据库的 Mapper 接口分别存放到不同的 package，Spring 去扫描不同的包，注入不同的数据源来实现多数据源。原理跟 JPA 多数据源实现基本一致。创建 mybatis-multip-datasource 项目数据库脚本参考： Springboot 之 JPA 多数据源实...
Spring Boot(七)：Mybatis 多数据源最简解决方案
weixin_34342992的博客
11-25 128
说起多数据源，一般都来解决那些问题呢，主从模式或者业务比较复杂需要连接不同的分库来支持业务。我们遇到的情况是后者，网上找了很多，大都是根据 Jpa 来做多数据源解决方案，要不就是老的 Spring 多数据源解决方案，还有的是利用 Aop 动态切换，感觉有点小复杂，其实我只是想找一个简单的多数据支持而已，折腾了两个小时整理出来，供大家参考。 废话不多说直接上代码吧 我们以 Mybatis Xml...
极简Spring Boot整合MyBatis多数据源
江南一点雨的专栏
03-23 2358
关于多数据源的配置，前面和大伙介绍过JdbcTemplate多数据源配置，那个比较简单，本文来和大伙说说MyBatis多数据源的配置。 其实关于多数据源，我的态度还是和之前一样，复杂的就直接上分布式数据库中间件，简单的再考虑多数据源。这是项目中的建议，技术上的话，当然还是各种技术都要掌握的。 工程创建 首先需要创建MyBatis项目，项目创建和前文的一样，添加MyBatis、MySQL以及Web依...
Springboot2.7.0 + mybatis 搭建多数据源
06-20
4. **配置MyBatis**：创建`Mybatis`配置类，通过`@Bean`注解为每个数据源创建SqlSessionFactory。 ```java @Configuration public class MybatisConfig { @Autowired private DataSource primaryDataSource; @...
详解springboot+mybatis多数据源最简解决方案
08-30
SpringBoot+MyBatis多数据源解决方案 SpringBoot框架中，使用MyBatis框架来实现多数据源解决方案是非常常见的场景。本篇文章将详细介绍如何使用SpringBoot框架来实现多数据源解决方案，并提供了一个简单的解决方案...
springboot2+mybatis多数据源配置
04-21
相信很多朋友在开发的时候，可能会碰到需要一个项目，配置多个数据源的需求，可能是同一种数据库，也可能是不同种类的数据库，这种情况，我们就需要配置多数据源对程序的支持了。 本项目就是一个多数据源的配置，...
Spring Boot(七) : Mybatis多数据源最简解决方案
m0_68850571的博客
06-01 2934
说起多数据源，一般都来解决那些问题呢，主从模式或者业务比较复杂需要连接不同的分库来支持业务。我们遇到的情况是后者，网上找了很多，大都是根据 Jpa 来做多数据源解决方案，要不就是老的 Spring 多数据源解决方案，还有的是利用 Aop 动态切换，感觉有点小复杂，其实我只是想找一个简单的多数据支持而已，折腾了两个小时整理出来，供大家参考。我们以 Mybatis Xml 版本为例，给大家展示如何如何配置多数据源。Pom 包就不贴了比较简单该依赖的就依赖，主要是数据库这边的配置： 一个 test1 库和一个
MyBatis 多数据源
小心仔的博客
10-19 1626
一、AOP多数据源 二、配合注解实现
Spring Boot下配置MyBatis多数据源
weixin_34007020的博客
05-06 156
Spring Boot最大的特点是简化开发，因此使用Java Config实现去xml配置，本文将使用这种方式完成对阿里云ADS和RDS两个产品的多数据源配置。同时，会用到阿里巴巴的开源数据源Druid。 依赖 因为ADS和RDS都兼容mysql的JDBC实现，因此工程只需要依赖mysql的driver。 Spring Boot易用性的特点是通过Sta...
MyBatisPlus--多数据源
热门推荐
qq_45917176的博客
04-21 1万+
官网地址：多数据源 | MyBatis-Plus (baomidou.com) 支持 数据源分组 ，适用于多种场景、纯粹多库、读写分离、一主多从、混合模式。 目前来模拟一个纯粹多库的一个场景，其他场景类似；场景说明： 创建两个库，分别为：mybatis_plus与mybatis_plus_1，使每个库一张表，通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功。 1、创建数据库及表 创建数据库mybatis_plus和表user CREATE DATABASE `mybatis_plu.
springboot mybatis 多数据源
qq_42744664的博客
08-23 460
坑点1：在创建SqlSessionFactory的时候需要指定mapper.xml文件的路径，原因：在我们使用多数据源的时候，因为关闭了springboot的默认数据源配置，使用我们自己定义的数据源，此时我们在配置文件中配置的路径是不会生效的，需要我们在定义数据源代码的时候，手动指向一下mapper.xml的位置。一个是getResource，一个是getResources。4.创建两个数据源的DataSource。1.先看一下项目结构。
springboot-mybatis—多数据源
csdn_ygy的博客
04-18 2943
工作老系统添加新的功能 需要调用其他数据库的资源，应用多数据源，老大只给一晚上解决，哎，总算是磨出来（看了很多好的博客），我也记录一篇，也给后人方便。 原理简单说明，详细请看代码分析。 1. 配置多个数据源 =》 每个数据源一个key。 2. 将多个数据源注入到DynmicDataSource（自己定义，必须实现AbstractRoutingDataSource）。 3. 设置默认数据
springBoot+mybatis多数据源
殇之何伤的博客
02-19 309
介绍 使用idea创建springboot项目，使用mybatis链接mysql数据库（多数据源），使用druid(阿里巴巴)的连接池。 工程整体目录 一、pom.xml文件配置 <?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
springboot+mybatis 多数据源
baidu_37366055的博客
07-07 275
在网上看了很多，关于mybatis多数据源的文章，存在很多种实现的方法，有的文章不知所云，所以最终决定使用下面这种方式，因为这种方法使用的人较多。所有参考到的文章都列在了最下方，你也可以去看看 一、多数据源的应用场景 当业务数据量达到了一定程度，DBA 需要合理配置数据库资源。即配置主库的机器高配置，把核心高频的数据放在主库上；把次要的数据放在从库，低配置。开源节流嘛，就这个意思。把数据放在不...
springboot中mybatis多数据源实现
相逢一笑
05-04 247
多种数据源的共同使用在日常开发中是很常见的，当然微服务中可能没那么常见，毕竟服务划分细致，数据源也就单独出去了。这里来看一下，在springboot中mybatis的多数据源实现（这里选择mysql为数据库）。 多数据源配置 mybatis和mysql在springboot中的引入这里就不在说了，不了解的可以参见springboot中mysql与mybatis的引入。 多数据源，即为配置多个数据...
SpringBoot+MyBatis多数据源配置详解与实战
在Spring Boot项目中集成MyBatis时，配置多数据源是一项常见的需求，尤其是在处理分布式系统或者需要隔离不同业务模块的数据访问时。本文将详细介绍如何在Spring Boot项目中实现Spring Boot + MyBatis的多数据源配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值