springboot2.0+mybatis多数据源集成

最近在学springboot，把学的记录下来。主要有springboot2.0+mybatis多数据源集成，logback日志集成，springboot单元测试。

一、代码结构如下

二、pom.xml文件如下

 <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>spring-boot-2</groupId>
   <artifactId>spring-boot-2</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>spring-boot-2</name>
   <url>http://maven.apache.org</url>

   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

   <dependencies>
       <!-- spring boot依赖 -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
         <version>2.0.3.RELEASE</version>
     </dependency>

     <!-- spring boot测试 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <version>2.0.3.RELEASE</version>
         <scope>test</scope>
     </dependency>

     <!-- spring boot热启动 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-devtools</artifactId>
         <optional>true</optional>
         <version>2.0.3.RELEASE</version>
     </dependency>

     <!-- mysql -->
     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.38</version>
     </dependency>

     <!-- mybatis -->
     <dependency>
          <groupId>org.mybatis.spring.boot</groupId>
          <artifactId>mybatis-spring-boot-starter</artifactId>
          <version>1.3.2</version>
     </dependency>

     <!-- alibaba的druid数据库连接池 -->
     <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid-spring-boot-starter</artifactId>
          <version>1.1.9</version>
     </dependency>
   </dependencies>

   <build>
     <plugins>
         <!-- 规避检查src/main/webapp/WEB-INF下没有web.xml文件 -->
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-war-plugin</artifactId>
             <version>2.3</version>
             <configuration>
                 <failOnMissingWebXml>false</failOnMissingWebXml>
             </configuration>
         </plugin>
         <!-- maven热启动 -->
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <configuration>
                 <fork>true</fork>
             </configuration>
         </plugin>
         <!-- 跳过单元测试 -->
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
               <skip>true</skip>
             </configuration>
         </plugin>

         <!-- 指定jdk版本 -->
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
                 <source>1.8</source>
                 <target>1.8</target>
             </configuration>
         </plugin>
     </plugins>
   </build>
 </project>

三、编写application.yml文件，springboot支持properties和yml两种格式的配置文件，我使用的是yml文件。使用yml文件需要注意的是只支持空格，不支持tab等，可以下个eclipse的yml插件。

配置文件如下

 # 数据源
 spring:
     datasource:
        # master数据源配置
        master:
            driverClassName: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
            username: root
            password: root
        # cluster数据源配置
        cluster:
            driverClassName: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8
            username: root
            password: root
            

四、编写主从库的配置代码，代码差不多一样，只不过主库配置类的方法上需要加@Primary注解，用来告诉spring默认使用这个配置，主库配置类代码如下

 package com.spring.boot.config;

 import javax.sql.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.Qualifier;
 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;

 /**
  * mysql从库配置类
  * @日期： 2018年7月5日 下午10:05:25
  * @作者： Chendb
  */
 @Configuration
 @MapperScan(basePackages = "com.spring.boot.master.mapper",sqlSessionTemplateRef = "masterSqlSessionTemplate")
 public class MasterDataSourceConfig {

     /**
      * 创建数据源
      *@return DataSource
      */
     @Bean(name = "masterDataSource")
     @ConfigurationProperties(prefix = "spring.datasource.master")
     @Primary
     public DataSource masterDataSource() {
         return DataSourceBuilder.create().build();
     }

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

     /**
      * 创建事务
      *@param dataSource
      *@return DataSourceTransactionManager
      */
     @Bean(name = "masterTransactionManager")
     @Primary
     public DataSourceTransactionManager masterDataSourceTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) {
         return new DataSourceTransactionManager(dataSource);
     }

     /**
      * 创建模板
      *@param sqlSessionFactory
      *@return SqlSessionTemplate
      */
     @Bean(name = "masterSqlSessionTemplate")
     @Primary
     public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
         return new SqlSessionTemplate(sqlSessionFactory);
     }

 }

从库配置类代码如下

 package com.spring.boot.config;

 import javax.sql.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.Qualifier;
 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;

 /**
  * mysql主库配置类
  * @日期： 2018年7月5日 下午10:05:25
  * @作者： Chendb
  */
 @Configuration
 @MapperScan(basePackages = "com.spring.boot.mapper.cluster",sqlSessionTemplateRef = "clusterSqlSessionTemplate")
 public class ClusterDataSourceConfig {

     /**
      * 创建数据源
      *@return DataSource
      */
     @Bean(name = "clusterDataSource")
     @ConfigurationProperties(prefix = "spring.datasource.cluster")
     public DataSource masterDataSource() {
         return DataSourceBuilder.create().build();
     }

     /**
      * 创建工厂
      *@param dataSource
      *@throws Exception
      *@return SqlSessionFactory
      */
     @Bean(name = "clusterSqlSessionFactory")
     public SqlSessionFactory masterSqlSessionFactory(@Qualifier("clusterDataSource") DataSource dataSource) throws Exception {
         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
         bean.setDataSource(dataSource);
         bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/cluster/*.xml"));
         return bean.getObject();
     }

     /**
      * 创建事务
      *@param dataSource
      *@return DataSourceTransactionManager
      */
     @Bean(name = "clusterTransactionManager")
     public DataSourceTransactionManager masterDataSourceTransactionManager(@Qualifier("clusterDataSource") DataSource dataSource) {
         return new DataSourceTransactionManager(dataSource);
     }

     /**
      * 创建模板
      *@param sqlSessionFactory
      *@return SqlSessionTemplate
      */
     @Bean(name = "clusterSqlSessionTemplate")
     public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("clusterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
         return new SqlSessionTemplate(sqlSessionFactory);
     }

 }

五、配置mybatis的mapper文件，主库的mapper文件如下

 <?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.spring.boot.mapper.cluster.ClusterUserMapper" >
     <!-- 结果映射 -->
     <resultMap id="BaseMap" type="com.spring.boot.model.UserModel">
         <id column="userId" property="userId" jdbcType="INTEGER" />
         <result column="userName" property="userName" jdbcType="VARCHAR" />
         <result column="password" property="password" jdbcType="VARCHAR" />
         <result column="phone" property="phone" jdbcType="VARCHAR" />
     </resultMap>

     <!-- 表所有字段 -->
     <sql id="allColumns">
         userId, userName, password, phone
     </sql>

     <!-- 查询所有数据 -->
       <select id="getAll" resultMap="BaseMap">
             SELECT
             <include refid="allColumns" />
             FROM T_USER
       </select>

       <!-- 根据主键查询数据 -->
     <select id="get" resultMap="BaseMap" parameterType="java.util.Map">
         SELECT
         <include refid="allColumns" />
         FROM
             t_user u
         WHERE
             1 = 1
         AND userId = #{userId}
     </select>

     <!-- 插入数据 -->
     <insert id="insert" parameterType="java.util.Map">
         <!--获取最新更新的主键-->
         <selectKey resultType="java.lang.Integer" order="AFTER" keyProperty="userId">
           SELECT LAST_INSERT_ID() AS userId
         </selectKey>
         INSERT INTO T_USER (<include refid="allColumns" />)
         VALUES (
             #{userId},
             #{userName},
             #{password},
             #{phone}
         )
     </insert>

      <!-- 修改数据 -->
     <update id="update" parameterType="java.util.Map">
         UPDATE T_USER SET
             userName = #{userName},
             PASSWORD = #{password},
             PHONE = #{phone}
         WHERE userId = #{userId}
     </update>

     <!-- 根据主键删除数据 -->
     <delete id="delete" parameterType="Integer">
         DELETE FROM T_USER WHERE userId = #{userId}
     </delete>

 </mapper>

从库的mapper文件如下

 <?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.spring.boot.mapper.master.MasterUserMapper" >
     <!-- 结果映射 -->
     <resultMap id="BaseMap" type="com.spring.boot.model.UserModel">
         <id column="userId" property="userId" jdbcType="INTEGER" />
         <result column="userName" property="userName" jdbcType="VARCHAR" />
         <result column="password" property="password" jdbcType="VARCHAR" />
         <result column="phone" property="phone" jdbcType="VARCHAR" />
     </resultMap>

     <!-- 表所有字段 -->
     <sql id="allColumns">
         userId, userName, password, phone
     </sql>

     <!-- 查询所有数据 -->
       <select id="getAll" resultMap="BaseMap">
             SELECT
             <include refid="allColumns" />
             FROM T_USER
       </select>

       <!-- 根据主键查询数据 -->
     <select id="get" resultMap="BaseMap" parameterType="java.util.Map">
         SELECT
         <include refid="allColumns" />
         FROM
             t_user u
         WHERE
             1 = 1
         AND userid = #{userId}
     </select>

     <!-- 插入数据，返回主键 -->
     <insert id="insert" parameterType="java.util.Map" useGeneratedKeys="true" keyProperty="userId" keyColumn="userId">
         INSERT INTO T_USER (userName,password,phone)
         VALUES (
             #{userName},
             #{password},
             #{phone}
         )
     </insert>

      <!-- 修改数据 -->
     <update id="update" parameterType="java.util.Map">
         UPDATE T_USER SET
             userName = #{userName},
             PASSWORD = #{password},
             PHONE = #{phone}
         WHERE userId = #{userId}
     </update>

     <!-- 根据主键删除数据 -->
     <delete id="delete" parameterType="Integer">
         DELETE FROM T_USER WHERE userId = #{userId}
     </delete>

 </mapper>

六、编写mybatis的dao层，这里不需要编写具体的dao层实现，只写接口类，只要保证mapper配置文件的命名空间和接口类的全限定名一致并且接口方法名和mapper文件的sql标识符对应即可

主库的接口类如下

 package com.spring.boot.mapper.master;

 import java.util.List;

 import com.spring.boot.model.UserModel;

 public interface MasterUserMapper {

     /**
      * 获取全部用户数据
      *@return List<UserModel> 用户列表
      */
     List<UserModel> getAll();

     /**
      * 获取用户数据
      *@param userId 用户id
      *@return UserModel 用户数据
      */
     UserModel get(Integer userId);

     /**
      * 保存用户
      *@param userModel 用户数据
      *@return Integer 是否成功，1成功，0失败
      */
     Integer insert(UserModel userModel);

     /**
      * 更新用户
      *@param userModel 用户数据
      *@return Integer 是否成功，1成功，0失败
      */
     Integer update(UserModel userModel);

     /**
      * 删除用户
      *@param userId 用户id
      *@return Integer 是否成功，1成功，0失败
      */
     Integer delete(Integer userId);
 }

从库的接口类如下

 package com.spring.boot.mapper.cluster;

 import java.util.List;

 import com.spring.boot.model.UserModel;

 public interface ClusterUserMapper {
     /**
      * 获取全部用户数据
      *@return List<UserModel> 用户列表
      */
     List<UserModel> getAll();

     /**
      * 获取用户数据
      *@param userId 用户id
      *@return UserModel 用户数据
      */
     UserModel get(Integer userId);

     /**
      * 保存用户
      *@param userModel 用户数据
      *@return Integer 是否成功，1成功，0失败
      */
     Integer insert(UserModel userModel);

     /**
      * 更新用户
      *@param userModel 用户数据
      *@return Integer 是否成功，1成功，0失败
      */
     Integer update(UserModel userModel);

     /**
      * 删除用户
      *@param userId 用户id
      *@return Integer 是否成功，1成功，0失败
      */
     Integer delete(Integer userId);
 }

七、springboot启动类

 package com.spring.boot;

 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;

 /**
  * springboot启动类
  * @日期： 2018年7月5日 下午10:03:36
  * @作者： Chendb
  */
 @SpringBootApplication
 @MapperScan("com.spring.boot.mapper")
 public class Application {

     public static void main(String[] args) {
         SpringApplication.run(Application.class, args);
     }

 }

八、实体类和数据库表

 package com.spring.boot.model;

 import java.io.Serializable;

 public class UserModel implements Serializable{
     /**
      *
      */
     private static final long serialVersionUID = 1L;

     /**
      * 用户id
      */
     private Integer userId;

     /**
      * 用户名称
      */
     private String userName;

     /**
      * 用户密码
      */
     private String password;

     /**
      * 电话
      */
     private String phone;

     /**
      * 获取用户id
      *@return Integer 用户id
      */
     public Integer getUserId() {
         return userId;
     }

     /**
      * 设置用户id
      *@param userId 用户id
      *@return void
      */
     public void setUserId(Integer userId) {
         this.userId = userId;
     }

     /**
      * 获取用户名称
      *@return String 用户名称
      */
     public String getUserName() {
         return userName;
     }

     /**
      * 设置用户名称
      *@param userName 用户名称
      *@return void
      */
     public void setUserName(String userName) {
         this.userName = userName;
     }

     /**
      * 获取用户密码
      *@return String 用户密码
      */
     public String getPassword() {
         return password;
     }

     /**
      * 设置用户密码
      *@param password 用户密码
      *@return void
      */
     public void setPassword(String password) {
         this.password = password;
     }

     /**
      * 获取电话
      *@return String 电话
      */
     public String getPhone() {
         return phone;
     }

     /**
      * 设置电话
      *@param phone 电话
      *@return void
      */
     public void setPhone(String phone) {
         this.phone = phone;
     }
 }

 /*
 Navicat MySQL Data Transfer

 Source Server         : local
 Source Server Version : 50713
 Source Host           : localhost:3306
 Source Database       : test2

 Target Server Type    : MYSQL
 Target Server Version : 50713
 File Encoding         : 65001

 Date: 2018-07-06 23:14:03
 */

 SET FOREIGN_KEY_CHECKS=0;

 -- ----------------------------
 -- Table structure for t_user
 -- ----------------------------
 DROP TABLE IF EXISTS `t_user`;
 CREATE TABLE `t_user` (
   `userId` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
   `userName` varchar(255) NOT NULL COMMENT '用户名称',
   `password` varchar(255) NOT NULL COMMENT '用户密码',
   `phone` varchar(255) NOT NULL COMMENT '电话',
   PRIMARY KEY (`userId`)
 ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

九、控制层以及单元测试类

 package com.spring.boot.controller;

 import java.util.List;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

 import com.spring.boot.mapper.cluster.ClusterUserMapper;
 import com.spring.boot.mapper.master.MasterUserMapper;
 import com.spring.boot.model.UserModel;

 /**
  * 用户控制层
  * @日期： 2018年7月5日 下午11:18:04
  * @作者： Chendb
  */
 @RestController
 public class UserController {

     @Autowired
     private MasterUserMapper masterUserMapper;

     @Autowired
     private ClusterUserMapper clusterUserMapper;

     /************************主库控制层接口-start******************************/
     @RequestMapping("user/getAllMaster")
     public List<UserModel> getAllMaster() {
         return masterUserMapper.getAll();
     }

     @RequestMapping("user/getMaster")
     public UserModel getUserMaster(Integer userId) {
         return masterUserMapper.get(userId);
     }

     @RequestMapping("user/insertMaster")
     public Integer insertMaster(UserModel userModel) {
         masterUserMapper.insert(userModel);
         // 必须使用对象获取id，否则无法获取到主键，而是获取到0（插入失败）或者1（插入成功）
         return userModel.getUserId();
     }

     @RequestMapping("user/updateMaster")
     public Integer updateMaster(UserModel userModel) {
         return masterUserMapper.update(userModel);
     }

     @RequestMapping("user/deleteMaster")
     public Integer deleteMaster(Integer userId) {
         return masterUserMapper.delete(userId);
     }
     /************************主库控制层接口-end******************************/

     /************************从库控制层接口-start******************************/
     @RequestMapping("user/getAllCluster")
     public List<UserModel> getAllCluster() {
         return clusterUserMapper.getAll();
     }

     @RequestMapping("user/getCluster")
     public UserModel getUserCluster(Integer userId) {
         return clusterUserMapper.get(userId);
     }

     @RequestMapping("user/insertCluster")
     public Integer insertCluster(UserModel userModel) {
         clusterUserMapper.insert(userModel);
         // 必须使用对象获取id，否则无法获取到主键，而是获取到0（插入失败）或者1（插入成功）
         return userModel.getUserId();
     }

     @RequestMapping("user/updateCluster")
     public Integer updateCluster(UserModel userModel) {
         return clusterUserMapper.update(userModel);
     }

     @RequestMapping("user/deleteCluster")
     public Integer deleteCluster(Integer userId) {
         return clusterUserMapper.delete(userId);
     }
     /************************从库控制层接口-end******************************/
 }

 package com.spring.boot;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.http.MediaType;
 import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.ResultActions;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.web.context.WebApplicationContext;

 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserControllerTest {

     @Autowired
     private WebApplicationContext context;

     private MockMvc mvc;

     @Before
     public void setUp() throws Exception {
         this.mvc = MockMvcBuilders.webAppContextSetup(context).build();
     }

     /************************主库控制层接口测试-start******************************/
     @Test
     public void testInsertMaster() throws Exception {
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertMaster")
                 .param("userName", "testName")
                 .param("password", "password")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
         String userId = action.andReturn().getResponse().getContentAsString();

         System.out.println("userId:" + userId);
     }

     @Test
     public void testGetAllMaster() throws Exception {

         // 先保存，确保有数据
         mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertMaster")
                 .param("userName", "testName")
                 .param("password", "password")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         mvc.perform(MockMvcRequestBuilders
                 .get("/user/getAllMaster")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testGetMaster() throws Exception {
         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertMaster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .get("/user/getMaster")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testUpdateMaster() throws Exception {
         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertMaster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .post("/user/updateMaster")
                 .param("userName", "修改")
                 .param("password", "password")
                 .param("phone", "13578236975")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testDeleteMaster() throws Exception {

         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertMaster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .delete("/user/deleteMaster")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }
     /************************主库控制层接口测试-end******************************/

     /************************从库控制层接口测试-start******************************/

     @Test
     public void testInsertCluster() throws Exception {
         mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertCluster")
                 .param("userName", "testName")
                 .param("password", "password")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testGetAllCluster() throws Exception {
         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertCluster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .get("/user/getAllCluster")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testGetCluster() throws Exception {
         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertCluster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .get("/user/getCluster")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testUpdateCluster() throws Exception {
         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertCluster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .post("/user/updateCluster")
                 .param("userName", "testName修改")
                 .param("password", "password")
                 .param("phone", "13578236975")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }

     @Test
     public void testDeleteCluster() throws Exception {

         // 先保存，确保有数据
         ResultActions action = mvc.perform(MockMvcRequestBuilders
                 .post("/user/insertCluster")
                 .param("userName", "testName1")
                 .param("password", "password1")
                 .param("phone", "13578236975")
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());    

         String userId = action.andReturn().getResponse().getContentAsString();
         System.out.println("userId:" + userId);

         mvc.perform(MockMvcRequestBuilders
                 .delete("/user/deleteCluster")
                 .param("userId", userId)
                 .content(MediaType.APPLICATION_JSON_UTF8_VALUE)
                 .accept(MediaType.APPLICATION_JSON))
                 .andExpect(MockMvcResultMatchers.status().isOk())
                 .andDo(MockMvcResultHandlers.print());
     }
     /************************从库控制层接口测试-end******************************/
 }

十、springboot已经包含了logback的相关jar包，只要在类路径下有名为“logback-spring”的xml文件即可进行日志打印，具体配置如下

 <?xml version="1.0" encoding="UTF-8"?>
 <configuration scan="true" scanPeriod="10 seconds">
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
         <encoder>
             <!-- do not add line number output , it will slow down the execution speed -->
             <pattern>%d{HH:mm:ss.SSS} [%thread] %level %logger{36} - %msg%n</pattern>
         </encoder>
     </appender>
     <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
         <!-- 按天来回滚，如果需要按小时来回滚，则设置为{yyyy-MM-dd_HH} -->
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
             <!--文件路径和文件名称-->
             <fileNamePattern>${catalina.base}/logs/test.%d{yyyy-MM-dd}.log</fileNamePattern>
             <!-- 如果按天来回滚，则最大保存时间为1天，1天之前的都将被清理掉 -->
             <maxHistory>30</maxHistory>
         </rollingPolicy>
         <!-- 日志输出格式 -->
         <layout class="ch.qos.logback.classic.PatternLayout">
             <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} -%msg%n</Pattern>
         </layout>
     </appender>
     <!-- 异步输出 -->
     <!--输出文件-->
     <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
         <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
         <discardingThreshold>0</discardingThreshold>
         <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
         <queueSize>512</queueSize>
         <!-- 添加附加的appender,最多只能添加一个 -->
         <appender-ref ref="FILE"/>
     </appender>
     <!--输出控制台-->
     <appender name="ASYNC_STD" class="ch.qos.logback.classic.AsyncAppender">
         <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 -->
         <discardingThreshold>0</discardingThreshold>
         <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
         <queueSize>512</queueSize>
         <!-- 添加附加的appender,最多只能添加一个 -->
         <appender-ref ref="STDOUT"/>
     </appender>

     <root level="DEBUG">
         <!-- 输出到控制台 -->
            <appender-ref ref="ASYNC_STD"/>
            <!-- 输出到文件 -->
            <!-- <appender-ref ref="ASYNC"/> -->
     </root>

 </configuration>

github地址：https://github.com/1053531172/springboot2

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