004 微服务架构 SpringBoot-整合MyBatis&Druid

1.创建项目配置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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cc</groupId>
    <artifactId>springboot-mybatis-druid</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis-druid</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <fastjson.version>1.1.26</fastjson.version>
        <mybatis.version>3.4.1</mybatis.version>
        <mybatis-spring.version>1.3.0</mybatis-spring.version>
        <druid.version>1.0.24</druid.version>
        <servlet-api.version>3.1.0</servlet-api.version> 
        <fasterxml.uuid.version>3.1.4</fasterxml.uuid.version>
        <org.codehaus.jackson.version>1.9.13</org.codehaus.jackson.version>
        <github.miemiedev.version>1.2.17</github.miemiedev.version>
    </properties>

    <dependencies>
        <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>
        
        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>         
        
        <!--对json格式的支持 -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>${org.codehaus.jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>   
        <dependency>
            <groupId>com.fasterxml.uuid</groupId>
            <artifactId>java-uuid-generator</artifactId>
            <version>${fasterxml.uuid.version}</version>
        </dependency>        

        <!-- 添加JDBC jar --> 
        <dependency>
          <groupId>org.mybatis.spring.boot</groupId>
          <artifactId>mybatis-spring-boot-starter</artifactId>
          <version>1.1.1</version>
        </dependency>
        <dependency>
          <groupId>tk.mybatis</groupId><!-- 自动生成CRUD -->
          <artifactId>mapper-spring-boot-starter</artifactId>
          <version>1.1.0</version>
        </dependency>    
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- mybatis分页插件 -->
        <dependency>  
            <groupId>com.github.miemiedev</groupId>  
            <artifactId>mybatis-paginator</artifactId>  
            <version>${github.miemiedev.version}</version>  
            <exclusions>
                <exclusion>
                     <groupId>org.mybatis</groupId>
                    <artifactId>mybatis</artifactId>
                </exclusion>
            </exclusions>            
        </dependency>                    
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>    
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.创建工程目录结构：

3.配置application.properties：

server.servlet.context-path=/mybatis-druid
server.port=8001

spring.http.encoding.charset=UTF-8
spring.jackson.date-format=yyyy-MM-DD HH:mm:ss
spring.jackson.time-zone=GMT+8
#过滤空值
spring.jackson.default-property-inclusion=NON_NULL

#连接池初始化
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password==123456

#mybatis初始化
mybatis.type-aliases-package=com.cc.springbootmybatisdruid
mybatis.mapper-locations=classpath:com/cc/springbootmybatisdruid/mapping/*.xml
#tk.mybatis提供的日志输出,设置为TRACE输出轨迹
logging.level.tk.mybatis=TRACE

4. 创建druid的设置类DruidDataSourceConfig

package com.cc.springbootmybatisdruid.config.database;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter; 
/**
 * 1.@Configuration声明是个配置类，可以当做xml
 * 2.@EnableTransactionManagement启动事务声明
 *
 */
@Configuration
@EnableTransactionManagement
public class DruidDataSourceConfig {
    
    private static Logger logger = LoggerFactory.getLogger(DruidDataSourceConfig.class);
    
    //注入DruidDataSourceSettings，为运行配置提供属性
    @Autowired
    private DruidDataSourceSettings druidSettings;
    
    public static String DRIVER_CLASSNAME ;
    
    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigure(){
        return new PropertySourcesPlaceholderConfigurer();
    }    
    
    /**
     * druid监控台配置
     * druidServlet拦截器
     */
    @Bean
    public ServletRegistrationBean druidServlet() {
        
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
//        reg.setAsyncSupported(true);
        reg.addUrlMappings("/druid/*");
        reg.addInitParameter("allow", "127.0.0.1");
//        reg.addInitParameter("deny","/deny");
//        reg.addInitParameter("loginUsername", "bfxy");
//        reg.addInitParameter("loginPassword", "bfxy");
        logger.info(" druid console manager init : {} ", reg);
        return reg;
    }

    /**
     * filter拦截器
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico, /druid/*");
        logger.info(" druid filter register : {} ", filterRegistrationBean);
        return filterRegistrationBean;
    }
    /**
     * 创建druid数据源
     * @return
     * @throws SQLException
     */
    @Bean
    public DataSource dataSource() throws SQLException {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(druidSettings.getDriverClassName());
        DRIVER_CLASSNAME = druidSettings.getDriverClassName();
        ds.setUrl(druidSettings.getUrl());
        ds.setUsername(druidSettings.getUsername());
        ds.setPassword(druidSettings.getPassword());
        ds.setInitialSize(druidSettings.getInitialSize());
        ds.setMinIdle(druidSettings.getMinIdle());
        ds.setMaxActive(druidSettings.getMaxActive());
        ds.setTimeBetweenEvictionRunsMillis(druidSettings.getTimeBetweenEvictionRunsMillis());
        ds.setMinEvictableIdleTimeMillis(druidSettings.getMinEvictableIdleTimeMillis());
        ds.setValidationQuery(druidSettings.getValidationQuery());
        ds.setTestWhileIdle(druidSettings.isTestWhileIdle());
        ds.setTestOnBorrow(druidSettings.isTestOnBorrow());
        ds.setTestOnReturn(druidSettings.isTestOnReturn());
        ds.setPoolPreparedStatements(druidSettings.isPoolPreparedStatements());
        ds.setMaxPoolPreparedStatementPerConnectionSize(druidSettings.getMaxPoolPreparedStatementPerConnectionSize());
        ds.setFilters(druidSettings.getFilters());
        ds.setConnectionProperties(druidSettings.getConnectionProperties());
        logger.info(" druid datasource config : {} ", ds);
        return ds;
    }

    /**
     * 如果使用事务，就将druid数据源加入到事务中
     * @return
     * @throws Exception
     */
    @Bean
    public PlatformTransactionManager transactionManager() throws Exception {
        DataSourceTransactionManager txManager = new DataSourceTransactionManager();
        txManager.setDataSource(dataSource());
        return txManager;
    }
    
}

5.创建druid.properties补充数据源配置：

##下面为连接池的补充设置，应用到上面所有数据源中
#初始化大小，最小，最大
druid.initialSize=5
druid.minIdle=10
druid.maxActive=300
#配置获取连接等待超时的时间
druid.maxWait=60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 
druid.timeBetweenEvictionRunsMillis=60000
#配置一个连接在池中最小生存的时间，单位是毫秒
druid.minEvictableIdleTimeMillis=300000
druid.validationQuery=SELECT 1 FROM DUAL
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
#打开PSCache，并且指定每个连接上PSCache的大小
druid.poolPreparedStatements=true
druid.maxPoolPreparedStatementPerConnectionSize=20
#配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙 ,（log4j一旦加入filters就会报错，未找到原因）

#（此处大坑，springboot1X可以正常加上log4j监控，springboot2X不能用一旦使用就报错,原因在于log4j与框架自带的logback冲突，需要在pom.xml中忽略logback，然后配置log4j，此处并未修改）

#druid.filters=stat,wall,log4j
druid.filters=stat,wall,logback
#通过connectProperties属性来打开mergeSql功能；慢SQL记录
druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
#合并多个DruidDataSource的监控数据
druid.useGlobalDataSourceStat=true

 6.创建DruidDataSourceSettings：

package com.cc.springbootmybatisdruid.config.database;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.stereotype.Component;
/**
 * 1.@Component作为组件注入到spring
 * 2.@ConfigurationProperties(prefix="spring.datasource")默认以
 * spring.datasource为前缀的配置属性都要使用，默认从application.properties中找，
 * spring.datasource为前缀的，匹配后的设置属性；
 * 3.@PropertySource("classpath:druid.properties")读取druid数据源配置
 *
 */
@Component
@ConfigurationProperties(prefix="spring.datasource") 
@PropertySource("classpath:druid.properties")
public class DruidDataSourceSettings {

    /**
     * 从application.properties中匹配
     */
    private String driverClassName;  
    private String url;
    private String username;
    private String password;
    /**
     * 将druid.properties中的属性注入进来
     */
    @Value("${druid.initialSize}")
    private int initialSize;
    
    @Value("${druid.minIdle}")
    private int minIdle;
    
    @Value("${druid.maxActive}")
    private int maxActive;
    
    @Value("${druid.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;
    
    @Value("${druid.minEvictableIdleTimeMillis}")
    private long minEvictableIdleTimeMillis;
    
    @Value("${druid.validationQuery}")
    private String validationQuery;
    
    @Value("${druid.testWhileIdle}")
    private boolean testWhileIdle;
    
    @Value("${druid.testOnBorrow}")
    private boolean testOnBorrow;
    
    @Value("${druid.testOnReturn}")
    private boolean testOnReturn;
    
    @Value("${druid.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    
    @Value("${druid.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
    
    @Value("${druid.filters}")
    private String filters;
    
    @Value("${druid.connectionProperties}")
    private String connectionProperties;
    
    @Bean
    public static PropertySourcesPlaceholderConfigurer properdtyConfigure(){
        return new PropertySourcesPlaceholderConfigurer();
    }
    
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getInitialSize() {
        return initialSize;
    }
    public void setInitialSize(int initialSize) {
        this.initialSize = initialSize;
    }
    public int getMinIdle() {
        return minIdle;
    }
    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }
    public int getMaxActive() {
        return maxActive;
    }
    public void setMaxActive(int maxActive) {
        this.maxActive = maxActive;
    }
    public long getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }
    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }
    public long getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }
    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }
    public String getValidationQuery() {
        return validationQuery;
    }
    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }
    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }
    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }
    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }
    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }
    public boolean isTestOnReturn() {
        return testOnReturn;
    }
    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }
    public boolean isPoolPreparedStatements() {
        return poolPreparedStatements;
    }
    public void setPoolPreparedStatements(boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }
    public int getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }
    public void setMaxPoolPreparedStatementPerConnectionSize(
            int maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }
    public String getFilters() {
        return filters;
    }
    public void setFilters(String filters) {
        this.filters = filters;
    }
    public String getConnectionProperties() {
        return connectionProperties;
    }
    public void setConnectionProperties(String connectionProperties) {
        this.connectionProperties = connectionProperties;
    }
    
}
 

7. 创建MybatisDataSourceConfig

package com.cc.springbootmybatisdruid.config.database;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

@Configuration
public class MybatisDataSourceConfig {
    
    //注入数据源
    @Autowired
    private DataSource dataSource;
    //创建sessionFactory
    @Bean(name="sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactoryBean() throws SQLException {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);//将dataSource数据源放入sessionFactory
        // 添加mapperXML目录
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            bean.setMapperLocations(resolver.getResources("classpath:com/cc/springbootmybatisdruid/mapping/*.xml"));
            SqlSessionFactory sqlSessionFactory = bean.getObject();
            sqlSessionFactory.getConfiguration().setCacheEnabled(Boolean.TRUE);//启用缓存
            
            return sqlSessionFactory;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //为特殊查询提供SessionTemplate工具
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}
 

8.创建MybatisMapperScanerConfig

package com.cc.springbootmybatisdruid.config.database;

import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 1.mybatis扫描配置类
 * 2.@AutoConfigureAfter(MybatisDataSourceConfig.class)
 * 只有MybatisDataSourceConfig类在spring中初始化完毕后，再初始化
 * MybatisMapperScanerConfig类；
 *
 */
@Configuration
@AutoConfigureAfter(MybatisDataSourceConfig.class)
public class MybatisMapperScanerConfig {
    
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        mapperScannerConfigurer.setBasePackage("com.cc.springbootmybatisdruid.mapper");
        return mapperScannerConfigurer;
    }

}
 

9.启动验证配置：

10.使用generator：

【生成语句：java -jar mybatis-generator-core-1.3.2.jar -configfile generator.xml -overwrite】

先清空src内容，生成后会在src创建文件；配置generator.xml；

将生成完成的类copy到工程就可以了。

11.应用tk_mabatise:

-1创建BaseMapper：

package com.bfxy.springboot.config.database;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

public interface BaseMapper<T> extends Mapper<T>, MySqlMapper<T> {

}
-2修改MstDictMapper：

package com.bfxy.springboot.mapper;

import com.bfxy.springboot.entity.MstDict;
import com.github.miemiedev.mybatis.paginator.domain.PageBounds;

import java.util.List;

import org.apache.ibatis.annotations.Param;

import com.bfxy.springboot.config.database.BaseMapper;

public interface MstDictMapper extends BaseMapper<MstDict>{

    List<MstDict> findByStatus(@Param("status")String status, PageBounds pageBounds);
    
}

-3修改MstDickMapper.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.bfxy.springboot.mapper.MstDictMapper" >
  <resultMap id="BaseResultMap" type="com.bfxy.springboot.entity.MstDict" >
    <result column="id" property="id" jdbcType="VARCHAR" />
    <result column="code" property="code" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="status" property="status" jdbcType="VARCHAR" />
  </resultMap>
  <sql id="Base_Column_List">
      id,code,name,status
  </sql>
  
  <select id="findByStatus" resultMap="BaseResultMap">
      select id,code,name,status from mst_dict md
      where status = #{status,jdbcType=VARCHAR}
  </select>
  
</mapper>

-4创建一个service：

package com.bfxy.springboot.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.bfxy.springboot.entity.MstDict;
import  com.bfxy.springboot.mapper.MstDictMapper;
import com.github.miemiedev.mybatis.paginator.domain.PageBounds;

@Service
public class MstDickService {
    @Autowired
    private MstDictMapper dictMapper;
    
    //特殊查询，分页PageBounds 组件
    public List<MstDict> findByStatus(String status,int page,int limit) throws Exception {
        PageBounds pageBounds = new PageBounds(page,limit);
        return this.dictMapper.findByStatus(status,pageBounds);
    }
}

-5注意：应用tk_mybatis必须在entity类中修改：

package com.bfxy.springboot.entity;

import java.io.Serializable;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;

public class MstDict implements Serializable{
    
    private static final long serialVersionUID = -4212158978884756778L;

    /**
     * 使用tk_mybatis必须用这步
     */
    @Id
    @GeneratedValue(generator = "UUID")
    private String id;

    private String code;

    private String name;

    private String status;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code == null ? null : code.trim();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status == null ? null : status.trim();
    }
}

12.测试用例应用分页：

package com.bfxy.springboot;

import java.util.List;

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.test.context.junit4.SpringRunner;

import com.bfxy.springboot.entity.MstDict;
import com.bfxy.springboot.mapper.MstDictMapper;
import com.bfxy.springboot.service.MstDickService;

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

    @Test
    public void contextLoads() {
    }
    
    @Autowired
    private MstDictMapper mstDictMapper;
    
    @Test
    public void testInsert() throws Exception{
        MstDict md1 = new MstDict();
        md1.setCode("001");
        md1.setName("jam");
        md1.setStatus("1");
        
        MstDict md2 = new MstDict();
        md2.setCode("001");
        md2.setName("jack");
        md2.setStatus("1");
        
        MstDict md3 = new MstDict();
        md3.setCode("001");
        md3.setName("mary");
        md3.setStatus("1");
        
        MstDict md4 = new MstDict();
        md4.setCode("001");
        md4.setName("grrin");
        md4.setStatus("0");
        
        mstDictMapper.insert(md1);
        mstDictMapper.insert(md2);
        mstDictMapper.insert(md3);
        mstDictMapper.insert(md4);
    }
    
    @Autowired
    private MstDickService mstDictService;
    
    @Test
    public void testFind() throws Exception{
        List<MstDict> list = mstDictService.findByStatus("1", 1, 2);
        
        for(MstDict md : list) {
            System.out.println(md.getName());
        }
    }
}

13.应用logback打印sql：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true 
    scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
    debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。
-->
<configuration scan="true" scanPeriod="30 seconds" debug="false" >
    <!-- 每个logger都关联到logger上下文，默认上下文名称为default。但可以使用<contextName>设置成其他名字，用于区分不同应用程序的记录。一旦设置，不能修改。 -->
    <contextName>bfxy-002-springboot-mybatis-druid</contextName>
    <!-- 通过<property>定义的值会被插入到logger上下文中。定义变量后，可以使"${}"来使用变量     -->
    <property name="logback.path" value="d:/logs" />
    <property name="logback.level" value="INFO" />
    <property name="logback.additivity" value="true" />
    <!--格式化输出：%d表示日期，%t表示线程名，%-5p：级别从左显示5个字符宽度   %m：日志消息，%n是换行符--> 
    <property name="logback.pattern" value="%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p - %m%n" />    
    <!-- %d [%t] %-5p %c.%M[%L] - %m%n -->
    <!-- %d{yyyy-MM-dd HH:mm:ss} [%thread]  %-5level %logger{50} - %msg%n -->    

    <!-- 
        <appender>是<configuration>的子节点，是负责写日志的组件 
        <appender>有两个必要属性name和class。name指定appender名称，class指定appender的全限定名。
        ConsoleAppender:把日志添加到控制台，有以下子节点：
        <encoder>：对日志进行格式化。（具体参数稍后讲解 ）
        <target>：字符串  System.out 或者 System.err    默认 System.out    
    -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <charset>UTF-8</charset>
            <layout class="ch.qos.logback.classic.PatternLayout">
                  <pattern>${logback.pattern}</pattern>
            </layout>
          </encoder>
    </appender>

    <!-- 
        FileAppender:把日志添加到文件，有以下子节点
         <file>：被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值。
        <append>：如果是 true，日志被追加到文件结尾，如果是 false，清空现存文件，默认是true。
        <encoder>：对记录事件进行格式化。
        <prudent>：如果是 true，日志会被安全的写入文件，即使其他的FileAppender也在向此文件做写入操作，效率低，默认是 false。    
     -->    
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${logback.path}/bfxy-002-springboot-mybatis-druid.%d{yyyy-MM-dd}.log</FileNamePattern>
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <charset>UTF-8</charset>
            <layout class="ch.qos.logback.classic.PatternLayout">
                  <pattern>${logback.pattern}</pattern>
            </layout>
          </encoder>
    </appender>
    
    <appender name ="ANSY_FILE" class= "ch.qos.logback.classic.AsyncAppender">
        <!-- 不丢失日志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的日志 --> 
        <discardingThreshold >0</discardingThreshold>
        <!-- 更改默认的队列的深度,该值会影响性能.默认值为256 --> 
        <queueSize>256</queueSize>
        <appender-ref ref ="FILE"/>
    </appender>
    
    <logger name="org.springframework" level="INFO"/>
    <logger name="org.apache" level="ERROR"/>
    <logger name="com.bfxy.springboot.mapper" level="DEBUG"></logger>
    <logger name="java.sql" level="ERROR"/> 
       
    <!-- 
        <root> 也是<loger>元素，但是它是根loger。只有一个level属性，应为已经被命名为"root" 
        level: 用来设置打印级别，大小写无关：TRACE < DEBUG < INFO < WARN < ERROR, ALL 和 OFF，不能设置为INHERITED或者同义词NULL。 默认是DEBUG
        <loger>和<root>可以包含零个或多个<appender-ref>元素，标识这个引用的appender将会被添加到这个loger中。
    -->
    <root level="${logback.level}">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="ANSY_FILE" />
    </root>
</configuration>
结果：