Spring Boot + Mybatis 实现动态数据源案例分析

程序员文章站 2024-02-28 21:27:58

动态数据源在很多具体应用场景的时候，我们需要用到动态数据源的情况，比如多租户的场景，系统登录时需要根据用户信息切换到用户对应的数据库。又比如业务a要访问a数据库，业务b...

动态数据源

在很多具体应用场景的时候，我们需要用到动态数据源的情况，比如多租户的场景，系统登录时需要根据用户信息切换到用户对应的数据库。又比如业务a要访问a数据库，业务b要访问b数据库等，都可以使用动态数据源方案进行解决。接下来，我们就来讲解如何实现动态数据源，以及在过程中剖析动态数据源背后的实现原理。

实现案例

本教程案例基于 spring boot + mybatis + mysql 实现。

数据库设计

首先需要安装好mysql数据库，新建数据库 master，slave，分别创建用户表，用来测试数据源，sql脚本如下。

-- ----------------------------------------------------
-- 用户
-- ----------------------------------------------------
-- table structure for `sys_user`
-- ----------------------------------------------------
drop table if exists `sys_user`;
create table `sys_user` (
 `id` bigint not null auto_increment comment '编号',
 `name` varchar(50) not null comment '用户名',
 `password` varchar(100) comment '密码',
 `salt` varchar(40) comment '盐',
 `email` varchar(100) comment '邮箱',
 `mobile` varchar(100) comment '手机号',
 `status` tinyint comment '状态 0：禁用 1：正常',
 `dept_id` bigint(20) comment '机构id',
 `create_by` varchar(50) comment '创建人',
 `create_time` datetime comment '创建时间',
 `last_update_by` varchar(50) comment '更新人',
 `last_update_time` datetime comment '更新时间',
 `del_flag` tinyint default 0 comment '是否删除 -1：已删除 0：正常',
 primary key (`id`),
 unique index (`name`)
) engine=innodb default charset=utf8 comment='用户';

新建工程

新建一个spring boot工程，最终代码结构如下。

Spring Boot + Mybatis 实现动态数据源案例分析

添加依赖

添加spring boot，spring aop，mybatis，mysql，swagger相关依赖。swagger方便用来测试接口。

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: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>top.ivan.demo</groupid>
 <artifactid>springboot-dynamic-datasource</artifactid>
 <version>0.0.1-snapshot</version>
 <packaging>jar</packaging>

 <name>springboot-dynamic-datasource</name>
 <description>demo project for spring boot</description>

 <parent>
  <groupid>org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-parent</artifactid>
  <version>2.0.4.release</version>
  <relativepath/> <!-- lookup parent from repository -->
 </parent>

 <properties>
  <project.build.sourceencoding>utf-8</project.build.sourceencoding>
  <project.reporting.outputencoding>utf-8</project.reporting.outputencoding>
  <java.version>1.8</java.version>
  <mybatis.spring.version>1.3.2</mybatis.spring.version>
  <swagger.version>2.8.0</swagger.version>
 </properties>

 <dependencies>
   <!-- spring boot -->
  <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>
  <!-- spring aop -->
  <dependency>
   <groupid>org.springframework.boot</groupid>
   <artifactid>spring-boot-starter-aop</artifactid>
  </dependency>
  <!-- mybatis -->
  <dependency>
   <groupid>org.mybatis.spring.boot</groupid>
   <artifactid>mybatis-spring-boot-starter</artifactid>
   <version>${mybatis.spring.version}</version>
  </dependency>
  <!-- mysql -->
  <dependency>
   <groupid>mysql</groupid>
   <artifactid>mysql-connector-java</artifactid>
  </dependency>
  <!-- swagger -->
  <dependency>
   <groupid>io.springfox</groupid>
   <artifactid>springfox-swagger2</artifactid>
   <version>${swagger.version}</version>
  </dependency>
  <dependency>
   <groupid>io.springfox</groupid>
   <artifactid>springfox-swagger-ui</artifactid>
   <version>${swagger.version}</version>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-maven-plugin</artifactid>
   </plugin>
  </plugins>
 </build>

</project>

配置文件

修改配置文件，添加两个数据源，可以是同一个主机地址的两个数据库master，slave，也可是两个不同主机的地址，根据实际情况配置。

application.yml

spring:
 datasource:
 master:
  driver-class-name: com.mysql.jdbc.driver
  type: com.zaxxer.hikari.hikaridatasource
  jdbcurl: jdbc:mysql://127.0.0.1:3306/master?useunicode=true&zerodatetimebehavior=converttonull&autoreconnect=true&characterencoding=utf-8
  username: root
  password: 123
 slave:
  driver-class-name: com.mysql.jdbc.driver
  type: com.zaxxer.hikari.hikaridatasource
  jdbcurl: jdbc:mysql://127.0.0.1:3306/slave?useunicode=true&zerodatetimebehavior=converttonull&autoreconnect=true&characterencoding=utf-8
  username: root
  password: 123

启动类

启动类添加 exclude = {datasourceautoconfiguration.class}， 以禁用数据源默认自动配置。

数据源默认自动配置会读取 spring.datasource.* 的属性创建数据源，所以要禁用以进行定制。

@componentscan(basepackages = "com.louis.springboot") 是扫描范围，都知道不用多说。

dynamicdatasourceapplication.java

package com.louis.springboot.dynamic.datasource;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.boot.autoconfigure.jdbc.datasourceautoconfiguration;
import org.springframework.context.annotation.componentscan;

/**
 * 启动器
 * @author louis
 * @date oct 31, 2018
 */
@springbootapplication(exclude = {datasourceautoconfiguration.class}) // 禁用数据源自动配置
@componentscan(basepackages = "com.louis.springboot")
public class dynamicdatasourceapplication {

 public static void main(string[] args) {
  springapplication.run(dynamicdatasourceapplication.class, args);
 }
}

数据源配置类

创建一个数据源配置类，主要做以下几件事情：

1. 配置 dao，model，xml mapper文件的扫描路径。

2. 注入数据源配置属性，创建master、slave数据源。

3. 创建一个动态数据源，并装入master、slave数据源。

4. 将动态数据源设置到sql会话工厂和事务管理器。

如此，当进行数据库操作时，就会通过我们创建的动态数据源去获取要操作的数据源了。

package com.louis.springboot.dynamic.datasource.config;

import java.util.hashmap;
import java.util.map;

import javax.sql.datasource;

import org.mybatis.spring.sqlsessionfactorybean;
import org.mybatis.spring.annotation.mapperscan;
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.context.annotation.primary;
import org.springframework.core.io.support.pathmatchingresourcepatternresolver;
import org.springframework.jdbc.datasource.datasourcetransactionmanager;
import org.springframework.transaction.platformtransactionmanager;

import com.louis.springboot.dynamic.datasource.dds.dynamicdatasource;

/**
 * mybatis配置
 * @author louis
 * @date oct 31, 2018
 */
@configuration
@mapperscan(basepackages = {"com.louis.**.dao"}) // 扫描dao
public class mybatisconfig {

 @bean("master")
 @primary
 @configurationproperties(prefix = "spring.datasource.master")
 public datasource master() {
  return datasourcebuilder.create().build();
 }

 @bean("slave")
 @configurationproperties(prefix = "spring.datasource.slave")
 public datasource slave() {
  return datasourcebuilder.create().build();
 }

 @bean("dynamicdatasource")
 public datasource dynamicdatasource() {
  dynamicdatasource dynamicdatasource = new dynamicdatasource();
  map<object, object> datasourcemap = new hashmap<>(2);
  datasourcemap.put("master", master());
  datasourcemap.put("slave", slave());
  // 将 master 数据源作为默认指定的数据源
  dynamicdatasource.setdefaultdatasource(master());
  // 将 master 和 slave 数据源作为指定的数据源
  dynamicdatasource.setdatasources(datasourcemap);
  return dynamicdatasource;
 }

 @bean
 public sqlsessionfactorybean sqlsessionfactorybean() throws exception {
  sqlsessionfactorybean sessionfactory = new sqlsessionfactorybean();
  // 配置数据源，此处配置为关键配置，如果没有将 dynamicdatasource作为数据源则不能实现切换
  sessionfactory.setdatasource(dynamicdatasource());
  sessionfactory.settypealiasespackage("com.louis.**.model"); // 扫描model
  pathmatchingresourcepatternresolver resolver = new pathmatchingresourcepatternresolver();
  sessionfactory.setmapperlocations(resolver.getresources("classpath*:**/sqlmap/*.xml")); // 扫描映射文件
  return sessionfactory;
 }

 @bean
 public platformtransactionmanager transactionmanager() {
  // 配置事务管理, 使用事务时在方法头部添加@transactional注解即可
  return new datasourcetransactionmanager(dynamicdatasource());
 }
}

动态数据源类

我们上一步把这个动态数据源设置到了sql会话工厂和事务管理器，这样在操作数据库时就会通过动态数据源类来获取要操作的数据源了。

动态数据源类集成了spring提供的abstractroutingdatasource类，abstractroutingdatasource 中获取数据源的方法就是 determinetargetdatasource，而此方法又通过 determinecurrentlookupkey 方法获取查询数据源的key。

所以如果我们需要动态切换数据源，就可以通过以下两种方式定制：

1. 覆写 determinecurrentlookupkey 方法

通过覆写 determinecurrentlookupkey 方法，从一个自定义的 dynamicdatasourcecontextholder.getdatasourcekey() 获取数据源key值，这样在我们想动态切换数据源的时候，只要通过 dynamicdatasourcecontextholder.setdatasourcekey(key) 的方式就可以动态改变数据源了。这种方式要求在获取数据源之前，要先初始化各个数据源到 dynamicdatasource 中，我们案例就是采用这种方式实现的，所以在 mybatisconfig 中把master和slave数据源都事先初始化到dynamicdatasource 中。

2. 可以通过覆写 determinetargetdatasource，因为数据源就是在这个方法创建并返回的，所以这种方式就比较*了，支持到任何你希望的地方读取数据源信息，只要最终返回一个 datasource 的实现类即可。比如你可以到数据库、本地文件、网络接口等方式读取到数据源信息然后返回相应的数据源对象就可以了。

dynamicdatasource.java

package com.louis.springboot.dynamic.datasource.dds;

import java.util.map;

import javax.sql.datasource;

import org.springframework.jdbc.datasource.lookup.abstractroutingdatasource;

/**
 * 动态数据源实现类
 * @author louis
 * @date oct 31, 2018
 */
public class dynamicdatasource extends abstractroutingdatasource {
  
  
  /**
   * 如果不希望数据源在启动配置时就加载好，可以定制这个方法，从任何你希望的地方读取并返回数据源
   * 比如从数据库、文件、外部接口等读取数据源信息，并最终返回一个datasource实现类对象即可
   */
  @override
  protected datasource determinetargetdatasource() {
    return super.determinetargetdatasource();
  }
  
  /**
   * 如果希望所有数据源在启动配置时就加载好，这里通过设置数据源key值来切换数据，定制这个方法
   */
  @override
  protected object determinecurrentlookupkey() {
    return dynamicdatasourcecontextholder.getdatasourcekey();
  }
  
  /**
   * 设置默认数据源
   * @param defaultdatasource
   */
  public void setdefaultdatasource(object defaultdatasource) {
    super.setdefaulttargetdatasource(defaultdatasource);
  }
  
  /**
   * 设置数据源
   * @param datasources
   */
  public void setdatasources(map<object, object> datasources) {
    super.settargetdatasources(datasources);
    // 将数据源的 key 放到数据源上下文的 key 集合中，用于切换时判断数据源是否有效
    dynamicdatasourcecontextholder.adddatasourcekeys(datasources.keyset());
  }
}

数据源上下文

动态数据源的切换主要是通过调用这个类的方法来完成的。在任何想要进行切换数据源的时候都可以通过调用这个类的方法实现切换。比如系统登录时，根据用户信息调用这个类的数据源切换方法切换到用户对应的数据库。

主要方法介绍：

1. 切换数据源

在任何想要进行切换数据源的时候都可以通过调用这个类的方法实现切换。

  /**
   * 切换数据源
   * @param key
   */
  public static void setdatasourcekey(string key) {
    contextholder.set(key);
  }

2. 重置数据源

将数据源重置回默认的数据源。默认数据源通过 dynamicdatasource.setdefaultdatasource(ds) 进行设置。

  /**
   * 重置数据源
   */
  public static void cleardatasourcekey() {
    contextholder.remove();
  }

3. 获取当前数据源key

  /**
   * 获取数据源
   * @return
   */
  public static string getdatasourcekey() {
    return contextholder.get();
  }

完整代码如下

dynamicdatasourcecontextholder.java

package com.louis.springboot.dynamic.datasource.dds;

import java.util.arraylist;
import java.util.collection;
import java.util.list;

/**
 * 动态数据源上下文
 * @author louis
 * @date oct 31, 2018
 */
public class dynamicdatasourcecontextholder {

  private static final threadlocal<string> contextholder = new threadlocal<string>() {
    /**
     * 将 master 数据源的 key作为默认数据源的 key
     */
    @override
    protected string initialvalue() {
      return "master";
    }
  };


  /**
   * 数据源的 key集合，用于切换时判断数据源是否存在
   */
  public static list<object> datasourcekeys = new arraylist<>();

  /**
   * 切换数据源
   * @param key
   */
  public static void setdatasourcekey(string key) {
    contextholder.set(key);
  }

  /**
   * 获取数据源
   * @return
   */
  public static string getdatasourcekey() {
    return contextholder.get();
  }

  /**
   * 重置数据源
   */
  public static void cleardatasourcekey() {
    contextholder.remove();
  }

  /**
   * 判断是否包含数据源
   * @param key 数据源key
   * @return
   */
  public static boolean containdatasourcekey(string key) {
    return datasourcekeys.contains(key);
  }
  
  /**
   * 添加数据源keys
   * @param keys
   * @return
   */
  public static boolean adddatasourcekeys(collection<? extends object> keys) {
    return datasourcekeys.addall(keys);
  }
}

注解式数据源

到这里，在任何想要动态切换数据源的时候，只要调用 dynamicdatasourcecontextholder.setdatasourcekey(key) 就可以完成了。

接下来我们实现通过注解的方式来进行数据源的切换，原理就是添加注解（如@datasource(value="master")），然后实现注解切面进行数据源切换。

创建一个动态数据源注解，拥有一个value值，用于标识要切换的数据源的key。

datasource.java

package com.louis.springboot.dynamic.datasource.dds;

import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;

/**
 * 动态数据源注解
 * @author louis
 * @date oct 31, 2018
 */
@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented
public @interface datasource {
  
  /**
   * 数据源key值
   * @return
   */
  string value();
  
}

创建一个aop切面，拦截带 @datasource 注解的方法，在方法执行前切换至目标数据源，执行完成后恢复到默认数据源。

dynamicdatasourceaspect.java

package com.louis.springboot.dynamic.datasource.dds;

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.after;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.springframework.core.annotation.order;
import org.springframework.stereotype.component;

/**
 * 动态数据源切换处理器
 * @author louis
 * @date oct 31, 2018
 */
@aspect
@order(-1) // 该切面应当先于 @transactional 执行
@component
public class dynamicdatasourceaspect {
  
  /**
   * 切换数据源
   * @param point
   * @param datasource
   */
  @before("@annotation(datasource))")
  public void switchdatasource(joinpoint point, datasource datasource) {
    if (!dynamicdatasourcecontextholder.containdatasourcekey(datasource.value())) {
      system.out.println("datasource [{}] doesn't exist, use default datasource [{}] " + datasource.value());
    } else {
      // 切换数据源
      dynamicdatasourcecontextholder.setdatasourcekey(datasource.value());
      system.out.println("switch datasource to [" + dynamicdatasourcecontextholder.getdatasourcekey()
        + "] in method [" + point.getsignature() + "]");
    }
  }

  /**
   * 重置数据源
   * @param point
   * @param datasource
   */
  @after("@annotation(datasource))")
  public void restoredatasource(joinpoint point, datasource datasource) {
    // 将数据源置为默认数据源
    dynamicdatasourcecontextholder.cleardatasourcekey();
    system.out.println("restore datasource to [" + dynamicdatasourcecontextholder.getdatasourcekey() 
      + "] in method [" + point.getsignature() + "]");
  }
}

到这里，动态数据源相关的处理代码就完成了。

编写用户业务代码

接下来编写用户查询业务代码，用来进行测试，只需添加一个查询接口即可。

编写一个控制器，包含两个查询方法，分别注解 master 和 slave 数据源。

sysusercontroller.java
package com.louis.springboot.dynamic.datasource.controller;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;
import com.louis.springboot.dynamic.datasource.dds.datasource;
import com.louis.springboot.dynamic.datasource.service.sysuserservice;
/**
 * 用户控制器
 * @author louis
 * @date oct 31, 2018
 */
@restcontroller
@requestmapping("user")
public class sysusercontroller {
  @autowired
  private sysuserservice sysuserservice;
  @datasource(value="master")
  @postmapping(value="/findall")
  public object findall() {
    return sysuserservice.findall();
  }
  @datasource(value="slave")
  @postmapping(value="/findall2")
  public object findall2() {
    return sysuserservice.findall();
  }
}

下面是正常的业务代码，没有什么好说明的，直接贴代码了。

sysuser.java
public class sysuser {
  private long id;
  private string name;
  private string password;
  private string salt;
  private string email;
  private string mobile;
  private byte status;
  private long deptid;
  private string deptname;
  private byte delflag;
  private string createby;
  private date createtime;
  private string lastupdateby;
  private date lastupdatetime;
　　...setter and getter
}
sysusermapper.java
package com.louis.springboot.dynamic.datasource.dao;
import java.util.list;
import com.louis.springboot.dynamic.datasource.model.sysuser;
public interface sysusermapper {
  int deletebyprimarykey(long id);
  int insert(sysuser record);
  int insertselective(sysuser record);
  sysuser selectbyprimarykey(long id);
  int updatebyprimarykeyselective(sysuser record);
  int updatebyprimarykey(sysuser record);
  list<sysuser> findall();
}

sysusermapper.xml

<?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.louis.springboot.dynamic.datasource.dao.sysusermapper">
 <resultmap id="baseresultmap" type="com.louis.springboot.dynamic.datasource.model.sysuser">
  <id column="id" jdbctype="bigint" property="id" />
  <result column="name" jdbctype="varchar" property="name" />
  <result column="password" jdbctype="varchar" property="password" />
  <result column="salt" jdbctype="varchar" property="salt" />
  <result column="email" jdbctype="varchar" property="email" />
  <result column="mobile" jdbctype="varchar" property="mobile" />
  <result column="status" jdbctype="tinyint" property="status" />
  <result column="dept_id" jdbctype="bigint" property="deptid" />
  <result column="create_by" jdbctype="bigint" property="createby" />
  <result column="create_time" jdbctype="timestamp" property="createtime" />
  <result column="last_update_by" jdbctype="bigint" property="lastupdateby" />
  <result column="last_update_time" jdbctype="timestamp" property="lastupdatetime" />
  <result column="del_flag" jdbctype="tinyint" property="delflag" />
 </resultmap>
 <sql id="base_column_list">
  id, name, password, salt, email, mobile, status, dept_id, create_by, create_time, 
  last_update_by, last_update_time, del_flag
 </sql>
 <select id="selectbyprimarykey" parametertype="java.lang.long" resultmap="baseresultmap">
  select 
  <include refid="base_column_list" />
  from sys_user
  where id = #{id,jdbctype=bigint}
 </select>
 <delete id="deletebyprimarykey" parametertype="java.lang.long">
  delete from sys_user
  where id = #{id,jdbctype=bigint}
 </delete>
 <insert id="insert" parametertype="com.louis.springboot.dynamic.datasource.model.sysuser">
  insert into sys_user (id, name, password, 
   salt, email, mobile, 
   status, dept_id, create_by, 
   create_time, last_update_by, last_update_time, 
   del_flag)
  values (#{id,jdbctype=bigint}, #{name,jdbctype=varchar}, #{password,jdbctype=varchar}, 
   #{salt,jdbctype=varchar}, #{email,jdbctype=varchar}, #{mobile,jdbctype=varchar}, 
   #{status,jdbctype=tinyint}, #{deptid,jdbctype=bigint}, #{createby,jdbctype=bigint}, 
   #{createtime,jdbctype=timestamp}, #{lastupdateby,jdbctype=bigint}, #{lastupdatetime,jdbctype=timestamp}, 
   #{delflag,jdbctype=tinyint})
 </insert>
 <insert id="insertselective" parametertype="com.louis.springboot.dynamic.datasource.model.sysuser">
  insert into sys_user
  <trim prefix="(" suffix=")" suffixoverrides=",">
   <if test="id != null">
    id,
   </if>
   <if test="name != null">
    name,
   </if>
   <if test="password != null">
    password,
   </if>
   <if test="salt != null">
    salt,
   </if>
   <if test="email != null">
    email,
   </if>
   <if test="mobile != null">
    mobile,
   </if>
   <if test="status != null">
    status,
   </if>
   <if test="deptid != null">
    dept_id,
   </if>
   <if test="createby != null">
    create_by,
   </if>
   <if test="createtime != null">
    create_time,
   </if>
   <if test="lastupdateby != null">
    last_update_by,
   </if>
   <if test="lastupdatetime != null">
    last_update_time,
   </if>
   <if test="delflag != null">
    del_flag,
   </if>
  </trim>
  <trim prefix="values (" suffix=")" suffixoverrides=",">
   <if test="id != null">
    #{id,jdbctype=bigint},
   </if>
   <if test="name != null">
    #{name,jdbctype=varchar},
   </if>
   <if test="password != null">
    #{password,jdbctype=varchar},
   </if>
   <if test="salt != null">
    #{salt,jdbctype=varchar},
   </if>
   <if test="email != null">
    #{email,jdbctype=varchar},
   </if>
   <if test="mobile != null">
    #{mobile,jdbctype=varchar},
   </if>
   <if test="status != null">
    #{status,jdbctype=tinyint},
   </if>
   <if test="deptid != null">
    #{deptid,jdbctype=bigint},
   </if>
   <if test="createby != null">
    #{createby,jdbctype=bigint},
   </if>
   <if test="createtime != null">
    #{createtime,jdbctype=timestamp},
   </if>
   <if test="lastupdateby != null">
    #{lastupdateby,jdbctype=bigint},
   </if>
   <if test="lastupdatetime != null">
    #{lastupdatetime,jdbctype=timestamp},
   </if>
   <if test="delflag != null">
    #{delflag,jdbctype=tinyint},
   </if>
  </trim>
 </insert>
 <update id="updatebyprimarykeyselective" parametertype="com.louis.springboot.dynamic.datasource.model.sysuser">
  update sys_user
  <set>
   <if test="name != null">
    name = #{name,jdbctype=varchar},
   </if>
   <if test="password != null">
    password = #{password,jdbctype=varchar},
   </if>
   <if test="salt != null">
    salt = #{salt,jdbctype=varchar},
   </if>
   <if test="email != null">
    email = #{email,jdbctype=varchar},
   </if>
   <if test="mobile != null">
    mobile = #{mobile,jdbctype=varchar},
   </if>
   <if test="status != null">
    status = #{status,jdbctype=tinyint},
   </if>
   <if test="deptid != null">
    dept_id = #{deptid,jdbctype=bigint},
   </if>
   <if test="createby != null">
    create_by = #{createby,jdbctype=bigint},
   </if>
   <if test="createtime != null">
    create_time = #{createtime,jdbctype=timestamp},
   </if>
   <if test="lastupdateby != null">
    last_update_by = #{lastupdateby,jdbctype=bigint},
   </if>
   <if test="lastupdatetime != null">
    last_update_time = #{lastupdatetime,jdbctype=timestamp},
   </if>
   <if test="delflag != null">
    del_flag = #{delflag,jdbctype=tinyint},
   </if>
  </set>
  where id = #{id,jdbctype=bigint}
 </update>
 <update id="updatebyprimarykey" parametertype="com.louis.springboot.dynamic.datasource.model.sysuser">
  update sys_user
  set name = #{name,jdbctype=varchar},
   password = #{password,jdbctype=varchar},
   salt = #{salt,jdbctype=varchar},
   email = #{email,jdbctype=varchar},
   mobile = #{mobile,jdbctype=varchar},
   status = #{status,jdbctype=tinyint},
   dept_id = #{deptid,jdbctype=bigint},
   create_by = #{createby,jdbctype=bigint},
   create_time = #{createtime,jdbctype=timestamp},
   last_update_by = #{lastupdateby,jdbctype=bigint},
   last_update_time = #{lastupdatetime,jdbctype=timestamp},
   del_flag = #{delflag,jdbctype=tinyint}
  where id = #{id,jdbctype=bigint}
 </update>
 <select id="findall" resultmap="baseresultmap">
  select 
  <include refid="base_column_list" />
  from sys_user
 </select>
</mapper>

sysuserservice.java

package com.louis.springboot.dynamic.datasource.service;
import java.util.list;
import com.louis.springboot.dynamic.datasource.model.sysuser;
/**
 * 用户管理
 * @author louis
 * @date oct 31, 2018
 */
public interface sysuserservice {
  /**
   * 查找全部用户信息
   * @return
   */
  list<sysuser> findall();
}
sysuserserviceimpl.java
package com.louis.springboot.dynamic.datasource.service.impl;
import java.util.list;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
import com.louis.springboot.dynamic.datasource.dao.sysusermapper;
import com.louis.springboot.dynamic.datasource.model.sysuser;
import com.louis.springboot.dynamic.datasource.service.sysuserservice;
@service
public class sysuserserviceimpl implements sysuserservice {
  @autowired
  private sysusermapper sysusermapper;
  /**
   * 查找全部用户信息
   * @return
   */
  public list<sysuser> findall() {
    return sysusermapper.findall();
  }
}

测试效果

启动系统，访问，分别测试两个接口，成功返回数据。

user/findall (master数据源)

Spring Boot + Mybatis 实现动态数据源案例分析