springboot 配置多数据源（按包划分）

最新推荐文章于 2024-08-09 18:07:53 发布
最新推荐文章于 2024-08-09 18:07:53 发布
阅读量946 收藏 4
点赞数 1
分类专栏： # Spring Boot 文章标签： springboot配置多数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42428264/article/details/98735066
版权

第一步：引入jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         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.mf</groupId>
    <artifactId>spring2.0</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--spring-boot-starter-parent 整合第三方常用框架依赖信息(各种依赖信息)-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

    <dependencies>
        <!--添加 spring-boot-starter-web 模块依赖-->
        <!--
            spring-boot-starter-web 是springBoot 整合springMVC web
            实现原理：Maven依赖继承关系，相当于把第三方常用maven依赖信息，在parent 项目中封装好了，使用
            springboot 提供依赖信息关联整合的jar包
            在springboot中 快速开发原理（Maven 子父依赖关系）springboot 对常用依赖信息的封装
         -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--可以不用写版本号在parent中已经写好了-->
            <!--<version>2.0.0.RELEASE</version>-->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!--springboot 外部tomcat支持-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!--整合 FreeMarker-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <!-- springboot-log4j-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.4.0.BUILD-SNAPSHOT</version>
        </dependency>
        <!--springboot-aop 技术-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--springboot 集成lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- springboot集成mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- springboot 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.45</version>
        </dependency>
        <!-- 添加JDBC依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- com.alibaba.druid数据库连接池 -->
        <dependency>
            <groupId>com.alibaba.druid</groupId>
            <artifactId>druid-wrapper</artifactId>
            <version>0.2.9</version>
        </dependency>

        <!--jta+atomikos:全局事务-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <!--springboot 整合 pagehelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.10</version>
        </dependency>

    </dependencies>

</project>

 

第二步：新建配置文件

新建springboot配置文件 application.properties：

#配置端口号
server.port=8084
#####配置默认环境（default environment）
spring.profiles.active=dev

新建开发环境（development environment）配置文件 application-dev.properties：

#######      development environment   开发环境 #########

# 配置多数据源
## 主库
spring.datasource.master.url=jdbc:mysql://localhost:3306/test01
spring.datasource.master.username=root
spring.datasource.master.password=soft01
spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.master.minPoolSize=3
spring.datasource.master.maxPoolSize=10
spring.datasource.master.maxLifetime=20000
spring.datasource.master.borrowConnectionTimeout=30
spring.datasource.master.loginTimeout=30
spring.datasource.master.mainteanceInterval=60
spring.datasource.master.maxIdleTime=60

## 从库
spring.datasource.slaver.url=jdbc:mysql://localhost:3306/test02
spring.datasource.slaver.username=root
spring.datasource.slaver.password=soft01
spring.datasource.slaver.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.slaver.minPoolSize=3
spring.datasource.slaver.maxPoolSize=10
spring.datasource.slaver.maxLifetime=20000
spring.datasource.slaver.borrowConnectionTimeout=30
spring.datasource.slaver.loginTimeout=30
spring.datasource.slaver.mainteanceInterval=60
spring.datasource.slaver.maxIdleTime=60

第三步：写两个配置数据库类。

配置主数据库 MasterDataSourceConfiguration.java 使用@Primary 注解默认数据源

package com.mf.util.datasource;

import com.alibaba.druid.pool.DruidDataSource;
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.Qualifier;
import org.springframework.beans.factory.annotation.Value;
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;

@Configuration
@MapperScan(basePackages = "com.mf.mapper.master", sqlSessionTemplateRef  = "masterSqlSessionTemplate")
public class MasterDataSourceConfiguration {

	@Value("${spring.datasource.master.driver-class-name}")
	private String driverClassName;

	@Value("${spring.datasource.master.url}")
	private String url;

	@Value("${spring.datasource.master.username}")
	private String username;

	@Value("${spring.datasource.master.password}")
	private String password;

	@Bean(name = "masterDataSource")
	@Primary
	public DataSource dataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setDriverClassName(this.driverClassName);
		dataSource.setUrl(this.url);
		dataSource.setUsername(this.username);
		dataSource.setPassword(this.password);
		return dataSource;
	}

	@Bean(name = "masterSqlSessionFactory")
	@Primary
	public SqlSessionFactory sqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource) throws Exception {
		// 创建SqlSession工厂
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mybatis/master/*.xml"));
		return bean.getObject();
	}

	@Bean(name = "masterTransactionManager")
	@Primary
	public DataSourceTransactionManager transactionManager(@Qualifier("masterDataSource") DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource);
	}

	@Bean(name = "masterSqlSessionTemplate")
	@Primary
	public SqlSessionTemplate sqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}

}

配置从数据库  SlaverDataSourceConfiguration.java 

package com.mf.util.datasource;

import com.alibaba.druid.pool.DruidDataSource;
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.Qualifier;
import org.springframework.beans.factory.annotation.Value;
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 SlaverDataSourceConfiguration
 * @Description TODO
 * @Author msi
 * @Date 2019/8/2 21:44
 */
@Configuration
@MapperScan(basePackages = "com.mf.mapper.slaver", sqlSessionTemplateRef  = "slaverSqlSessionTemplate")
public class SlaverDataSourceConfiguration {

	@Value("${spring.datasource.slaver.driver-class-name}")
	private String driverClassName;

	@Value("${spring.datasource.slaver.url}")
	private String url;

	@Value("${spring.datasource.slaver.username}")
	private String username;

	@Value("${spring.datasource.slaver.password}")
	private String password;


	@Bean(name = "slaverDataSource")
	public DataSource dataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setDriverClassName(this.driverClassName);
		dataSource.setUrl(this.url);
		dataSource.setUsername(this.username);
		dataSource.setPassword(this.password);
		return dataSource;
	}

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

	@Bean(name = "slaverTransactionManager")
	public DataSourceTransactionManager transactionManager(@Qualifier("slaverDataSource") DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource);
	}

	@Bean(name = "slaverSqlSessionTemplate")
	public SqlSessionTemplate sqlSessionTemplate(@Qualifier("slaverSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}

}

第四步：业务代码

主库dao 级 xml ：

package com.mf.mapper.master;

import com.mf.entity.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @ClassName UserMasterDao
 * @Description TODO
 * @Author msi
 * @Date 2019/8/2 22:12
 */
public interface UserMasterDao {
	int addUser(User user);
	int deleteUserById(Long id);
	int updateUserById(User user);
	User queryUserById(Integer id);
	List<User> queryUserList();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mf.mapper.master.UserMasterDao" >
    <!-- Result Map-->
    <resultMap id="BaseResultMap" type="com.mf.entity.User" >
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
    </resultMap>

    <!-- th_role_user table all fields -->
    <sql id="Base_Column_List" >
    id, name, age
</sql>

    <insert id="addUser" parameterType="com.mf.entity.User" >
    insert into t_user (id, name, age)
    values (#{id},#{name},#{age});
</insert>

    <delete id="deleteUserById" parameterType="java.lang.Long">
 delete from t_user where id=#{id}
</delete>

    <update id="updateUserById" parameterType="com.mf.entity.User" >
        update t_user set
        <trim  suffixOverrides="," >
            <if test="id != null and id != ''">
                id=#{id},
            </if>
            <if test="name != null and name != ''">
                name=#{name},
            </if>
            <if test="age != null and age != ''">
                age=#{age},
            </if>
        </trim> where id=#{id}
    </update>

    <select id="queryUserById" resultMap="BaseResultMap" parameterType="java.lang.Integer">
        select <include refid="Base_Column_List" />
        from t_user where id = #{id}
    </select>

    <select id="queryUserList" resultMap="BaseResultMap">
        select <include refid="Base_Column_List" />
        from t_user
    </select>

</mapper>

从库库dao 级 xml ：

package com.mf.mapper.slaver;

import com.mf.entity.User;

import java.util.List;

/**
 * @ClassName UserMasterDao
 * @Description TODO
 * @Author msi
 * @Date 2019/8/2 22:12
 */
public interface UserSlaverDao {
	int addUser(User user);
	int deleteUserById(Long id);
	int updateUserById(User user);
	User queryUserById(Integer id);
	List<User> queryUserList();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mf.mapper.slaver.UserSlaverDao" >
    <!-- Result Map-->
    <resultMap id="BaseResultMap" type="com.mf.entity.User" >
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
    </resultMap>

    <!-- th_role_user table all fields -->
    <sql id="Base_Column_List" >
    id, name, age
</sql>

    <insert id="addUser" parameterType="com.mf.entity.User" >
    insert into t_user (id, name, age)
    values (#{id},#{name},#{age});
</insert>

    <delete id="deleteUserById" parameterType="java.lang.Long">
 delete from t_user where id=#{id}
</delete>

    <update id="updateUserById" parameterType="com.mf.entity.User" >
        update t_user set
        <trim  suffixOverrides="," >
            <if test="id != null and id != ''">
                id=#{id},
            </if>
            <if test="name != null and name != ''">
                name=#{name},
            </if>
            <if test="age != null and age != ''">
                age=#{age},
            </if>
        </trim> where id=#{id}
    </update>

    <select id="queryUserById" resultMap="BaseResultMap" parameterType="java.lang.Integer">
        select <include refid="Base_Column_List" />
        from t_user where id = #{id}
    </select>

    <select id="queryUserList" resultMap="BaseResultMap">
        select <include refid="Base_Column_List" />
        from t_user
    </select>

</mapper>

service:（在使用事务时需要明确指定具体事务：@Transactional(transactionManager = "masterTransactionManager")）

package com.mf.service;

import com.mf.entity.User;
import com.mf.mapper.master.UserMasterDao;
import com.mf.mapper.slaver.UserSlaverDao;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @ClassName UserService
 * @Description TODO
 * @Author msi
 * @Date 2019/8/1 21:34
 */
@Service
@Slf4j // Lombok日志注解，需要引入jar包，IDE安装插件
public class UserService {
	@Autowired
	private UserMasterDao masterDao;

	@Autowired
	private UserSlaverDao slaverDao;

	/**********数据源一************/
	public User getUserByid(Integer id){
		log.info("###################id:{}", id);
		return masterDao.queryUserById(id);
	}
	// 有事务时的情况下：在当前方法执行完毕前报错，那么sql执行失败，事务回滚。
	// 没有事务的情况：在异常前执行的sql仍然生效，sql执行成功。
	// 没有指定事务管理器，不然不知道需要回滚哪个事务
	// 在这里value 和 transactionManager 一样的效果
	// @Transactional(value = "masterTransactionManager")
	@Transactional(transactionManager = "masterTransactionManager")
	 public Integer insertUserTest01(Integer age, String name){
		User user = new User();
		user.setName(name);
		user.setAge(age);
		Integer value = masterDao.addUser(user);

		// 当age=0 模拟错误，查看事务回滚
		int i = 10/age;

		return value;
	 }


	/**********数据源二************/
	public User getUserSlaveById(Integer id){
		return slaverDao.queryUserById(id);
	}

	@Transactional(value = "slaverTransactionManager")
	public Integer insertUserTest02(Integer age, String name){
		User user = new User();
		user.setName(name);
		user.setAge(age);
		Integer value = slaverDao.addUser(user);
		// 当age=0 模拟错误，查看事务回滚
		// int i = 10/age;
		return value;
	}

}

controller:

package com.mf.controller;

import com.mf.entity.User;
import com.mf.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName UserCOntroller
 * @Description TODO
 * @Author msi
 * @Date 2019/8/1 21:37
 */
@RestController
public class UserController {
	@Autowired
	private UserService userService;

	/**
	 * 数据库test1
	 * @param id
	 * @return
	 */
	@RequestMapping("/getUser01ById")
	public User selectUserById(Integer id){
		return userService.getUserByid(id);
	}
	@RequestMapping("/addUserTest01")
	public String addUser1(Integer age, String name){
		userService.insertUserTest01(age,name);
		return "addUser1成功";
	}
/************************************************/
	/**
	 * 数据库test2
	 * @param id
	 * @return
	 */
	@RequestMapping("/getUser02ById")
	public User selectUserSlaveById(Integer id){
		return userService.getUserSlaveById(id);
	}

	@RequestMapping("/addUserTest02")
	public String addUser2(Integer age, String name){
		userService.insertUserTest02(age,name);
		return "addUser2成功";
	}
}

浏览器访问测试：http://localhost:8084/getUser01ById?id=1

访问 http://localhost:8084/getUser02ById?id=1

至此springboot的多数据源配置成功。

总结：springboot配置多数据源的方法有两种

1.分包名（业务）

2. 注解方式（使用AOP在执行方法前设置指定数据源）。

上面就是根据分包来配置多数据源

胸大的请先讲
关注
专栏目录
多数据源配置之分包实现
qfchenjunbo的博客
08-18 483
一. 概述 随着并发量的不断增加，单个数据库可能难以承受高并发所带来的压力，此时我们通常会对数据库进行拆分或是引入其他数据库，一个项目中使用多个数据库(无论是主从复制- - 读写分离还是分布式数据库结构)的重要性变得越来越明显，那么我们就需要配置多个数据源。 一般项目中整合多数据源有两种方法：分包和AOP。 下面我就先基于Spring-data-jpa，以分包的方式来配置多数据源。 二. 多数据源配置实现 1. 创建web项目 我们按照之前的经验，创建一个web程序，并将之改造成Spring B
SpringBoot中多数据源灵活切换解决方案
lucky_love816的博客
04-26 1113
本篇内容介绍了“SpringBoot中如何使用Dynamic Datasource配置多数据源”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。支持无数据源启动，支持配置懒启动数据源(3.3.2+)。支持数据库敏感配置信息 加密 ENC()。支持每个数据库独立初始化表结构schema和数据库database。
SpringBoot根据包名进行区分使用多数据源
疙瘩陈
08-12 9374
就是让一个项目应用并使用多个数据库，这里采用的是SpringBoot2.0、MySql5.7，使用两个两个MySql数据库 1、建立两个数据库 2、建立一个SpringBoot项目 3、Pom文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4....
Java框架—SpringBoot+MyBatis实现多数据源配置
最新发布
weixin_41624547的博客
08-09 1397
spring:druid:master:slave:DruidDataSourceAutoConfigure会注入一个DataSourceWrapper，其会在原生的spring.datasource下找 url, username, password 等。动态数据源 URL 等配置是在 druid下，因此需要排除，否则会报错。
SpringBoot自学笔记11--区分多数据源
QilanAllen的博客
02-28 834
在项目中,我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源: 如何区分多个数据源：通过包来区分:com.db1.mapper com.db2.mapper 1.加入依赖 <!-- springboot集成mybatis --> <dependency> <groupId>org.mybatis.spring.boot&...
SpringBoot配置多数据源（动态切换）
桐花思雨
09-02 3057
目录前言项目搭建主要工具版本数据准备 前言 随着业务的不断增加，我们的系统会越来越庞大。显然单个数据库已经承受不了高并发带来的压力。一个项目使用多个数据库（无论是主从复制- - 读写分离还是分布式数据库结构）的重要性变得越来越明显。整合多数据源有两种方法：分包 和 AOP 分包：分包主要是根据业务划分 AOP：实际上就是通过 AOP 进行拦截，不同的注解里面的值，指向不同的数据源 项目搭建 主要工具版本 springboot：2.0.6.RELEASE JDK：1.8 mysql：5.7 数据准备
springboot双数据源(oracle,mysql).rar
07-19
9. **配置文件**：在SpringBoot项目中，通常使用`application.properties`或`application.yml`来配置数据源信息，包括数据源类型、URL、用户名、密码等。对于多数据源，可能需要创建额外的配置文件或配置块。 10. *...
优秀的后台管理框架可以配置多数据源，集成SpringBoot，Mybatis，Shiro,Thymeleaf，Bootstrap
07-28
5. 角色管理：角色菜单权限分配、设置角色按机构进行数据范围权限划分。 6. 字典管理：对系统中经常使用的一些较为固定的数据进行维护。 7. 参数管理：对系统动态配置常用参数。 8. 通知公告：系统通知公告信息发布...
SpringBoot系列：Spring Boot多数据源，Mybatis方式
Simple_Yangger的博客
09-15 494
一、Mybatis配置多数据源 mybatis可谓是国内最火的ORM框架了，mybatis的多数据源当然在实际使用中也必不可少。mybatis多数据源一般有两种方式，一种是基于不同的包使用不同的数据源，这个类似于JPA配置多数据源，另一种则是注解+aop实现。 本章节就来看一看使用不同的包怎么做到多数据源。 首先是pom文件，除了SpringBoot的依赖外，主要就是mybatis及数据库的依赖了...
【SpringBoot】springboot整合多数据拆分思路 及 使用分包方式拆分数据源
qq_41738687的博客
08-08 2005
一、springboot整合多数据拆分思路 1、多数据源：就是一个项目中使用多个jdbc连接不同的数据库； 例举：一个公司有两个数据库，一个是专门存放共同配置文件的数据库，一个是数据库垂直业务数据库。（垂直：根据业务划分具体数据库） 2、在一个项目中如何划分多数据源：分包名（业务）划分，或者通过注解方式划分 其实也就是怎么区别这个方法或者这个类具体用的哪个数据库 二、使用分包方式拆分数据...
springboot整合多数据源----分包的方式
王一的博客
07-23 313
1.在application.properties里配置两个数据源 ####test01 datasource spring.datasource.test1.driverClassName = com.mysql.jdbc.Driver spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3306/test1?useUnicode=...
以 MyBatis-Plus 为框架 搭建最简易多数据源(不同包下走不同的数据源)
weixin 19953181360
07-18 1382
目录1.项目工程搭建：1.1 引入pom依赖1.2 application.yml 配置1.3.1 `第一个数据源Master` JavaBean对象1.3.2 `第二个数据源Master` JavaBean对象 1.项目工程搭建： 1.1 引入pom依赖 引入SpringBoot和SpringCloud版本时特别注意下他们的兼容        参考: https://spring.io/projects/spring-cloud &l
springboot -- druid 多数据源(根据mapp位置区分业务数据库)
喝醉的咕咕鸟
12-03 806
1.多数据源切换：指项目所需要不止一个数据库的连接信息，eg：同一数据库地址下的不同库或者压根连地址都不同。 项目中不同的业务需求保存在不同的数据库中。 如 会员信息---会员数据库中 订单信息-- 订单数据库中。 多数据源彼此切换，要求不同的mybatis实例的mapper映射目录不能相同 如图： sql脚本: zhw-demo: CREATE TABLE `cat_use...
springboot包设置的问题
wumanxin2018的博客
09-27 729
springboot包设置的问题
一篇搞懂springboot多数据源
ITzhongzi的博客
02-27 830
一篇搞懂springboot多数据源
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值