SpringBoot原理以及多数据源使用探究

最新推荐文章于 2025-06-20 12:42:14 发布
转载 最新推荐文章于 2025-06-20 12:42:14 发布 · 653 阅读 · 1

本文详细介绍了SpringBoot中事务配置的方法，包括数据源配置、sqlSessionFactory配置、MapperScannerConfigurer配置及事务管理器配置等关键步骤，并展示了如何实现多数据源的支持。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、前言

最近微服务很热，而SpringBoot以轻量级和内嵌tomcat，方便启动调试为微服务越来越被采用，而现在前言的技术的demo一般都也使用SpringBoot编写，所以与必要研究下SpringBoot原理。

二、启动

启动时序图

0?wx_fmt=png

上面流程启动从SpringApplication的run方法开始，到解析application.properties结束。

三、创建应用程序上下文和嵌入式tomcat

上面配置文件解析完毕后紧接着就是创建应用程序上下文

0?wx_fmt=png

四、ConfigurationProperties Bean的创建

SpringBoot中不建议使用XML配置，所以比较常用的是使用ConfigurationProperties注解创建bean从application.properties中加载配置项。

@ConfigurationProperties(prefix = "mysql")public class MySqlProperties {    private String driverClassName;    private String url;    public String getDriverClassName() {        return driverClassName;
    }    public void setDriverClassName(String driverClassName) {        this.driverClassName = driverClassName;
    }    public String getUrl() {        return url;
    }    public void setUrl(String url) {        this.url = url;
    }    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;
    }    private String userName;    private String passWord;

}

而application.properties中配置为：
mysql.passWord =

0?wx_fmt=png

五、 事务配置

Spring中使用XML配置的事务管理，那么springboot中如何进行配置对应的东西那？

5.1 SpringBoot中 DataSource的配置

首先数据源属性Bean

@ConfigurationProperties(prefix = "mysql")public class MySqlProperties {    private String driverClassName;    private String url;    public String getDriverClassName() {        return driverClassName;
    }    public void setDriverClassName(String driverClassName) {        this.driverClassName = driverClassName;
    }    public String getUrl() {        return url;
    }    public void setUrl(String url) {        this.url = url;
    }    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;
    }    private String userName;    private String passWord;

}

然后创建DataSource的bean

@Configuration@EnableConfigurationProperties(MySqlProperties.class)@ConditionalOnClass(TDataSource.class)@AutoConfigureBefore(DataSourceAutoConfiguration.class)// 三、设置扫描器@MapperScan(basePackages = "com.zlx.demo.web.speech2.mapper", sqlSessionFactoryRef = "sqlSessionFactory1")public class MysqlAutoConfiguration {    @Autowired
    private MySqlProperties properties;    // 一、创建数据源
    @Primary
    @Bean(name = "dataSource")    public DataSource dataSource() throws TddlException {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(properties.getDriverClassName());
        dataSource.setUrl(properties.getUrl());
        dataSource.setUsername(properties.getUserName());
        dataSource.setPassword(properties.getPassWord());        return dataSource;
    }
}

5.2 SpringBoot中 sqlSessionFactory的配置

Spring中XML配置知道要创建个sqlSessionFactory对象并且要进行属性配置，所以下面首先讲下mybaits的属性配置：

@ConfigurationProperties(prefix="mybatis")public class MybatisProperties{  public static final String MYBATIS_PREFIX = "mybatis";  private String configLocation;  private String[] mapperLocations;  private String typeAliasesPackage;  private String typeHandlersPackage;  private boolean checkConfigLocation = false;  private ExecutorType executorType;  private Properties configurationProperties;  @NestedConfigurationProperty
  private Configuration configuration;  public String getConfigLocation()
  {    return this.configLocation;
  }  public void setConfigLocation(String configLocation)
  {    this.configLocation = configLocation;
  }  @Deprecated
  public String getConfig()
  {    return this.configLocation;
  }  @Deprecated
  public void setConfig(String config)
  {    this.configLocation = config;
  }  public String[] getMapperLocations()
  {    return this.mapperLocations;
  }  public void setMapperLocations(String[] mapperLocations)
  {    this.mapperLocations = mapperLocations;
  }  public String getTypeHandlersPackage()
  {    return this.typeHandlersPackage;
  }  public void setTypeHandlersPackage(String typeHandlersPackage)
  {    this.typeHandlersPackage = typeHandlersPackage;
  }  public String getTypeAliasesPackage()
  {    return this.typeAliasesPackage;
  }  public void setTypeAliasesPackage(String typeAliasesPackage)
  {    this.typeAliasesPackage = typeAliasesPackage;
  }  public boolean isCheckConfigLocation()
  {    return this.checkConfigLocation;
  }  public void setCheckConfigLocation(boolean checkConfigLocation)
  {    this.checkConfigLocation = checkConfigLocation;
  }  public ExecutorType getExecutorType()
  {    return this.executorType;
  }  public void setExecutorType(ExecutorType executorType)
  {    this.executorType = executorType;
  }  public Properties getConfigurationProperties()
  {    return this.configurationProperties;
  }  public void setConfigurationProperties(Properties configurationProperties)
  {    this.configurationProperties = configurationProperties;
  }  public Configuration getConfiguration()
  {    return this.configuration;
  }  public void setConfiguration(Configuration configuration)
  {    this.configuration = configuration;
  }  public Resource[] resolveMapperLocations()
  {
    ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
    List<Resource> resources = new ArrayList();    if (this.mapperLocations != null) {      for (String mapperLocation : this.mapperLocations) {        try
        {
          Resource[] mappers = resourceResolver.getResources(mapperLocation);
          resources.addAll(Arrays.asList(mappers));
        }        catch (IOException localIOException) {}
      }
    }    return (Resource[])resources.toArray(new Resource[resources.size()]);
  }
}

同样这些配置想从application.properties中进行配置，

@Configuration@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})@ConditionalOnBean({DataSource.class})@EnableConfigurationProperties({MybatisProperties.class})@AutoConfigureAfter({DataSourceAutoConfiguration.class})public class MybatisAutoConfiguration{  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);  private final MybatisProperties properties;  private final Interceptor[] interceptors;  private final ResourceLoader resourceLoader;  private final DatabaseIdProvider databaseIdProvider;  public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider)
  {    this.properties = properties;    this.interceptors = ((Interceptor[])interceptorsProvider.getIfAvailable());    this.resourceLoader = resourceLoader;    this.databaseIdProvider = ((DatabaseIdProvider)databaseIdProvider.getIfAvailable());
  }  @PostConstruct
  public void checkConfigFileExists()
  {    if ((this.properties.isCheckConfigLocation()) && (StringUtils.hasText(this.properties.getConfigLocation())))
    {
      Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
      Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
    }
  }  @Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource)
    throws Exception  {
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    factory.setConfiguration(this.properties.getConfiguration());    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }    return factory.getObject();
  }  @Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory)
  {
    ExecutorType executorType = this.properties.getExecutorType();    if (executorType != null) {      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    }    return new SqlSessionTemplate(sqlSessionFactory);
  }  public static class AutoConfiguredMapperScannerRegistrar
    implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware
  {    private BeanFactory beanFactory;    private ResourceLoader resourceLoader;    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)
    {
      MybatisAutoConfiguration.logger.debug("Searching for mappers annotated with @Mapper");

      ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);      try
      {        if (this.resourceLoader != null) {
          scanner.setResourceLoader(this.resourceLoader);
        }
        List<String> packages = AutoConfigurationPackages.get(this.beanFactory);        if (MybatisAutoConfiguration.logger.isDebugEnabled()) {          for (String pkg : packages) {
            MybatisAutoConfiguration.logger.debug("Using auto-configuration base package '{}'", pkg);
          }
        }
        scanner.setAnnotationClass(Mapper.class);
        scanner.registerFilters();
        scanner.doScan(StringUtils.toStringArray(packages));
      }      catch (IllegalStateException ex)
      {
        MybatisAutoConfiguration.logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.", ex);
      }
    }    public void setBeanFactory(BeanFactory beanFactory)
      throws BeansException    {      this.beanFactory = beanFactory;
    }    public void setResourceLoader(ResourceLoader resourceLoader)
    {      this.resourceLoader = resourceLoader;
    }
  }  @Configuration
  @Import({MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})  @ConditionalOnMissingBean({MapperFactoryBean.class})  public static class MapperScannerRegistrarNotFoundConfiguration
  {    @PostConstruct
    public void afterPropertiesSet()
    {
      MybatisAutoConfiguration.logger.debug("No {} found.", MapperFactoryBean.class.getName());
    }
  }
}

如果自己没有注入的话，springboot会通过上面代码进入注入，其中注解 @ConditionalOnMissingBean

    @Bean(name = "sqlSessionFactory1")    @Primary
    public SqlSessionFactory sqlSessionFactoryBean1() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dataSource1());
        sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations(new String[]{"classpath:mapper/*.xml"}));        return sqlSessionFactoryBean.getObject();
    }    public Resource[] resolveMapperLocations(String[] mapperLocations) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        List<Resource> resources = new ArrayList();        if (mapperLocations != null) {            for (String mapperLocation : mapperLocations) {                try {
                    Resource[] mappers = resourceResolver.getResources(mapperLocation);
                    resources.addAll(Arrays.asList(mappers));
                } catch (IOException localIOException) {
                }
            }
        }        return (Resource[]) resources.toArray(new Resource[resources.size()]);
    }

5.3 SpringBoot中MapperScannerConfigurer配置

Spring中XML配置知道这个主要是配置扫描mapper路径然后生成数据库操作代理类，那么在SpringBoot中只需要一个简单的注解：0?wx_fmt=png

5.4 SpringBoot中事务管理器配置

Spring中XML配置知道有注解式和xml配置式，SpringBoot不推荐XML配置，所有讲下注解。之前xml开启事务管理器需要创建DataSourceTransactionManager对象，现在Springboot中只需要：0?wx_fmt=png0?wx_fmt=png

5.4.1 SpringBoot中多数据源使用

@EnableTransactionManagement@RestController@SpringBootApplicationpublic class DemoApp implements TransactionManagementConfigurer{    @RequestMapping("/")    String home() {        return "Hello Demo!";
    }    @Resource(name="txManager1")    private PlatformTransactionManager txManager1;    // 实现接口 TransactionManagementConfigurer 方法，其返回值代表在拥有多个事务管理器的情况下默认使用的事务管理器
    @Override
    public PlatformTransactionManager annotationDrivenTransactionManager() {        return txManager1;
    }    @Bean
    public StartRunner startRunner(){        return new StartRunner();
    }    public static void main( String[] args )
    {
        SpringApplication.run(DemoApp.class, args);
    }
}

数据源一配置：

//三、设置扫描器// 三、设置扫描器@MapperScan(basePackages = "com.zlx.demo.web.speech2.mapper", sqlSessionFactoryRef = "sqlSessionFactory1")public class MysqlAutoConfiguration {    @Autowired
    private MySqlProperties properties;    // 一、创建数据源
    @Primary
    @Bean(name = "dataSource1")    public DataSource dataSource1() throws TddlException {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(properties.getDriverClassName());
        dataSource.setUrl(properties.getUrl());
        dataSource.setUsername(properties.getUserName());
        dataSource.setPassword(properties.getPassWord());        return dataSource;
    }    // 二、创建SqlSessionFactory
    @Bean(name = "sqlSessionFactory1")    @Primary
    public SqlSessionFactory sqlSessionFactoryBean1() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dataSource1());
        sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations(new String[] { "classpath:mapper/*.xml" }));        return sqlSessionFactoryBean.getObject();
    }    // 四、 创建事务管理器
    @Bean(name = "txManager1")    @Primary
    public PlatformTransactionManager txManager1(@Qualifier("dataSource1") DataSource dataSource) {

        System.out.println("-----------dataource-----" + dataSource.toString());        return new DataSourceTransactionManager(dataSource);
    }    // 创建SqlSessionTemplate
    @Bean("sqlSessionTemplate1")    @Primary
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory1") SqlSessionFactory sqlSessionFactory) {
        System.out.println("-----------sqlSessionFactory-----" + sqlSessionFactory.toString());        return new SqlSessionTemplate(sqlSessionFactory);
    }    public Resource[] resolveMapperLocations(String[] mapperLocations) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        List<Resource> resources = new ArrayList();        if (mapperLocations != null) {            for (String mapperLocation : mapperLocations) {                try {
                    Resource[] mappers = resourceResolver.getResources(mapperLocation);
                    resources.addAll(Arrays.asList(mappers));
                } catch (IOException localIOException) {
                }
            }
        }        return (Resource[]) resources.toArray(new Resource[resources.size()]);
    }

数据源二配置：

//三、设置扫描器
@MapperScan(basePackages = "com.zlx.demo.web.business.mapper", sqlSessionFactoryRef = "sqlSessionFactory1")
public class MysqlAutoConfiguration2 {

    @Autowired
    private MySqlProperties properties;

    // 一、创建数据源
    @Primary
    @Bean(name = "dataSource2")
    public DataSource dataSource1() throws TddlException {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(properties.getDriverClassName());
        dataSource.setUrl(properties.getUrl());
        dataSource.setUsername(properties.getUserName());
        dataSource.setPassword(properties.getPassWord());
        return dataSource;
    }

    // 二、创建SqlSessionFactory
    @Bean(name = "sqlSessionFactory2")
    @Primary
    public SqlSessionFactory sqlSessionFactoryBean1() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dataSource1());
        sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations(new String[] { "classpath:mapper/*.xml" }));

        return sqlSessionFactoryBean.getObject();
    }

    // 四、 创建事务管理器
    @Bean(name = "txManager2")
    @Primary
    public PlatformTransactionManager txManager1(@Qualifier("dataSource1") DataSource dataSource) {

        System.out.println("-----------dataource-----" + dataSource.toString());
        return new DataSourceTransactionManager(dataSource);
    }

    // 创建SqlSessionTemplate
    @Bean("sqlSessionTemplate2")
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory1") SqlSessionFactory sqlSessionFactory) {
        System.out.println("-----------sqlSessionFactory-----" + sqlSessionFactory.toString());

        return new SqlSessionTemplate(sqlSessionFactory);
    }

    public Resource[] resolveMapperLocations(String[] mapperLocations) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        List<Resource> resources = new ArrayList();
        if (mapperLocations != null) {
            for (String mapperLocation : mapperLocations) {
                try {
                    Resource[] mappers = resourceResolver.getResources(mapperLocation);
                    resources.addAll(Arrays.asList(mappers));
                } catch (IOException localIOException) {
                }
            }
        }
        return (Resource[]) resources.toArray(new Resource[resources.size()]);
    }

另外SqlSessionTemplate是对SqlSessionFactory的一个包装，这里每个数据源也配置了一个，如果想使用它的话，只需要修改@mapperscan，设置sqlSessionTemplateRef替换sqlSessionFactoryRef

阿里加多
关注
【SpringBoot学习笔记】配置多数据源
A_coding的博客
03-03 540
最近项目需要又重新复习了下springboot，关于springboot配置多数据源，做了笔记，分享给有需要的小伙伴们，视频看的动力节点王鹤老师讲的， 动力节点王鹤老师讲解的springboot教程，由浅入深，带你体验Spring Boot的极速开发过程，内容丰富，涵盖了SpringBoot开发的方方面面，并且同步更新到Spring Boot 2.x系列的最新版本。 视频链接：动力节点springboot视频教程-初学springboot必备教程-springboot最新完整版_哔哩哔哩_bilibil
springboot 实现多数据源的底层原理
一天不写代码难受的博客
10-16 853
多数据源
Spring Boot多数据源配置全解析：从静态到动态，实战指南
最新发布
weixin_42148384的博客
06-20 985
在Java开发中，单数据源早已无法满足复杂业务需求——主从读写分离、多租户数据隔离、分库分表……这些场景都需要多数据源支持。本文将介绍Spring Boot中多数据源的静态配置和动态切换实战，附完整代码和避坑指南！
多数据源（Springboot）
~~~的博客
07-03 7015
多数据源 1、关键类： ThreadLocal：线程局部变量，所谓线程局部变量，就是仅仅只能被本线程访问，不能在线程之间进行共享访问的变量 AbstractRoutingDataSource：getConnection（）根据查找lookup key键对不同目标源的调用，通常是通过（但不一定）某些线程绑定的事务上下文来实现 2、实现多数据源步骤： 步骤1：在Springboot中，增加多数据的配置 步骤2：扩展Spring的AbstractRoutingDataSource抽象类，AbstractRouti
关于spring boot mybatis 多数据源的多种方法原理概述
ichsonx的专栏
07-29 6705
初衷：微服务的盛行及对于mybatis的习惯。对于现有的数据+应用的架构希望寻找及总结一种灵活、扩展性好、方便的方案作为以后长期使用。 目标是可以支持多数据源、读写分离、原理配置简单。 方案1： 原理：使用mysql自带的replicationDriver来实现。replicationDriver简单来说就是存在2个connection：masterConnection和slav
SpringBoot如何配置动态数据源？原理+实战
避免专业名词，喜欢讲人话。
08-18 2816
若没空探究原理可直接跳转到“实现方式：注解+切面”目录 数据源切换方法 Spring对数据源的管理类似于策略模式，不懂策略模式也没关系，其实就是有一个全局的键值对，类型是Map。当JDBC操作数据库之时，会根据不同的key值选择不同的数据源。而这个key值可以放到方法的注解里。 所以切换数据源的思路就是让JDBC在获取数据源时根据key获取到要切换的数据源。 JDBC提供了AbstractRoutingDataSource抽象类，类名意思是数据源路由，该类提供了一个抽
SpringBoot高级技术实践与原理探究
高级话题可能包括事务管理、数据源配置、性能优化等。 ### SpringBoot的配置管理 SpringBoot允许开发者通过application.properties或application.yml文件来管理应用配置。但高级用法中还包括使用外部配置、动态...
Spring Boot 多数据源解决方案：dynamic-datasource-spring-boot-starter 的奥秘（上）
weixin_45593273的博客
12-22 3522
dynamic-datasource-spring-boot-starter 是一个用于在 Spring Boot 项目中实现动态数据源切换的工具。在实际的应用开发中，经常会遇到需要连接多个数据源的情况，例如一个销售系统会根据不同的业务模块，如线索、订单、库存、物流等连接到不同的数据库。手动管理多个数据源的切换和配置是一项复杂且容易出错的任务，而这个 starter 就是为了解决这些问题而生。
SpringBoot:快速使用Spring
lm12032015的博客
08-03 3215
SpringBoot,Shiro,Swagger,Dubbo等微服务技术讲解
【Spring Boot】Spring Boot整合多数据源
DreamSun的博客
08-24 2274
在实际的开发工作中，我们经常会遇到需要整合多个数据源的情况，比如同时连接多个数据库、读写分离、跨数据库查询等。本文将介绍如何使用Spring Boot来实现多数据源的整合，对于刚刚接触开发的小伙伴可能有一些帮助。在一个应用程序中使用多个数据源意味着我们需要在不同的数据源之间进行切换，以便从不同的数据源中获取数据。多数据源可以是关系数据库、NoSQL 数据库、平面文件、XML 文件等。在一个应用程序中使用多数据源的好处是，我们可以根据应用程序的需求选择最合适的数据源，从而提高应用程序的性能和可扩展性。
SpringBoot整合多数据源，并实现本地分布式事务
03-20
SpringBoot整合多数据源，并实现本地分布式事务。实现读写分离。
springboot多数据源即分布式事务解决方案
10-16
实现系统对多数据源的操作。 实现系统对多数据源的分布式事务管理，包括事务的提交和回滚。
Spring Boot 动态数据源示例（多数据源自动切换）
08-31
本篇文章主要介绍了Spring Boot 动态数据源示例（多数据源自动切换），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
完整Demo：springboot集成多数据源
07-28
完整Demo：springboot集成多数据源，是一个完整的项目，直接下载下来导入eclipse或idea，启动后运行即可。
【SpringBoot】多数据源N种实现详解
精益求精
10-31 8139
1、SpringBoot+MyBatis整合多数据源 2、SpringBoot+MyBatis-Plus整合多数据源 3，AbstractRoutingDataSource+AOP实现多数据源 4，JdbcTemplate 实现多数据源整合
Spring Boot多数据源
weixin_30423977的博客
03-08 108
我们在开发过程中可能需要用到多个数据源，我们有一个项目（MySQL）就是和别的项目（SQL Server）混合使用了。其中SQL Server是别的公司开发的，有些基本数据需要从他们平台进行调取，那么在项目中就需要支持多数据源，不然就只能获取到自己的数据源的数据了。当然还有很多其它方面的使用场景，多数据库，比如有专门负责生成id的数据库，或者主从库分离等等。总之多数据源可能在实际中还是需要用到的。...
springboot实现多数据源
weixin_45934981的博客
01-02 3079
在当今复杂多变的应用场景下，对多数据源的需求日益增长。特别是在微服务架构和分布式系统中，同时连接多个数据库成为一种常见的业务需求。为了应对这一挑战，本文将探讨如何在Spring Boot应用中利用MyBatis框架实现多数据源的灵活配置。通过逐步引导读者完成关键步骤，我们将深入了解如何配置不同的数据源、管理事务，以及在MyBatis的Mapper接口和XML文件中定义清晰而模块化的SQL操作。这不仅提高了系统的可维护性，还为开发者们提供了更为灵活和高效的数据访问解决方案。
springboot+mysql多数据源的使用原理
人的一生就是在学习的道路上不断进步
03-18 1132
springboot+mysql多数据源的使用原理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值