在很多具體應用場景的時候，我們需要用到動態數據源的情況，比如多租戶的場景，系統登錄時需要根據用戶信息切換到用戶對應的數據庫。又比如業務a要訪問a數據庫，業務b要訪問b數據庫等，都可以使用動態數據源方案進行解決。接下來，我們就來講解如何實現動態數據源，以及在過程中剖析動態數據源背后的實現原理。
實現案例
本教程案例基于 spring boot + mybatis + mysql 實現。
數據庫設計
首先需要安裝好mysql數據庫，新建數據庫 master，slave，分別創建用戶表，用來測試數據源，sql腳本如下。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
-- ------------------------------------------------------ 用戶-- ------------------------------------------------------ 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，spring aop，mybatis，mysql，swagger相關依賴。swagger方便用來測試接口。
pom.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
<?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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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") 是掃描范圍，都知道不用多說。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
dynamicdatasourceapplication.javapackage 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會話工廠和事務管理器。
如此，當進行數據庫操作時，就會通過我們創建的動態數據源去獲取要操作的數據源了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
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"}) // 掃描daopublic 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 的實現類即可。比如你可以到數據庫、本地文件、網絡接口等方式讀取到數據源信息然后返回相應的數據源對象就可以了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
dynamicdatasource.javapackage 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. 切換數據源
在任何想要進行切換數據源的時候都可以通過調用這個類的方法實現切換。
|
1
2
3
4
5
6
7
|
/** * 切換數據源 * @param key */public static void setdatasourcekey(string key) { contextholder.set(key);} |
2. 重置數據源
將數據源重置回默認的數據源。默認數據源通過 dynamicdatasource.setdefaultdatasource(ds) 進行設置。
|
1
2
3
4
5
6
|
/** * 重置數據源 */public static void cleardatasourcekey() { contextholder.remove();} |
3. 獲取當前數據源key
|
1
2
3
4
5
6
7
|
/** * 獲取數據源 * @return */public static string getdatasourcekey() { return contextholder.get();} |
完整代碼如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
dynamicdatasourcecontextholder.javapackage 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。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
datasource.javapackage 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)@documentedpublic @interface datasource { /** * 數據源key值 * @return */ string value(); } |
創建一個aop切面，攔截帶 @datasource 注解的方法，在方法執行前切換至目標數據源，執行完成后恢復到默認數據源。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
dynamicdatasourceaspect.javapackage 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 執行@componentpublic 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 數據源。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
sysusercontroller.javapackage 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(); }} |
下面是正常的業務代碼，沒有什么好說明的，直接貼代碼了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
sysuser.javapublic 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.javapackage 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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
<?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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
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.javapackage 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;@servicepublic class sysuserserviceimpl implements sysuserservice { @autowired private sysusermapper sysusermapper; /** * 查找全部用戶信息 * @return */ public list<sysuser> findall() { return sysusermapper.findall(); }} |
測試效果
啟動系統，訪問 http://localhost:8080/swagger-ui.html ，分別測試兩個接口，成功返回數據。
user/findall (master數據源)
user/findall2 (slave數據源)
源碼下載
碼云：https://gitee.com/liuge1988/spring-boot-demo.git
總結
以上所述是小編給大家介紹的spring boot + mybatis 實現動態數據源案例分析，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
原文鏈接：http://www.cnblogs.com/xifengxiaoma/p/9888240.html
