基于mybatis-plus自动生成代码完善

最新推荐文章于 2024-07-23 08:26:35 发布

点击抽奖

最新推荐文章于 2024-07-23 08:26:35 发布

阅读量375

点赞数

分类专栏： java 文章标签： mybatis-plus 代码生成

本文链接：https://blog.csdn.net/a249040113/article/details/109384525

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

mybatis-plus自动生成代码

基于mybatis-plus改造完善出来的代码生成工具

项目依赖

<?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">
    <parent>
        <groupId>com.wmang.generator</groupId>
        <artifactId>generator-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>generator-gencode</artifactId>
    <version>1.1.0</version>

    <dependencies>

        <dependency>
            <groupId>com.wmang.gen</groupId>
            <artifactId>gen-common</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!-- 字符串操作工具类-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!-- mariadb驱动 -->
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!-- mybatis-plus代码生成 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- mybatis-plus代码生成模板 -->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.29</version>
        </dependency>

        <!-- 自动生成代码,减少代码量 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!-- 主要用于运行日志 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>

        <!-- logback -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.7</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.7</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-access</artifactId>
            <version>1.1.7</version>
        </dependency>
        <!-- 主要用于运行日志 -->


    </dependencies>


    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

生成代码逻辑处理

package com.wmang.generator.code;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.wmang.generator.convert.CustMysqlTypeConvert;
import com.wmang.generator.dto.GenCodeGeneratorDto;
import com.wmang.gen.common.base.BaseEntity;
import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GenCodeGenerator {

    private static final String SRCJAVA_URL = File.separator + "src" + File.separator + "main" + File.separator + "java";
    private static final String RESOURCE_URL = File.separator + "src" + File.separator + "main" + File.separator + "resources";


    public void build(GenCodeGeneratorDto genCodeGeneratorDto) {

        // 代码生成器
        AutoGenerator autoGenerator = new AutoGenerator();

        // 包配置
        PackageConfig packageConfig = initPackageConfig(genCodeGeneratorDto);
        // 自定义配置
        InjectionConfig injectionConfig = initInjectionConfig(genCodeGeneratorDto);
        // 自定义模板配置
        List<FileOutConfig> focList = loadFileOutConfig(RESOURCE_URL, SRCJAVA_URL, genCodeGeneratorDto, packageConfig);
        injectionConfig.setFileOutConfigList(focList);
        // 全局配置
        GlobalConfig globalConfig = initGlobalConfig(genCodeGeneratorDto);
        // 策略配置
        StrategyConfig strategyConfig = initStrategyConfig(genCodeGeneratorDto);
        // 数据源配置
        DataSourceConfig dataSourceConfig = initDataSourceConfig(genCodeGeneratorDto);
        // 模板配置
        TemplateConfig templateConfig = initTemplateConfig(genCodeGeneratorDto);

        autoGenerator.setCfg(injectionConfig);
        autoGenerator.setGlobalConfig(globalConfig);    
        autoGenerator.setPackageInfo(packageConfig);
        autoGenerator.setDataSource(dataSourceConfig);
        autoGenerator.setStrategy(strategyConfig);
        autoGenerator.setTemplate(templateConfig);
        autoGenerator.setTemplateEngine(new FreemarkerTemplateEngine());
        autoGenerator.execute();

    }

    /**
     * 初始化模板配置
     *
     * @param genCodeGeneratorDto
     */
    private TemplateConfig initTemplateConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        TemplateConfig templateConfig = new TemplateConfig();
        // 配置Controller模板
        templateConfig.setController("/tmpl/controller.java");
        templateConfig.setXml(null);
        return templateConfig;
    }

    /**
     * 初始化包配置
     *
     * @param genCodeGeneratorDto
     */
    private PackageConfig initPackageConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        PackageConfig packageConfig = new PackageConfig();
        // 包路径
        packageConfig.setParent(genCodeGeneratorDto.getBasePackage());
        // entity路径
        packageConfig.setEntity("domain.entity");
        return packageConfig;
    }

    /**
     * 初始化数据源配置
     *
     * @param genCodeGeneratorDto
     */
    private DataSourceConfig initDataSourceConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig.setUrl(genCodeGeneratorDto.getJdbcUrl());
        dataSourceConfig.setDriverName(genCodeGeneratorDto.getJdbcDriverName());
        dataSourceConfig.setUsername(genCodeGeneratorDto.getJdbcUserName());
        dataSourceConfig.setPassword(genCodeGeneratorDto.getJdbcPassWord());
        dataSourceConfig.setTypeConvert(new CustMysqlTypeConvert());
        return dataSourceConfig;
    }

    /**
     * 初始化全局配置
     *
     * @param genCodeGeneratorDto
     */
    private GlobalConfig initGlobalConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        GlobalConfig globalConfig = new GlobalConfig();
        // 是否覆盖源文件
        globalConfig.setFileOverride(genCodeGeneratorDto.getFileOverride());
        // 文件输出路径
        globalConfig.setOutputDir(genCodeGeneratorDto.getBasePath() + SRCJAVA_URL);
        // 作者
        globalConfig.setAuthor(genCodeGeneratorDto.getAuthor());
        // xml生成columList
        globalConfig.setBaseColumnList(true);
        // xml生成baseResultMap
        globalConfig.setBaseResultMap(true);
        // xml是否启用缓存
        globalConfig.setEnableCache(false);

        globalConfig.setOpen(false);
        // 开启Swagger2
        globalConfig.setSwagger2(true);
        // 主键类型自增
        globalConfig.setIdType(IdType.AUTO);
        return globalConfig;
    }

    /**
     * 初始化策略配置
     *
     * @param genCodeGeneratorDto
     */
    private StrategyConfig initStrategyConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        StrategyConfig strategyConfig = new StrategyConfig();
        // 文件名-驼峰
        strategyConfig.setNaming(NamingStrategy.underline_to_camel);
        // 字段名-驼峰
        strategyConfig.setColumnNaming(NamingStrategy.underline_to_camel);
        // 是否rest风格.默认rest
        strategyConfig.setRestControllerStyle(true);
        // 是否生成实体 常量 字段名
        strategyConfig.setEntityColumnConstant(true);
        // entity生成lombok模式
        strategyConfig.setEntityLombokModel(true);
        // entity生成注释
        strategyConfig.setEntityTableFieldAnnotationEnable(true);
        // entity继承父类 子类将不再生成id字段
        strategyConfig.setSuperEntityClass(BaseEntity.class);
        // 生成序列化id
        strategyConfig.setEntitySerialVersionUID(false);
        if (StringUtils.isNotBlank(genCodeGeneratorDto.getTablePrefix())) {
            // 过滤表前缀
            strategyConfig.setTablePrefix(genCodeGeneratorDto.getTablePrefix() + "_");
        }
        // 生成表
        strategyConfig.setInclude(genCodeGeneratorDto.getTables().split(","));
        // 不生成的公共字段，在父类已定义
        strategyConfig.setSuperEntityColumns("id", "delete_flag", "lock_version", "created_by", "created_at", "updated_by", "updated_at");
        return strategyConfig;
    }

    /**
     * 自定义配置
     *
     * @param genCodeGeneratorDto
     * @return
     */
    private InjectionConfig initInjectionConfig(GenCodeGeneratorDto genCodeGeneratorDto) {
        InjectionConfig injectionConfig = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
                Map<String, Object> map = new HashMap<>();
                map.put("superDtoClass", "BaseDto");
                map.put("superDtoClassPkg", "com.wmang.gen.common.base.BaseDto");
                map.put("dtoClassPkg", genCodeGeneratorDto.getBasePackage() + ".domain.dto");
                map.put("superParamClass", "BaseParam");
                map.put("superParamClassPkg", "com.wmang.gen.common.base.BaseParam");
                map.put("paramClassPkg", genCodeGeneratorDto.getBasePackage() + ".domain.param");
                super.setMap(map);
            }
        };
        return injectionConfig;
    }

    /**
     * 自定义魔板输出配置
     *
     * @param resourcePath
     * @param genCodeGeneratorDto
     * @return
     */
    private List<FileOutConfig> loadFileOutConfig(String resourcePath, String srcJavaPath, GenCodeGeneratorDto genCodeGeneratorDto, PackageConfig packageConfig) {

        /**
         *  自定义mapper xml文件模板生成
         */
        String mapperTemplatePath = "/templates/mapper.xml.ftl";
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(mapperTemplatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return genCodeGeneratorDto.getBasePath() + File.separator + resourcePath + File.separator + "mapper" + File.separator + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });

        /**
         *  自定义entity文件模板生成
         */
        String entityTemplatePath = "/templates/entity.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(entityTemplatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                String fileName = tableInfo.getEntityName() + StringPool.DOT_JAVA;
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return genCodeGeneratorDto.getBasePath() + File.separator + srcJavaPath + File.separator + genCodeGeneratorDto.getBasePackagePath() + File.separator + "domain" + File.separator + "entity" + File.separator + fileName;
            }
        });


        /**
         *  dto模板生成
         */
        String dtoTemplatePath = "/tmpl/dto.java.ftl";
        focList.add(new FileOutConfig(dtoTemplatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                String fileName = tableInfo.getEntityName() + "Dto" + StringPool.DOT_JAVA;
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 dto 的名称会跟着发生变化！！
                return genCodeGeneratorDto.getBasePath() + File.separator + srcJavaPath + File.separator + genCodeGeneratorDto.getBasePackagePath() + File.separator + "domain" + File.separator + "dto" + File.separator + fileName;
            }
        });


        /**
         *  param模板生成
         */
        String paramTemplatePath = "/tmpl/param.java.ftl";
        focList.add(new FileOutConfig(paramTemplatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                String fileName = tableInfo.getEntityName() + "Param" + StringPool.DOT_JAVA;
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 param 的名称会跟着发生变化！！
                return genCodeGeneratorDto.getBasePath() + File.separator + srcJavaPath + File.separator + genCodeGeneratorDto.getBasePackagePath() + File.separator + "domain" + File.separator + "param" + File.separator + fileName;
            }
        });
        return focList;
    }
}

类型转换器

package com.wmang.generator.convert;

import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.ITypeConvert;
import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
import com.baomidou.mybatisplus.generator.config.rules.IColumnType;
/**
 * @author: wmang
 * @date: 2019/12/27 16:59
 * @description:  int(11) unsigned
 */
public class CustMysqlTypeConvert implements ITypeConvert {
    public CustMysqlTypeConvert() {
    }

    @Override
    public IColumnType processTypeConvert(GlobalConfig globalConfig, String fieldType) {
        String t = fieldType.toLowerCase();
        if (t.contains("char")) {
            return DbColumnType.STRING;
        } else if (t.contains("bigint")) {
            return DbColumnType.LONG;
        } else if (t.contains("tinyint(1)")) {
            return DbColumnType.BOOLEAN;
        } else if (t.contains("int")) {
            if(t.indexOf("int")==0 && (t.indexOf("unsigned")+"unsigned".length()) == t.length()){
                return DbColumnType.LONG;
            }else{
                return DbColumnType.INTEGER;
            }
        } else if (t.contains("text")) {
            return DbColumnType.STRING;
        } else if (t.contains("bit")) {
            return DbColumnType.BOOLEAN;
        } else if (t.contains("decimal")) {
            return DbColumnType.BIG_DECIMAL;
        } else if (t.contains("clob")) {
            return DbColumnType.CLOB;
        } else if (t.contains("blob")) {
            return DbColumnType.BLOB;
        } else if (t.contains("binary")) {
            return DbColumnType.BYTE_ARRAY;
        } else if (t.contains("float")) {
            return DbColumnType.FLOAT;
        } else if (t.contains("double")) {
            return DbColumnType.DOUBLE;
        } else if (!t.contains("json") && !t.contains("enum")) {
            if (t.contains("date") || t.contains("time") || t.contains("year")) {
                byte var5;
                switch(globalConfig.getDateType()) {
                    case ONLY_DATE:
                        return DbColumnType.DATE;
                    case SQL_PACK:
                        var5 = -1;
                        switch(t.hashCode()) {
                            case 3076014:
                                if (t.equals("date")) {
                                    var5 = 0;
                                }
                                break;
                            case 3560141:
                                if (t.equals("time")) {
                                    var5 = 1;
                                }
                                break;
                            case 3704893:
                                if (t.equals("year")) {
                                    var5 = 2;
                                }
                        }

                        switch(var5) {
                            case 0:
                                return DbColumnType.DATE_SQL;
                            case 1:
                                return DbColumnType.TIME;
                            case 2:
                                return DbColumnType.DATE_SQL;
                            default:
                                return DbColumnType.TIMESTAMP;
                        }
                    case TIME_PACK:
                        var5 = -1;
                        switch(t.hashCode()) {
                            case 3076014:
                                if (t.equals("date")) {
                                    var5 = 0;
                                }
                                break;
                            case 3560141:
                                if (t.equals("time")) {
                                    var5 = 1;
                                }
                                break;
                            case 3704893:
                                if (t.equals("year")) {
                                    var5 = 2;
                                }
                        }

                        switch(var5) {
                            case 0:
                                return DbColumnType.LOCAL_DATE;
                            case 1:
                                return DbColumnType.LOCAL_TIME;
                            case 2:
                                return DbColumnType.YEAR;
                            default:
                                return DbColumnType.LOCAL_DATE_TIME;
                        }
                }
            }

            return DbColumnType.STRING;
        } else {
            return DbColumnType.STRING;
        }
    }
}

pojo对象

package com.wmang.generator.dto;

import lombok.Data;

@Data
public class GenCodeGeneratorDto {

    /**
     * 覆盖原文件
     */
    private Boolean fileOverride = false;

    /**
     * 项目绝对路径
     */
    private String basePath;

    /**
     * 包路径
     */
    private String basePackage;

    /**
     * 包文件路径
     */
    private String basePackagePath;

    /**
     * 过滤表前缀
     */
    private String tablePrefix;

    /**
     * 需要生成的表，用英文符号,隔开
     */
    private String tables;

    /**
     * 作者
     */
    private String author;

    /**
     * jdbc url
     */
    private String jdbcUrl;

    /**
     * jdbc driver
     */
    private String jdbcDriverName;

    /**
     * jdbc username
     */
    private String jdbcUserName;

    /**
     * jdbc password
     */
    private String jdbcPassWord;
}

工具类

package com.wmang.generator.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.Set;

/**
 * @author: wmang
 * @date: 2019/12/18 16:59
 * @description:
 */
public class PropertiesUtils {
    /**
     * 单独抽取的方法，用户检测能否正确操纵Properties
     *
     * @throws IOException 为了排版美观，直接抛出异常
     */
    public void printKeyValue() {
        Properties properties = loadProperties();
        Set<Object> keys = properties.keySet();
        for (Object key : keys) {
            System.out.println(key + " = " + properties.get(key));
        }
    }

    /**
     * 获取属性
     *
     * @param key
     * @return
     */
    public String getValue(String key) {
        Properties properties = loadProperties();
        return properties.getProperty(key);
    }

    public Properties loadProperties() {
        Properties properties = new Properties();
        try {
            InputStream inputStream = this.getPropertiesFromClassLoader();
            properties.load(inputStream);
        } catch (IOException e) {
            System.out.println("属性读取失败");
            e.printStackTrace();
        }
        return properties;
    }


    /***
     * 从当前的类加载器的getResourcesAsStream来获取.
     * 使用Class.class.getClassLoader().getResourcesAsStream()进行获取的时候，所填写的路径只能为项目的绝对路径
     * @throws IOException
     */
    public InputStream getPropertiesFromResourceAsStream() throws IOException {
        InputStream resourceAsStream = PropertiesUtils.class.getClassLoader().getResourceAsStream("generator.properties");
        return resourceAsStream;
    }

    /***
     * 从文件中获取,使用InputStream字节
     * 主要是需要加上src这个文件夹名。。。路径配置需要精确到绝对地址级别
     * 什么意思，就是如果这个mylog4j文件在com/dimple/getproperityfile/mylog4j.properties下，而这个com文件夹
     * 又在src目录下，那么写的时候需要加上这个src，这样的相对路径+项目地址能够构成一个完整的访问地址即可
     * @throws IOException
     */
    public InputStream getPropertiesFromFile() throws IOException {
        InputStream inputStream = new FileInputStream(new File("generator.properties"));
        return inputStream;
    }

    /**
     * 使用Class类的getSystemResourceAsStream方法
     * 和使用当前类的ClassLoader是一样的
     *
     * @throws IOException
     */
    public InputStream getPropertiesFromClassLoader() throws IOException {
        InputStream systemResourceAsStream = ClassLoader.getSystemResourceAsStream("generator.properties");
        return systemResourceAsStream;
    }
}

yml生成工具类

package com.wmang.generator.util;

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.util.Properties;

public class YamlConfigurerUtils {

    public YamlConfigurerUtils(String ymlFile) {
        //1:加载配置文件
        Resource app = new ClassPathResource(ymlFile);
        YamlPropertiesFactoryBean yamlPropertiesFactoryBean = new YamlPropertiesFactoryBean();
        // 2:将加载的配置文件交给 YamlPropertiesFactoryBean
        yamlPropertiesFactoryBean.setResources(app);
        // 3：将yml转换成 key：val
        Properties properties = yamlPropertiesFactoryBean.getObject();
        // 4: 将Properties 通过构造方法交给我们写的工具类
        this.setYmlProperties(properties);
    }

    private Properties ymlProperties = new Properties();

    private void setYmlProperties(Properties properties) {
        ymlProperties = properties;
    }

    public String getStrYmlVal(String key) {
        return ymlProperties.getProperty(key);
    }

    public Integer getIntegerYmlVal(String key) {
        return Integer.valueOf(ymlProperties.getProperty(key));
    }
}

自定义模板-controller

package ${package.Controller};

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.*;
import ${package.Entity}.${entity};
import ${cfg.dtoClassPkg}.${entity}Dto;
import ${cfg.paramClassPkg}.${entity}Param;
import ${package.Service}.${table.serviceName};
import org.springframework.beans.BeanUtils;
import java.util.ArrayList;
import java.util.List;

<#if restControllerStyle>
import org.springframework.web.bind.annotation.RestController;
<#else>
import org.springframework.stereotype.Controller;
</#if>
<#if superControllerClassPackage??>
import ${superControllerClassPackage};
</#if>

/**
 * ${table.comment!} 前端控制器
 *
 * @author ${author}
 * @since ${date}
 */
<#if restControllerStyle>
@RestController
<#else>
@Controller
</#if>
@RequestMapping("/<#if controllerMappingHyphenStyle??>${controllerMappingHyphen}<#else>${table.entityPath}s</#if>")
<#if kotlin>
class ${table.controllerName}<#if superControllerClass??> : ${superControllerClass}()</#if>
<#else>
<#if superControllerClass??>
public class ${table.controllerName} extends ${superControllerClass} {
<#else>
public class ${table.controllerName} {
</#if>

    @Autowired
    private ${table.serviceName} service;

    /**
     * 基础方法-分页方法,带请求对象
     *
     * @return 查询分页对象
     */
    @GetMapping("/<#if controllerMappingHyphenStyle??>${controllerMappingHyphen}<#else>${table.entityPath}</#if>/page")
    public Page<${entity}Dto> listByPages(@SpringQueryMap ${entity}Param param) {
        Page<${entity}> page = param.getPage();
        QueryWrapper<${entity}> wrapper = new QueryWrapper();
        /** TODO:此处填写条件查询拼接 wrapper对象 */

        Page<${entity}> pages = service.page(page, wrapper);
        Page<${entity}Dto> dtoPages = new Page<>();
        BeanUtils.copyProperties(pages, dtoPages);
        List<${entity}Dto> dtos = new ArrayList<>();
        pages.getRecords().forEach((item) -> {
            ${entity}Dto dto = new ${entity}Dto();
            BeanUtils.copyProperties(item, dto);
            dtos.add(dto);
        });
        dtoPages.setRecords(dtos);
        return dtoPages;
    }

    /**
     * 基础方法-不带分页方法,带请求对象
     *
     * @return 查询分页对象
     */
    @GetMapping
    public List<${entity}Dto> listDatas(@SpringQueryMap ${entity}Param query) {
        QueryWrapper<${entity}> wrapper = new QueryWrapper();
        /** TODO:此处填写条件查询拼接 wrapper对象 */

        List<${entity}> entityList = service.list(wrapper);
        List<${entity}Dto> dtos = new ArrayList<>();
        entityList.forEach((item) -> {
            ${entity}Dto dto = new ${entity}Dto();
            BeanUtils.copyProperties(item, dto);
            dtos.add(dto);
        });
        return dtos;
    }

    /**
     * 基础方法-根据主键id查询对象
     *
     * @param id
     * @return 查询对象
     */
    @GetMapping("/{id}")
    public ${entity}Dto selectById(@PathVariable("id") Long id) {
        ${entity}Dto dto = new ${entity}Dto();
        ${entity} entity = service.getById(id);
        BeanUtils.copyProperties(entity, dto);
        return dto;
    }

    /**
     * 基础方法-新增对象方法
     *
     * @param dto
     * @return 是否成功
     */
    @PostMapping
    public boolean save(@RequestBody ${entity}Dto dto) {
        ${entity} entity = new ${entity}();
        BeanUtils.copyProperties(dto, entity);
        return service.save(entity);
    }

    /**
     * 基础方法-修改对象方法,根据id覆盖更新
     *
     * @param dto
     * @return 是否成功
     */
    @PutMapping
    public boolean update(@RequestBody ${entity}Dto dto) {
        ${entity} entity = new ${entity}();
        BeanUtils.copyProperties(dto, entity);
        return service.updateById(entity);
    }

    /**
     * 基础方法-修改对象方法,根据id更新对象中非空字段
     *
     * @param dto
     * @return 是否成功
     */
    @PatchMapping
    public boolean updateByParam(@RequestBody ${entity}Dto dto) {
        ${entity} entity = new ${entity}();
        BeanUtils.copyProperties(dto, entity);
        return service.updateById(entity);
    }

    /**
     * 基础方法-根据id删除对象方法
     *
     * @param id 主键id
     * @return 是否成功
     */
    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable("id") Long id) {
        return service.removeById(id);
    }
}
</#if>

自定义模板-dto

package ${cfg.dtoClassPkg};

<#list table.importPackages as pkg>
import ${pkg};
</#list>
<#if swagger2>
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
</#if>
<#if entityLombokModel>
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
</#if>
<#if cfg.superDtoClass??>
import ${cfg.superDtoClassPkg};
</#if>

/**
 * ${table.comment!} DTO对象
 *
 * @author ${author}
 * @since ${date}
 */
<#if entityLombokModel>
@Data
    <#if cfg.superDtoClass??>
@EqualsAndHashCode(callSuper = true)
    <#else>
@EqualsAndHashCode(callSuper = false)
    </#if>
@Accessors(chain = true)
</#if>
<#if swagger2>
@ApiModel(value = "${entity}Dto对象", description = "${table.comment!}")
</#if>
@JsonIgnoreProperties(ignoreUnknown=true)
<#if cfg.superDtoClass??>
public class ${entity}Dto extends ${cfg.superDtoClass}  {
<#else>
public class ${entity}Dto implements Serializable {
</#if>
<#if entitySerialVersionUID>

    private static final long serialVersionUID = 1L;
</#if>
<#-- ----------  BEGIN 字段循环遍历  ---------->
<#list table.fields as field>
    <#if field.comment!?length gt 0>
        <#if swagger2>

    @ApiModelProperty(value = "${field.comment}")
        <#else>
    /**
     * ${field.comment}
     */
        </#if>
    </#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 entityBuilderModel>
    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 entityBuilderModel>
        return this;
        </#if>
    }
    </#list>
</#if>
<#if activeRecord>

    @Override
    protected Serializable pkVal() {
    <#if keyPropertyName??>
        return this.${keyPropertyName};
    <#else>
        return null;
    </#if>
    }
</#if>
<#if !entityLombokModel>

    @Override
    public String toString() {
        return "${entity}DTO{" +
    <#list table.fields as field>
        <#if field_index==0>
            "${field.propertyName}=" + ${field.propertyName} +
        <#else>
            ", ${field.propertyName}=" + ${field.propertyName} +
        </#if>
    </#list>
        "}";
    }
</#if>
}

自定义模板feign

package ${cfg.feignClassPkg};

import com.baomidou.mybatisplus.core.metadata.IPage;
<#if cfg.superFeignClass??>
import ${cfg.superFeignClassPkg};
</#if>
import ${cfg.dtoClassPkg}.${entity}Dto;
import ${cfg.requestParamClassPkg}.${entity}Param;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.*;
import ${cfg.superFeignConfigClassPkg};
import java.util.List;


/**
 * ${table.comment!} 对外提供api接口
 *
 * @author ${author}
 * @since ${date}
 */
@FeignClient(name = "${cfg.feignName}", path = "${cfg.feignPath}", configuration = GenFeignConfiguration.class)
@RequestMapping("/<#if controllerMappingHyphenStyle??>${controllerMappingHyphen}<#else>${table.entityPath}s</#if>")
<#if kotlin>
class I${entity}FeignApi <#if cfg.superFeignClass??> : ${cfg.superFeignClass}()</#if>
<#else>
<#if cfg.superFeignClass??>
public interface ${entity}FeignApi extends ${cfg.superFeignClass} {
<#else>
public interface ${entity}FeignApi {
</#if>

    /**
     * 基础方法-分页方法,带请求对象
     *
     * @return 查询分页对象
     */
    @GetMapping("/page")
    IPage<${entity}Dto> listByPages(@SpringQueryMap ${entity}Param param);

    /**
    * 基础方法-不带分页方法,带请求对象
    *
    * @return 列表对象
    */
    @GetMapping
    List<${entity}Dto> listDatas(@SpringQueryMap ${entity}Param param);

     /**
     * 基础方法-根据主键id查询对象
     *
     * @param id
     * @return 查询对象
     */
    @GetMapping("/{id}")
    ${entity}Dto selectById(@PathVariable Long id);

    /**
     * 基础方法-新增对象方法
     *
     * @param dto
     * @return 是否成功
     */
    @PostMapping
    boolean save(@RequestBody ${entity}Dto dto);

    /**
     * 基础方法-修改对象方法,根据id覆盖更新
     *
     * @param dto
     * @return 是否成功
     */
    @PutMapping
    boolean update(@RequestBody ${entity}Dto dto);

    /**
     * 基础方法-修改对象方法,根据id更新对象中非空字段
     *
     * @param dto
     * @return 是否成功
     */
    @PatchMapping
    boolean updateByParam(@RequestBody ${entity}Dto dto);

    /**
     * 基础方法-根据id删除对象方法
     *
     * @param id 主键id
     * @return 是否成功
     */
    @DeleteMapping("/{id}")
    boolean delete(@PathVariable Long id);
}
</#if>

自定义模板-参数对象

package ${cfg.paramClassPkg};

<#list table.importPackages as pkg>
import ${pkg};
</#list>
<#if swagger2>
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
</#if>
<#if entityLombokModel>
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
</#if>
<#if cfg.superParamClass??>
import ${cfg.superParamClassPkg};
</#if>

/**
 * ${table.comment!} Param 请求传输对象
 *
 * @author ${author}
 * @since ${date}
 */
<#if entityLombokModel>
@Data
<#if cfg.superParamClass??>
@EqualsAndHashCode(callSuper = true)
<#else>
@EqualsAndHashCode(callSuper = false)
</#if>
@Accessors(chain = true)
</#if>
<#if swagger2>
@ApiModel(value = "${entity}Param对象", description = "${table.comment!}")
</#if>
@JsonIgnoreProperties(ignoreUnknown=true)
<#if cfg.superParamClass??>
public class ${entity}Param extends ${cfg.superParamClass}  {
<#else>
public class ${entity}Param implements Serializable {
</#if>
<#if entitySerialVersionUID>

    private static final long serialVersionUID = 1L;
</#if>
<#-- ----------  BEGIN 字段循环遍历  ---------->
<#list table.fields as field>
<#if field.comment!?length gt 0>
    <#if swagger2>

    @ApiModelProperty(value = "${field.comment}")
    <#else>
    /**
     * ${field.comment}
     */
    </#if>
</#if>
    private ${field.propertyType} ${field.propertyName};
</#list>
<#------------  END 字段循环遍历  ---------->
<#if !entityLombokModel>

    @Override
    public String toString() {
    return "${entity}DTO{" +
    <#list table.fields as field>
        <#if field_index==0>
            "${field.propertyName}=" + ${field.propertyName} +
        <#else>
            ", ${field.propertyName}=" + ${field.propertyName} +
        </#if>
    </#list>
    "}";
    }
</#if>
}

Test生成样例

package gencoder;

import com.wmang.generator.code.GenCodeGenerator;
import com.wmang.generator.dto.GenCodeGeneratorDto;
import lombok.extern.slf4j.Slf4j;

import java.io.File;

/**
 * 代码生成
 */
@Slf4j
public class CarCodeGencoder {

    public static void main(String[] args) {
        // 项目路径
        String basePath = getBasePath();
        // 从local配置文件获取数据库配置
        GenCodeGeneratorDto dto = new GenCodeGeneratorDto();

        // 项目路径
        dto.setBasePath(basePath);
        // 包路径
        dto.setBasePackage("com.wmang.basic");
        // 包文件路径
        dto.setBasePackagePath("com" + File.separator + "wmang" + File.separator + "basic");
        // JDBC配置
        dto.setJdbcDriverName("org.mariadb.jdbc.Driver");
        dto.setJdbcUrl("jdbc:mariadb://localhost:3306/xxx?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&autoReconnect=true&failOverReadOnly=false");
        dto.setJdbcUserName("root");
        dto.setJdbcPassWord("123");
        // 过滤表前缀
        dto.setTablePrefix("car");
        // 要生成的表  多个表时用","隔开,例： test_table1, test_table2
        dto.setTables("test_table1, test_table2");
        // 作者
        dto.setAuthor("wmang");

        GenCodeGenerator genCodeGenerator = new GenCodeGenerator();
        genCodeGenerator.build(dto);
    }

    /**
     * 获取项目绝对路径
     *
     * @return
     */
    private static String getBasePath() {
        String basePath = System.getProperty("user.dir");
        if (basePath.endsWith("base-dir")) {
            basePath = basePath + File.separator + "base-dir2,";
        } else {
            basePath = basePath + File.separator + "base-dir" + File.separator + "base-dir2";
        }
        log.info("basePath:{}", basePath);
        return basePath;
    }

}