基于SpringBoot、Mybatis-Generator实现数据库表自动生成全套后台代码

背景

我们在日常开发过程，大多数都是使用主流MVC架构，如下图所示。

从图中可以看出，我们主要的业务代码基本都是从Controller->Service->Dao/Mapper，由Dao/Mapper则通过Mybatis连接数据库连接池的方式与数据库进行指令数据交互。

因此，可以知道一张业务表一般可以对应上述一套后台代码，如果业务表众多就会对应多套后台代码，很明显这是重复且麻烦的代码生成工作。基于此，我们考虑能否实现一个与Ideaj代码生成工具有相似功能的工具类，根据我们定义的后台代码模板，来帮助我们个性化生成我们想要的后台代码。

技术路线

我们基于Springboot Gradle构建工程，将工程分为两部分模块。

（1）代码生成器模块：主要基于Freemarker和Velocity模板引擎，对需要的后台代码内容和风格自定义ftl模板。在Generator的主程序中连接数据库，加载模板文件，执行引擎方法，生成数据库表对应的后台代码到指定包路径中；

（2）服务发布模块：基于已生成的后台代码，使用SpringBoot进行发布，发布后通过浏览器访问，验证生成的后台代码是否满足指定业务表的增删改查（全量和分页查询）。

模块解析

（1）公共配置依赖：主要为build.gradle和application.properties配置

build.gradle：

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.1.3.RELEASE'
}

group = 'com.example.mybatis'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
tasks.withType(JavaCompile) {
    options.encoding = "utf-8"
}

repositories {
    mavenCentral()
}

configurations {
    compileOnly { //仅在编译时依赖，此处为lombok使用，相关注解在编译时生成getter、setter等
        extendsFrom annotationProcessor
    }
}

dependencies {
    compile 'com.alibaba:druid:1.2.8'
    compile 'mysql:mysql-connector-java:5.1.47'
    compile (group: 'org.mybatis.spring.boot', name: 'mybatis-spring-boot-starter', version: '1.1.1'){
        exclude group:'org.springframework.boot', module:'spring-boot-autoconfigure'
        exclude group:'org.springframework.boot', module:'spring-boot-starter-logging'
        exclude group:'org.springframework.boot', module: 'spring-boot-starter'
    }
    compile (group:'com.baomidou', name:'mybatis-plus-boot-starter', version:'3.5.1'){
        exclude group:'org.springframework.boot', module:'spring-boot-starter-jdbc'
        exclude group:'org.springframework.boot', module:'spring-boot-autoconfigure'
        exclude group:'org.springframework.boot', module: 'spring-boot-starter'
    }
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-parent', version: '2.0.7.RELEASE'
    compile group: 'org.springframework.boot', name: 'spring-boot-starter', version: '2.0.7.RELEASE'
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.0.7.RELEASE'
    compileOnly 'org.projectlombok:lombok:1.18.6'
    compile group: 'junit', name: 'junit', version: '4.12'
    compile (group:'com.github.pagehelper', name:'pagehelper-spring-boot-starter', version:'1.3.1'){
        exclude group:'org.mybatis.spring.boot', module: 'mybatis-spring-boot-starter'
        exclude group:'org.springframework.boot', module:'spring-boot-autoconfigure'
        exclude group:'org.springframework.boot', module: 'spring-boot-starter'
    }
    compile 'org.apache.commons:commons-io:1.3.2'
    compile group: 'io.springfox', name: 'springfox-swagger2', version:'2.9.2'
    compile group: 'io.springfox', name: 'springfox-swagger-ui', version:'2.9.2'
    compile('com.baomidou:mybatis-plus-generator:3.5.1')
    compile 'org.apache.velocity:velocity-engine-core:2.2'
    compile 'org.freemarker:freemarker:2.3.28'
}

application.properties：

spring.application.name=mybatis-generator-application
server.port=8080

# druid
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# druid参数调优（可选）
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
# 测试连接
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters
spring.datasource.filters=stat
# asyncInit是1.1.4中新增加的配置，如果有initialSize数量较多时，打开会加快应用启动时间
spring.datasource.asyncInit=true

#数据库配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/mysql?serverTimeZone=UTC&useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=

#分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置helperDialect 属性来指定分页插件使用哪种方言。
pagehelper.helper-dialect=mysql
#分页合理化参数，默认值为 false 。当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages （超过总数时），会查询最后一页。
pagehelper.reasonable=true
#支持通过Mapper接口参数传递page参数,默认值为falset
pagehelper.support-methods-arguments=true
#默认值为 false ，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit =0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）。
pagehelper.pageSizeZero=true
#为了支持 startPage(Object params) 方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值
pagehelper.params=count=countSql

公共包

BaseController.java：

package com.common;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class BaseController extends AbstractController {

    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
        return null;
    }

    /**

     * 响应返回结果

     * 参数result 类型可自行更换

     * 如：

     * boolean result -> return result == true ? success() : error();

     * int result -> return result > 0 ? success() : error();

     */

    protected AjaxResult toAjax(boolean result) {

        return result == true ? success() : error();

    }

    protected AjaxResult toAjax(int result) {
        return result > 0 ? success() : error();
    }

    /**

     * 返回成功

     */

    public AjaxResult success() {

        return AjaxResult.success();

    }

    /**

     * 返回失败

     */

    public AjaxResult error() {

        return AjaxResult.error();

    }

    /**

     * 返回成功消息

     */

    public AjaxResult success(String message)

    {

        return AjaxResult.success(message);

    }

    /**

     * 返回失败消息

     */

    public AjaxResult error(String message)

    {

        return AjaxResult.error(message);

    }

    /**

     * 返回错误码消息

     */

    public AjaxResult error(int code, String message)

    {

        return AjaxResult.error(code, message);

    }

}

AjaxResult.java：

package com.common;




import org.apache.commons.lang3.StringUtils;

import java.util.HashMap;

/**
 * 操作消息提醒
 *
 *
 */
public class AjaxResult extends HashMap<String, Object>
{
    private static final long serialVersionUID = 1L;

    /** 状态码 */
    public static final String CODE_TAG = "code";

    /** 返回内容 */
    public static final String MSG_TAG = "msg";

    /** 数据对象 */
    public static final String DATA_TAG = "data";

    /**
     * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
     */
    public AjaxResult()
    {
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     *
     * @param code 状态码
     * @param msg 返回内容
     */
    public AjaxResult(int code, String msg)
    {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     *
     * @param code 状态码
     * @param msg 返回内容
     * @param data 数据对象
     */
    public AjaxResult(int code, String msg, Object data)
    {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
        if (null != data)
        {
            super.put(DATA_TAG, data);
        }
    }

    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static AjaxResult success()
    {
        return AjaxResult.success("操作成功");
    }

    /**
     * 返回成功数据
     *
     * @return 成功消息
     */
    public static AjaxResult success(Object data)
    {
        return AjaxResult.success("操作成功", data);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @return 成功消息
     */
    public static AjaxResult success(String msg)
    {
        return AjaxResult.success(msg, null);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static AjaxResult success(String msg, Object data)
    {
        return new AjaxResult(HttpStatus.SUCCESS, msg, data);
    }

    /**
     * 返回错误消息
     *
     * @return
     */
    public static AjaxResult error()
    {
        return AjaxResult.error("操作失败");
    }

    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static AjaxResult error(String msg)
    {
        return AjaxResult.error(msg, null);
    }

    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static AjaxResult error(String msg, Object data)
    {
        return new AjaxResult(HttpStatus.ERROR, msg, data);
    }

    /**
     * 返回错误消息
     *
     * @param code 状态码
     * @param msg 返回内容
     * @return 警告消息
     */
    public static AjaxResult error(int code, String msg)
    {
        return new AjaxResult(code, msg, null);
    }

    /**
     * 方便链式调用
     *
     * @param key 键
     * @param value 值
     * @return 数据对象
     */
    @Override
    public AjaxResult put(String key, Object value)
    {
        super.put(key, value);
        return this;
    }
}

BaseEntity.java：

package com.common;

import java.io.Serializable;

public class BaseEntity implements Serializable {

    private int page;

    private int limit;

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public int getLimit() {
        return limit;
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    @Override
    public String toString() {
        return "BaseEntity{" +
                "page=" + page +
                ", limit=" + limit +
                '}';
    }
}

HttpStatus.java：

package com.common;

/**
 * 返回状态码
 *
 *
 */
public class HttpStatus
{
    /**
     * 操作成功
     */
    public static final int SUCCESS = 200;

    /**
     * 对象创建成功
     */
    public static final int CREATED = 201;

    /**
     * 请求已经被接受
     */
    public static final int ACCEPTED = 202;

    /**
     * 操作已经执行成功，但是没有返回数据
     */
    public static final int NO_CONTENT = 204;

    /**
     * 资源已被移除
     */
    public static final int MOVED_PERM = 301;

    /**
     * 重定向
     */
    public static final int SEE_OTHER = 303;

    /**
     * 资源没有被修改
     */
    public static final int NOT_MODIFIED = 304;

    /**
     * 参数列表错误（缺少，格式不匹配）
     */
    public static final int BAD_REQUEST = 400;

    /**
     * 未授权
     */
    public static final int UNAUTHORIZED = 401;

    /**
     * 访问受限，授权过期
     */
    public static final int FORBIDDEN = 403;

    /**
     * 资源，服务未找到
     */
    public static final int NOT_FOUND = 404;

    /**
     * 不允许的http方法
     */
    public static final int BAD_METHOD = 405;

    /**
     * 资源冲突，或者资源被锁
     */
    public static final int CONFLICT = 409;

    /**
     * 不支持的数据，媒体类型
     */
    public static final int UNSUPPORTED_TYPE = 415;

    /**
     * 系统内部错误
     */
    public static final int ERROR = 500;

    /**
     * 接口未实现
     */
    public static final int NOT_IMPLEMENTED = 501;
}

（2）代码生成器模块：该模块核心是定义ftl文件，然后主程序加载并执行模板引擎。

Generator.java

package com.generator;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.baomidou.mybatisplus.generator.fill.Column;
import com.baomidou.mybatisplus.generator.fill.Property;

import java.io.File;
import java.util.*;
/**
 * mybatis-plus
 */
public class Generator {
    //输出文件的作者注释
    public static final String auth = "test";
    //项目路径
    public static final String finalProjectPath = "F:\\workspaces4ideaj";
    //输出.java文件的根目录
    public static final String javaRootPath = "/src/main/java";
    //输出java文件的包目录
    public static final String parent = "com.test";
    //输出mapper.xml文件的包目录
    public static final String mapperPath = "/src/main/resources/mapper";
    //数据库信息
    public static final String url = "jdbc:mysql://127.0.0.1:3306/mysql?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&serverTimezone=GMT%2b8&useSSL=false";
    public static final String username = "root";
    public static final String password = "";

    public static void main(String[] args) {
        //创建生成器，连接数据库
        FastAutoGenerator.create(url, username, password)
                //全局配置
                .globalConfig(builder -> {
                    builder.author(auth)
                            //swagger模式
                            .enableSwagger()
                            //关闭覆盖已生成文件功能，解决自定义模板被覆盖问题
                            //.fileOverride()
                            .outputDir(finalProjectPath + javaRootPath) // 指定输出目录
                            .disableOpenDir();
                })
                .packageConfig((scanner, builder) ->
                        builder
                        .other("vo")
                        .pathInfo(Collections.singletonMap(OutputFile.mapperXml, finalProjectPath + mapperPath))
                        .parent(parent + "." + scanner.apply("Please enter a package name：")
                        ))
                //策略配置
                .strategyConfig((scanner, builder) -> builder.addInclude(
                   getTables(scanner.apply("Please enter a table name separated by dot, all input all: "))
                 )
                // 设置过滤表前缀
                .addTablePrefix("sys_")
                .controllerBuilder()
                .serviceBuilder()
                .mapperBuilder()
                .entityBuilder()
                .disableSerialVersionUID()
                .enableLombok() // 开启Lombok
                .enableTableFieldAnnotation()
                .addTableFills(new Column("create_time", FieldFill.INSERT))
                .addTableFills(new Property("update_time", FieldFill.INSERT_UPDATE))
                .idType(IdType.AUTO)
                .build()
                )
        // 自定义注入模
        // .vm为velocity引擎的，.ftl为freemarker引擎的
            .injectionConfig(consumer -> {
            Map<String, String> customFile = new HashMap<>();
            customFile.put("Controller.java", "/templates/ftl/controller.java.ftl");
            customFile.put("Service.java", "/templates/ftl/service.java.ftl");
            customFile.put("ServiceImpl.java", "/templates/ftl/serviceImpl.java.ftl");
            customFile.put("Mapper.java", "/templates/ftl/mapper.java.ftl");
            customFile.put(".java", "/templates/ftl/entity.java.ftl");
            customFile.put("Mapper.xml", "/templates/ftl/mapper.xml.ftl");
            customFile.put("Vo.java", "/templates/ftl/vo.java.ftl");
            consumer.customFile(customFile);
        })
            /*//自定义模板模式
                .templateConfig(builder -> {
                    //禁止所有模板
                    builder.disable(TemplateType.ENTITY);
                    builder.disable(TemplateType.XML);
                    builder.disable(TemplateType.MAPPER);
                    builder.disable(TemplateType.SERVICE);
                    builder.disable(TemplateType.SERVICEIMPL);
                    builder.disable(TemplateType.CONTROLLER);
                })
             */
        //使用Framemarker引擎模板，默认Velocity引擎模板
        .templateEngine(new EnhanceFreemarkerTemplateEngine()).execute();
    }
    //处理输入为all所有表
    protected static List<String> getTables(String tables) {
        return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));
    }
    /**
     * 代码生成器支持自定义[DTO\VO等]模版
     */
    public final static class EnhanceFreemarkerTemplateEngine extends FreemarkerTemplateEngine {
        @Override
        protected void outputCustomFile(Map<String, String> customFile, TableInfo tableInfo, Map<String, Object> objectMap) {
            String entityName = tableInfo.getEntityName();
            String otherPath = this.getPathInfo(OutputFile.other);
            String controller = this.getPathInfo(OutputFile.controller);
            String service = this.getPathInfo(OutputFile.service);
            String serviceImpl = this.getPathInfo(OutputFile.serviceImpl);
            String mapper = this.getPathInfo(OutputFile.mapper);
            String entity = this.getPathInfo(OutputFile.entity);
            String mapperXml = this.getPathInfo(OutputFile.mapperXml);
            customFile.forEach((key, value) -> {
                //指定输出文件路径
                if ("Controller.java".equals(key)) {
                    String fileName = String.format(controller + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if ("Service.java".equals(key)) {
                    String fileName = String.format(service + File.separator + "I" + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if ("ServiceImpl.java".equals(key)) {
                    String fileName = String.format(serviceImpl + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if ("Mapper.java".equals(key)) {
                    String fileName = String.format(mapper + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if (".java".equals(key)) {
                    String fileName = String.format(entity + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if ("Mapper.xml".equals(key)) {
                    String fileName = String.format(mapperXml + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                // 过滤掉非vo或dto对象自定义文件
                if ("Vo.java".equals(key)) {
                    String fileName = String.format(otherPath + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
                if ("Dto.java".equals(key)) {
                    String fileName = String.format(otherPath + File.separator + entityName + "%s", key);
                    outputFile(new File(fileName), objectMap, value);
                }
            });
        }
    }
}

src/main/resources/mybatis-generator.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>

    <!-- 本地数据库驱动程序jar包的全路径 -->
    <!--<classPathEntry location="F:\repository\mysql\mysql-connector-java\5.1.44\mysql-connector-java-5.1.44.jar"/>-->

    <context id="context" targetRuntime="MyBatis3Simple">
        <!--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"/>

        <commentGenerator>
            <!-- 是否取消注释 -->
            <property name="suppressAllComments" value="true"/>
            <!-- 是否生成注释代时间戳-->
            <property name="suppressDate" value="true"/>
        </commentGenerator>

        <!-- 数据库的相关配置 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://127.0.0.1:3306/mysql?useUnicode=true"
                        userId="root"
                        password=""/>
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <!-- 实体类生成的位置 -->
        <javaModelGenerator targetPackage="com.core" targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- *Mapper.xml 文件的位置 -->
        <sqlMapGenerator targetPackage="mapping" targetProject="src/main/resources">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!-- Mapper 接口文件的位置，注意type的值这里是熟悉的xml格式 -->
        <!--
         type：选择怎么生成mapper接口（在MyBatis3/MyBatis3Simple下）：
                1，ANNOTATEDMAPPER：会生成使用Mapper接口+Annotation的方式创建（SQL生成在annotation中），不会生成对应的XML；
                2，MIXEDMAPPER：使用混合配置，会生成Mapper接口，并适当添加合适的Annotation，但是XML会生成在XML中；
                3，XMLMAPPER：会生成Mapper接口，接口完全依赖XML；
            注意，如果context是MyBatis3Simple：只支持ANNOTATEDMAPPER和XMLMAPPER
        -->
        <javaClientGenerator targetPackage="com.core" targetProject="src/main/java" type="XMLMAPPER">
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>

        <!-- 相关表的配置 -->
        <table tableName="t_order" enableCountByExample="false" enableDeleteByExample="false"
               enableSelectByExample="false"
               enableUpdateByExample="false" selectByExampleQueryId="true"/>
    </context>
</generatorConfiguration>

src/main/resources/templates/ftl/文件

controller.java.ftl：

package ${package.Controller};
import ${package.Entity}.${entity};
import ${package.Other}.${entity}Vo;
import ${package.Service}.${table.serviceName};
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.*;
import com.common.AjaxResult;
import com.common.BaseController;
import java.util.List;
import java.util.Map;
<#if superControllerClassPackage??>
    import ${superControllerClassPackage};
</#if>
/**
* ${table.comment!} 前端控制器
* @author ${author}
* @since ${date}
*/
@Api(tags = "${table.comment!}文档")
@RestController
@RequestMapping("<#if package.ModuleName?? && package.ModuleName != "">/${package.ModuleName}</#if>/<#if controllerMappingHyphenStyle??>${controllerMappingHyphen}<#else>${table.entityPath}</#if>")
public class ${table.controllerName} extends BaseController{

   @Resource(name="${entity?lower_case}Service")
   private ${table.serviceName} ${entity?lower_case}Service;

/**
*
* 分页查詢列表
* @return page
*/
@ApiOperation(value = "分页查询列表", httpMethod = "GET", notes = "分页查询列表")
@ApiImplicitParam(paramType = "body", name = "${entity?lower_case}Vo", value = "对象", dataType = "${entity}Vo")
@ApiResponses({
@ApiResponse(code = 200, message = "响应对象", response = ${entity}.class)
})
@GetMapping("/queryListByPagging")
public AjaxResult queryListByPagging(${entity}Vo ${entity?lower_case}Vo) {
  Map<String,Object> map = ${entity?lower_case}Service.select${entity}ListByPagging(${entity?lower_case}Vo);
  return AjaxResult.success(map);
}
/**
*
* 查詢列表
* @return page
*/
@ApiOperation(value = "查询列表", httpMethod = "GET", notes = "查询列表")
@ApiImplicitParam(paramType = "body", name = "${entity?lower_case}Vo", value = "对象", dataType = "${entity}Vo")
@ApiResponses({
@ApiResponse(code = 200, message = "响应对象", response = ${entity}.class)
})
@GetMapping("/queryList")
public AjaxResult queryList(${entity}Vo ${entity?lower_case}Vo) {
  List<${entity}> list = ${entity?lower_case}Service.select${entity}List(${entity?lower_case}Vo);
  return AjaxResult.success(list);
}
/**
* 新增
*/
@ApiOperation(value = "新增", httpMethod = "POST")
@ApiImplicitParam(paramType = "body", name = "${entity?lower_case}", value = "对象", dataType = "${entity}")
@PostMapping("/insert${entity}")
public AjaxResult insert${entity}(@RequestBody ${entity} ${entity?lower_case}){
  return toAjax(${entity?lower_case}Service.insert${entity}(${entity?lower_case}));
}
/**
* 修改
*/
@ApiOperation(value = "修改", httpMethod = "POST")
@ApiImplicitParam(paramType = "body", name = "${entity?lower_case}", value = "对象", dataType = "${entity}")
@PostMapping("/update${entity}")
public AjaxResult update${entity}(@RequestBody ${entity} ${entity?lower_case}){
return toAjax(${entity?lower_case}Service.update${entity}(${entity?lower_case}));
}
/**
* 删除
*/
@ApiOperation(value = "删除", httpMethod = "POST")
@ApiImplicitParam(paramType = "query", name = "id", value = "主键id")
@PostMapping("/delete${entity}")
public AjaxResult delete${entity}(@RequestParam("id") Integer id){
return toAjax(${entity?lower_case}Service.delete${entity}(id));
}
}

service.java.ftl：

package ${package.Service};
import ${package.Entity}.${entity};
import ${package.Other}.${entity}Vo;
import ${superServiceClassPackage};
import java.util.List;
import java.util.Map;
/**
* ${table.comment!} 服务类
* @author ${author}
* @since ${date}
*/
public interface ${table.serviceName} extends ${superServiceClass}<${entity}> {
/**
* 查询${table.comment!}数量
*/
public Integer select${entity}Count(${entity}Vo ${entity?lower_case}Vo);
/**
* 查詢${table.comment!}列表
* @return page
*/
List<${entity}> select${entity}List(${entity}Vo ${entity?lower_case}Vo);
/**
* 分页查詢${table.comment!}列表
* @return page
*/
Map<String,Object> select${entity}ListByPagging(${entity}Vo ${entity?lower_case}Vo);
/**
* 新增${table.comment!}
*/
int insert${entity}(${entity} ${entity?lower_case});
/**
* 修改${table.comment!}
*/
int update${entity}(${entity} ${entity?lower_case});
/**
* 删除${table.comment!}
*/
int delete${entity}(Integer id);
}

serviceImpl.java.ftl：

package ${package.ServiceImpl};
import ${package.Entity}.${entity};
import ${package.Mapper}.${table.mapperName};
import ${package.Service}.${table.serviceName};
import ${superServiceImplClassPackage};
import ${package.Other}.${entity}Vo;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
/**
* ${table.comment!}服务实现类
* @author ${author}
* @since ${date}
*/
@Slf4j
@Service("${entity?lower_case}Service")
public class ${table.serviceImplName} extends ${superServiceImplClass}<${table.mapperName}, ${entity}> implements ${table.serviceName} {
@Autowired
private ${table.mapperName} ${entity?lower_case}Mapper;
/**
 * 查询${table.comment!}数量
 */
@Override
public Integer select${entity}Count(${entity}Vo ${entity?lower_case}Vo) {
return ${entity?lower_case}Mapper.queryCount(${entity?lower_case}Vo);
}
/**
*
* 查詢${table.comment!}列表
*
* @return page
*/
@Override
public List<${entity}> select${entity}List(${entity}Vo ${entity?lower_case}Vo) {
return ${entity?lower_case}Mapper.queryList(${entity?lower_case}Vo);
}
/**
* 分页查詢${table.comment!}列表
* @return Map<String,Object>
*/
public Map<String,Object> select${entity}ListByPagging(${entity}Vo ${entity?lower_case}Vo){
    Integer count = select${entity}Count(${entity?lower_case}Vo);
    Map<String,Object> map = new HashMap<String,Object>();
    List<${entity}> list = null;
    if(null != count && count > 0){
        PageInfo pageInfo = null;
        try {
            PageHelper.startPage(${entity?lower_case}Vo.getPage(), ${entity?lower_case}Vo.getLimit());
            list = select${entity}List(${entity?lower_case}Vo);
        }finally {
            PageHelper.clearPage();
        }
    }
    map.put("count", count);
    map.put("list", list);
    return map;
}
/**
* 新增${table.comment!}
*
* @return 结果
*/
@Override
public int insert${entity}(${entity} ${entity?lower_case}) {
return ${entity?lower_case}Mapper.insert(${entity?lower_case});
}
/**
* 修改${table.comment!}
*
* @return 结果
*/
@Override
public int update${entity}(${entity} ${entity?lower_case}) {
return ${entity?lower_case}Mapper.updateById(${entity?lower_case});
}
/**
* 删除${table.comment!}
*
* @return 结果
*/
@Override
public int delete${entity}(Integer id) {
return ${entity?lower_case}Mapper.deleteById(id);
}
}

entity.java.ftl：

package ${package.Entity};
<#list table.importPackages as pkg>
    import ${pkg};
</#list>
<#if swagger>
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
</#if>
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.io.Serializable;
/**
* ${table.comment!}
* @author ${author}
* @since ${date}
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
<#if chainModel>
    @Accessors(chain = true)
</#if>
<#if table.convert>
    @TableName("${schemaName}${table.name}")
</#if>
<#if swagger>
    @ApiModel(value = "${entity}对象", description = "${table.comment!}")
</#if>
public class ${entity} implements Serializable {
private static final long serialVersionUID = 1L;
<#-- ----------  BEGIN 字段循环遍历  ---------->
<#list table.fields as field>
    <#if field.keyFlag>
        <#assign keyPropertyName="${field.propertyName}"/>
    </#if>
    <#if field.comment!?length gt 0>
        <#if swagger>
            @ApiModelProperty("${field.comment}")
        <#else>
            /**
            * ${field.comment}
            */
        </#if>
    </#if>
    <#if field.keyFlag>
    <#-- 主键 -->
        <#if field.keyIdentityFlag>
            @TableId(value = "${field.annotationColumnName}", type = IdType.AUTO)
        <#elseif idType??>
            @TableId(value = "${field.annotationColumnName}", type = IdType.${idType})
        <#elseif field.convert>
            @TableId("${field.annotationColumnName}")
        </#if>
    <#-- 普通字段 -->
    <#elseif field.fill??>
    <#-- -----   存在字段填充设置   ----->
        <#if field.convert>
            @TableField(value = "${field.annotationColumnName}", fill = FieldFill.${field.fill})
        <#else>
            @TableField(fill = FieldFill.${field.fill})
        </#if>
    <#elseif field.convert>
        @TableField("${field.annotationColumnName}")
    </#if>
<#-- 乐观锁注解 -->
    <#if field.versionField>
        @Version
    </#if>
<#-- 逻辑删除注解 -->
    <#if field.logicDeleteField>
        @TableLogic
    </#if>
    private ${field.propertyType} ${field.propertyName};
</#list>
<#------------  END 字段循环遍历  ---------->
<#if !entityLombokModel>
    <#list table.fields as field>
        <#if field.propertyType == "boolean">
            <#assign getprefix="is"/>
        <#else>
            <#assign getprefix="get"/>
        </#if>
        public ${field.propertyType} ${getprefix}${field.capitalName}() {
        return ${field.propertyName};
        }
        <#if chainModel>
            public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
        <#else>
            public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
        </#if>
        this.${field.propertyName} = ${field.propertyName};
        <#if chainModel>
            return this;
        </#if>
        }
    </#list>
</#if>
<#if entityColumnConstant>
    <#list table.fields as field>
        public static final String ${field.name?upper_case} = "${field.name}";
    </#list>
</#if>
<#if activeRecord>
    @Override
    public Serializable pkVal() {
    <#if keyPropertyName??>
        return this.${keyPropertyName};
    <#else>
        return null;
    </#if>
    }
</#if>
<#if !entityLombokModel>
    @Override
    public String toString() {
    return "${entity}{" +
    <#list table.fields as field>
        <#if field_index==0>
            "${field.propertyName}=" + ${field.propertyName} +
        <#else>
            ", ${field.propertyName}=" + ${field.propertyName} +
        </#if>
    </#list>
    "}";
    }
</#if>
}

vo.java.ftl：

package ${package.Other};
<#list table.importPackages as pkg>
    import ${pkg};
</#list>
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import io.swagger.annotations.ApiModel;
import com.common.BaseEntity;
/**
* <p>
    *   ${table.comment!}
    * </p>
*
* @author ${author}
* @since ${date}
*/
@Data
@EqualsAndHashCode(callSuper = true)
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "${entity}对象", description = "${table.comment!}")
public class ${entity}Vo extends BaseEntity {
private static final long serialVersionUID = 1L;
<#list table.fields as field>
private ${field.propertyType} ${field.propertyName};
</#list>

@Override
public String toString() {
return "TOrderVo{" +
<#list table.fields as field>
    "${field.propertyName}=" + ${field.propertyName} + "," +
</#list>
"}";
}

}

mapper.java.ftl：

package ${package.Mapper};
import ${package.Entity}.${entity};
import ${package.Other}.${entity}Vo;
import ${superMapperClassPackage};
import java.util.List;
<#if mapperAnnotation>
    import org.apache.ibatis.annotations.Mapper;
</#if>
/**
* ${table.comment!} Mapper 接口
* @author ${author}
* @since ${date}
*/
<#if mapperAnnotation>
    @Mapper
</#if>
public interface ${table.mapperName} extends ${superMapperClass}<${entity}> {

/**
* 查詢${table.comment!}数量
* @return Integer
*/
Integer queryCount(${entity}Vo ${entity?lower_case}Vo);

/**
* 查詢${table.comment!}列表
* @return List<${entity}>
*/
List<${entity}> queryList(${entity}Vo ${entity?lower_case}Vo);
}

mapper.xml.ftl：

<?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="${package.Mapper}.${table.mapperName}">
    <#if enableCache>
        <!-- 开启二级缓存 -->
        <cache type="${cacheClassName}"/>
    </#if>

    <!-- 通用查询映射结果 -->
    <resultMap id="ResultMap" type="${package.Entity}.${entity}">
        <#list table.fields as field>
            <#if field.keyFlag><#--生成主键排在第一位-->
                <id column="${field.name}" property="${field.propertyName}" />
            </#if>
        </#list>
        <#list table.commonFields as field><#--生成公共字段 -->
            <result column="${field.name}" property="${field.propertyName}" />
        </#list>
        <#list table.fields as field>
            <#if !field.keyFlag><#--生成普通字段 -->
                <result column="${field.name}" property="${field.propertyName}" />
            </#if>
        </#list>
    </resultMap>
    <!-- 通用查询结果列 -->
    <sql id="BaseColumnList">
        <#list table.commonFields as field>
            ${field.columnName},
        </#list>
        ${table.fieldNames}
    </sql>
    <!-- 通用查询过滤列 -->
    <sql id="Base_Column_Query_List">
        <#list table.fields as field>
            <if test="${field.propertyName} != null and ${field.propertyName} != ''">
                AND ${field.name} = #${r"{"}${field.propertyName}${r"}"}
            </if>
        </#list>
        <#list table.commonFields as field><#--生成公共字段 -->
            <if test="${field.propertyName} != null and ${field.propertyName} != ''">
                AND ${field.name} = #${r"{"}${field.propertyName}${r"}"}
            </if>
        </#list>
    </sql>

    <select id="queryCount" resultType="java.lang.Integer">
        select COUNT(1)
        from ${table.name}
        <where>
            <include refid="Base_Column_Query_List"/>
        </where>
    </select>
    <select id="queryList" resultMap="ResultMap">
        select
        <include refid="BaseColumnList"/>
        from ${table.name}
        <where>
            <include refid="Base_Column_Query_List"/>
        </where>
    </select>
</mapper>

然后启动mysql服务，创建一张t_bill表，并新增4条记录。

CREATE TABLE t_bill(

bill_id INT NOT NULL AUTO_INCREMENT,

bill_title VARCHAR(100) NOT NULL,

bill_author VARCHAR(40) NOT NULL,

bill_date DATE,

PRIMARY KEY ( bill_id )

);

mysql> select * from t_bill;

+---------+------------+-------------+-----------+

+---------+------------+-------------+-----------+

+---------+------------+-------------+-----------+

4 rows in set (0.00 sec)

执行Generator工具类，输入需要创建的子包名、表名，执行结束即可看到工程中自动生成该表的后台代码：

（3）服务发布模块：该模块启动Springboot工程，将生成的后台代码发布到tomcat后通过浏览器访问。

BootApplicationl.java：

package com;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
@MapperScan(value="com.test")
public class BootApplication {
    public static void main(String[] args) {
        SpringApplication.run(BootApplication.class, args);
    }
}

然后可通过浏览器访问查询/分页查询方法服务

http://localhost:8080/t-bill/queryList

{"msg":"操作成功","code":200,"data":[{"billId":1,"billTitle":"haha","billAuthor":"test","billDate":null},{"billId":2,"billTitle":"haha","billAuthor":"test","billDate":null},{"billId":3,"billTitle":"haha","billAuthor":"test","billDate":null},{"billId":4,"billTitle":"haha55","billAuthor":"test","billDate":null}]}

http://localhost:8080/t-bill/queryListByPagging?page=1&limit=2

{"msg":"操作成功","code":200,"data":{"count":4,"list":[{"billId":1,"billTitle":"haha","billAuthor":"test","billDate":null},{"billId":2,"billTitle":"haha","billAuthor":"test","billDate":null}]}}

http://localhost:8080/t-bill/queryListByPagging?page=2&limit=2

{"msg":"操作成功","code":200,"data":{"count":4,"list":[{"billId":3,"billTitle":"haha","billAuthor":"test","billDate":null},{"billId":4,"billTitle":"haha55","billAuthor":"test","billDate":null}]}}

也可使用postman等工具测试insert，update，delete服务

http://localhost:8080/t-bill/insertTBill

{

"billId":888,

"billTitle":"888",

"billAuthor":"888",

"LocalDate":null

}

{

"msg": "操作成功",

"code": 200

}