1

13693261870

2024-11-25 800f8676e3a6e65d2b6d02f3bcaffaf403ea5677

1

 se-modules/se-system/pom.xml

@@ -105,6 +105,12 @@
            <groupId>com.se</groupId>
            <artifactId>se-api-system</artifactId>
        </dependency>

        <!-- Apache Velocity -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
        </dependency>
    </dependencies>

    <build>

 se-modules/se-system/src/main/java/com/se/system/config/GenConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,66 @@
package com.se.system.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * ä»£ç ç”Ÿæˆç›¸å…³é…ç½®
 * 
 * @author admin
 */
@Component
@ConfigurationProperties(prefix = "gen")
public class GenConfig
{
    /** ä½œè€… */
    public static String author;

    /** ç”ŸæˆåŒ…路径 */
    public static String packageName;

    /** è‡ªåŠ¨åŽ»é™¤è¡¨å‰ç¼€ï¼Œé»˜è®¤æ˜¯false */
    public static boolean autoRemovePre;

    /** è¡¨å‰ç¼€(类名不会包含表前缀) */
    public static String tablePrefix;

    public static String getAuthor()
    {
        return author;
    }

    public void setAuthor(String author)
    {
        GenConfig.author = author;
    }

    public static String getPackageName()
    {
        return packageName;
    }

    public void setPackageName(String packageName)
    {
        GenConfig.packageName = packageName;
    }

    public static boolean getAutoRemovePre()
    {
        return autoRemovePre;
    }

    public void setAutoRemovePre(boolean autoRemovePre)
    {
        GenConfig.autoRemovePre = autoRemovePre;
    }

    public static String getTablePrefix()
    {
        return tablePrefix;
    }

    public void setTablePrefix(String tablePrefix)
    {
        GenConfig.tablePrefix = tablePrefix;
    }
}

 se-modules/se-system/src/main/java/com/se/system/controller/GenController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,205 @@
package com.se.system.controller;

import com.se.common.core.text.Convert;
import com.se.common.core.web.controller.BaseController;
import com.se.common.core.web.domain.AjaxResult;
import com.se.common.core.web.page.TableDataInfo;
import com.se.common.log.annotation.Log;
import com.se.common.log.enums.BusinessType;
import com.se.common.security.annotation.RequiresPermissions;
import com.se.system.domain.GenTable;
import com.se.system.domain.GenTableColumn;
import com.se.system.service.inte.IGenTableColumnService;
import com.se.system.service.inte.IGenTableService;
import org.apache.commons.io.IOUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ä»£ç ç”Ÿæˆ æ“ä½œå¤„理
 * 
 * @author admin
 */
@RequestMapping("/gen")
@RestController
public class GenController extends BaseController
{
    @Resource
    private IGenTableService genTableService;

    @Resource
    private IGenTableColumnService genTableColumnService;

    /**
     * æŸ¥è¯¢ä»£ç ç”Ÿæˆåˆ—表
     */
    @RequiresPermissions("tool:gen:list")
    @GetMapping("/list")
    public TableDataInfo genList(GenTable genTable)
    {
        startPage();
        List<GenTable> list = genTableService.selectGenTableList(genTable);
        return getDataTable(list);
    }

    /**
     * ä¿®æ”¹ä»£ç ç”Ÿæˆä¸šåŠ¡
     */
    @RequiresPermissions("tool:gen:query")
    @GetMapping(value = "/{tableId}")
    public AjaxResult getInfo(@PathVariable Long tableId)
    {
        GenTable table = genTableService.selectGenTableById(tableId);
        List<GenTable> tables = genTableService.selectGenTableAll();
        List<GenTableColumn> list = genTableColumnService.selectGenTableColumnListByTableId(tableId);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("info", table);
        map.put("rows", list);
        map.put("tables", tables);
        return success(map);
    }

    /**
     * æŸ¥è¯¢æ•°æ®åº“列表
     */
    @RequiresPermissions("tool:gen:list")
    @GetMapping("/db/list")
    public TableDataInfo dataList(GenTable genTable)
    {
        startPage();
        List<GenTable> list = genTableService.selectDbTableList(genTable);
        return getDataTable(list);
    }

    /**
     * æŸ¥è¯¢æ•°æ®è¡¨å­—段列表
     */
    @GetMapping(value = "/column/{tableId}")
    public TableDataInfo columnList(Long tableId)
    {
        TableDataInfo dataInfo = new TableDataInfo();
        List<GenTableColumn> list = genTableColumnService.selectGenTableColumnListByTableId(tableId);
        dataInfo.setRows(list);
        dataInfo.setTotal(list.size());
        return dataInfo;
    }

    /**
     * å¯¼å…¥è¡¨ç»“构（保存）
     */
    @RequiresPermissions("tool:gen:import")
    @Log(title = "代码生成", businessType = BusinessType.IMPORT)
    @PostMapping("/importTable")
    public AjaxResult importTableSave(String tables)
    {
        String[] tableNames = Convert.toStrArray(tables);
        // æŸ¥è¯¢è¡¨ä¿¡æ¯
        List<GenTable> tableList = genTableService.selectDbTableListByNames(tableNames);
        genTableService.importGenTable(tableList);
        return success();
    }

    /**
     * ä¿®æ”¹ä¿å­˜ä»£ç ç”Ÿæˆä¸šåŠ¡
     */
    @RequiresPermissions("tool:gen:edit")
    @Log(title = "代码生成", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult editSave(@Validated @RequestBody GenTable genTable)
    {
        genTableService.validateEdit(genTable);
        genTableService.updateGenTable(genTable);
        return success();
    }

    /**
     * åˆ é™¤ä»£ç ç”Ÿæˆ
     */
    @RequiresPermissions("tool:gen:remove")
    @Log(title = "代码生成", businessType = BusinessType.DELETE)
    @DeleteMapping("/{tableIds}")
    public AjaxResult remove(@PathVariable Long[] tableIds)
    {
        genTableService.deleteGenTableByIds(tableIds);
        return success();
    }

    /**
     * é¢„览代码
     */
    @RequiresPermissions("tool:gen:preview")
    @GetMapping("/preview/{tableId}")
    public AjaxResult preview(@PathVariable("tableId") Long tableId) throws IOException
    {
        Map<String, String> dataMap = genTableService.previewCode(tableId);
        return success(dataMap);
    }

    /**
     * ç”Ÿæˆä»£ç ï¼ˆä¸‹è½½æ–¹å¼ï¼‰
     */
    @RequiresPermissions("tool:gen:code")
    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
    @GetMapping("/download/{tableName}")
    public void download(HttpServletResponse response, @PathVariable("tableName") String tableName) throws IOException
    {
        byte[] data = genTableService.downloadCode(tableName);
        genCode(response, data);
    }

    /**
     * ç”Ÿæˆä»£ç ï¼ˆè‡ªå®šä¹‰è·¯å¾„）
     */
    @RequiresPermissions("tool:gen:code")
    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
    @GetMapping("/genCode/{tableName}")
    public AjaxResult genCode(@PathVariable("tableName") String tableName)
    {
        genTableService.generatorCode(tableName);
        return success();
    }

    /**
     * åŒæ­¥æ•°æ®åº“
     */
    @RequiresPermissions("tool:gen:edit")
    @Log(title = "代码生成", businessType = BusinessType.UPDATE)
    @GetMapping("/synchDb/{tableName}")
    public AjaxResult synchDb(@PathVariable("tableName") String tableName)
    {
        genTableService.synchDb(tableName);
        return success();
    }

    /**
     * æ‰¹é‡ç”Ÿæˆä»£ç 
     */
    @RequiresPermissions("tool:gen:code")
    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
    @GetMapping("/batchGenCode")
    public void batchGenCode(HttpServletResponse response, String tables) throws IOException
    {
        String[] tableNames = Convert.toStrArray(tables);
        byte[] data = genTableService.downloadCode(tableNames);
        genCode(response, data);
    }

    /**
     * ç”Ÿæˆzip文件
     */
    private void genCode(HttpServletResponse response, byte[] data) throws IOException
    {
        response.reset();
        response.setHeader("Content-Disposition", "attachment; filename=\"se.zip\"");
        response.addHeader("Content-Length", "" + data.length);
        response.setContentType("application/octet-stream; charset=UTF-8");
        IOUtils.write(data, response.getOutputStream());
    }
}

 se-modules/se-system/src/main/java/com/se/system/domain/GenTable.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,384 @@
package com.se.system.domain;

import com.se.common.core.constant.GenConstants;
import com.se.common.core.utils.StringUtils;
import com.se.common.core.web.domain.BaseEntity;
import org.apache.commons.lang3.ArrayUtils;

import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import java.util.List;

/**
 * ä¸šåŠ¡è¡¨ gen_table
 * 
 * @author admin
 */
public class GenTable extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** ç¼–号 */
    private Long tableId;

    /** è¡¨åç§° */
    @NotBlank(message = "表名称不能为空")
    private String tableName;

    /** è¡¨æè¿° */
    @NotBlank(message = "表描述不能为空")
    private String tableComment;

    /** å…³è”父表的表名 */
    private String subTableName;

    /** æœ¬è¡¨å…³è”父表的外键名 */
    private String subTableFkName;

    /** å®žä½“类名称(首字母大写) */
    @NotBlank(message = "实体类名称不能为空")
    private String className;

    /** ä½¿ç”¨çš„模板（crud单表操作 tree树表操作 sub主子表操作） */
    private String tplCategory;

    /** å‰ç«¯ç±»åž‹ï¼ˆelement-ui模版 element-plus模版） */
    private String tplWebType;

    /** ç”ŸæˆåŒ…路径 */
    @NotBlank(message = "生成包路径不能为空")
    private String packageName;

    /** ç”Ÿæˆæ¨¡å—名 */
    @NotBlank(message = "生成模块名不能为空")
    private String moduleName;

    /** ç”Ÿæˆä¸šåŠ¡å */
    @NotBlank(message = "生成业务名不能为空")
    private String businessName;

    /** ç”ŸæˆåŠŸèƒ½å */
    @NotBlank(message = "生成功能名不能为空")
    private String functionName;

    /** ç”Ÿæˆä½œè€… */
    @NotBlank(message = "作者不能为空")
    private String functionAuthor;

    /** ç”Ÿæˆä»£ç æ–¹å¼ï¼ˆ0zip压缩包 1自定义路径） */
    private String genType;

    /** ç”Ÿæˆè·¯å¾„（不填默认项目路径） */
    private String genPath;

    /** ä¸»é”®ä¿¡æ¯ */
    private GenTableColumn pkColumn;

    /** å­è¡¨ä¿¡æ¯ */
    private GenTable subTable;

    /** è¡¨åˆ—信息 */
    @Valid
    private List<GenTableColumn> columns;

    /** å…¶å®ƒç”Ÿæˆé€‰é¡¹ */
    private String options;

    /** æ ‘编码字段 */
    private String treeCode;

    /** æ ‘父编码字段 */
    private String treeParentCode;

    /** æ ‘名称字段 */
    private String treeName;

    /** ä¸Šçº§èœå•ID字段 */
    private String parentMenuId;

    /** ä¸Šçº§èœå•åç§°å­—段 */
    private String parentMenuName;

    public Long getTableId()
    {
        return tableId;
    }

    public void setTableId(Long tableId)
    {
        this.tableId = tableId;
    }

    public String getTableName()
    {
        return tableName;
    }

    public void setTableName(String tableName)
    {
        this.tableName = tableName;
    }

    public String getTableComment()
    {
        return tableComment;
    }

    public void setTableComment(String tableComment)
    {
        this.tableComment = tableComment;
    }

    public String getSubTableName()
    {
        return subTableName;
    }

    public void setSubTableName(String subTableName)
    {
        this.subTableName = subTableName;
    }

    public String getSubTableFkName()
    {
        return subTableFkName;
    }

    public void setSubTableFkName(String subTableFkName)
    {
        this.subTableFkName = subTableFkName;
    }

    public String getClassName()
    {
        return className;
    }

    public void setClassName(String className)
    {
        this.className = className;
    }

    public String getTplCategory()
    {
        return tplCategory;
    }

    public void setTplCategory(String tplCategory)
    {
        this.tplCategory = tplCategory;
    }

    public String getTplWebType()
    {
        return tplWebType;
    }

    public void setTplWebType(String tplWebType)
    {
        this.tplWebType = tplWebType;
    }

    public String getPackageName()
    {
        return packageName;
    }

    public void setPackageName(String packageName)
    {
        this.packageName = packageName;
    }

    public String getModuleName()
    {
        return moduleName;
    }

    public void setModuleName(String moduleName)
    {
        this.moduleName = moduleName;
    }

    public String getBusinessName()
    {
        return businessName;
    }

    public void setBusinessName(String businessName)
    {
        this.businessName = businessName;
    }

    public String getFunctionName()
    {
        return functionName;
    }

    public void setFunctionName(String functionName)
    {
        this.functionName = functionName;
    }

    public String getFunctionAuthor()
    {
        return functionAuthor;
    }

    public void setFunctionAuthor(String functionAuthor)
    {
        this.functionAuthor = functionAuthor;
    }

    public String getGenType()
    {
        return genType;
    }

    public void setGenType(String genType)
    {
        this.genType = genType;
    }

    public String getGenPath()
    {
        return genPath;
    }

    public void setGenPath(String genPath)
    {
        this.genPath = genPath;
    }

    public GenTableColumn getPkColumn()
    {
        return pkColumn;
    }

    public void setPkColumn(GenTableColumn pkColumn)
    {
        this.pkColumn = pkColumn;
    }

    public GenTable getSubTable()
    {
        return subTable;
    }

    public void setSubTable(GenTable subTable)
    {
        this.subTable = subTable;
    }
    public List<GenTableColumn> getColumns()
    {
        return columns;
    }

    public void setColumns(List<GenTableColumn> columns)
    {
        this.columns = columns;
    }

    public String getOptions()
    {
        return options;
    }

    public void setOptions(String options)
    {
        this.options = options;
    }

    public String getTreeCode()
    {
        return treeCode;
    }

    public void setTreeCode(String treeCode)
    {
        this.treeCode = treeCode;
    }

    public String getTreeParentCode()
    {
        return treeParentCode;
    }

    public void setTreeParentCode(String treeParentCode)
    {
        this.treeParentCode = treeParentCode;
    }

    public String getTreeName()
    {
        return treeName;
    }

    public void setTreeName(String treeName)
    {
        this.treeName = treeName;
    }

    public String getParentMenuId()
    {
        return parentMenuId;
    }

    public void setParentMenuId(String parentMenuId)
    {
        this.parentMenuId = parentMenuId;
    }

    public String getParentMenuName()
    {
        return parentMenuName;
    }

    public void setParentMenuName(String parentMenuName)
    {
        this.parentMenuName = parentMenuName;
    }

    public boolean isSub()
    {
        return isSub(this.tplCategory);
    }

    public static boolean isSub(String tplCategory)
    {
        return tplCategory != null && StringUtils.equals(GenConstants.TPL_SUB, tplCategory);
    }
    public boolean isTree()
    {
        return isTree(this.tplCategory);
    }

    public static boolean isTree(String tplCategory)
    {
        return tplCategory != null && StringUtils.equals(GenConstants.TPL_TREE, tplCategory);
    }

    public boolean isCrud()
    {
        return isCrud(this.tplCategory);
    }

    public static boolean isCrud(String tplCategory)
    {
        return tplCategory != null && StringUtils.equals(GenConstants.TPL_CRUD, tplCategory);
    }

    public boolean isSuperColumn(String javaField)
    {
        return isSuperColumn(this.tplCategory, javaField);
    }

    public static boolean isSuperColumn(String tplCategory, String javaField)
    {
        if (isTree(tplCategory))
        {
            return StringUtils.equalsAnyIgnoreCase(javaField,
                    ArrayUtils.addAll(GenConstants.TREE_ENTITY, GenConstants.BASE_ENTITY));
        }
        return StringUtils.equalsAnyIgnoreCase(javaField, GenConstants.BASE_ENTITY);
    }
}

 se-modules/se-system/src/main/java/com/se/system/domain/GenTableColumn.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,374 @@
package com.se.system.domain;

import com.se.common.core.utils.StringUtils;
import com.se.common.core.web.domain.BaseEntity;

import javax.validation.constraints.NotBlank;

/**
 * ä»£ç ç”Ÿæˆä¸šåŠ¡å­—段表 gen_table_column
 * 
 * @author admin
 */
public class GenTableColumn extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** ç¼–号 */
    private Long columnId;

    /** å½’属表编号 */
    private Long tableId;

    /** åˆ—名称 */
    private String columnName;

    /** åˆ—描述 */
    private String columnComment;

    /** åˆ—类型 */
    private String columnType;

    /** JAVA类型 */
    private String javaType;

    /** JAVA字段名 */
    @NotBlank(message = "Java属性不能为空")
    private String javaField;

    /** æ˜¯å¦ä¸»é”®ï¼ˆ1是） */
    private String isPk;

    /** æ˜¯å¦è‡ªå¢žï¼ˆ1是） */
    private String isIncrement;

    /** æ˜¯å¦å¿…填（1是） */
    private String isRequired;

    /** æ˜¯å¦ä¸ºæ’入字段（1是） */
    private String isInsert;

    /** æ˜¯å¦ç¼–辑字段（1是） */
    private String isEdit;

    /** æ˜¯å¦åˆ—表字段（1是） */
    private String isList;

    /** æ˜¯å¦æŸ¥è¯¢å­—段（1是） */
    private String isQuery;

    /** æŸ¥è¯¢æ–¹å¼ï¼ˆEQ等于、NE不等于、GT大于、LT小于、LIKE模糊、BETWEEN范围） */
    private String queryType;

    /** æ˜¾ç¤ºç±»åž‹ï¼ˆinput文本框、textarea文本域、select下拉框、checkbox复选框、radio单选框、datetime日期控件、image图片上传控件、upload文件上传控件、editor富文本控件） */
    private String htmlType;

    /** å­—典类型 */
    private String dictType;

    /** æŽ’序 */
    private Integer sort;

    public void setColumnId(Long columnId)
    {
        this.columnId = columnId;
    }

    public Long getColumnId()
    {
        return columnId;
    }

    public void setTableId(Long tableId)
    {
        this.tableId = tableId;
    }

    public Long getTableId()
    {
        return tableId;
    }

    public void setColumnName(String columnName)
    {
        this.columnName = columnName;
    }

    public String getColumnName()
    {
        return columnName;
    }

    public void setColumnComment(String columnComment)
    {
        this.columnComment = columnComment;
    }

    public String getColumnComment()
    {
        return columnComment;
    }

    public void setColumnType(String columnType)
    {
        this.columnType = columnType;
    }

    public String getColumnType()
    {
        return columnType;
    }

    public void setJavaType(String javaType)
    {
        this.javaType = javaType;
    }

    public String getJavaType()
    {
        return javaType;
    }

    public void setJavaField(String javaField)
    {
        this.javaField = javaField;
    }

    public String getJavaField()
    {
        return javaField;
    }

    public String getCapJavaField()
    {
        return StringUtils.capitalize(javaField);
    }

    public void setIsPk(String isPk)
    {
        this.isPk = isPk;
    }

    public String getIsPk()
    {
        return isPk;
    }

    public boolean isPk()
    {
        return isPk(this.isPk);
    }

    public boolean isPk(String isPk)
    {
        return isPk != null && StringUtils.equals("1", isPk);
    }

    public String getIsIncrement()
    {
        return isIncrement;
    }

    public void setIsIncrement(String isIncrement)
    {
        this.isIncrement = isIncrement;
    }

    public boolean isIncrement()
    {
        return isIncrement(this.isIncrement);
    }

    public boolean isIncrement(String isIncrement)
    {
        return isIncrement != null && StringUtils.equals("1", isIncrement);
    }

    public void setIsRequired(String isRequired)
    {
        this.isRequired = isRequired;
    }

    public String getIsRequired()
    {
        return isRequired;
    }

    public boolean isRequired()
    {
        return isRequired(this.isRequired);
    }

    public boolean isRequired(String isRequired)
    {
        return isRequired != null && StringUtils.equals("1", isRequired);
    }

    public void setIsInsert(String isInsert)
    {
        this.isInsert = isInsert;
    }

    public String getIsInsert()
    {
        return isInsert;
    }

    public boolean isInsert()
    {
        return isInsert(this.isInsert);
    }

    public boolean isInsert(String isInsert)
    {
        return isInsert != null && StringUtils.equals("1", isInsert);
    }

    public void setIsEdit(String isEdit)
    {
        this.isEdit = isEdit;
    }

    public String getIsEdit()
    {
        return isEdit;
    }

    public boolean isEdit()
    {
        return isInsert(this.isEdit);
    }

    public boolean isEdit(String isEdit)
    {
        return isEdit != null && StringUtils.equals("1", isEdit);
    }

    public void setIsList(String isList)
    {
        this.isList = isList;
    }

    public String getIsList()
    {
        return isList;
    }

    public boolean isList()
    {
        return isList(this.isList);
    }

    public boolean isList(String isList)
    {
        return isList != null && StringUtils.equals("1", isList);
    }

    public void setIsQuery(String isQuery)
    {
        this.isQuery = isQuery;
    }

    public String getIsQuery()
    {
        return isQuery;
    }

    public boolean isQuery()
    {
        return isQuery(this.isQuery);
    }

    public boolean isQuery(String isQuery)
    {
        return isQuery != null && StringUtils.equals("1", isQuery);
    }

    public void setQueryType(String queryType)
    {
        this.queryType = queryType;
    }

    public String getQueryType()
    {
        return queryType;
    }

    public String getHtmlType()
    {
        return htmlType;
    }

    public void setHtmlType(String htmlType)
    {
        this.htmlType = htmlType;
    }

    public void setDictType(String dictType)
    {
        this.dictType = dictType;
    }

    public String getDictType()
    {
        return dictType;
    }

    public void setSort(Integer sort)
    {
        this.sort = sort;
    }

    public Integer getSort()
    {
        return sort;
    }

    public boolean isSuperColumn()
    {
        return isSuperColumn(this.javaField);
    }

    public static boolean isSuperColumn(String javaField)
    {
        return StringUtils.equalsAnyIgnoreCase(javaField,
                // BaseEntity
                "createBy", "createTime", "updateBy", "updateTime", "remark",
                // TreeEntity
                "parentName", "parentId", "orderNum", "ancestors");
    }

    public boolean isUsableColumn()
    {
        return isUsableColumn(javaField);
    }

    public static boolean isUsableColumn(String javaField)
    {
        // isSuperColumn()中的名单用于避免生成多余Domain属性，若某些属性在生成页面时需要用到不能忽略，则放在此处白名单
        return StringUtils.equalsAnyIgnoreCase(javaField, "parentId", "orderNum", "remark");
    }

    public String readConverterExp()
    {
        String remarks = StringUtils.substringBetween(this.columnComment, "（", "）");
        StringBuffer sb = new StringBuffer();
        if (StringUtils.isNotEmpty(remarks))
        {
            for (String value : remarks.split(" "))
            {
                if (StringUtils.isNotEmpty(value))
                {
                    Object startStr = value.subSequence(0, 1);
                    String endStr = value.substring(1);
                    sb.append("").append(startStr).append("=").append(endStr).append(",");
                }
            }
            return sb.deleteCharAt(sb.length() - 1).toString();
        }
        else
        {
            return this.columnComment;
        }
    }
}

 se-modules/se-system/src/main/java/com/se/system/mapper/GenTableColumnMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
package com.se.system.mapper;

import com.se.system.domain.GenTableColumn;

import java.util.List;

/**
 * ä¸šåŠ¡å­—段 æ•°æ®å±‚
 * 
 * @author admin
 */
public interface GenTableColumnMapper
{
    /**
     * æ ¹æ®è¡¨åç§°æŸ¥è¯¢åˆ—信息
     * 
     * @param tableName è¡¨åç§°
     * @return åˆ—信息
     */
    public List<GenTableColumn> selectDbTableColumnsByName(String tableName);

    /**
     * æŸ¥è¯¢ä¸šåŠ¡å­—段列表
     * 
     * @param tableId ä¸šåŠ¡å­—段编号
     * @return ä¸šåŠ¡å­—段集合
     */
    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId);

    /**
     * æ–°å¢žä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    public int insertGenTableColumn(GenTableColumn genTableColumn);

    /**
     * ä¿®æ”¹ä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    public int updateGenTableColumn(GenTableColumn genTableColumn);

    /**
     * åˆ é™¤ä¸šåŠ¡å­—段
     * 
     * @param genTableColumns åˆ—数据
     * @return ç»“æžœ
     */
    public int deleteGenTableColumns(List<GenTableColumn> genTableColumns);

    /**
     * æ‰¹é‡åˆ é™¤ä¸šåŠ¡å­—段
     * 
     * @param ids éœ€è¦åˆ é™¤çš„数据ID
     * @return ç»“æžœ
     */
    public int deleteGenTableColumnByIds(Long[] ids);
}

 se-modules/se-system/src/main/java/com/se/system/mapper/GenTableMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,84 @@
package com.se.system.mapper;

import com.se.system.domain.GenTable;

import java.util.List;

/**
 * ä¸šåŠ¡ æ•°æ®å±‚
 * 
 * @author admin
 */
public interface GenTableMapper
{
    /**
     * æŸ¥è¯¢ä¸šåŠ¡åˆ—表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ä¸šåŠ¡é›†åˆ
     */
    public List<GenTable> selectGenTableList(GenTable genTable);

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return æ•°æ®åº“表集合
     */
    public List<GenTable> selectDbTableList(GenTable genTable);

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param tableNames è¡¨åç§°ç»„
     * @return æ•°æ®åº“表集合
     */
    public List<GenTable> selectDbTableListByNames(String[] tableNames);

    /**
     * æŸ¥è¯¢æ‰€æœ‰è¡¨ä¿¡æ¯
     * 
     * @return è¡¨ä¿¡æ¯é›†åˆ
     */
    public List<GenTable> selectGenTableAll();

    /**
     * æŸ¥è¯¢è¡¨ID业务信息
     * 
     * @param id ä¸šåŠ¡ID
     * @return ä¸šåŠ¡ä¿¡æ¯
     */
    public GenTable selectGenTableById(Long id);

    /**
     * æŸ¥è¯¢è¡¨åç§°ä¸šåŠ¡ä¿¡æ¯
     * 
     * @param tableName è¡¨åç§°
     * @return ä¸šåŠ¡ä¿¡æ¯
     */
    public GenTable selectGenTableByName(String tableName);

    /**
     * æ–°å¢žä¸šåŠ¡
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ç»“æžœ
     */
    public int insertGenTable(GenTable genTable);

    /**
     * ä¿®æ”¹ä¸šåŠ¡
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ç»“æžœ
     */
    public int updateGenTable(GenTable genTable);

    /**
     * æ‰¹é‡åˆ é™¤ä¸šåŠ¡
     * 
     * @param ids éœ€è¦åˆ é™¤çš„数据ID
     * @return ç»“æžœ
     */
    public int deleteGenTableByIds(Long[] ids);
}

 se-modules/se-system/src/main/java/com/se/system/service/impl/GenTableColumnServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,70 @@
package com.se.system.service.impl;

import com.se.common.core.text.Convert;
import com.se.system.domain.GenTableColumn;
import com.se.system.mapper.GenTableColumnMapper;
import com.se.system.service.inte.IGenTableColumnService;
import org.springframework.stereotype.Service;

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

/**
 * ä¸šåŠ¡å­—段 æœåŠ¡å±‚实现
 * 
 * @author admin
 */
@Service
public class GenTableColumnServiceImpl implements IGenTableColumnService
{
    @Resource
    private GenTableColumnMapper genTableColumnMapper;

    /**
     * æŸ¥è¯¢ä¸šåŠ¡å­—段列表
     * 
     * @param tableId ä¸šåŠ¡å­—段编号
     * @return ä¸šåŠ¡å­—段集合
     */
    @Override
    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId)
    {
        return genTableColumnMapper.selectGenTableColumnListByTableId(tableId);
    }
	
    /**
     * æ–°å¢žä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    @Override
    public int insertGenTableColumn(GenTableColumn genTableColumn)
    {
        return genTableColumnMapper.insertGenTableColumn(genTableColumn);
    }
	
    /**
     * ä¿®æ”¹ä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    @Override
    public int updateGenTableColumn(GenTableColumn genTableColumn)
    {
        return genTableColumnMapper.updateGenTableColumn(genTableColumn);
    }

    /**
     * åˆ é™¤ä¸šåŠ¡å­—段对象
     * 
     * @param ids éœ€è¦åˆ é™¤çš„数据ID
     * @return ç»“æžœ
     */
    @Override
    public int deleteGenTableColumnByIds(String ids)
    {
        return genTableColumnMapper.deleteGenTableColumnByIds(Convert.toLongArray(ids));
    }
}

 se-modules/se-system/src/main/java/com/se/system/service/impl/GenTableServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,523 @@
package com.se.system.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.se.common.core.constant.Constants;
import com.se.common.core.constant.GenConstants;
import com.se.common.core.exception.ServiceException;
import com.se.common.core.text.CharsetKit;
import com.se.common.core.utils.StringUtils;
import com.se.common.security.utils.SecurityUtils;
import com.se.system.domain.GenTable;
import com.se.system.domain.GenTableColumn;
import com.se.system.mapper.GenTableColumnMapper;
import com.se.system.mapper.GenTableMapper;
import com.se.system.service.inte.IGenTableService;
import com.se.system.utils.GenUtils;
import com.se.system.utils.VelocityInitializer;
import com.se.system.utils.VelocityUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * ä¸šåŠ¡ æœåŠ¡å±‚实现
 * 
 * @author admin
 */
@Service
public class GenTableServiceImpl implements IGenTableService
{
    private static final Logger log = LoggerFactory.getLogger(GenTableServiceImpl.class);

    @Resource
    private GenTableMapper genTableMapper;

    @Resource
    private GenTableColumnMapper genTableColumnMapper;

    /**
     * æŸ¥è¯¢ä¸šåŠ¡ä¿¡æ¯
     * 
     * @param id ä¸šåŠ¡ID
     * @return ä¸šåŠ¡ä¿¡æ¯
     */
    @Override
    public GenTable selectGenTableById(Long id)
    {
        GenTable genTable = genTableMapper.selectGenTableById(id);
        setTableFromOptions(genTable);
        return genTable;
    }

    /**
     * æŸ¥è¯¢ä¸šåŠ¡åˆ—表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ä¸šåŠ¡é›†åˆ
     */
    @Override
    public List<GenTable> selectGenTableList(GenTable genTable)
    {
        return genTableMapper.selectGenTableList(genTable);
    }

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return æ•°æ®åº“表集合
     */
    @Override
    public List<GenTable> selectDbTableList(GenTable genTable)
    {
        return genTableMapper.selectDbTableList(genTable);
    }

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param tableNames è¡¨åç§°ç»„
     * @return æ•°æ®åº“表集合
     */
    @Override
    public List<GenTable> selectDbTableListByNames(String[] tableNames)
    {
        return genTableMapper.selectDbTableListByNames(tableNames);
    }

    /**
     * æŸ¥è¯¢æ‰€æœ‰è¡¨ä¿¡æ¯
     * 
     * @return è¡¨ä¿¡æ¯é›†åˆ
     */
    @Override
    public List<GenTable> selectGenTableAll()
    {
        return genTableMapper.selectGenTableAll();
    }

    /**
     * ä¿®æ”¹ä¸šåŠ¡
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ç»“æžœ
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateGenTable(GenTable genTable)
    {
        String options = JSON.toJSONString(genTable.getParams());
        genTable.setOptions(options);
        int row = genTableMapper.updateGenTable(genTable);
        if (row > 0)
        {
            for (GenTableColumn cenTableColumn : genTable.getColumns())
            {
                genTableColumnMapper.updateGenTableColumn(cenTableColumn);
            }
        }
    }

    /**
     * åˆ é™¤ä¸šåŠ¡å¯¹è±¡
     * 
     * @param tableIds éœ€è¦åˆ é™¤çš„数据ID
     * @return ç»“æžœ
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteGenTableByIds(Long[] tableIds)
    {
        genTableMapper.deleteGenTableByIds(tableIds);
        genTableColumnMapper.deleteGenTableColumnByIds(tableIds);
    }

    /**
     * å¯¼å…¥è¡¨ç»“æž„
     * 
     * @param tableList å¯¼å…¥è¡¨åˆ—表
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void importGenTable(List<GenTable> tableList)
    {
        String operName = SecurityUtils.getUsername();
        try
        {
            for (GenTable table : tableList)
            {
                String tableName = table.getTableName();
                GenUtils.initTable(table, operName);
                int row = genTableMapper.insertGenTable(table);
                if (row > 0)
                {
                    // ä¿å­˜åˆ—信息
                    List<GenTableColumn> genTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
                    for (GenTableColumn column : genTableColumns)
                    {
                        GenUtils.initColumnField(column, table);
                        genTableColumnMapper.insertGenTableColumn(column);
                    }
                }
            }
        }
        catch (Exception e)
        {
            throw new ServiceException("导入失败：" + e.getMessage());
        }
    }

    /**
     * é¢„览代码
     * 
     * @param tableId è¡¨ç¼–号
     * @return é¢„览数据列表
     */
    @Override
    public Map<String, String> previewCode(Long tableId)
    {
        Map<String, String> dataMap = new LinkedHashMap<>();
        // æŸ¥è¯¢è¡¨ä¿¡æ¯
        GenTable table = genTableMapper.selectGenTableById(tableId);
        // è®¾ç½®ä¸»å­è¡¨ä¿¡æ¯
        setSubTable(table);
        // è®¾ç½®ä¸»é”®åˆ—信息
        setPkColumn(table);
        VelocityInitializer.initVelocity();

        VelocityContext context = VelocityUtils.prepareContext(table);

        // èŽ·å–模板列表
        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
        for (String template : templates)
        {
            // æ¸²æŸ“模板
            StringWriter sw = new StringWriter();
            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
            tpl.merge(context, sw);
            dataMap.put(template, sw.toString());
        }
        return dataMap;
    }

    /**
     * ç”Ÿæˆä»£ç ï¼ˆä¸‹è½½æ–¹å¼ï¼‰
     * 
     * @param tableName è¡¨åç§°
     * @return æ•°æ®
     */
    @Override
    public byte[] downloadCode(String tableName)
    {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ZipOutputStream zip = new ZipOutputStream(outputStream);
        generatorCode(tableName, zip);
        IOUtils.closeQuietly(zip);
        return outputStream.toByteArray();
    }

    /**
     * ç”Ÿæˆä»£ç ï¼ˆè‡ªå®šä¹‰è·¯å¾„）
     * 
     * @param tableName è¡¨åç§°
     */
    @Override
    public void generatorCode(String tableName)
    {
        // æŸ¥è¯¢è¡¨ä¿¡æ¯
        GenTable table = genTableMapper.selectGenTableByName(tableName);
        // è®¾ç½®ä¸»å­è¡¨ä¿¡æ¯
        setSubTable(table);
        // è®¾ç½®ä¸»é”®åˆ—信息
        setPkColumn(table);

        VelocityInitializer.initVelocity();

        VelocityContext context = VelocityUtils.prepareContext(table);

        // èŽ·å–模板列表
        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
        for (String template : templates)
        {
            if (!StringUtils.containsAny(template, "sql.vm", "api.js.vm", "index.vue.vm", "index-tree.vue.vm"))
            {
                // æ¸²æŸ“模板
                StringWriter sw = new StringWriter();
                Template tpl = Velocity.getTemplate(template, Constants.UTF8);
                tpl.merge(context, sw);
                try
                {
                    String path = getGenPath(table, template);
                    FileUtils.writeStringToFile(new File(path), sw.toString(), CharsetKit.UTF_8);
                }
                catch (IOException e)
                {
                    throw new ServiceException("渲染模板失败，表名：" + table.getTableName());
                }
            }
        }
    }

    /**
     * åŒæ­¥æ•°æ®åº“
     * 
     * @param tableName è¡¨åç§°
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void synchDb(String tableName)
    {
        GenTable table = genTableMapper.selectGenTableByName(tableName);
        List<GenTableColumn> tableColumns = table.getColumns();
        Map<String, GenTableColumn> tableColumnMap = tableColumns.stream().collect(Collectors.toMap(GenTableColumn::getColumnName, Function.identity()));

        List<GenTableColumn> dbTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
        if (StringUtils.isEmpty(dbTableColumns))
        {
            throw new ServiceException("同步数据失败，原表结构不存在");
        }
        List<String> dbTableColumnNames = dbTableColumns.stream().map(GenTableColumn::getColumnName).collect(Collectors.toList());

        dbTableColumns.forEach(column -> {
            GenUtils.initColumnField(column, table);
            if (tableColumnMap.containsKey(column.getColumnName()))
            {
                GenTableColumn prevColumn = tableColumnMap.get(column.getColumnName());
                column.setColumnId(prevColumn.getColumnId());
                if (column.isList())
                {
                    // å¦‚果是列表，继续保留查询方式/字典类型选项
                    column.setDictType(prevColumn.getDictType());
                    column.setQueryType(prevColumn.getQueryType());
                }
                if (StringUtils.isNotEmpty(prevColumn.getIsRequired()) && !column.isPk()
                        && (column.isInsert() || column.isEdit())
                        && ((column.isUsableColumn()) || (!column.isSuperColumn())))
                {
                    // å¦‚果是(新增/修改&非主键/非忽略及父属性)，继续保留必填/显示类型选项
                    column.setIsRequired(prevColumn.getIsRequired());
                    column.setHtmlType(prevColumn.getHtmlType());
                }
                genTableColumnMapper.updateGenTableColumn(column);
            }
            else
            {
                genTableColumnMapper.insertGenTableColumn(column);
            }
        });

        List<GenTableColumn> delColumns = tableColumns.stream().filter(column -> !dbTableColumnNames.contains(column.getColumnName())).collect(Collectors.toList());
        if (StringUtils.isNotEmpty(delColumns))
        {
            genTableColumnMapper.deleteGenTableColumns(delColumns);
        }
    }

    /**
     * æ‰¹é‡ç”Ÿæˆä»£ç ï¼ˆä¸‹è½½æ–¹å¼ï¼‰
     * 
     * @param tableNames è¡¨æ•°ç»„
     * @return æ•°æ®
     */
    @Override
    public byte[] downloadCode(String[] tableNames)
    {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ZipOutputStream zip = new ZipOutputStream(outputStream);
        for (String tableName : tableNames)
        {
            generatorCode(tableName, zip);
        }
        IOUtils.closeQuietly(zip);
        return outputStream.toByteArray();
    }

    /**
     * æŸ¥è¯¢è¡¨ä¿¡æ¯å¹¶ç”Ÿæˆä»£ç 
     */
    private void generatorCode(String tableName, ZipOutputStream zip)
    {
        // æŸ¥è¯¢è¡¨ä¿¡æ¯
        GenTable table = genTableMapper.selectGenTableByName(tableName);
        // è®¾ç½®ä¸»å­è¡¨ä¿¡æ¯
        setSubTable(table);
        // è®¾ç½®ä¸»é”®åˆ—信息
        setPkColumn(table);

        VelocityInitializer.initVelocity();

        VelocityContext context = VelocityUtils.prepareContext(table);

        // èŽ·å–模板列表
        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
        for (String template : templates)
        {
            // æ¸²æŸ“模板
            StringWriter sw = new StringWriter();
            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
            tpl.merge(context, sw);
            try
            {
                // æ·»åŠ åˆ°zip
                zip.putNextEntry(new ZipEntry(VelocityUtils.getFileName(template, table)));
                IOUtils.write(sw.toString(), zip, Constants.UTF8);
                IOUtils.closeQuietly(sw);
                zip.flush();
                zip.closeEntry();
            }
            catch (IOException e)
            {
                log.error("渲染模板失败，表名：" + table.getTableName(), e);
            }
        }
    }

    /**
     * ä¿®æ”¹ä¿å­˜å‚数校验
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     */
    @Override
    public void validateEdit(GenTable genTable)
    {
        if (GenConstants.TPL_TREE.equals(genTable.getTplCategory()))
        {
            String options = JSON.toJSONString(genTable.getParams());
            JSONObject paramsObj = JSON.parseObject(options);
            if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_CODE)))
            {
                throw new ServiceException("树编码字段不能为空");
            }
            else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_PARENT_CODE)))
            {
                throw new ServiceException("树父编码字段不能为空");
            }
            else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_NAME)))
            {
                throw new ServiceException("树名称字段不能为空");
            }
            else if (GenConstants.TPL_SUB.equals(genTable.getTplCategory()))
            {
                if (StringUtils.isEmpty(genTable.getSubTableName()))
                {
                    throw new ServiceException("关联子表的表名不能为空");
                }
                else if (StringUtils.isEmpty(genTable.getSubTableFkName()))
                {
                    throw new ServiceException("子表关联的外键名不能为空");
                }
            }
        }
    }

    /**
     * è®¾ç½®ä¸»é”®åˆ—信息
     * 
     * @param table ä¸šåŠ¡è¡¨ä¿¡æ¯
     */
    public void setPkColumn(GenTable table)
    {
        for (GenTableColumn column : table.getColumns())
        {
            if (column.isPk())
            {
                table.setPkColumn(column);
                break;
            }
        }
        if (StringUtils.isNull(table.getPkColumn()))
        {
            table.setPkColumn(table.getColumns().get(0));
        }
        if (GenConstants.TPL_SUB.equals(table.getTplCategory()))
        {
            for (GenTableColumn column : table.getSubTable().getColumns())
            {
                if (column.isPk())
                {
                    table.getSubTable().setPkColumn(column);
                    break;
                }
            }
            if (StringUtils.isNull(table.getSubTable().getPkColumn()))
            {
                table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0));
            }
        }
    }

    /**
     * è®¾ç½®ä¸»å­è¡¨ä¿¡æ¯
     * 
     * @param table ä¸šåŠ¡è¡¨ä¿¡æ¯
     */
    public void setSubTable(GenTable table)
    {
        String subTableName = table.getSubTableName();
        if (StringUtils.isNotEmpty(subTableName))
        {
            table.setSubTable(genTableMapper.selectGenTableByName(subTableName));
        }
    }

    /**
     * è®¾ç½®ä»£ç ç”Ÿæˆå…¶ä»–选项值
     * 
     * @param genTable è®¾ç½®åŽçš„生成对象
     */
    public void setTableFromOptions(GenTable genTable)
    {
        JSONObject paramsObj = JSON.parseObject(genTable.getOptions());
        if (StringUtils.isNotNull(paramsObj))
        {
            String treeCode = paramsObj.getString(GenConstants.TREE_CODE);
            String treeParentCode = paramsObj.getString(GenConstants.TREE_PARENT_CODE);
            String treeName = paramsObj.getString(GenConstants.TREE_NAME);
            String parentMenuId = paramsObj.getString(GenConstants.PARENT_MENU_ID);
            String parentMenuName = paramsObj.getString(GenConstants.PARENT_MENU_NAME);

            genTable.setTreeCode(treeCode);
            genTable.setTreeParentCode(treeParentCode);
            genTable.setTreeName(treeName);
            genTable.setParentMenuId(parentMenuId);
            genTable.setParentMenuName(parentMenuName);
        }
    }

    /**
     * èŽ·å–代码生成地址
     * 
     * @param table ä¸šåŠ¡è¡¨ä¿¡æ¯
     * @param template æ¨¡æ¿æ–‡ä»¶è·¯å¾„
     * @return ç”Ÿæˆåœ°å€
     */
    public static String getGenPath(GenTable table, String template)
    {
        String genPath = table.getGenPath();
        if (StringUtils.equals(genPath, "/"))
        {
            return System.getProperty("user.dir") + File.separator + "src" + File.separator + VelocityUtils.getFileName(template, table);
        }
        return genPath + File.separator + VelocityUtils.getFileName(template, table);
    }
}

 se-modules/se-system/src/main/java/com/se/system/service/inte/IGenTableColumnService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,45 @@
package com.se.system.service.inte;

import com.se.system.domain.GenTableColumn;

import java.util.List;

/**
 * ä¸šåŠ¡å­—段 æœåŠ¡å±‚
 * 
 * @author admin
 */
public interface IGenTableColumnService
{
    /**
     * æŸ¥è¯¢ä¸šåŠ¡å­—段列表
     * 
     * @param tableId ä¸šåŠ¡å­—段编号
     * @return ä¸šåŠ¡å­—段集合
     */
    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId);

    /**
     * æ–°å¢žä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    public int insertGenTableColumn(GenTableColumn genTableColumn);

    /**
     * ä¿®æ”¹ä¸šåŠ¡å­—段
     * 
     * @param genTableColumn ä¸šåŠ¡å­—段信息
     * @return ç»“æžœ
     */
    public int updateGenTableColumn(GenTableColumn genTableColumn);

    /**
     * åˆ é™¤ä¸šåŠ¡å­—段信息
     * 
     * @param ids éœ€è¦åˆ é™¤çš„数据ID
     * @return ç»“æžœ
     */
    public int deleteGenTableColumnByIds(String ids);
}

 se-modules/se-system/src/main/java/com/se/system/service/inte/IGenTableService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
package com.se.system.service.inte;

import com.se.system.domain.GenTable;

import java.util.List;
import java.util.Map;

/**
 * ä¸šåŠ¡ æœåŠ¡å±‚
 * 
 * @author admin
 */
public interface IGenTableService
{
    /**
     * æŸ¥è¯¢ä¸šåŠ¡åˆ—表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ä¸šåŠ¡é›†åˆ
     */
    public List<GenTable> selectGenTableList(GenTable genTable);

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return æ•°æ®åº“表集合
     */
    public List<GenTable> selectDbTableList(GenTable genTable);

    /**
     * æŸ¥è¯¢æ®åº“列表
     * 
     * @param tableNames è¡¨åç§°ç»„
     * @return æ•°æ®åº“表集合
     */
    public List<GenTable> selectDbTableListByNames(String[] tableNames);

    /**
     * æŸ¥è¯¢æ‰€æœ‰è¡¨ä¿¡æ¯
     * 
     * @return è¡¨ä¿¡æ¯é›†åˆ
     */
    public List<GenTable> selectGenTableAll();

    /**
     * æŸ¥è¯¢ä¸šåŠ¡ä¿¡æ¯
     * 
     * @param id ä¸šåŠ¡ID
     * @return ä¸šåŠ¡ä¿¡æ¯
     */
    public GenTable selectGenTableById(Long id);

    /**
     * ä¿®æ”¹ä¸šåŠ¡
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     * @return ç»“æžœ
     */
    public void updateGenTable(GenTable genTable);

    /**
     * åˆ é™¤ä¸šåŠ¡ä¿¡æ¯
     * 
     * @param tableIds éœ€è¦åˆ é™¤çš„表数据ID
     * @return ç»“æžœ
     */
    public void deleteGenTableByIds(Long[] tableIds);

    /**
     * å¯¼å…¥è¡¨ç»“æž„
     * 
     * @param tableList å¯¼å…¥è¡¨åˆ—表
     */
    public void importGenTable(List<GenTable> tableList);

    /**
     * é¢„览代码
     * 
     * @param tableId è¡¨ç¼–号
     * @return é¢„览数据列表
     */
    public Map<String, String> previewCode(Long tableId);

    /**
     * ç”Ÿæˆä»£ç ï¼ˆä¸‹è½½æ–¹å¼ï¼‰
     * 
     * @param tableName è¡¨åç§°
     * @return æ•°æ®
     */
    public byte[] downloadCode(String tableName);

    /**
     * ç”Ÿæˆä»£ç ï¼ˆè‡ªå®šä¹‰è·¯å¾„）
     * 
     * @param tableName è¡¨åç§°
     * @return æ•°æ®
     */
    public void generatorCode(String tableName);

    /**
     * åŒæ­¥æ•°æ®åº“
     * 
     * @param tableName è¡¨åç§°
     */
    public void synchDb(String tableName);

    /**
     * æ‰¹é‡ç”Ÿæˆä»£ç ï¼ˆä¸‹è½½æ–¹å¼ï¼‰
     * 
     * @param tableNames è¡¨æ•°ç»„
     * @return æ•°æ®
     */
    public byte[] downloadCode(String[] tableNames);

    /**
     * ä¿®æ”¹ä¿å­˜å‚数校验
     * 
     * @param genTable ä¸šåŠ¡ä¿¡æ¯
     */
    public void validateEdit(GenTable genTable);
}

 se-modules/se-system/src/main/java/com/se/system/utils/GenUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,258 @@
package com.se.system.utils;

import com.se.common.core.constant.GenConstants;
import com.se.common.core.utils.StringUtils;
import com.se.system.config.GenConfig;
import com.se.system.domain.GenTable;
import com.se.system.domain.GenTableColumn;
import org.apache.commons.lang3.RegExUtils;

import java.util.Arrays;

/**
 * ä»£ç ç”Ÿæˆå™¨ å·¥å…·ç±»
 * 
 * @author admin
 */
public class GenUtils
{
    /**
     * åˆå§‹åŒ–表信息
     */
    public static void initTable(GenTable genTable, String operName)
    {
        genTable.setClassName(convertClassName(genTable.getTableName()));
        genTable.setPackageName(GenConfig.getPackageName());
        genTable.setModuleName(getModuleName(GenConfig.getPackageName()));
        genTable.setBusinessName(getBusinessName(genTable.getTableName()));
        genTable.setFunctionName(replaceText(genTable.getTableComment()));
        genTable.setFunctionAuthor(GenConfig.getAuthor());
        genTable.setCreateBy(operName);
    }

    /**
     * åˆå§‹åŒ–列属性字段
     */
    public static void initColumnField(GenTableColumn column, GenTable table)
    {
        String dataType = getDbType(column.getColumnType());
        String columnName = column.getColumnName();
        column.setTableId(table.getTableId());
        column.setCreateBy(table.getCreateBy());
        // è®¾ç½®java字段名
        column.setJavaField(StringUtils.toCamelCase(columnName));
        // è®¾ç½®é»˜è®¤ç±»åž‹
        column.setJavaType(GenConstants.TYPE_STRING);
        column.setQueryType(GenConstants.QUERY_EQ);

        if (arraysContains(GenConstants.COLUMNTYPE_STR, dataType) || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType))
        {
            // å­—符串长度超过500设置为文本域
            Integer columnLength = getColumnLength(column.getColumnType());
            String htmlType = columnLength >= 500 || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType) ? GenConstants.HTML_TEXTAREA : GenConstants.HTML_INPUT;
            column.setHtmlType(htmlType);
        }
        else if (arraysContains(GenConstants.COLUMNTYPE_TIME, dataType))
        {
            column.setJavaType(GenConstants.TYPE_DATE);
            column.setHtmlType(GenConstants.HTML_DATETIME);
        }
        else if (arraysContains(GenConstants.COLUMNTYPE_NUMBER, dataType))
        {
            column.setHtmlType(GenConstants.HTML_INPUT);

            // å¦‚果是浮点型 ç»Ÿä¸€ç”¨BigDecimal
            String[] str = StringUtils.split(StringUtils.substringBetween(column.getColumnType(), "(", ")"), ",");
            if (str != null && str.length == 2 && Integer.parseInt(str[1]) > 0)
            {
                column.setJavaType(GenConstants.TYPE_BIGDECIMAL);
            }
            // å¦‚果是整形
            else if (str != null && str.length == 1 && Integer.parseInt(str[0]) <= 10)
            {
                column.setJavaType(GenConstants.TYPE_INTEGER);
            }
            // é•¿æ•´å½¢
            else
            {
                column.setJavaType(GenConstants.TYPE_LONG);
            }
        }

        // æ’入字段（默认所有字段都需要插入）
        column.setIsInsert(GenConstants.REQUIRE);

        // ç¼–辑字段
        if (!arraysContains(GenConstants.COLUMNNAME_NOT_EDIT, columnName) && !column.isPk())
        {
            column.setIsEdit(GenConstants.REQUIRE);
        }
        // åˆ—表字段
        if (!arraysContains(GenConstants.COLUMNNAME_NOT_LIST, columnName) && !column.isPk())
        {
            column.setIsList(GenConstants.REQUIRE);
        }
        // æŸ¥è¯¢å­—段
        if (!arraysContains(GenConstants.COLUMNNAME_NOT_QUERY, columnName) && !column.isPk())
        {
            column.setIsQuery(GenConstants.REQUIRE);
        }

        // æŸ¥è¯¢å­—段类型
        if (StringUtils.endsWithIgnoreCase(columnName, "name"))
        {
            column.setQueryType(GenConstants.QUERY_LIKE);
        }
        // çŠ¶æ€å­—段设置单选框
        if (StringUtils.endsWithIgnoreCase(columnName, "status"))
        {
            column.setHtmlType(GenConstants.HTML_RADIO);
        }
        // ç±»åž‹&性别字段设置下拉框
        else if (StringUtils.endsWithIgnoreCase(columnName, "type")
                || StringUtils.endsWithIgnoreCase(columnName, "sex"))
        {
            column.setHtmlType(GenConstants.HTML_SELECT);
        }
        // å›¾ç‰‡å­—段设置图片上传控件
        else if (StringUtils.endsWithIgnoreCase(columnName, "image"))
        {
            column.setHtmlType(GenConstants.HTML_IMAGE_UPLOAD);
        }
        // æ–‡ä»¶å­—段设置文件上传控件
        else if (StringUtils.endsWithIgnoreCase(columnName, "file"))
        {
            column.setHtmlType(GenConstants.HTML_FILE_UPLOAD);
        }
        // å†…容字段设置富文本控件
        else if (StringUtils.endsWithIgnoreCase(columnName, "content"))
        {
            column.setHtmlType(GenConstants.HTML_EDITOR);
        }
    }

    /**
     * æ ¡éªŒæ•°ç»„是否包含指定值
     * 
     * @param arr æ•°ç»„
     * @param targetValue å€¼
     * @return æ˜¯å¦åŒ…含
     */
    public static boolean arraysContains(String[] arr, String targetValue)
    {
        return Arrays.asList(arr).contains(targetValue);
    }

    /**
     * èŽ·å–模块名
     * 
     * @param packageName åŒ…名
     * @return æ¨¡å—名
     */
    public static String getModuleName(String packageName)
    {
        int lastIndex = packageName.lastIndexOf(".");
        int nameLength = packageName.length();
        return StringUtils.substring(packageName, lastIndex + 1, nameLength);
    }

    /**
     * èŽ·å–业务名
     * 
     * @param tableName è¡¨å
     * @return ä¸šåŠ¡å
     */
    public static String getBusinessName(String tableName)
    {
        int lastIndex = tableName.lastIndexOf("_");
        int nameLength = tableName.length();
        return StringUtils.substring(tableName, lastIndex + 1, nameLength);
    }

    /**
     * è¡¨åè½¬æ¢æˆJava类名
     * 
     * @param tableName è¡¨åç§°
     * @return ç±»å
     */
    public static String convertClassName(String tableName)
    {
        boolean autoRemovePre = GenConfig.getAutoRemovePre();
        String tablePrefix = GenConfig.getTablePrefix();
        if (autoRemovePre && StringUtils.isNotEmpty(tablePrefix))
        {
            String[] searchList = StringUtils.split(tablePrefix, ",");
            tableName = replaceFirst(tableName, searchList);
        }
        return StringUtils.convertToCamelCase(tableName);
    }

    /**
     * æ‰¹é‡æ›¿æ¢å‰ç¼€
     * 
     * @param replacementm æ›¿æ¢å€¼
     * @param searchList æ›¿æ¢åˆ—表
     * @return
     */
    public static String replaceFirst(String replacementm, String[] searchList)
    {
        String text = replacementm;
        for (String searchString : searchList)
        {
            if (replacementm.startsWith(searchString))
            {
                text = replacementm.replaceFirst(searchString, "");
                break;
            }
        }
        return text;
    }

    /**
     * å…³é”®å­—替换
     * 
     * @param text éœ€è¦è¢«æ›¿æ¢çš„名字
     * @return æ›¿æ¢åŽçš„名字
     */
    public static String replaceText(String text)
    {
        return RegExUtils.replaceAll(text, "(?:表|SE)", "");
    }

    /**
     * èŽ·å–数据库类型字段
     * 
     * @param columnType åˆ—类型
     * @return æˆªå–后的列类型
     */
    public static String getDbType(String columnType)
    {
        if (StringUtils.indexOf(columnType, "(") > 0)
        {
            return StringUtils.substringBefore(columnType, "(");
        }
        else
        {
            return columnType;
        }
    }

    /**
     * èŽ·å–字段长度
     * 
     * @param columnType åˆ—类型
     * @return æˆªå–后的列类型
     */
    public static Integer getColumnLength(String columnType)
    {
        if (StringUtils.indexOf(columnType, "(") > 0)
        {
            String length = StringUtils.substringBetween(columnType, "(", ")");
            return Integer.valueOf(length);
        }
        else
        {
            return 0;
        }
    }
}

 se-modules/se-system/src/main/java/com/se/system/utils/VelocityInitializer.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
package com.se.system.utils;

import com.se.common.core.constant.Constants;
import org.apache.velocity.app.Velocity;

import java.util.Properties;

/**
 * VelocityEngine工厂
 * 
 * @author admin
 */
public class VelocityInitializer
{
    /**
     * åˆå§‹åŒ–vm方法
     */
    public static void initVelocity()
    {
        Properties p = new Properties();
        try
        {
            // åŠ è½½classpath目录下的vm文件
            p.setProperty("resource.loader.file.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
            // å®šä¹‰å­—符集
            p.setProperty(Velocity.INPUT_ENCODING, Constants.UTF8);
            // åˆå§‹åŒ–Velocity引擎，指定配置Properties
            Velocity.init(p);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
}

 se-modules/se-system/src/main/java/com/se/system/utils/VelocityUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,409 @@
package com.se.system.utils;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.se.common.core.constant.GenConstants;
import com.se.common.core.utils.DateUtils;
import com.se.common.core.utils.StringUtils;
import com.se.system.domain.GenTable;
import com.se.system.domain.GenTableColumn;
import org.apache.velocity.VelocityContext;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * æ¨¡æ¿å·¥å…·ç±»
 * 
 * @author admin
 */
public class VelocityUtils
{
    /** é¡¹ç›®ç©ºé—´è·¯å¾„ */
    private static final String PROJECT_PATH = "main/java";

    /** mybatis空间路径 */
    private static final String MYBATIS_PATH = "main/resources/mapper";

    /** é»˜è®¤ä¸Šçº§èœå•ï¼Œç³»ç»Ÿå·¥å…· */
    private static final String DEFAULT_PARENT_MENU_ID = "3";

    /**
     * è®¾ç½®æ¨¡æ¿å˜é‡ä¿¡æ¯
     *
     * @return æ¨¡æ¿åˆ—表
     */
    public static VelocityContext prepareContext(GenTable genTable)
    {
        String moduleName = genTable.getModuleName();
        String businessName = genTable.getBusinessName();
        String packageName = genTable.getPackageName();
        String tplCategory = genTable.getTplCategory();
        String functionName = genTable.getFunctionName();

        VelocityContext velocityContext = new VelocityContext();
        velocityContext.put("tplCategory", genTable.getTplCategory());
        velocityContext.put("tableName", genTable.getTableName());
        velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
        velocityContext.put("ClassName", genTable.getClassName());
        velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName()));
        velocityContext.put("moduleName", genTable.getModuleName());
        velocityContext.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName()));
        velocityContext.put("businessName", genTable.getBusinessName());
        velocityContext.put("basePackage", getPackagePrefix(packageName));
        velocityContext.put("packageName", packageName);
        velocityContext.put("author", genTable.getFunctionAuthor());
        velocityContext.put("datetime", DateUtils.getDate());
        velocityContext.put("pkColumn", genTable.getPkColumn());
        velocityContext.put("importList", getImportList(genTable));
        velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
        velocityContext.put("columns", genTable.getColumns());
        velocityContext.put("table", genTable);
        velocityContext.put("dicts", getDicts(genTable));
        setMenuVelocityContext(velocityContext, genTable);
        if (GenConstants.TPL_TREE.equals(tplCategory))
        {
            setTreeVelocityContext(velocityContext, genTable);
        }
        if (GenConstants.TPL_SUB.equals(tplCategory))
        {
            setSubVelocityContext(velocityContext, genTable);
        }
        return velocityContext;
    }

    public static void setMenuVelocityContext(VelocityContext context, GenTable genTable)
    {
        String options = genTable.getOptions();
        JSONObject paramsObj = JSON.parseObject(options);
        String parentMenuId = getParentMenuId(paramsObj);
        context.put("parentMenuId", parentMenuId);
    }

    public static void setTreeVelocityContext(VelocityContext context, GenTable genTable)
    {
        String options = genTable.getOptions();
        JSONObject paramsObj = JSON.parseObject(options);
        String treeCode = getTreecode(paramsObj);
        String treeParentCode = getTreeParentCode(paramsObj);
        String treeName = getTreeName(paramsObj);

        context.put("treeCode", treeCode);
        context.put("treeParentCode", treeParentCode);
        context.put("treeName", treeName);
        context.put("expandColumn", getExpandColumn(genTable));
        if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE))
        {
            context.put("tree_parent_code", paramsObj.getString(GenConstants.TREE_PARENT_CODE));
        }
        if (paramsObj.containsKey(GenConstants.TREE_NAME))
        {
            context.put("tree_name", paramsObj.getString(GenConstants.TREE_NAME));
        }
    }

    public static void setSubVelocityContext(VelocityContext context, GenTable genTable)
    {
        GenTable subTable = genTable.getSubTable();
        String subTableName = genTable.getSubTableName();
        String subTableFkName = genTable.getSubTableFkName();
        String subClassName = genTable.getSubTable().getClassName();
        String subTableFkClassName = StringUtils.convertToCamelCase(subTableFkName);

        context.put("subTable", subTable);
        context.put("subTableName", subTableName);
        context.put("subTableFkName", subTableFkName);
        context.put("subTableFkClassName", subTableFkClassName);
        context.put("subTableFkclassName", StringUtils.uncapitalize(subTableFkClassName));
        context.put("subClassName", subClassName);
        context.put("subclassName", StringUtils.uncapitalize(subClassName));
        context.put("subImportList", getImportList(genTable.getSubTable()));
    }

    /**
     * èŽ·å–模板信息
     * @param tplCategory ç”Ÿæˆçš„模板
     * @param tplWebType å‰ç«¯ç±»åž‹
     * @return æ¨¡æ¿åˆ—表
     */
    public static List<String> getTemplateList(String tplCategory, String tplWebType)
    {
        String useWebType = "vm/vue";
        if ("element-plus".equals(tplWebType))
        {
            useWebType = "vm/vue/v3";
        }
        List<String> templates = new ArrayList<String>();
        templates.add("vm/java/domain.java.vm");
        templates.add("vm/java/mapper.java.vm");
        templates.add("vm/java/service.java.vm");
        templates.add("vm/java/serviceImpl.java.vm");
        templates.add("vm/java/controller.java.vm");
        templates.add("vm/xml/mapper.xml.vm");
        templates.add("vm/sql/sql.vm");
        templates.add("vm/js/api.js.vm");
        if (GenConstants.TPL_CRUD.equals(tplCategory))
        {
            templates.add(useWebType + "/index.vue.vm");
        }
        else if (GenConstants.TPL_TREE.equals(tplCategory))
        {
            templates.add(useWebType + "/index-tree.vue.vm");
        }
        else if (GenConstants.TPL_SUB.equals(tplCategory))
        {
            templates.add(useWebType + "/index.vue.vm");
            templates.add("vm/java/sub-domain.java.vm");
        }
        return templates;
    }

    /**
     * èŽ·å–文件名
     */
    public static String getFileName(String template, GenTable genTable)
    {
        // æ–‡ä»¶åç§°
        String fileName = "";
        // åŒ…路径
        String packageName = genTable.getPackageName();
        // æ¨¡å—名
        String moduleName = genTable.getModuleName();
        // å¤§å†™ç±»å
        String className = genTable.getClassName();
        // ä¸šåŠ¡åç§°
        String businessName = genTable.getBusinessName();

        String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
        String mybatisPath = MYBATIS_PATH + "/" + moduleName;
        String vuePath = "vue";

        if (template.contains("domain.java.vm"))
        {
            fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
        }
        if (template.contains("sub-domain.java.vm") && StringUtils.equals(GenConstants.TPL_SUB, genTable.getTplCategory()))
        {
            fileName = StringUtils.format("{}/domain/{}.java", javaPath, genTable.getSubTable().getClassName());
        }
        else if (template.contains("mapper.java.vm"))
        {
            fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className);
        }
        else if (template.contains("service.java.vm"))
        {
            fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className);
        }
        else if (template.contains("serviceImpl.java.vm"))
        {
            fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className);
        }
        else if (template.contains("controller.java.vm"))
        {
            fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className);
        }
        else if (template.contains("mapper.xml.vm"))
        {
            fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
        }
        else if (template.contains("sql.vm"))
        {
            fileName = businessName + "Menu.sql";
        }
        else if (template.contains("api.js.vm"))
        {
            fileName = StringUtils.format("{}/api/{}/{}.js", vuePath, moduleName, businessName);
        }
        else if (template.contains("index.vue.vm"))
        {
            fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
        }
        else if (template.contains("index-tree.vue.vm"))
        {
            fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
        }
        return fileName;
    }

    /**
     * èŽ·å–包前缀
     *
     * @param packageName åŒ…名称
     * @return åŒ…前缀名称
     */
    public static String getPackagePrefix(String packageName)
    {
        int lastIndex = packageName.lastIndexOf(".");
        return StringUtils.substring(packageName, 0, lastIndex);
    }

    /**
     * æ ¹æ®åˆ—类型获取导入包
     * 
     * @param genTable ä¸šåŠ¡è¡¨å¯¹è±¡
     * @return è¿”回需要导入的包列表
     */
    public static HashSet<String> getImportList(GenTable genTable)
    {
        List<GenTableColumn> columns = genTable.getColumns();
        GenTable subGenTable = genTable.getSubTable();
        HashSet<String> importList = new HashSet<String>();
        if (StringUtils.isNotNull(subGenTable))
        {
            importList.add("java.util.List");
        }
        for (GenTableColumn column : columns)
        {
            if (!column.isSuperColumn() && GenConstants.TYPE_DATE.equals(column.getJavaType()))
            {
                importList.add("java.util.Date");
                importList.add("com.fasterxml.jackson.annotation.JsonFormat");
            }
            else if (!column.isSuperColumn() && GenConstants.TYPE_BIGDECIMAL.equals(column.getJavaType()))
            {
                importList.add("java.math.BigDecimal");
            }
        }
        return importList;
    }

    /**
     * æ ¹æ®åˆ—类型获取字典组
     * 
     * @param genTable ä¸šåŠ¡è¡¨å¯¹è±¡
     * @return è¿”回字典组
     */
    public static String getDicts(GenTable genTable)
    {
        List<GenTableColumn> columns = genTable.getColumns();
        Set<String> dicts = new HashSet<String>();
        addDicts(dicts, columns);
        if (StringUtils.isNotNull(genTable.getSubTable()))
        {
            List<GenTableColumn> subColumns = genTable.getSubTable().getColumns();
            addDicts(dicts, subColumns);
        }
        return StringUtils.join(dicts, ", ");
    }

    /**
     * æ·»åŠ å­—典列表
     * 
     * @param dicts å­—典列表
     * @param columns åˆ—集合
     */
    public static void addDicts(Set<String> dicts, List<GenTableColumn> columns)
    {
        for (GenTableColumn column : columns)
        {
            if (!column.isSuperColumn() && StringUtils.isNotEmpty(column.getDictType()) && StringUtils.equalsAny(
                    column.getHtmlType(),
                    new String[] { GenConstants.HTML_SELECT, GenConstants.HTML_RADIO, GenConstants.HTML_CHECKBOX }))
            {
                dicts.add("'" + column.getDictType() + "'");
            }
        }
    }

    /**
     * èŽ·å–权限前缀
     *
     * @param moduleName æ¨¡å—名称
     * @param businessName ä¸šåŠ¡åç§°
     * @return è¿”回权限前缀
     */
    public static String getPermissionPrefix(String moduleName, String businessName)
    {
        return StringUtils.format("{}:{}", moduleName, businessName);
    }

    /**
     * èŽ·å–上级菜单ID字段
     *
     * @param paramsObj ç”Ÿæˆå…¶ä»–选项
     * @return ä¸Šçº§èœå•ID字段
     */
    public static String getParentMenuId(JSONObject paramsObj)
    {
        if (StringUtils.isNotEmpty(paramsObj) && paramsObj.containsKey(GenConstants.PARENT_MENU_ID)
                && StringUtils.isNotEmpty(paramsObj.getString(GenConstants.PARENT_MENU_ID)))
        {
            return paramsObj.getString(GenConstants.PARENT_MENU_ID);
        }
        return DEFAULT_PARENT_MENU_ID;
    }

    /**
     * èŽ·å–树编码
     *
     * @param paramsObj ç”Ÿæˆå…¶ä»–选项
     * @return æ ‘编码
     */
    public static String getTreecode(JSONObject paramsObj)
    {
        if (paramsObj.containsKey(GenConstants.TREE_CODE))
        {
            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_CODE));
        }
        return StringUtils.EMPTY;
    }

    /**
     * èŽ·å–树父编码
     *
     * @param paramsObj ç”Ÿæˆå…¶ä»–选项
     * @return æ ‘父编码
     */
    public static String getTreeParentCode(JSONObject paramsObj)
    {
        if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE))
        {
            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_PARENT_CODE));
        }
        return StringUtils.EMPTY;
    }

    /**
     * èŽ·å–树名称
     *
     * @param paramsObj ç”Ÿæˆå…¶ä»–选项
     * @return æ ‘名称
     */
    public static String getTreeName(JSONObject paramsObj)
    {
        if (paramsObj.containsKey(GenConstants.TREE_NAME))
        {
            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_NAME));
        }
        return StringUtils.EMPTY;
    }

    /**
     * èŽ·å–需要在哪一列上面显示展开按钮
     *
     * @param genTable ä¸šåŠ¡è¡¨å¯¹è±¡
     * @return å±•å¼€æŒ‰é’®åˆ—序号
     */
    public static int getExpandColumn(GenTable genTable)
    {
        String options = genTable.getOptions();
        JSONObject paramsObj = JSON.parseObject(options);
        String treeName = paramsObj.getString(GenConstants.TREE_NAME);
        int num = 0;
        for (GenTableColumn column : genTable.getColumns())
        {
            if (column.isList())
            {
                num++;
                String columnName = column.getColumnName();
                if (columnName.equals(treeName))
                {
                    break;
                }
            }
        }
        return num;
    }
}

 se-modules/se-system/src/main/resources/mapper/system/GenTableColumnMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,127 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.se.system.mapper.GenTableColumnMapper">

    <resultMap type="GenTableColumn" id="GenTableColumnResult">
        <id     property="columnId"       column="column_id"      />
        <result property="tableId"        column="table_id"       />
        <result property="columnName"     column="column_name"    />
        <result property="columnComment"  column="column_comment" />
        <result property="columnType"     column="column_type"    />
        <result property="javaType"       column="java_type"      />
        <result property="javaField"      column="java_field"     />
        <result property="isPk"           column="is_pk"          />
        <result property="isIncrement"    column="is_increment"   />
        <result property="isRequired"     column="is_required"    />
        <result property="isInsert"       column="is_insert"      />
        <result property="isEdit"         column="is_edit"        />
        <result property="isList"         column="is_list"        />
        <result property="isQuery"        column="is_query"       />
        <result property="queryType"      column="query_type"     />
        <result property="htmlType"       column="html_type"      />
        <result property="dictType"       column="dict_type"      />
        <result property="sort"           column="sort"           />
        <result property="createBy"       column="create_by"      />
        <result property="createTime"     column="create_time"    />
        <result property="updateBy"       column="update_by"      />
        <result property="updateTime"     column="update_time"    />
    </resultMap>

    <sql id="selectGenTableColumnVo">
        select column_id, table_id, column_name, column_comment, column_type, java_type, java_field, is_pk, is_increment, is_required, is_insert, is_edit, is_list, is_query, query_type, html_type, dict_type, sort, create_by, create_time, update_by, update_time from gen_table_column
    </sql>

    <select id="selectGenTableColumnListByTableId" parameterType="GenTableColumn" resultMap="GenTableColumnResult">
        <include refid="selectGenTableColumnVo"/>
        where table_id = #{tableId}
        order by sort
    </select>

    <select id="selectDbTableColumnsByName" parameterType="String" resultMap="GenTableColumnResult">
        select column_name, (case when (is_nullable = 'no' <![CDATA[ && ]]> column_key != 'PRI') then '1' else null end) as is_required, (case when column_key = 'PRI' then '1' else '0' end) as is_pk, ordinal_position as sort, column_comment, (case when extra = 'auto_increment' then '1' else '0' end) as is_increment, column_type
        from information_schema.columns where table_schema = (select database()) and table_name = (#{tableName})
        order by ordinal_position
    </select>

    <insert id="insertGenTableColumn" parameterType="GenTableColumn" useGeneratedKeys="true" keyProperty="columnId">
        insert into gen_table_column (
            <if test="tableId != null and tableId != ''">table_id,</if>
            <if test="columnName != null and columnName != ''">column_name,</if>
            <if test="columnComment != null and columnComment != ''">column_comment,</if>
            <if test="columnType != null and columnType != ''">column_type,</if>
            <if test="javaType != null and javaType != ''">java_type,</if>
            <if test="javaField != null  and javaField != ''">java_field,</if>
            <if test="isPk != null and isPk != ''">is_pk,</if>
            <if test="isIncrement != null and isIncrement != ''">is_increment,</if>
            <if test="isRequired != null and isRequired != ''">is_required,</if>
            <if test="isInsert != null and isInsert != ''">is_insert,</if>
            <if test="isEdit != null and isEdit != ''">is_edit,</if>
            <if test="isList != null and isList != ''">is_list,</if>
            <if test="isQuery != null and isQuery != ''">is_query,</if>
            <if test="queryType != null and queryType != ''">query_type,</if>
            <if test="htmlType != null and htmlType != ''">html_type,</if>
            <if test="dictType != null and dictType != ''">dict_type,</if>
            <if test="sort != null">sort,</if>
            <if test="createBy != null and createBy != ''">create_by,</if>
            create_time
         )values(
            <if test="tableId != null and tableId != ''">#{tableId},</if>
            <if test="columnName != null and columnName != ''">#{columnName},</if>
            <if test="columnComment != null and columnComment != ''">#{columnComment},</if>
            <if test="columnType != null and columnType != ''">#{columnType},</if>
            <if test="javaType != null and javaType != ''">#{javaType},</if>
            <if test="javaField != null and javaField != ''">#{javaField},</if>
            <if test="isPk != null and isPk != ''">#{isPk},</if>
            <if test="isIncrement != null and isIncrement != ''">#{isIncrement},</if>
            <if test="isRequired != null and isRequired != ''">#{isRequired},</if>
            <if test="isInsert != null and isInsert != ''">#{isInsert},</if>
            <if test="isEdit != null and isEdit != ''">#{isEdit},</if>
            <if test="isList != null and isList != ''">#{isList},</if>
            <if test="isQuery != null and isQuery != ''">#{isQuery},</if>
            <if test="queryType != null and queryType != ''">#{queryType},</if>
            <if test="htmlType != null and htmlType != ''">#{htmlType},</if>
            <if test="dictType != null and dictType != ''">#{dictType},</if>
            <if test="sort != null">#{sort},</if>
            <if test="createBy != null and createBy != ''">#{createBy},</if>
            sysdate()
         )
    </insert>

    <update id="updateGenTableColumn" parameterType="GenTableColumn">
        update gen_table_column
        <set>
            <if test="columnComment != null">column_comment = #{columnComment},</if>
            <if test="javaType != null">java_type = #{javaType},</if>
            <if test="javaField != null">java_field = #{javaField},</if>
            <if test="isInsert != null">is_insert = #{isInsert},</if>
            <if test="isEdit != null">is_edit = #{isEdit},</if>
            <if test="isList != null">is_list = #{isList},</if>
            <if test="isQuery != null">is_query = #{isQuery},</if>
            <if test="isRequired != null">is_required = #{isRequired},</if>
            <if test="queryType != null">query_type = #{queryType},</if>
            <if test="htmlType != null">html_type = #{htmlType},</if>
            <if test="dictType != null">dict_type = #{dictType},</if>
            <if test="sort != null">sort = #{sort},</if>
            <if test="updateBy != null">update_by = #{updateBy},</if>
            update_time = sysdate()
        </set>
        where column_id = #{columnId}
    </update>

    <delete id="deleteGenTableColumnByIds" parameterType="Long">
        delete from gen_table_column where table_id in
        <foreach collection="array" item="tableId" open="(" separator="," close=")">
            #{tableId}
        </foreach>
    </delete>
    
    <delete id="deleteGenTableColumns">
        delete from gen_table_column where column_id in
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item.columnId}
        </foreach>
    </delete>

</mapper>

 se-modules/se-system/src/main/resources/mapper/system/GenTableMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,206 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.se.system.mapper.GenTableMapper">

    <resultMap type="GenTable" id="GenTableResult">
        <id     property="tableId"        column="table_id"          />
        <result property="tableName"      column="table_name"        />
        <result property="tableComment"   column="table_comment"     />
        <result property="subTableName"   column="sub_table_name"    />
        <result property="subTableFkName" column="sub_table_fk_name" />
        <result property="className"      column="class_name"        />
        <result property="tplCategory"    column="tpl_category"      />
        <result property="tplWebType"     column="tpl_web_type"      />
        <result property="packageName"    column="package_name"      />
        <result property="moduleName"     column="module_name"       />
        <result property="businessName"   column="business_name"     />
        <result property="functionName"   column="function_name"     />
        <result property="functionAuthor" column="function_author"   />
        <result property="genType"        column="gen_type"          />
        <result property="genPath"        column="gen_path"          />
        <result property="options"        column="options"           />
        <result property="createBy"       column="create_by"         />
        <result property="createTime"     column="create_time"       />
        <result property="updateBy"       column="update_by"         />
        <result property="updateTime"     column="update_time"       />
        <result property="remark"         column="remark"            />
        <collection  property="columns"   javaType="java.util.List"  resultMap="GenTableColumnResult" />
    </resultMap>
	
    <resultMap type="GenTableColumn" id="GenTableColumnResult">
        <id     property="columnId"       column="column_id"      />
        <result property="tableId"        column="table_id"       />
        <result property="columnName"     column="column_name"    />
        <result property="columnComment"  column="column_comment" />
        <result property="columnType"     column="column_type"    />
        <result property="javaType"       column="java_type"      />
        <result property="javaField"      column="java_field"     />
        <result property="isPk"           column="is_pk"          />
        <result property="isIncrement"    column="is_increment"   />
        <result property="isRequired"     column="is_required"    />
        <result property="isInsert"       column="is_insert"      />
        <result property="isEdit"         column="is_edit"        />
        <result property="isList"         column="is_list"        />
        <result property="isQuery"        column="is_query"       />
        <result property="queryType"      column="query_type"     />
        <result property="htmlType"       column="html_type"      />
        <result property="dictType"       column="dict_type"      />
        <result property="sort"           column="sort"           />
        <result property="createBy"       column="create_by"      />
        <result property="createTime"     column="create_time"    />
        <result property="updateBy"       column="update_by"      />
        <result property="updateTime"     column="update_time"    />
    </resultMap>
	
    <sql id="selectGenTableVo">
        select table_id, table_name, table_comment, sub_table_name, sub_table_fk_name, class_name, tpl_category, tpl_web_type, package_name, module_name, business_name, function_name, function_author, gen_type, gen_path, options, create_by, create_time, update_by, update_time, remark from gen_table
    </sql>
    
    <select id="selectGenTableList" parameterType="GenTable" resultMap="GenTableResult">
        <include refid="selectGenTableVo"/>
        <where>
            <if test="tableName != null and tableName != ''">
                AND lower(table_name) like lower(concat('%', #{tableName}, '%'))
            </if>
            <if test="tableComment != null and tableComment != ''">
                AND lower(table_comment) like lower(concat('%', #{tableComment}, '%'))
            </if>
            <if test="params.beginTime != null and params.beginTime != ''"><!-- å¼€å§‹æ—¶é—´æ£€ç´¢ -->
                AND date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d')
            </if>
            <if test="params.endTime != null and params.endTime != ''"><!-- ç»“束时间检索 -->
                AND date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d')
            </if>
        </where>
    </select>

    <select id="selectDbTableList" parameterType="GenTable" resultMap="GenTableResult">
        select table_name, table_comment, create_time, update_time from information_schema.tables
        where table_schema = (select database())
        AND table_name NOT LIKE 'qrtz\_%' AND table_name NOT LIKE 'gen\_%'
        AND table_name NOT IN (select table_name from gen_table)
        <if test="tableName != null and tableName != ''">
            AND lower(table_name) like lower(concat('%', #{tableName}, '%'))
        </if>
        <if test="tableComment != null and tableComment != ''">
            AND lower(table_comment) like lower(concat('%', #{tableComment}, '%'))
        </if>
        <if test="params.beginTime != null and params.beginTime != ''"><!-- å¼€å§‹æ—¶é—´æ£€ç´¢ -->
            AND date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d')
        </if>
        <if test="params.endTime != null and params.endTime != ''"><!-- ç»“束时间检索 -->
            AND date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d')
        </if>
        order by create_time desc
    </select>
	
    <select id="selectDbTableListByNames" resultMap="GenTableResult">
        select table_name, table_comment, create_time, update_time from information_schema.tables
        where table_name NOT LIKE 'qrtz\_%' and table_name NOT LIKE 'gen\_%' and table_schema = (select database())
        and table_name in
        <foreach collection="array" item="name" open="(" separator="," close=")">
             #{name}
        </foreach> 
    </select>
	
    <select id="selectTableByName" parameterType="String" resultMap="GenTableResult">
        select table_name, table_comment, create_time, update_time from information_schema.tables
        where table_comment <![CDATA[ <> ]]> '' and table_schema = (select database())
        and table_name = #{tableName}
    </select>
	
    <select id="selectGenTableById" parameterType="Long" resultMap="GenTableResult">
        SELECT t.table_id, t.table_name, t.table_comment, t.sub_table_name, t.sub_table_fk_name, t.class_name, t.tpl_category, t.tpl_web_type, t.package_name, t.module_name, t.business_name, t.function_name, t.function_author, t.gen_type, t.gen_path, t.options, t.remark,
               c.column_id, c.column_name, c.column_comment, c.column_type, c.java_type, c.java_field, c.is_pk, c.is_increment, c.is_required, c.is_insert, c.is_edit, c.is_list, c.is_query, c.query_type, c.html_type, c.dict_type, c.sort
        FROM gen_table t
             LEFT JOIN gen_table_column c ON t.table_id = c.table_id
        where t.table_id = #{tableId} order by c.sort
    </select>
	
    <select id="selectGenTableByName" parameterType="String" resultMap="GenTableResult">
        SELECT t.table_id, t.table_name, t.table_comment, t.sub_table_name, t.sub_table_fk_name, t.class_name, t.tpl_category, t.tpl_web_type, t.package_name, t.module_name, t.business_name, t.function_name, t.function_author, t.gen_type, t.gen_path, t.options, t.remark,
               c.column_id, c.column_name, c.column_comment, c.column_type, c.java_type, c.java_field, c.is_pk, c.is_increment, c.is_required, c.is_insert, c.is_edit, c.is_list, c.is_query, c.query_type, c.html_type, c.dict_type, c.sort
        FROM gen_table t
             LEFT JOIN gen_table_column c ON t.table_id = c.table_id
        where t.table_name = #{tableName} order by c.sort
    </select>
	
    <select id="selectGenTableAll" parameterType="String" resultMap="GenTableResult">
        SELECT t.table_id, t.table_name, t.table_comment, t.sub_table_name, t.sub_table_fk_name, t.class_name, t.tpl_category, t.tpl_web_type, t.package_name, t.module_name, t.business_name, t.function_name, t.function_author, t.options, t.remark,
               c.column_id, c.column_name, c.column_comment, c.column_type, c.java_type, c.java_field, c.is_pk, c.is_increment, c.is_required, c.is_insert, c.is_edit, c.is_list, c.is_query, c.query_type, c.html_type, c.dict_type, c.sort
        FROM gen_table t
             LEFT JOIN gen_table_column c ON t.table_id = c.table_id
        order by c.sort
    </select>
	
    <insert id="insertGenTable" parameterType="GenTable" useGeneratedKeys="true" keyProperty="tableId">
        insert into gen_table (
            <if test="tableName != null">table_name,</if>
            <if test="tableComment != null and tableComment != ''">table_comment,</if>
            <if test="className != null and className != ''">class_name,</if>
            <if test="tplCategory != null and tplCategory != ''">tpl_category,</if>
            <if test="tplWebType != null and tplWebType != ''">tpl_web_type,</if>
            <if test="packageName != null and packageName != ''">package_name,</if>
            <if test="moduleName != null and moduleName != ''">module_name,</if>
            <if test="businessName != null and businessName != ''">business_name,</if>
            <if test="functionName != null and functionName != ''">function_name,</if>
            <if test="functionAuthor != null and functionAuthor != ''">function_author,</if>
            <if test="genType != null and genType != ''">gen_type,</if>
            <if test="genPath != null and genPath != ''">gen_path,</if>
            <if test="remark != null and remark != ''">remark,</if>
             <if test="createBy != null and createBy != ''">create_by,</if>
            create_time
         )values(
            <if test="tableName != null">#{tableName},</if>
            <if test="tableComment != null and tableComment != ''">#{tableComment},</if>
            <if test="className != null and className != ''">#{className},</if>
            <if test="tplCategory != null and tplCategory != ''">#{tplCategory},</if>
            <if test="tplWebType != null and tplWebType != ''">#{tplWebType},</if>
            <if test="packageName != null and packageName != ''">#{packageName},</if>
            <if test="moduleName != null and moduleName != ''">#{moduleName},</if>
            <if test="businessName != null and businessName != ''">#{businessName},</if>
            <if test="functionName != null and functionName != ''">#{functionName},</if>
            <if test="functionAuthor != null and functionAuthor != ''">#{functionAuthor},</if>
            <if test="genType != null and genType != ''">#{genType},</if>
            <if test="genPath != null and genPath != ''">#{genPath},</if>
            <if test="remark != null and remark != ''">#{remark},</if>
             <if test="createBy != null and createBy != ''">#{createBy},</if>
            sysdate()
         )
    </insert>
    
    <update id="updateGenTable" parameterType="GenTable">
        update gen_table
        <set>
            <if test="tableName != null">table_name = #{tableName},</if>
            <if test="tableComment != null and tableComment != ''">table_comment = #{tableComment},</if>
            <if test="subTableName != null">sub_table_name = #{subTableName},</if>
            <if test="subTableFkName != null">sub_table_fk_name = #{subTableFkName},</if>
            <if test="className != null and className != ''">class_name = #{className},</if>
            <if test="functionAuthor != null and functionAuthor != ''">function_author = #{functionAuthor},</if>
            <if test="genType != null and genType != ''">gen_type = #{genType},</if>
            <if test="genPath != null and genPath != ''">gen_path = #{genPath},</if>
            <if test="tplCategory != null and tplCategory != ''">tpl_category = #{tplCategory},</if>
            <if test="tplWebType != null and tplWebType != ''">tpl_web_type = #{tplWebType},</if>
            <if test="packageName != null and packageName != ''">package_name = #{packageName},</if>
            <if test="moduleName != null and moduleName != ''">module_name = #{moduleName},</if>
            <if test="businessName != null and businessName != ''">business_name = #{businessName},</if>
            <if test="functionName != null and functionName != ''">function_name = #{functionName},</if>
            <if test="options != null and options != ''">options = #{options},</if>
            <if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
            <if test="remark != null">remark = #{remark},</if>
            update_time = sysdate()
        </set>
        where table_id = #{tableId}
    </update>
    
    <delete id="deleteGenTableByIds" parameterType="Long">
        delete from gen_table where table_id in 
        <foreach collection="array" item="tableId" open="(" separator="," close=")">
            #{tableId}
        </foreach>
    </delete>

</mapper>

 ˵Ã÷.txt

@@ -34,4 +34,16 @@
  accessKey: minioadmin
  secretKey: minioadmin
  bucketName: test

# ä»£ç ç”Ÿæˆ
gen:
  # ä½œè€…
  author: se
  # é»˜è®¤ç”ŸæˆåŒ…路径 system éœ€æ”¹æˆè‡ªå·±çš„模块名称 å¦‚ system monitor tool
  packageName: com.se.system
  # è‡ªåŠ¨åŽ»é™¤è¡¨å‰ç¼€ï¼Œé»˜è®¤æ˜¯false
  autoRemovePre: false
  # è¡¨å‰ç¼€ï¼ˆç”Ÿæˆç±»åä¸ä¼šåŒ…含表前缀，多个用逗号分隔）
  tablePrefix: sys_

--------------------------------------------------------