springboot集成(tkmybatis)生成简单语句的逆向

1. pom

    <dependencies>

        <!--springboot web启动依赖包-->
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--加入lombok,注解生成Getter、Setter-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--mysql 数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>


        <!-- servlet 依赖. -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>

        <!-- JSTL-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!--通用Mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>


        <!--jdbc驱动-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

        <!--使用阿里巴巴的druid数据源，有利于监控sql的执行情况-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--添加单元测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.5.2</version>
        </dependency>


        <!--添加swagger2依赖的jar包-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.6.1</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>


        <!--引入thymeaf模版-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf</artifactId>
            <version>3.0.11.RELEASE</version>
        </dependency>

        <!--后端JSR303校验依赖包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.9.Final</version>
        </dependency>

        <!--spring Boot测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.3.RELEASE</version>
            <scope>compile</scope>
        </dependency>


    </dependencies>

    <!-- 构建节点. -->
    <build>
        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version>
                <configuration>
                    <!-- 是否覆盖，true表示会替换生成的JAVA文件，false则不覆盖 -->
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                    <configurationFile>
                        src/main/resources/generatorConfig.xml
                    </configurationFile>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>4.0.3</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

2. 配置文件

(a) application.properties

###datasource
spring.datasource.url = jdbc:mysql://152.136.27.48:3306/d_xiaokai?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
spring.datasource.username = root
spring.datasource.password = 123456
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

#SpringBoot项目解决全局响应返回中文乱码问题
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true
server.tomcat.uri-encoding=UTF-8

(b) application.yml

#指定端口号
server:
  port: 8001

##配置mmysql数据源
spring:
  datasource:
#    url: jdbc:mysql://152.136.27.48:3306/d_xiaokai?serverTimezone=GMT%2B8
#    username: root
#    password: 123456
#    driver-class-name: com.mysql.jdbc.Driver

    #配置数据连接池
    type: com.alibaba.druid.pool.DruidDataSource
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: true
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500



#配置MYBATIS
mybatis:
  #指定映射文件的位置
  mapper-locations: classpath:mapper/*.xml
  #指定实体类包的位置
  type-aliases-package: com.tina.springboot.springboot.entity
  configuration:
    map-underscore-to-camel-case: true #下划线转驼峰


#配置分页插件
pagehelper:
  helperDialect: mysql
  reasonable: true #跳转分页合理化参数
  supportMethodsArguments: true
  params: count=countSql

#打印sql
logging:
  level:
    com.tina.springboot.springboot.mapper : debug

(c)generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

    <!--系统全局配置文件-->

    <!--指定数据源的位置-->
    <properties resource="application.properties" />

    <!-- 数据库驱动:mysql数据库驱动包路径 -->
    <classPathEntry location="/Users/lvxiaokai/Desktop/tina/apache-maven-3.6.3/repository/mysql/mysql-connector-java/5.1.47/mysql-connector-java-5.1.47.jar"/>

    <!--context：代码生成规则配置的上下文
            id:标识
            targetRuntime: MyBatis3Simple 只会生成基本的CRUD操作-->
    <context id="Mysql" targetRuntime="MyBatis3Simple"  defaultModelType="flat">

        <!-- 生成的Java文件的编码 -->
        <property name="javaFileEncoding" value="UTF-8"/>
        <!-- 格式化java代码 -->
        <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
        <!-- 格式化XML代码 -->
        <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
        <!-- beginningDelimiter和endingDelimiter：
        指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； -->
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>

        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
            <property name="caseSensitive" value="true"/>
            <!--集成lombok-->
            <property name="lombok" value="Getter,Setter,ToString"/>
        </plugin>

        <!-- 生成的实体Bean,将实现Serializable -->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"></plugin>

        <!--commentGenerator：注释生成策略-->
        <commentGenerator>
            <!--suppressDate:是否阻止时间戳生成--><!-- 如果生成日期，会造成即使修改一个字段，整个实体类所有属性都会发生变化，不利于版本控制，所以设置为true -->
            <property name="suppressDate" value="true"/>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
             <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!--数据库链接URL，用户名、密码 -->
        <jdbcConnection driverClass="${spring.datasource.driverClassName}"
                        connectionURL="${spring.datasource.url}"
                        userId="${spring.datasource.username}"
                        password="${spring.datasource.password}">
        </jdbcConnection>

        <!-- 类型转换 -->
        <javaTypeResolver >
            <!-- 是否使用bigDecimal,
                false: 把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer(默认)
                true:  把JDBC DECIMAL 和 NUMERIC 类型解析为java.math.BigDecimal
            -->
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!--domain生成策略；targetPackage：生成到哪个包下面，targetProject：生成到哪个项目目录下面-->
        <javaModelGenerator targetPackage="com.tina.springboot.springboot.entity" targetProject="src/main/java">
            <!-- 默认false 是否允许子包 -->
            <property name="enableSubPackages" value="true" />
            <!-- 默认false 是否对model添加 构造函数 -->
            <property name="constructorBased" value="false"/>
            <!-- 默认false 建立的Model对象是否不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="true"/>
            <!--表示是否修剪字符串（去掉空格--><!-- 默认false 是否对类CHAR类型的列的数据进行trim操作 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!--sqlMapGenerator：映射文件生成策略
              targetPackage:生成到哪个包下面，targetProject：生成到哪个项目目录下面
       -->
        <sqlMapGenerator targetPackage="mapper"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <!--mapper接口生成策略
                   type:ANNOTATEDMAPPER:注解的形式
                        XMLMAPPER：xml映射的形式-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.tina.springboot.springboot.mapper" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>


        <!-- 指定要生成代码的表  domainObjectName：设置表对应的domain实体类生成的名称
                    tableName是数据库中的表名或视图名 -->
        <table tableName="t_depart"
               domainObjectName="Depart"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false">
        </table>
        <table tableName="t_employee"
               domainObjectName="Employee"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false">
        </table>

    </context>
</generatorConfiguration>

3. 实体类

Depart

package com.tina.springboot.springboot.entity;

import lombok.Data;

import java.io.Serializable;
import javax.persistence.*;

@Table(name = "t_depart")
@Data
public class Depart implements Serializable {
    @Id
    @Column(name = "dep_id")
    private String depId;

    @Column(name = "dep_name")
    private String depName;

    /**
     * 是否删除 删除为0 ，不删除为1， 默认为1 
     */
    @Column(name = "del_flag")
    private String delFlag;

    public Depart(String depId, String depName, String delFlag) {
        this.depId = depId;
        this.depName = depName;
        this.delFlag = delFlag;
    }

    public Depart() {
    }
}

Employee

package com.tina.springboot.springboot.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;

@Table(name = "t_employee")
@Data
public class Employee implements Serializable {
    @Id
    @Column(name = "emp_id")
    private String empId;

    @Column(name = "emp_name")
    private String empName;

    private String gender;

    private String email;

    @Column(name = "create_time")
    private String createTime;

    @Column(name = "dep_id")
    private String depId;

    /**
     * 是否删除 0是删除 1 是不删除 默认是1
     */
    @Column(name = "del_flag")
    private String delFlag;


    public Employee(String empId, String empName, String gender, String email, String createTime, String depId, String delFlag) {
        this.empId = empId;
        this.empName = empName;
        this.gender = gender;
        this.email = email;
        this.createTime = createTime;
        this.depId = depId;
        this.delFlag = delFlag;
    }

    public Employee() {
    }
}

4. dao

package com.tina.springboot.springboot.mapper;

import com.tina.springboot.springboot.entity.Depart;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface DepartMapper extends Mapper<Depart> {
    List<Depart> selectDepExceptDel();
}

package com.tina.springboot.springboot.mapper;

import com.tina.springboot.springboot.entity.Employee;
import com.tina.springboot.springboot.resp.EmployeeResp;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface EmployeeMapper extends Mapper<Employee> {
    List<EmployeeResp> selectEmpsWithDep();

    EmployeeResp selectEmpById(String empId);
}

5. service

package com.tina.springboot.springboot.service.Impl;

import com.tina.springboot.springboot.entity.Depart;
import com.tina.springboot.springboot.entity.Employee;
import com.tina.springboot.springboot.exception.Code;
import com.tina.springboot.springboot.exception.EntityResp;
import com.tina.springboot.springboot.mapper.DepartMapper;
import com.tina.springboot.springboot.mapper.EmployeeMapper;
import com.tina.springboot.springboot.resp.EmployeeResp;
import com.tina.springboot.springboot.service.EmployeeService;
import com.tina.springboot.springboot.utils.CreatedTime;
import org.junit.Assert;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;

/**
 * @program: springboot-mybatis-plugins
 * @description
 * @author: tina.liu
 * @create: 2020-02-03 17:55
 **/
@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Resource
    private EmployeeMapper employeeMapper;

    @Resource
    private DepartMapper departMapper;

    @Override////根据查询员工的信息和部门
    public List<EmployeeResp> selectEmpsWithDep() {
        List<EmployeeResp> employeeRespList = employeeMapper.selectEmpsWithDep();
        return employeeRespList;
    }

    @Override////根据id查询员工的信息及所属的部门
    public EntityResp<EmployeeResp> selectEmpById(String empId) {
        EmployeeResp employeeResp = employeeMapper.selectEmpById(empId);
        // 添加所有部分
        List<Depart> departs = this.departMapper.selectDepExceptDel();
        employeeResp.setDepartList(departs);
        return new EntityResp<>(employeeResp, Code.SERVER_SUCCESS);
    }

    @Override//// 根据id删除员工的信息
    public EntityResp<Object> deleteEmpById(String empId) {
        Employee employee = new Employee();
        employee.setEmpId(empId);
        employee.setDelFlag("0");
        int effected = employeeMapper.updateByPrimaryKeySelective(employee);
        return new EntityResp<>(effected, Code.SERVER_SUCCESS);
    }

    @Override //修改员工信息及部门信息 并添加valid进行校验
    public EntityResp<Object> updateEmp(Employee employee) {
        //对邮箱的唯一性进行校验
        Employee empCheck = new Employee();
        empCheck.setEmail(employee.getEmail());
        //Employee empResult = employeeMapper.selectOne(empCheck);
        if (StringUtils.isEmpty(employeeMapper.selectOne(empCheck))) {
            employee.setCreateTime(CreatedTime.getTime());
            //int effected = employeeMapper.updateByPrimaryKeySelective(employee);
            Assert.assertEquals(1,employeeMapper.updateByPrimaryKeySelective(employee));
            return new EntityResp<>("修改信息成功！", Code.SERVER_SUCCESS);
        } else {
            return new EntityResp<>(employee.getEmail() + "已存在系统不能重复添加", Code.SERVER_OTHER_ERROR);
        }
    }


    @Override// 添加员工//注解@Valid 对参数进行校验
    public EntityResp<Object> addEmp(Employee employee) {
        //分别对象对前台传来的数据姓名和邮箱进行校验：
        Employee empCheck1 = new Employee();
        empCheck1.setEmpName(employee.getEmpName());
        if (!StringUtils.isEmpty(employeeMapper.selectOne(empCheck1))) {
            //如果存在数据库
            return new EntityResp<>(employee.getEmpName() + "已存在数据库，不能重复添加", Code.SERVER_OTHER_ERROR);
        }
        //////
        Employee empcheck2 = new Employee();
        empcheck2.setEmail(employee.getEmail());
        if (!StringUtils.isEmpty(employeeMapper.selectOne(empcheck2))) {
            //如果存在数据库
            return new EntityResp<>(employee.getEmail() + "已存在数据库，不能重复添加", Code.SERVER_OTHER_ERROR);
        }
        //执行修改的操作String empId, String empName, String gender, String email, String createTime, String depId, String delFlag
        String empId = UUID.randomUUID().toString().substring(0, 5);
        Employee empAdd = new Employee(empId, employee.getEmpName(), employee.getGender(), employee.getEmail(), CreatedTime.getTime(), employee.getDepId(), "1");
       // int effected = employeeMapper.insertSelective(empAdd);
        Assert.assertEquals(1, employeeMapper.insertSelective(empAdd));
        return new EntityResp<>("添加成功",Code.SERVER_SUCCESS);

    }

    @Override//根据ID数组批量删除用户
    public EntityResp<Object> deleteEmpByIds(List<String> empIds) {
        for (String empId : empIds) {
            Employee employee = new Employee();
            employee.setEmpId(empId);
            employee.setDelFlag("0");
            int effected = employeeMapper.updateByPrimaryKeySelective(employee);
        }
        return new EntityResp<>("批量删除成功", Code.SERVER_SUCCESS);
    }


}//类的大括号

package com.tina.springboot.springboot.service.Impl;
import com.tina.springboot.springboot.entity.Depart;
import com.tina.springboot.springboot.exception.Code;
import com.tina.springboot.springboot.exception.EntityResp;
import com.tina.springboot.springboot.mapper.DepartMapper;
import com.tina.springboot.springboot.req.DepartReq;
import com.tina.springboot.springboot.req.UpdateDepartReq;
import com.tina.springboot.springboot.service.DepartService;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;

/**
 * @program: springboot-mybatis-plugins
 * @description
 * @author: tina.liu
 * @create: 2020-02-03 18:35
 **/
@Service
public class DepartServiceImpl implements DepartService {

    @Resource
    private DepartMapper departMapper;

    @Override
    public void insert(Depart depart) {
        departMapper.insertSelective(depart);
    }

    @Override
    public Depart selectById(String s) {
        return  departMapper.selectByPrimaryKey(s);
    }

    @Override////查询员工表中所有的部门
    public EntityResp<Object> selectDepName() {
        List<Depart> departs = departMapper.selectDepExceptDel();
       return new EntityResp<>(departs, Code.SERVER_SUCCESS);
    }

    @Override////根据ID删除部门表中的部门
    public EntityResp<Object> deleteDepById(String depId) {
        int effected = departMapper.deleteByPrimaryKey(depId);
        return new EntityResp<>(effected,Code.SERVER_SUCCESS);
    }

    @Override//新增部门表的信息
    public EntityResp<Object> AddDepart(DepartReq req) {
        Depart depart = new Depart();
        String depId= UUID.randomUUID().toString().substring(0, 5);
        depart.setDepId(depId);
        depart.setDelFlag("1");
        depart.setDepName(req.getDepName());
        int effected  = departMapper.insertSelective(depart);
        return new EntityResp<>(effected,Code.SERVER_SUCCESS);
    }

    @Override////修改部门表中的部门名
    public EntityResp<Object> updateDepName(UpdateDepartReq depName) {
        Depart depart = new Depart();
        BeanUtils.copyProperties(depName,depart);
        int effected= departMapper.updateByPrimaryKeySelective(depart);
        return new EntityResp<>(effected,Code.SERVER_SUCCESS);
    }

}//类的大括号

5, 自动生成的映射文件

<?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.tina.springboot.springboot.mapper.DepartMapper">
  <resultMap id="BaseResultMap" type="com.tina.springboot.springboot.entity.Depart">
    <!--
      WARNING - @mbg.generated
    -->
    <constructor>
      <idArg column="dep_id" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="dep_name" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="del_flag" javaType="java.lang.String" jdbcType="VARCHAR" />
    </constructor>
  </resultMap>


  <!--查询没有删除的所有部门表中的信息-->
  <select id="selectDepExceptDel" resultType="com.tina.springboot.springboot.entity.Depart">
    select
      td.dep_id,
      td.dep_name,
      td.del_flag
    from t_depart as td where td.del_flag = "1"
  </select>
</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.tina.springboot.springboot.mapper.EmployeeMapper">
  <resultMap id="BaseResultMap" type="com.tina.springboot.springboot.entity.Employee">
    <!--
      WARNING - @mbg.generated
    -->
    <constructor>
      <idArg column="emp_id" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="emp_name" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="gender" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="email" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="create_time" javaType="java.util.Date" jdbcType="TIMESTAMP" />
      <arg column="dep_id" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="del_flag" javaType="java.lang.String" jdbcType="VARCHAR" />
    </constructor>
  </resultMap>


  <!--/根据查询员工的信息和部门-->
  <select id="selectEmpsWithDep" resultType="com.tina.springboot.springboot.resp.EmployeeResp">
      SELECT
            te.emp_id,
            te.emp_name,
            te.gender,
            te.email,
            te.create_time,
            td.dep_id,
            td.dep_name
        FROM
            t_employee AS te
                LEFT JOIN
            t_depart AS td ON te.dep_id = td.dep_id
        WHERE
            te.del_flag = '1' AND td.del_flag = '1'
        ORDER BY te.create_time DESC
  </select>


  <!--根据id查询员工的信息及所属的部门-->
  <select id="selectEmpById" parameterType="java.lang.String" resultType="com.tina.springboot.springboot.resp.EmployeeResp">
    SELECT
        te.emp_id,
        te.emp_name,
        te.gender,
        te.email,
        te.create_time,
        td.dep_id,
        td.dep_name
    FROM
        t_employee AS te
            LEFT JOIN
        t_depart AS td ON te.dep_id = td.dep_id
    WHERE
        te.del_flag = '1' AND td.del_flag = '1'
        and te.emp_id = #{te.emp_id}
  </select>


</mapper>

6. controller

package com.tina.springboot.springboot.controller;
        import com.github.pagehelper.PageHelper;
        import com.github.pagehelper.PageInfo;
        import com.tina.springboot.springboot.entity.Employee;
        import com.tina.springboot.springboot.exception.Code;
        import com.tina.springboot.springboot.exception.EntityResp;
        import com.tina.springboot.springboot.req.DeleteReq;
        import com.tina.springboot.springboot.resp.EmployeeResp;
        import com.tina.springboot.springboot.service.EmployeeService;
        import io.swagger.annotations.Api;
        import io.swagger.annotations.ApiOperation;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.validation.BindingResult;
        import org.springframework.web.bind.annotation.*;
        import javax.validation.Valid;
        import java.util.List;

/**
 * @program: springboot-mybatis-plugins
 * @description
 * @author: tina.liu
 * @create: 2020-02-03 17:56
 **/
@RestController
@Api(value = "Employee模块")
@RequestMapping("/test")
@CrossOrigin
@tk.mybatis.spring.annotation.MapperScan(basePackages= "com.tina.springboot.springboot.mapper") //扫秒指定位置的mapper接口
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    //批量删除员工的信息
    @PostMapping(value = "deleteEmpByIds")
    @ApiOperation(value = "批量删除员工的信息")
    public EntityResp<Object> deleteEmpByIds(@RequestBody DeleteReq req){
        return employeeService.deleteEmpByIds(req.getIds());
    }

    // 添加员工 //对邮箱进行校验,有效方可以数据方可以储存，后台数据库会对邮箱的唯一性自动校验
    @PostMapping(value = "/addEmp")
    @ApiOperation(value = "添加员工")
    public EntityResp<Object> addEmp(@Valid @RequestBody Employee employee,
                                     BindingResult bindingResult){
        if(bindingResult.hasErrors()){
            return new EntityResp<>("邮箱进行JSR303校验失败", Code.SERVER_OTHER_ERROR);
        }else {
            return employeeService.addEmp(employee);
        }
    }

    ////修改员工信息及部门信息 并添加valid进行校验
    @PutMapping(value = "/updateEmp")
    @ApiOperation(value = "//修改员工信息及部门信息")
    public EntityResp<Object> updateEmp(@Valid @RequestBody Employee employee,
                                        BindingResult bindingResult){
        if(bindingResult.hasErrors()){
            return new EntityResp<>("对邮箱进行JSR303校验失败",Code.SERVER_OTHER_ERROR);
        }else{
            return  employeeService.updateEmp(employee);
        }
    }

    //查询员工的信息和部门
    @GetMapping(value = "/selectEmpsWithDep")
    @ApiOperation(value = "查询员工的信息和部门")
    public EntityResp<PageInfo<EmployeeResp>>  selectEmpsWithDep(@RequestParam(value = "pages",defaultValue = "1") Integer pages,
                                                                 @RequestParam(value ="rows",defaultValue = "5") Integer rows){
        //将当前页码和每页数量传入进入
        PageHelper.startPage(pages,rows);
        List<EmployeeResp> employeeRespList = employeeService.selectEmpsWithDep();
        //将数据库返回的数据封装到分页插件中去
        PageInfo<EmployeeResp> employeeRespPageInfo = new PageInfo<>(employeeRespList,5);
        return new EntityResp<PageInfo<EmployeeResp>>(employeeRespPageInfo, Code.SERVER_SUCCESS);
    }

    //根据id查询员工的信息及所属的部门
    @GetMapping(value = "/selectEmpById/{empId}")
    @ApiOperation(value = "根据id查询员工的信息及所属的部门")
    public EntityResp<EmployeeResp> selectEmpById(@PathVariable(value = "empId") String empId){
        return employeeService.selectEmpById(empId);
    }

    // 根据id删除员工的信息
    @DeleteMapping(value = "/deleteEmpById/{empId}")
    @ApiOperation(value = "根据id删除员工的信息")
    public EntityResp<Object> deleteEmpById(@PathVariable(value = "empId") String empId){
        return employeeService.deleteEmpById(empId);
    }


}//类的大括号

package com.tina.springboot.springboot.controller;
import com.tina.springboot.springboot.exception.EntityResp;
import com.tina.springboot.springboot.req.DepartReq;
import com.tina.springboot.springboot.req.UpdateDepartReq;
import com.tina.springboot.springboot.service.DepartService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import tk.mybatis.spring.annotation.MapperScan;

/**
 * @program: springboot-mybatis-plugins
 * @description
 * @author: tina.liu
 * @create: 2020-02-03 18:36
 **/
@Controller
@ResponseBody
@CrossOrigin
@MapperScan(basePackages= "com.tina.springboot.springboot.mapper") //扫秒指定位置的mapper接口
public class DepartController {

    @Autowired
    private DepartService departService;

    //查询员工表中所有的部门
    @GetMapping(value = "/selectDepName")
    @ApiOperation(value = "查询员工表中所有的部门")
    public EntityResp<Object> selectDepName(){
        return  departService.selectDepName();
    }

    //根据ID删除部门表中的部门
    @DeleteMapping(value = "/deleteDepById/{depId}")
    @ApiOperation(value = "根据ID删除部门表中的部门")
    public EntityResp<Object> deleteDepById(@PathVariable(value = "depId") String depId){
        return  departService.deleteDepById(depId);
    }

    //新增部门表的信息
    @PostMapping(value = "/AddDepart")
    @ApiOperation(value = "新增部门表的信息")
    public EntityResp<Object> AddDepart(@RequestBody DepartReq req ){
        return  departService.AddDepart(req);
    }

    //修改部门表中的部门名
    @PutMapping(value = "/updateDepName")
    @ApiOperation(value = "修改部门表中的部门名")
    public EntityResp<Object> updateDepName(@RequestBody UpdateDepartReq req){
        return  departService.updateDepName(req);
    }

}//类的大括号

7. 测试类

(a)config

@Configuration
public class getSqlSession {
    @Autowired
    private  SqlSessionFactory sqlSessionFactory;
    @Autowired
    SqlSession sqlSession;
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(){
        return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
    }
}

（b） test

@MapperScan(basePackages = "com.tina.springboot.springboot.mapper") //扫秒指定位置的mapper接口
@RunWith(SpringJUnit4ClassRunner.class) //junit单元测试
@SpringBootTest(classes = SpringbootMybatisPluginsApplication.class) //指定启动类
public class TestDepart {

    @Autowired
    private DepartService departService;

    @Autowired
    private DepartMapper departMapper;


    @Autowired
    SqlSession sqlSession;

    @Test
    public void test1() {
        EmployeeMapper employeeMapper = (EmployeeMapper) sqlSession.getMapper(EmployeeMapper.class);

        for (int i = 0; i < 10; i++) {
            String id = UUID.randomUUID().toString().substring(0, 8);
            Employee employee = new Employee(id, id + "bobo", "男", id + "@qq.com", CreatedTime.getTime(), "2", "1");
            employeeMapper.insertSelective(employee);
        }
        System.out.println("添加完成");
    }



    //测试Depart的通用Mapper的方法
    @Test
    public void TEST() {
        List<Depart> departs = departMapper.selectAll();
        System.out.println("depart 查询所有的结果集合为" + ":" + departs);

        Depart depart = departMapper.selectByPrimaryKey("1");
        System.out.println("depart的结果为" + ":" + depart);
    }


    @Test
    public void test2() {
        Depart depart = new Depart();
        depart.setDepId("1");
        Depart result = departMapper.selectOne(depart);
        System.out.println("查询的结果为：" + result);
    }


    @Test
    public void test3() {
        List<Depart> departLists = departMapper.selectDepExceptDel();
        System.out.println("查询的结果为：" + departLists);
    }


}//类的大括号