若依分离版代码生成器修改版

朱雀 2024-04-01 13:40 75阅读 0赞

### 当前版本 ###

当前为mybatis,修改为mybatis-plus  
集成了mybatis-plus  
添加了导入功能  
逻辑删除功能(支持的字段名 is\_delete,del\_flag,deleted)  
,处理了逻辑删除时自动注入修改人和修改时间不生效问题  
数据字典配置  
2022-11-17,解决主子表功能不能实现问题

#### 修改位置如下 ####

![在这里插入图片描述][3fe2b502cd8346b288907658f9592278.png]

##### 需对BaseEntity.class进行修改 #####

package com.fillke.common.core.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    import com.baomidou.mybatisplus.annotation.FieldFill;
    import com.baomidou.mybatisplus.annotation.TableField;
    import com.fasterxml.jackson.annotation.JsonFormat;
    
    /**
     * Entity基类
     *
     * @author
     */
    public class BaseEntity implements Serializable
    {
        private static final long serialVersionUID = 1L;
    
        /**
         * 搜索值
         */
        @TableField(exist = false)
        private String searchValue;
    
        /**
         * 创建者
         */
        @TableField(fill = FieldFill.INSERT)
        private String createBy;
    
        /**
         * 创建时间
         */
        @TableField(fill = FieldFill.INSERT)
        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        private Date createTime;
    
        /**
         * 更新者
         */
        @TableField(fill = FieldFill.UPDATE)
        private String updateBy;
    
        /**
         * 更新时间
         */
        @TableField(fill = FieldFill.UPDATE)
        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        private Date updateTime;
    
        /**
         * 备注
         */
        @TableField(exist = false)
        private String remark;
    
        /**
         * 请求参数
         */
        @TableField(exist = false)
        private Map<String, Object> params;
    
        public String getSearchValue()
        {
            return searchValue;
        }
    
        public void setSearchValue(String searchValue)
        {
            this.searchValue = searchValue;
        }
    
        public String getCreateBy()
        {
            return createBy;
        }
    
        public void setCreateBy(String createBy)
        {
            this.createBy = createBy;
        }
    
        public Date getCreateTime()
        {
            return createTime;
        }
    
        public void setCreateTime(Date createTime)
        {
            this.createTime = createTime;
        }
    
        public String getUpdateBy()
        {
            return updateBy;
        }
    
        public void setUpdateBy(String updateBy)
        {
            this.updateBy = updateBy;
        }
    
        public Date getUpdateTime()
        {
            return updateTime;
        }
    
        public void setUpdateTime(Date updateTime)
        {
            this.updateTime = updateTime;
        }
    
        public String getRemark()
        {
            return remark;
        }
    
        public void setRemark(String remark)
        {
            this.remark = remark;
        }
    
        public Map<String, Object> getParams()
        {
            if (params == null)
            {
                params = new HashMap<>();
            }
            return params;
        }
    
        public void setParams(Map<String, Object> params)
        {
            this.params = params;
        }
    }

##### controller.java.vm #####

package ${packageName}.controller;
    
    import java.util.List;
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.fillke.common.utils.StringUtils;
    import javax.servlet.http.HttpServletResponse;
    import org.springframework.security.access.prepost.PreAuthorize;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import com.fillke.common.annotation.Log;
    import com.fillke.common.core.controller.BaseController;
    import com.fillke.common.core.domain.AjaxResult;
    import com.fillke.common.enums.BusinessType;
    import lombok.RequiredArgsConstructor;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.web.multipart.MultipartFile;
    import ${packageName}.domain.${ClassName};
    import ${packageName}.service.I${ClassName}Service;
    import com.fillke.common.utils.poi.ExcelUtil;
    #if($table.crud || $table.sub)
    import com.fillke.common.core.page.TableDataInfo;
    #elseif($table.tree)
    #end
    
    /**
     * ${functionName}Controller
     *
     * @author ${author}
     * @date ${datetime}
     */
    @RequiredArgsConstructor(onConstructor_ = @Autowired)
    @RestController
    @RequestMapping("/${moduleName}/${businessName}")
    public class ${ClassName}Controller extends BaseController {
    
        private final I${ClassName}Service ${className}Service;
    
        /**
         * 查询${functionName}列表
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:list')")
        @GetMapping("/list")
    #if($table.crud || $table.sub)
        public TableDataInfo list(${ClassName} ${className}) {
            startPage();
            LambdaQueryWrapper<${ClassName}> lqw = new LambdaQueryWrapper<${ClassName}>();
    #foreach($column in $columns)
    #set($queryType=$column.queryType)
    #set($javaField=$column.javaField)
    #set($javaType=$column.javaType)
    #set($columnName=$column.columnName)
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
    #if($column.query)
    #if($column.queryType == "EQ")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.eq(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.eq(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "NE")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.ne(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.ne(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "GT")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.gt(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.gt(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "GTE")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.ge(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.ge(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "LT")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.lt(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.lt(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "LTE")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.le(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.le(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "LIKE")
        #if($javaType == 'String')
            if (StringUtils.isNotBlank(${className}.get$AttrName())){
                lqw.like(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #else
            if (${className}.get$AttrName() != null){
                lqw.like(${ClassName}::get$AttrName ,${className}.get$AttrName());
            }
        #end
    #elseif($queryType == "BETWEEN")
    #end
    #end
    #end
            List<${ClassName}> list = ${className}Service.list(lqw);
            return getDataTable(list);
        }
    #elseif($table.tree)
        public AjaxResult list(${ClassName} ${className}) {
            List<${ClassName}> list = ${className}Service.list(lqw);
            return AjaxResult.success(list);
        }
    #end
    
        /**
         * 下载导入模板
         * @param response
         */
        @PostMapping("/importTemplate")
        public void importTemplate(HttpServletResponse response) {
            ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class);
            util.importTemplateExcel(response, "${functionName}数据");
        }
    
        /**
         * 导入${functionName}数据
         * @param file
         * @return
         * @throws Exception
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:import')")
        @PostMapping("/importData")
        @ResponseBody
        @Transactional(rollbackFor = Exception.class)
        public AjaxResult importData(MultipartFile file) throws Exception {
            ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class);
            List<${ClassName}> list = util.importExcel(file.getInputStream());
    
            if (list.size() <= 0) {
                throw new RuntimeException("导入数据为空,请填充数据再导入！");
            }
            // 批量存入
            ${className}Service.saveBatch(list);
    
            return AjaxResult.success("导入成功");
        }
    
        /**
         * 导出${functionName}列表
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:export')")
        @Log(title = "${functionName}", businessType = BusinessType.EXPORT)
        @PostMapping("/export")
        public void export(HttpServletResponse response, ${ClassName} ${className}) {
            List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
            ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class);
            util.exportExcel(response, list, "${functionName}数据");
        }
    
        /**
         * 获取${functionName}详细信息
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:query')")
        @GetMapping(value = "/{${pkColumn.javaField}}")
        public AjaxResult getInfo(@PathVariable("${pkColumn.javaField}") ${pkColumn.javaType} ${pkColumn.javaField}) {
            return AjaxResult.success(${className}Service.select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaField}));
        }
    
        /**
         * 新增${functionName}
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:add')")
        @Log(title = "${functionName}", businessType = BusinessType.INSERT)
        @PostMapping
        public AjaxResult add(@RequestBody ${ClassName} ${className}) {
            return toAjax(${className}Service.insert${ClassName}(${className}));
        }
    
        /**
         * 修改${functionName}
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:edit')")
        @Log(title = "${functionName}", businessType = BusinessType.UPDATE)
        @PutMapping
        public AjaxResult edit(@RequestBody ${ClassName} ${className}) {
            return toAjax(${className}Service.update${ClassName}(${className}));
        }
    
        /**
         * 删除${functionName}
         */
        @PreAuthorize("@ss.hasPermi('${permissionPrefix}:remove')")
        @Log(title = "${functionName}", businessType = BusinessType.DELETE)
    	@DeleteMapping("/{${pkColumn.javaField}s}")
        public AjaxResult remove(@PathVariable ${pkColumn.javaType}[] ${pkColumn.javaField}s) {
            return toAjax(${className}Service.delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaField}s));
        }
    }

##### domain.java.vm #####

package ${packageName}.domain;
    
    #foreach ($import in $importList)
    import ${import};
    #end
    import com.baomidou.mybatisplus.annotation.*;
    import com.fillke.common.annotation.Excel;
    import com.fillke.common.core.domain.BaseEntity;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    import lombok.experimental.Accessors;
    import java.io.Serializable;
    #if($table.crud || $table.sub)
    #elseif($table.tree)
    #end
    
    /**
     * ${functionName}对象 ${tableName}
     *
     * @author ${author}
     * @date ${datetime}
     */
    #if($table.crud || $table.sub)
    #set($Entity="BaseEntity")
    #elseif($table.tree)
    #set($Entity="TreeEntity")
    #end
    @Data
    @EqualsAndHashCode(callSuper = true)
    @Accessors(chain = true)
    @TableName("${tableName}")
    public class ${ClassName} extends ${Entity} implements Serializable{
        private static final long serialVersionUID = 1L;
    
    #foreach ($column in $columns)
    #if(!$table.isSuperColumn($column.javaField))
        /** $column.columnComment */
    #if($column.list)
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #if($parentheseIndex != -1)
        @Excel(name = "${comment}", readConverterExp = "$column.readConverterExp()")
    #elseif($column.javaType == 'Date')
        @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss" )
        @Excel(name = "${comment}", width = 30, dateFormat = "yyyy-MM-dd")
    #elseif(!$column.dictType.equals(""))
        @Excel(name = "${comment}",dictType = "$column.dictType",prompt = "填入数据字典中对应的【字典标签】值" )
    #elseif($column.columnName.equals("is_delete") || $column.columnName.equals("del_flag") || $column.columnName.equals("deleted"))
    #else
        @Excel(name = "${comment}")
    #end
    #end
    #if($column.isPk==1)
        @TableId(value = "$column.columnName" ,type = IdType.AUTO)
        private $column.javaType $column.javaField;
    #elseif($column.columnName.equals("create_by") || $column.columnName.equals("create_time") || $column.columnName.equals("update_by") || $column.columnName.equals("update_time") )
    #elseif($column.columnName.equals("is_delete") || $column.columnName.equals("del_flag") || $column.columnName.equals("deleted"))
        @TableLogic
        private $column.javaType $column.javaField;
    #else
        private $column.javaType $column.javaField;
    #end
    #end
    #end
    #if($table.sub)
        /** $table.subTable.functionName信息 */
        @TableField(exist = false)
        private List<${subClassName}> ${subclassName}List;
    #end
    }

##### mapper.java.vm #####

package ${packageName}.mapper;
    
    import java.util.List;
    import ${packageName}.domain.${ClassName};
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.springframework.stereotype.Repository;
    #if($table.sub)
    import ${packageName}.domain.${subClassName};
    #end
    
    /**
     * ${functionName}Mapper接口
     *
     * @author ${author}
     * @date ${datetime}
     */
    @Repository
    public interface ${ClassName}Mapper extends BaseMapper<${ClassName}> {
    
        /**
         * 查询${functionName}
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return ${functionName}
         */
        public ${ClassName} select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField});
    
        /**
         * 查询${functionName}列表
         *
         * @param ${className} ${functionName}
         * @return ${functionName}集合
         */
        public List<${ClassName}> select${ClassName}List(${ClassName} ${className});
    
        /**
         * 新增${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
        public int insert${ClassName}(${ClassName} ${className});
    
        /**
         * 修改${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
        public int update${ClassName}(${ClassName} ${className});
    
        /**
         * 删除${functionName}
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return 结果
         */
        public int delete${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField});
    
        /**
         * 批量删除${functionName}
         *
         * @param ${pkColumn.javaField}s 需要删除的数据主键集合
         * @return 结果
         */
        public int delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaType}[] ${pkColumn.javaField}s);
    #if($table.sub)
    
        /**
         * 批量删除${subTable.functionName}
         *
         * @param ${pkColumn.javaField}s 需要删除的数据主键集合
         * @return 结果
         */
        public int delete${subClassName}By${subTableFkClassName}s(${pkColumn.javaType}[] ${pkColumn.javaField}s);
    
        /**
         * 批量新增${subTable.functionName}
         *
         * @param ${subclassName}List ${subTable.functionName}列表
         * @return 结果
         */
        public int batch${subClassName}(List<${subClassName}> ${subclassName}List);
    
    
        /**
         * 通过${functionName}主键删除${subTable.functionName}信息
         *
         * @param ${pkColumn.javaField} ${functionName}ID
         * @return 结果
         */
        public int delete${subClassName}By${subTableFkClassName}(${pkColumn.javaType} ${pkColumn.javaField});
    #end
    }

##### service.java.vm #####

package ${packageName}.service;
    
    import java.util.List;
    import ${packageName}.domain.${ClassName};
    import com.baomidou.mybatisplus.extension.service.IService;
    
    /**
     * ${functionName}Service接口
     *
     * @author ${author}
     * @date ${datetime}
     */
    public interface I${ClassName}Service extends IService<${ClassName}> {
    
        /**
         * 查询${functionName}
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return ${functionName}
         */
        public ${ClassName} select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField});
    
        /**
         * 查询${functionName}列表
         *
         * @param ${className} ${functionName}
         * @return ${functionName}集合
         */
        public List<${ClassName}> select${ClassName}List(${ClassName} ${className});
    
        /**
         * 新增${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
        public int insert${ClassName}(${ClassName} ${className});
    
        /**
         * 修改${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
        public int update${ClassName}(${ClassName} ${className});
    
        /**
         * 批量删除${functionName}
         *
         * @param ${pkColumn.javaField}s 需要删除的${functionName}主键集合
         * @return 结果
         */
        public int delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaType}[] ${pkColumn.javaField}s);
    
        /**
         * 删除${functionName}信息
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return 结果
         */
        public int delete${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField});
    }

##### serviceImpl.java.vm #####

package ${packageName}.service.impl;
    
    import java.util.List;
    #foreach ($column in $columns)
    #if($column.javaField == 'createTime' || $column.javaField == 'updateTime')
    import com.fillke.common.utils.DateUtils;
    #break
    #end
    #end
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    #if($table.sub)
    import java.util.ArrayList;
    import com.fillke.common.utils.StringUtils;
    import org.springframework.transaction.annotation.Transactional;
    import ${packageName}.domain.${subClassName};
    #end
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import ${packageName}.mapper.${ClassName}Mapper;
    import ${packageName}.domain.${ClassName};
    import ${packageName}.service.I${ClassName}Service;
    
    /**
     * ${functionName}Service业务层处理
     *
     * @author ${author}
     * @date ${datetime}
     */
    @Service
    public class ${ClassName}ServiceImpl extends ServiceImpl<${ClassName}Mapper, ${ClassName}> implements I${ClassName}Service {
    
        @Autowired
        private ${ClassName}Mapper ${className}Mapper;
    
        /**
         * 查询${functionName}
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return ${functionName}
         */
        @Override
        public ${ClassName} select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField}) {
            return ${className}Mapper.select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaField});
        }
    
        /**
         * 查询${functionName}列表
         *
         * @param ${className} ${functionName}
         * @return ${functionName}
         */
        @Override
        public List<${ClassName}> select${ClassName}List(${ClassName} ${className}) {
            return ${className}Mapper.select${ClassName}List(${className});
        }
    
        /**
         * 新增${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
    #if($table.sub)
        @Transactional
    #end
        @Override
        public int insert${ClassName}(${ClassName} ${className}) {
    #foreach ($column in $columns)
    #if($column.javaField == 'createTime')
            ${className}.setCreateTime(DateUtils.getNowDate());
    #end
    #end
    #if($table.sub)
            int rows = ${className}Mapper.insert(${className});
            insert${subClassName}(${className});
            return rows;
    #else
            return ${className}Mapper.insert${ClassName}(${className});
    #end
        }
    
        /**
         * 修改${functionName}
         *
         * @param ${className} ${functionName}
         * @return 结果
         */
    #if($table.sub)
        @Transactional
    #end
        @Override
        public int update${ClassName}(${ClassName} ${className}) {
    #foreach ($column in $columns)
    #if($column.javaField == 'updateTime')
            ${className}.setUpdateTime(DateUtils.getNowDate());
    #end
    #end
    #if($table.sub)
            ${className}Mapper.delete${subClassName}By${subTableFkClassName}(${className}.get${pkColumn.capJavaField}());
            insert${subClassName}(${className});
    #end
            return ${className}Mapper.update${ClassName}(${className});
        }
    
        /**
         * 批量删除${functionName}
         *
         * @param ${pkColumn.javaField}s 需要删除的${functionName}主键
         * @return 结果
         */
    #if($table.sub)
        @Transactional
    #end
        @Override
        public int delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaType}[] ${pkColumn.javaField}s) {
    #if($table.sub)
            ${className}Mapper.delete${subClassName}By${subTableFkClassName}s(${pkColumn.javaField}s);
    #end
    #* 主表处理逻辑删除 start *#
    #set($isLogicDelete=false)
    #foreach ($column in $columns)
        #if($column.columnName.equals("is_delete") || $column.columnName.equals("del_flag") || $column.columnName.equals("deleted"))
            #set($isLogicDelete=true)
            #set($DelFieldName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
            #set($delFieldJavaType=$column.javaType)
        #end
        #if($column.isPk==1)
            #set($IdName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
        #end
    #end
    #if($isLogicDelete)
            LambdaUpdateWrapper<${ClassName}> wrapper;
            for (Long id : ${pkColumn.javaField}s) {
                wrapper = Wrappers.lambdaUpdate(${ClassName}.class)
                    .eq(${ClassName}::get$IdName, id)
                #if($delFieldJavaType == 'String')
                    .set(${ClassName}::get$DelFieldName, "1");
                #else
                    .set(${ClassName}::get$DelFieldName, 1);
                #end
                super.update(new ${ClassName}(), wrapper);
            }
            return 1;
    #else
            return super.removeByIds(Arrays.asList(${pkColumn.javaField}s)) ;
    #end
        }
    
        /**
         * 删除${functionName}信息
         *
         * @param ${pkColumn.javaField} ${functionName}主键
         * @return 结果
         */
    #if($table.sub)
        @Transactional
    #end
        @Override
        public int delete${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaType} ${pkColumn.javaField}) {
    #if($table.sub)
            ${className}Mapper.delete${subClassName}By${subTableFkClassName}(${pkColumn.javaField});
    #end
            return ${className}Mapper.delete${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaField});
        }
    #if($table.sub)
    
        /**
         * 新增${subTable.functionName}信息
         *
         * @param ${className} ${functionName}对象
         */
        public void insert${subClassName}(${ClassName} ${className}) {
            List<${subClassName}> ${subclassName}List = ${className}.get${subClassName}List();
            ${pkColumn.javaType} ${pkColumn.javaField} = ${className}.get${pkColumn.capJavaField}();
            if (StringUtils.isNotNull(${subclassName}List))
            {
                List<${subClassName}> list = new ArrayList<${subClassName}>();
                for (${subClassName} ${subclassName} : ${subclassName}List)
                {
                    ${subclassName}.set${subTableFkClassName}(${pkColumn.javaField});
                    list.add(${subclassName});
                }
                if (list.size() > 0)
                {
                    ${className}Mapper.batch${subClassName}(list);
                }
            }
        }
    #end
    }

sub-domain.java.vm

package ${packageName}.domain;
    
    #foreach ($import in $subImportList)
    import ${import};
    #end
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableLogic;
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.fillke.common.annotation.Excel;
    import com.fillke.common.core.domain.BaseEntity;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    import lombok.experimental.Accessors;
    import com.fasterxml.jackson.annotation.JsonInclude;
    import java.io.Serializable;
    
    /**
     * ${subTable.functionName}对象 ${subTableName}
     *
     * @author ${author}
     * @date ${datetime}
     */
    @Data
    @EqualsAndHashCode(callSuper = true)
    @Accessors(chain = true)
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    @TableName("${subTableName}")
    public class ${subClassName} extends BaseEntity implements Serializable {
        private static final long serialVersionUID = 1L;
    
    #foreach ($column in $subTable.columns)
    #if(!$table.isSuperColumn($column.javaField))
        /** $column.columnComment */
    #if($column.list)
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #if($parentheseIndex != -1)
        @Excel(name = "${comment}", readConverterExp = "$column.readConverterExp()")
    #elseif($column.javaType == 'Date')
        @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss" )
        @Excel(name = "${comment}", width = 30, dateFormat = "yyyy-MM-dd")
    #elseif($column.columnName.equals("is_delete") || $column.columnName.equals("del_flag") || $column.columnName.equals("deleted"))
    #else
        @Excel(name = "${comment}")
    #end
    #end
    #if($column.isPk==1)
        @TableId(value = "$column.columnName" ,type = IdType.AUTO)
        private $column.javaType $column.javaField;
    #elseif($column.columnName.equals("create_by") || $column.columnName.equals("create_time") || $column.columnName.equals("update_by") || $column.columnName.equals("update_time") )
    #elseif($column.columnName.equals("is_delete") || $column.columnName.equals("del_flag") || $column.columnName.equals("deleted"))
        @TableLogic
        private $column.javaType $column.javaField;
    #else
        private $column.javaType $column.javaField;
    #end
    #end
    #end
    }

##### api.js.vm #####

import request from '@/utils/request'
    
    // 查询${functionName}列表
    export function list${BusinessName}(query) {
      return request({
        url: '/${moduleName}/${businessName}/list',
        method: 'get',
        params: query
      })
    }
    
    // 查询${functionName}详细
    export function get${BusinessName}(${pkColumn.javaField}) {
      return request({
        url: '/${moduleName}/${businessName}/' + ${pkColumn.javaField},
        method: 'get'
      })
    }
    
    // 新增${functionName}
    export function add${BusinessName}(data) {
      return request({
        url: '/${moduleName}/${businessName}',
        method: 'post',
        data: data
      })
    }
    
    // 修改${functionName}
    export function update${BusinessName}(data) {
      return request({
        url: '/${moduleName}/${businessName}',
        method: 'put',
        data: data
      })
    }
    
    // 删除${functionName}
    export function del${BusinessName}(${pkColumn.javaField}) {
      return request({
        url: '/${moduleName}/${businessName}/' + ${pkColumn.javaField},
        method: 'delete'
      })
    }

##### index.vue.vm #####

<template>
      <div class="app-container">
        <el-form :model="queryParams" ref="queryForm" size="small" :inline="true" v-show="showSearch" label-width="68px">
    #foreach($column in $columns)
    #if($column.query)
    #set($dictType=$column.dictType)
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #if($column.htmlType == "input")
          <el-form-item label="${comment}" prop="${column.javaField}">
            <el-input
              v-model="queryParams.${column.javaField}"
              placeholder="请输入${comment}"
              clearable
              @keyup.enter.native="handleQuery"
            />
          </el-form-item>
    #elseif(($column.htmlType == "select" || $column.htmlType == "radio") && "" != $dictType)
          <el-form-item label="${comment}" prop="${column.javaField}">
            <el-select v-model="queryParams.${column.javaField}" placeholder="请选择${comment}" clearable>
              <el-option
                v-for="dict in dict.type.${dictType}"
                :key="dict.value"
                :label="dict.label"
                :value="dict.value"
              />
            </el-select>
          </el-form-item>
    #elseif(($column.htmlType == "select" || $column.htmlType == "radio") && $dictType)
          <el-form-item label="${comment}" prop="${column.javaField}">
            <el-select v-model="queryParams.${column.javaField}" placeholder="请选择${comment}" clearable>
              <el-option label="请选择字典生成" value="" />
            </el-select>
          </el-form-item>
    #elseif($column.htmlType == "datetime" && $column.queryType != "BETWEEN")
          <el-form-item label="${comment}" prop="${column.javaField}">
            <el-date-picker clearable
              v-model="queryParams.${column.javaField}"
              type="date"
              value-format="yyyy-MM-dd"
              placeholder="请选择${comment}">
            </el-date-picker>
          </el-form-item>
    #elseif($column.htmlType == "datetime" && $column.queryType == "BETWEEN")
          <el-form-item label="${comment}">
            <el-date-picker
              v-model="daterange${AttrName}"
              style="width: 240px"
              value-format="yyyy-MM-dd"
              type="daterange"
              range-separator="-"
              start-placeholder="开始日期"
              end-placeholder="结束日期"
            ></el-date-picker>
          </el-form-item>
    #end
    #end
    #end
          <el-form-item>
            <el-button type="primary" icon="el-icon-search" size="mini" @click="handleQuery">搜索</el-button>
            <el-button icon="el-icon-refresh" size="mini" @click="resetQuery">重置</el-button>
          </el-form-item>
        </el-form>
    
        <el-row :gutter="10" class="mb8">
          <el-col :span="1.5">
            <el-button
              type="primary"
              plain
              icon="el-icon-plus"
              size="mini"
              @click="handleAdd"
              v-hasPermi="['${moduleName}:${businessName}:add']"
            >新增</el-button>
          </el-col>
          <el-col :span="1.5">
            <el-button
              type="success"
              plain
              icon="el-icon-edit"
              size="mini"
              :disabled="single"
              @click="handleUpdate"
              v-hasPermi="['${moduleName}:${businessName}:edit']"
            >修改</el-button>
          </el-col>
          <el-col :span="1.5">
            <el-button
              type="danger"
              plain
              icon="el-icon-delete"
              size="mini"
              :disabled="multiple"
              @click="handleDelete"
              v-hasPermi="['${moduleName}:${businessName}:remove']"
            >删除</el-button>
          </el-col>
          <el-col :span="1.5">
            <el-button
                type="info"
                plain
                icon="el-icon-upload2"
                size="mini"
                @click="handleImport"
                v-hasPermi="['${moduleName}:${businessName}:import']"
            >导入</el-button>
          </el-col>
          <el-col :span="1.5">
            <el-button
              type="warning"
              plain
              icon="el-icon-download"
              size="mini"
              @click="handleExport"
              v-hasPermi="['${moduleName}:${businessName}:export']"
            >导出</el-button>
          </el-col>
          <right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar>
        </el-row>
    
        <el-table v-loading="loading" :data="${businessName}List" @selection-change="handleSelectionChange">
          <el-table-column type="selection" width="55" align="center" />
    #foreach($column in $columns)
    #set($javaField=$column.javaField)
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #if($column.pk)
          <el-table-column label="${comment}" align="center" prop="${javaField}" />
    #elseif($column.list && $column.htmlType == "datetime")
          <el-table-column label="${comment}" align="center" prop="${javaField}" width="180">
            <template slot-scope="scope">
              <span>{
       { parseTime(scope.row.${javaField}, '{y}-{m}-{d}') }}</span>
            </template>
          </el-table-column>
    #elseif($column.list && $column.htmlType == "imageUpload")
          <el-table-column label="${comment}" align="center" prop="${javaField}" width="100">
            <template slot-scope="scope">
              <image-preview :src="scope.row.${javaField}" :width="50" :height="50"/>
            </template>
          </el-table-column>
    #elseif($column.list && "" != $column.dictType)
          <el-table-column label="${comment}" align="center" prop="${javaField}">
            <template slot-scope="scope">
    #if($column.htmlType == "checkbox")
              <dict-tag :options="dict.type.${column.dictType}" :value="scope.row.${javaField} ? scope.row.${javaField}.split(',') : []"/>
    #else
              <dict-tag :options="dict.type.${column.dictType}" :value="scope.row.${javaField}"/>
    #end
            </template>
          </el-table-column>
    #elseif($column.list && "" != $javaField)
          <el-table-column label="${comment}" align="center" prop="${javaField}" />
    #end
    #end
          <el-table-column label="操作" align="center" class-name="small-padding fixed-width">
            <template slot-scope="scope">
              <el-button
                size="mini"
                type="text"
                icon="el-icon-edit"
                @click="handleUpdate(scope.row)"
                v-hasPermi="['${moduleName}:${businessName}:edit']"
              >修改</el-button>
              <el-button
                size="mini"
                type="text"
                icon="el-icon-delete"
                @click="handleDelete(scope.row)"
                v-hasPermi="['${moduleName}:${businessName}:remove']"
              >删除</el-button>
            </template>
          </el-table-column>
        </el-table>
    
        <pagination
          v-show="total>0"
          :total="total"
          :page.sync="queryParams.pageNum"
          :limit.sync="queryParams.pageSize"
          @pagination="getList"
        />
    
        
        <el-dialog :title="title" :visible.sync="open" width="500px" append-to-body>
          <el-form ref="form" :model="form" :rules="rules" label-width="80px">
    #foreach($column in $columns)
    #set($field=$column.javaField)
    #if($column.insert && !$column.pk)
    #if(($column.usableColumn) || (!$column.superColumn))
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #set($dictType=$column.dictType)
    #if($column.htmlType == "input")
            <el-form-item label="${comment}" prop="${field}">
              <el-input v-model="form.${field}" placeholder="请输入${comment}" />
            </el-form-item>
    #elseif($column.htmlType == "imageUpload")
            <el-form-item label="${comment}">
              <image-upload v-model="form.${field}"/>
            </el-form-item>
    #elseif($column.htmlType == "fileUpload")
            <el-form-item label="${comment}">
              <file-upload v-model="form.${field}"/>
            </el-form-item>
    #elseif($column.htmlType == "editor")
            <el-form-item label="${comment}">
              <editor v-model="form.${field}" :min-height="192"/>
            </el-form-item>
    #elseif($column.htmlType == "select" && "" != $dictType)
            <el-form-item label="${comment}" prop="${field}">
              <el-select v-model="form.${field}" placeholder="请选择${comment}">
                <el-option
                  v-for="dict in dict.type.${dictType}"
                  :key="dict.value"
                  :label="dict.label"
                  #if($column.javaType == "Integer" || $column.javaType == "Long"):value="parseInt(dict.value)"#else:value="dict.value"#end
    
                ></el-option>
              </el-select>
            </el-form-item>
    #elseif($column.htmlType == "select" && $dictType)
            <el-form-item label="${comment}" prop="${field}">
              <el-select v-model="form.${field}" placeholder="请选择${comment}">
                <el-option label="请选择字典生成" value="" />
              </el-select>
            </el-form-item>
    #elseif($column.htmlType == "checkbox" && "" != $dictType)
            <el-form-item label="${comment}">
              <el-checkbox-group v-model="form.${field}">
                <el-checkbox
                  v-for="dict in dict.type.${dictType}"
                  :key="dict.value"
                  :label="dict.value">
                  {
       {dict.label}}
                </el-checkbox>
              </el-checkbox-group>
            </el-form-item>
    #elseif($column.htmlType == "checkbox" && $dictType)
            <el-form-item label="${comment}">
              <el-checkbox-group v-model="form.${field}">
                <el-checkbox>请选择字典生成</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
    #elseif($column.htmlType == "radio" && "" != $dictType)
            <el-form-item label="${comment}">
              <el-radio-group v-model="form.${field}">
                <el-radio
                  v-for="dict in dict.type.${dictType}"
                  :key="dict.value"
                  #if($column.javaType == "Integer" || $column.javaType == "Long"):label="parseInt(dict.value)"#else:label="dict.value"#end
    
                >{
       {dict.label}}</el-radio>
              </el-radio-group>
            </el-form-item>
    #elseif($column.htmlType == "radio" && $dictType)
            <el-form-item label="${comment}">
              <el-radio-group v-model="form.${field}">
                <el-radio label="1">请选择字典生成</el-radio>
              </el-radio-group>
            </el-form-item>
    #elseif($column.htmlType == "datetime")
            <el-form-item label="${comment}" prop="${field}">
              <el-date-picker clearable
                v-model="form.${field}"
                type="date"
                value-format="yyyy-MM-dd"
                placeholder="请选择${comment}">
              </el-date-picker>
            </el-form-item>
    #elseif($column.htmlType == "textarea")
            <el-form-item label="${comment}" prop="${field}">
              <el-input v-model="form.${field}" type="textarea" placeholder="请输入内容" />
            </el-form-item>
    #end
    #end
    #end
    #end
    #if($table.sub)
            <el-divider content-position="center">${subTable.functionName}信息</el-divider>
            <el-row :gutter="10" class="mb8">
              <el-col :span="1.5">
                <el-button type="primary" icon="el-icon-plus" size="mini" @click="handleAdd${subClassName}">添加</el-button>
              </el-col>
              <el-col :span="1.5">
                <el-button type="danger" icon="el-icon-delete" size="mini" @click="handleDelete${subClassName}">删除</el-button>
              </el-col>
            </el-row>
            <el-table :data="${subclassName}List" :row-class-name="row${subClassName}Index" @selection-change="handle${subClassName}SelectionChange" ref="${subclassName}">
              <el-table-column type="selection" width="50" align="center" />
              <el-table-column label="序号" align="center" prop="index" width="50"/>
    #foreach($column in $subTable.columns)
    #set($javaField=$column.javaField)
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
    #if($column.pk || $javaField == ${subTableFkclassName})
    #elseif($column.list && $column.htmlType == "input")
              <el-table-column label="$comment" prop="${javaField}" width="150">
                <template slot-scope="scope">
                  <el-input v-model="scope.row.$javaField" placeholder="请输入$comment" />
                </template>
              </el-table-column>
    #elseif($column.list && $column.htmlType == "datetime")
              <el-table-column label="$comment" prop="${javaField}" width="240">
                <template slot-scope="scope">
                  <el-date-picker clearable v-model="scope.row.$javaField" type="date" value-format="yyyy-MM-dd" placeholder="请选择$comment" />
                </template>
              </el-table-column>
    #elseif($column.list && ($column.htmlType == "select" || $column.htmlType == "radio") && "" != $column.dictType)
              <el-table-column label="$comment" prop="${javaField}" width="150">
                <template slot-scope="scope">
                  <el-select v-model="scope.row.$javaField" placeholder="请选择$comment">
                    <el-option
                      v-for="dict in dict.type.$column.dictType"
                      :key="dict.value"
                      :label="dict.label"
                      :value="dict.value"
                    ></el-option>
                  </el-select>
                </template>
              </el-table-column>
    #elseif($column.list && ($column.htmlType == "select" || $column.htmlType == "radio") && "" == $column.dictType)
              <el-table-column label="$comment" prop="${javaField}" width="150">
                <template slot-scope="scope">
                  <el-select v-model="scope.row.$javaField" placeholder="请选择$comment">
                    <el-option label="请选择字典生成" value="" />
                  </el-select>
                </template>
              </el-table-column>
    #end
    #end
            </el-table>
    #end
          </el-form>
          <div slot="footer" class="dialog-footer">
            <el-button type="primary" @click="submitForm">确 定</el-button>
            <el-button @click="cancel">取 消</el-button>
          </div>
        </el-dialog>
    
        
        <el-dialog :title="upload.title" :visible.sync="upload.open" width="400px" append-to-body>
          <el-upload
              ref="upload"
              :limit="1"
              accept=".xlsx, .xls"
              :headers="upload.headers"
              :action="upload.url + '?updateSupport=' + upload.updateSupport"
              :disabled="upload.isUploading"
              :on-progress="handleFileUploadProgress"
              :on-success="handleFileSuccess"
              :auto-upload="false"
              drag
          >
            <i class="el-icon-upload"></i>
            <div class="el-upload__text">将文件拖到此处，或<em>点击上传</em></div>
            <div class="el-upload__tip text-center" slot="tip">
              
              <span>仅允许导入xls、xlsx格式文件。</span>
              <el-link type="primary" :underline="false" style="font-size:12px;vertical-align: baseline;" @click="importTemplate">下载模板</el-link>
            </div>
          </el-upload>
          <div slot="footer" class="dialog-footer">
            <el-button type="primary" @click="submitFileForm">确 定</el-button>
            <el-button @click="upload.open = false">取 消</el-button>
          </div>
        </el-dialog>
      </div>
    </template>
    
    <script>
    import { list${BusinessName}, get${BusinessName}, del${BusinessName}, add${BusinessName}, update${BusinessName} } from "@/api/${moduleName}/${businessName}";
    import { getToken } from '@/utils/auth'
    
    export default {
      name: "${BusinessName}",
    #if(${dicts} != '')
      dicts: [${dicts}],
    #end
      data() {
        return {
          // 遮罩层
          loading: true,
          // 选中数组
          ids: [],
    #if($table.sub)
          // 子表选中数据
          checked${subClassName}: [],
    #end
          // 非单个禁用
          single: true,
          // 非多个禁用
          multiple: true,
          // 显示搜索条件
          showSearch: true,
          // 总条数
          total: 0,
          // ${functionName}表格数据
          ${businessName}List: [],
    #if($table.sub)
          // ${subTable.functionName}表格数据
          ${subclassName}List: [],
    #end
          // 弹出层标题
          title: "",
          // 是否显示弹出层
          open: false,
    #foreach ($column in $columns)
    #if($column.htmlType == "datetime" && $column.queryType == "BETWEEN")
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
          // $comment时间范围
          daterange${AttrName}: [],
    #end
    #end
          // 查询参数
          queryParams: {
            pageNum: 1,
            pageSize: 10,
    #foreach ($column in $columns)
    #if($column.query)
            $column.javaField: null#if($foreach.count != $columns.size()),#end
    #end
    #end
          },
          // 表单参数
          form: {},
          // 导入参数
          upload: {
            // 是否显示弹出层
            open: false,
            // 弹出层标题
            title: "",
            // 是否禁用上传
            isUploading: false,
            // 是否更新已经存在的用户数据
            updateSupport: 0,
            // 设置上传的请求头部
            headers: { Authorization: "Bearer " + getToken() },
            // 上传的地址
            url: process.env.VUE_APP_BASE_API + "/${moduleName}/${businessName}/importData"
          },
          // 表单校验
          rules: {
    #foreach ($column in $columns)
    #if($column.required)
    #set($parentheseIndex=$column.columnComment.indexOf("（"))
    #if($parentheseIndex != -1)
    #set($comment=$column.columnComment.substring(0, $parentheseIndex))
    #else
    #set($comment=$column.columnComment)
    #end
            $column.javaField: [
              { required: true, message: "$comment不能为空", trigger: #if($column.htmlType == "select")"change"#else"blur"#end }
            ]#if($foreach.count != $columns.size()),#end
    #end
    #end
          }
        };
      },
      created() {
        this.getList();
      },
      methods: {
        /** 查询${functionName}列表 */
        getList() {
          this.loading = true;
    #foreach ($column in $columns)
    #if($column.htmlType == "datetime" && $column.queryType == "BETWEEN")
          this.queryParams.params = {};
    #break
    #end
    #end
    #foreach ($column in $columns)
    #if($column.htmlType == "datetime" && $column.queryType == "BETWEEN")
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
          if (null != this.daterange${AttrName} && '' != this.daterange${AttrName}) {
            this.queryParams.params["begin${AttrName}"] = this.daterange${AttrName}[0];
            this.queryParams.params["end${AttrName}"] = this.daterange${AttrName}[1];
          }
    #end
    #end
          list${BusinessName}(this.queryParams).then(response => {
            this.${businessName}List = response.rows;
            this.total = response.total;
            this.loading = false;
          });
        },
        // 取消按钮
        cancel() {
          this.open = false;
          this.reset();
        },
        // 表单重置
        reset() {
          this.form = {
    #foreach ($column in $columns)
    #if($column.htmlType == "radio")
            $column.javaField: #if($column.javaType == "Integer" || $column.javaType == "Long")0#else"0"#end#if($foreach.count != $columns.size()),#end
    #elseif($column.htmlType == "checkbox")
            $column.javaField: []#if($foreach.count != $columns.size()),#end
    #else
            $column.javaField: null#if($foreach.count != $columns.size()),#end
    #end
    #end
          };
    #if($table.sub)
          this.${subclassName}List = [];
    #end
          this.resetForm("form");
        },
        /** 搜索按钮操作 */
        handleQuery() {
          this.queryParams.pageNum = 1;
          this.getList();
        },
        /** 重置按钮操作 */
        resetQuery() {
    #foreach ($column in $columns)
    #if($column.htmlType == "datetime" && $column.queryType == "BETWEEN")
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
          this.daterange${AttrName} = [];
    #end
    #end
          this.resetForm("queryForm");
          this.handleQuery();
        },
        // 多选框选中数据
        handleSelectionChange(selection) {
          this.ids = selection.map(item => item.${pkColumn.javaField})
          this.single = selection.length!==1
          this.multiple = !selection.length
        },
        /** 新增按钮操作 */
        handleAdd() {
          this.reset();
          this.open = true;
          this.title = "添加${functionName}";
        },
        /** 修改按钮操作 */
        handleUpdate(row) {
          this.reset();
          const ${pkColumn.javaField} = row.${pkColumn.javaField} || this.ids
          get${BusinessName}(${pkColumn.javaField}).then(response => {
            this.form = response.data;
    #foreach ($column in $columns)
    #if($column.htmlType == "checkbox")
            this.form.$column.javaField = this.form.${column.javaField}.split(",");
    #end
    #end
    #if($table.sub)
            this.${subclassName}List = response.data.${subclassName}List;
    #end
            this.open = true;
            this.title = "修改${functionName}";
          });
        },
        /** 提交按钮 */
        submitForm() {
          this.#[[$]]#refs["form"].validate(valid => {
            if (valid) {
    #foreach ($column in $columns)
    #if($column.htmlType == "checkbox")
              this.form.$column.javaField = this.form.${column.javaField}.join(",");
    #end
    #end
    #if($table.sub)
              this.form.${subclassName}List = this.${subclassName}List;
    #end
              if (this.form.${pkColumn.javaField} != null) {
                update${BusinessName}(this.form).then(response => {
                  this.#[[$modal]]#.msgSuccess("修改成功");
                  this.open = false;
                  this.getList();
                });
              } else {
                add${BusinessName}(this.form).then(response => {
                  this.#[[$modal]]#.msgSuccess("新增成功");
                  this.open = false;
                  this.getList();
                });
              }
            }
          });
        },
        /** 删除按钮操作 */
        handleDelete(row) {
          const ${pkColumn.javaField}s = row.${pkColumn.javaField} || this.ids;
          this.#[[$modal]]#.confirm('是否确认删除${functionName}编号为"' + ${pkColumn.javaField}s + '"的数据项？').then(function() {
            return del${BusinessName}(${pkColumn.javaField}s);
          }).then(() => {
            this.getList();
            this.#[[$modal]]#.msgSuccess("删除成功");
          }).catch(() => {});
        },
    #if($table.sub)
    	/** ${subTable.functionName}序号 */
        row${subClassName}Index({ row, rowIndex }) {
          row.index = rowIndex + 1;
        },
        /** ${subTable.functionName}添加按钮操作 */
        handleAdd${subClassName}() {
          let obj = {};
    #foreach($column in $subTable.columns)
    #if($column.pk || $column.javaField == ${subTableFkclassName})
    #elseif($column.list && "" != $javaField)
          obj.$column.javaField = "";
    #end
    #end
          this.${subclassName}List.push(obj);
        },
        /** ${subTable.functionName}删除按钮操作 */
        handleDelete${subClassName}() {
          if (this.checked${subClassName}.length == 0) {
            this.#[[$modal]]#.msgError("请先选择要删除的${subTable.functionName}数据");
          } else {
            const ${subclassName}List = this.${subclassName}List;
            const checked${subClassName} = this.checked${subClassName};
            this.${subclassName}List = ${subclassName}List.filter(function(item) {
              return checked${subClassName}.indexOf(item.index) == -1
            });
          }
        },
        /** 复选框选中数据 */
        handle${subClassName}SelectionChange(selection) {
          this.checked${subClassName} = selection.map(item => item.index)
        },
    #end
        /** 导出按钮操作 */
        handleExport() {
          this.download('${moduleName}/${businessName}/export', {
            ...this.queryParams
          }, `${functionName}.xlsx`)
        },
        // ======================  导入相关方法 start ===================
        /** 导入按钮操作 */
        handleImport() {
          this.upload.title = "${functionName}导入";
          this.upload.open = true;
        },
        /** 下载模板操作 */
        importTemplate() {
          this.download('${moduleName}/${businessName}/importTemplate', {
          }, `${functionName}导入模板.xlsx`)
        },
        // 文件上传中处理
        handleFileUploadProgress(event, file, fileList) {
          this.upload.isUploading = true;
        },
        // 文件上传成功处理
        handleFileSuccess(response, file, fileList) {
          this.upload.open = false;
          this.upload.isUploading = false;
          this.$refs.upload.clearFiles();
          this.$alert("<div style='overflow: auto;overflow-x: hidden;max-height: 70vh;padding: 10px 20px 0;'>" + response.msg + "</div>", "导入结果", { dangerouslyUseHTMLString: true });
          this.getList();
        },
        // 提交上传文件
        submitFileForm() {
          this.$refs.upload.submit();
        }
        // ======================  导入相关方法 end ===================
      }
    };
    </script>

##### mapper.xml.vm #####

<?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="${packageName}.mapper.${ClassName}Mapper">
    
        <resultMap type="${ClassName}" id="${ClassName}Result">
    #foreach ($column in $columns)
            <result property="${column.javaField}"    column="${column.columnName}"    />
    #end
        </resultMap>
    #if($table.sub)
    
        <resultMap id="${ClassName}${subClassName}Result" type="${ClassName}" extends="${ClassName}Result">
            <collection property="${subclassName}List" notNullColumn="sub_${subTable.pkColumn.columnName}" javaType="java.util.List" resultMap="${subClassName}Result" />
        </resultMap>
    
        <resultMap type="${subClassName}" id="${subClassName}Result">
    #foreach ($column in $subTable.columns)
            <result property="${column.javaField}"    column="sub_${column.columnName}"    />
    #end
        </resultMap>
    #end
    
        <sql id="select${ClassName}Vo">
            select#foreach($column in $columns) $column.columnName#if($foreach.count != $columns.size()),#end#end from ${tableName}
        </sql>
    
        <select id="select${ClassName}List" parameterType="${ClassName}" resultMap="${ClassName}Result">
            <include refid="select${ClassName}Vo"/>
            <where>
    #foreach($column in $columns)
    #set($queryType=$column.queryType)
    #set($javaField=$column.javaField)
    #set($javaType=$column.javaType)
    #set($columnName=$column.columnName)
    #set($AttrName=$column.javaField.substring(0,1).toUpperCase() + ${column.javaField.substring(1)})
    #if($column.query)
    #if($column.queryType == "EQ")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName = #{$javaField}</if>
    #elseif($queryType == "NE")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName != #{$javaField}</if>
    #elseif($queryType == "GT")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName > #{$javaField}</if>
    #elseif($queryType == "GTE")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName >= #{$javaField}</if>
    #elseif($queryType == "LT")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName < #{$javaField}</if>
    #elseif($queryType == "LTE")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName <= #{$javaField}</if>
    #elseif($queryType == "LIKE")
                <if test="$javaField != null #if($javaType == 'String' ) and $javaField.trim() != ''#end"> and $columnName like concat('%', #{$javaField}, '%')</if>
    #elseif($queryType == "BETWEEN")
                <if test="params.begin$AttrName != null and params.begin$AttrName != '' and params.end$AttrName != null and params.end$AttrName != ''"> and $columnName between #{params.begin$AttrName} and #{params.end$AttrName}</if>
    #end
    #end
    #end
            </where>
        </select>
    
        <select id="select${ClassName}By${pkColumn.capJavaField}" parameterType="${pkColumn.javaType}" resultMap="#if($table.sub)${ClassName}${subClassName}Result#else${ClassName}Result#end">
    #if($table.crud || $table.tree)
            <include refid="select${ClassName}Vo"/>
            where ${pkColumn.columnName} = #{${pkColumn.javaField}}
    #elseif($table.sub)
            select#foreach($column in $columns) a.$column.columnName#if($foreach.count != $columns.size()),#end#end,
               #foreach($column in $subTable.columns) b.$column.columnName as sub_$column.columnName#if($foreach.count != $subTable.columns.size()),#end#end
    
            from ${tableName} a
            left join ${subTableName} b on b.${subTableFkName} = a.${pkColumn.columnName}
            where a.${pkColumn.columnName} = #{${pkColumn.javaField}}
    #end
        </select>
    
        <insert id="insert${ClassName}" parameterType="${ClassName}"#if($pkColumn.increment) useGeneratedKeys="true" keyProperty="$pkColumn.javaField"#end>
            insert into ${tableName}
            <trim prefix="(" suffix=")" suffixOverrides=",">
    #foreach($column in $columns)
    #if($column.columnName != $pkColumn.columnName || !$pkColumn.increment)
                <if test="$column.javaField != null#if($column.javaType == 'String' && $column.required) and $column.javaField != ''#end">$column.columnName,</if>
    #end
    #end
             </trim>
            <trim prefix="values (" suffix=")" suffixOverrides=",">
    #foreach($column in $columns)
    #if($column.columnName != $pkColumn.columnName || !$pkColumn.increment)
                <if test="$column.javaField != null#if($column.javaType == 'String' && $column.required) and $column.javaField != ''#end">#{$column.javaField},</if>
    #end
    #end
             </trim>
        </insert>
    
        <update id="update${ClassName}" parameterType="${ClassName}">
            update ${tableName}
            <trim prefix="SET" suffixOverrides=",">
    #foreach($column in $columns)
    #if($column.columnName != $pkColumn.columnName)
                <if test="$column.javaField != null#if($column.javaType == 'String' && $column.required) and $column.javaField != ''#end">$column.columnName = #{$column.javaField},</if>
    #end
    #end
            </trim>
            where ${pkColumn.columnName} = #{${pkColumn.javaField}}
        </update>
    
        <delete id="delete${ClassName}By${pkColumn.capJavaField}" parameterType="${pkColumn.javaType}">
            delete from ${tableName} where ${pkColumn.columnName} = #{${pkColumn.javaField}}
        </delete>
    
        <delete id="delete${ClassName}By${pkColumn.capJavaField}s" parameterType="String">
            delete from ${tableName} where ${pkColumn.columnName} in
            <foreach item="${pkColumn.javaField}" collection="array" open="(" separator="," close=")">
                #{${pkColumn.javaField}}
            </foreach>
        </delete>
    #if($table.sub)
    
        <delete id="delete${subClassName}By${subTableFkClassName}s" parameterType="String">
            delete from ${subTableName} where ${subTableFkName} in
            <foreach item="${subTableFkclassName}" collection="array" open="(" separator="," close=")">
                #{${subTableFkclassName}}
            </foreach>
        </delete>
    
        <delete id="delete${subClassName}By${subTableFkClassName}" parameterType="${pkColumn.javaType}">
            delete from ${subTableName} where ${subTableFkName} = #{${subTableFkclassName}}
        </delete>
    
        <insert id="batch${subClassName}">
            insert into ${subTableName}(#foreach($column in $subTable.columns) $column.columnName#if($foreach.count != $subTable.columns.size()),#end#end) values
    		<foreach item="item" index="index" collection="list" separator=",">
                (#foreach($column in $subTable.columns) #{item.$column.javaField}#if($foreach.count != $subTable.columns.size()),#end#end)
            </foreach>
        </insert>
    #end
    </mapper>

[3fe2b502cd8346b288907658f9592278.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/59f706be1d7143a6a7fc174d3393f50e.png