RuoYi 阶段十一：代码生成器

NOTE
本文是 RuoYi 学习路线的阶段十一，聚焦代码生成器。学完本篇你应该能：

理解代码生成器的工作原理

掌握 Velocity 模板引擎的使用

知道如何自定义代码模板

前端视角：代码生成器像什么？#

RuoYi 代码生成器	前端类比
Velocity 模板	Handlebars / EJS 模板引擎
表结构解析	Schema 解析
代码生成	脚手架工具 (create-react-app)
模板配置	代码片段 (Snippets)
批量生成	代码模板批量应用

代码生成器架构#

1
┌─────────────────┐
2
│   数据库表      │
3
└────────┬────────┘
4
         │ 解析
5
         ▼
6
┌─────────────────┐
7
│   GenTable      │
8
│   GenTableColumn│
9
└────────┬────────┘
10
         │ 配置
11
         ▼
12
┌─────────────────┐
13
│  Velocity 模板  │
14
│  (vm 文件)      │
15
└────────┬────────┘
16
         │ 渲染
17
         ▼
18
┌─────────────────┐
19
│  生成的代码     │
20
│  Domain/Mapper/ │
21
│  Service/Controller│
22
└─────────────────┘

生成表实体类#

1
package com.ruoyi.generator.domain;
2

3
import java.util.List;
4
import javax.validation.Valid;
5
import javax.validation.constraints.NotBlank;
6
import org.apache.commons.lang3.ArrayUtils;
7
import com.ruoyi.common.constant.GenConstants;
8
import com.ruoyi.common.core.domain.BaseEntity;
9
import com.ruoyi.common.utils.StringUtils;
10

11
/**
12
 * 业务表 gen_table
13
 *
14
 * @author ruoyi
15
 */
16
public class GenTable extends BaseEntity {
17
    private static final long serialVersionUID = 1L;
18

19
    /** 编号 */
20
    private Long tableId;
21

22
    /** 表名称 */
23
    @NotBlank(message = "表名称不能为空")
24
    private String tableName;
25

26
    /** 表描述 */
27
    @NotBlank(message = "表描述不能为空")
28
    private String tableComment;
29

30
    /** 关联父表的表名 */
31
    private String subTableName;
32

33
    /** 本表与关联父表的外键名 */
34
    private String subTableFkName;
35

36
    /** 实体类名称(首字母大写) */
37
    @NotBlank(message = "实体类名称不能为空")
38
    private String className;
39

40
    /** 使用的模板（crud单表操作 tree树表操作 sub主子表操作） */
41
    private String tplCategory;
42

43
    /** 生成包路径 */
44
    @NotBlank(message = "生成包路径不能为空")
45
    private String packageName;
46

47
    /** 生成模块名 */
48
    @NotBlank(message = "生成模块名不能为空")
49
    private String moduleName;
50

51
    /** 生成业务名 */
52
    @NotBlank(message = "生成业务名不能为空")
53
    private String businessName;
54

55
    /** 生成功能名 */
56
    @NotBlank(message = "生成功能名不能为空")
57
    private String functionName;
58

59
    /** 生成作者 */
60
    @NotBlank(message = "作者不能为空")
61
    private String functionAuthor;
62

63
    /** 生成代码方式（0zip压缩包 1自定义路径） */
64
    private String genType;
65

66
    /** 生成路径（不填默认项目路径） */
67
    private String genPath;
68

69
    /** 主键信息 */
70
    private GenTableColumn pkColumn;
71

72
    /** 子表信息 */
73
    private GenTable subTable;
74

75
    /** 表列信息 */
76
    @Valid
77
    private List<GenTableColumn> columns;
78

79
    /** 其它生成选项 */
80
    private String options;
81

82
    /** 树编码字段 */
83
    private String treeCode;
84

85
    /** 树父编码字段 */
86
    private String treeParentCode;
87

88
    /** 树名称字段 */
89
    private String treeName;
90

91
    /** 上级菜单ID字段 */
92
    private String parentMenuId;
93

94
    /** 上级菜单名称字段 */
95
    private String parentMenuName;
96

97
    // Getter 和 Setter 省略...
98

99
    public boolean isSub() {
100
        return isSub(this.tplCategory);
101
    }
102

103
    public static boolean isSub(String tplCategory) {
104
        return tplCategory != null && StringUtils.equals(GenConstants.TPL_SUB, tplCategory);
105
    }
106

107
    public boolean isTree() {
108
        return isTree(this.tplCategory);
109
    }
110

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

115
    public boolean isCrud() {
116
        return isCrud(this.tplCategory);
117
    }
118

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

123
    public String getPermissionPrefix() {
124
        return getModuleName() + ":" + getBusinessName();
125
    }
126
}

生成列实体类#

1
package com.ruoyi.generator.domain;
2

3
import javax.validation.constraints.NotBlank;
4
import com.ruoyi.common.core.domain.BaseEntity;
5
import com.ruoyi.common.utils.StringUtils;
6

7
/**
8
 * 代码生成业务字段表 gen_table_column
9
 *
10
 * @author ruoyi
11
 */
12
public class GenTableColumn extends BaseEntity {
13
    private static final long serialVersionUID = 1L;
14

15
    /** 编号 */
16
    private Long columnId;
17

18
    /** 归属表编号 */
19
    private Long tableId;
20

21
    /** 列名称 */
22
    private String columnName;
23

24
    /** 列描述 */
25
    private String columnComment;
26

27
    /** 列类型 */
28
    private String columnType;
29

30
    /** JAVA类型 */
31
    private String javaType;
32

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

37
    /** 是否主键（1是） */
38
    private String isPk;
39

40
    /** 是否自增（1是） */
41
    private String isIncrement;
42

43
    /** 是否必填（1是） */
44
    private String isRequired;
45

46
    /** 是否为插入字段（1是） */
47
    private String isInsert;
48

49
    /** 是否编辑字段（1是） */
50
    private String isEdit;
51

52
    /** 是否列表字段（1是） */
53
    private String isList;
54

55
    /** 是否查询字段（1是） */
56
    private String isQuery;
57

58
    /** 查询方式（EQ等于、NE不等于、GT大于、LT小于、LIKE模糊、BETWEEN范围） */
59
    private String queryType;
60

61
    /** 显示类型（input文本框、textarea文本域、select下拉框、checkbox复选框、radio单选框、datetime日期控件、upload上传控件、editor富文本控件） */
62
    private String htmlType;
63

64
    /** 字典类型 */
65
    private String dictType;
66

67
    /** 排序 */
68
    private Integer sort;
69

70
    // Getter 和 Setter 省略...
71

72
    public boolean isPk() {
73
        return isPk(this.isPk);
74
    }
75

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

80
    public boolean isIncrement() {
81
        return isIncrement(this.isIncrement);
82
    }
83

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

88
    public boolean isRequired() {
89
        return isRequired(this.isRequired);
90
    }
91

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

96
    public boolean isInsert() {
97
        return isInsert(this.isInsert);
98
    }
99

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

104
    public boolean isEdit() {
105
        return isEdit(this.isEdit);
106
    }
107

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

112
    public boolean isList() {
113
        return isList(this.isList);
114
    }
115

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

120
    public boolean isQuery() {
121
        return isQuery(this.isQuery);
122
    }
123

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

128
    public boolean isSuperColumn() {
129
        return isSuperColumn(this.javaField);
130
    }
131

132
    public static boolean isSuperColumn(String javaField) {
133
        return StringUtils.equalsAnyIgnoreCase(javaField,
134
                // BaseEntity
135
                "createBy", "createTime", "updateBy", "updateTime", "remark",
136
                // TreeEntity
137
                "parentName", "parentId", "orderNum", "ancestors");
138
    }
139

140
    public boolean isUsableColumn() {
141
        return isUsableColumn(javaField);
142
    }
143

144
    public static boolean isUsableColumn(String javaField) {
145
        // isSuperColumn()中的名单用于避免生成多余Domain属性，若下列属性在BaseEntity/TreeEntity中已存在，
146
        // 则不需要在此处重复生成，因此排除
147
        return StringUtils.equalsAnyIgnoreCase(javaField, "parentId", "orderNum", "remark");
148
    }
149

150
    public String readConverterExp() {
151
        String remarks = StringUtils.substringBetween(this.columnComment, "（", "）");
152
        StringBuffer sb = new StringBuffer();
153
        if (StringUtils.isNotEmpty(remarks)) {
154
            for (String value : remarks.split(" ")) {
155
                if (StringUtils.isNotEmpty(value)) {
156
                    Object startStr = value.subSequence(0, 1);
157
                    String endStr = value.substring(1);
158
                    sb.append("").append(startStr).append("=").append(endStr).append(",");
159
                }
160
            }
161
            return sb.deleteCharAt(sb.length() - 1).toString();
162
        } else {
163
            return this.columnComment;
164
        }
165
    }
166
}

Velocity 模板引擎#

模板配置#

1
package com.ruoyi.generator.config;
2

3
import org.springframework.beans.factory.annotation.Value;
4
import org.springframework.boot.context.properties.ConfigurationProperties;
5
import org.springframework.context.annotation.PropertySource;
6
import org.springframework.stereotype.Component;
7

8
/**
9
 * 读取代码生成相关配置
10
 *
11
 * @author ruoyi
12
 */
13
@Component
14
@ConfigurationProperties(prefix = "gen")
15
@PropertySource(value = { "classpath:generator.yml" })
16
public class GenConfig {
17
    /** 作者 */
18
    public static String author;
19

20
    /** 生成包路径 */
21
    public static String packageName;
22

23
    /** 自动去除表前缀，默认是true */
24
    public static boolean autoRemovePre;
25

26
    /** 表前缀(类名不会包含表前缀) */
27
    public static String tablePrefix;
28

29
    /** 是否允许生成文件覆盖到本地（自定义路径），默认是false */
30
    public static boolean allowOverwrite;
31

32
    public static String getAuthor() {
33
        return author;
34
    }
35

36
    public void setAuthor(String author) {
37
        GenConfig.author = author;
38
    }
39

40
    public static String getPackageName() {
41
        return packageName;
42
    }
43

44
    public void setPackageName(String packageName) {
45
        GenConfig.packageName = packageName;
46
    }
47

48
    public static boolean getAutoRemovePre() {
49
        return autoRemovePre;
50
    }
51

52
    public void setAutoRemovePre(boolean autoRemovePre) {
53
        GenConfig.autoRemovePre = autoRemovePre;
54
    }
55

56
    public static String getTablePrefix() {
57
        return tablePrefix;
58
    }
59

60
    public void setTablePrefix(String tablePrefix) {
61
        GenConfig.tablePrefix = tablePrefix;
62
    }
63

64
    public static boolean isAllowOverwrite() {
65
        return allowOverwrite;
66
    }
67

68
    public void setAllowOverwrite(boolean allowOverwrite) {
69
        GenConfig.allowOverwrite = allowOverwrite;
70
    }
71
}

generator.yml 配置#

1
gen:
2
  # 作者
3
  author: ruoyi
4
  # 默认生成包路径 system 需改成自己的模块名称 如 system monitor tool
5
  packageName: com.ruoyi.system
6
  # 自动去除表前缀，默认是true
7
  autoRemovePre: true
8
  # 表前缀(类名不会包含表前缀)
9
  tablePrefix: sys_
10
  # 是否允许生成文件覆盖到本地（自定义路径），默认是false
11
  allowOverwrite: false

模板文件#

RuoYi 的代码模板位于 src/main/resources/vm 目录：

1
vm/
2
├── java/
3
│   ├── controller.java.vm      # Controller 模板
4
│   ├── domain.java.vm          # Domain 实体模板
5
│   ├── mapper.java.vm          # Mapper 接口模板
6
│   └── service.java.vm         # Service 接口模板
7
│   └── serviceImpl.java.vm     # Service 实现模板
8
├── xml/
9
│   └── mapper.xml.vm           # Mapper XML 模板
10
├── html/
11
│   ├── add.html.vm             # 新增页面模板
12
│   ├── edit.html.vm            # 编辑页面模板
13
│   └── list.html.vm            # 列表页面模板
14
└── sql/
15
    └── menu.sql.vm             # 菜单 SQL 模板

Controller 模板示例#

1
## src/main/resources/vm/java/controller.java.vm
2
package ${packageName}.controller;
3

4
import java.util.List;
5
import javax.servlet.http.HttpServletResponse;
6
import org.apache.shiro.authz.annotation.RequiresPermissions;
7
import org.springframework.beans.factory.annotation.Autowired;
8
import org.springframework.stereotype.Controller;
9
import org.springframework.ui.ModelMap;
10
import org.springframework.web.bind.annotation.*;
11
import com.ruoyi.common.annotation.Log;
12
import com.ruoyi.common.core.controller.BaseController;
13
import com.ruoyi.common.core.domain.AjaxResult;
14
import com.ruoyi.common.core.page.TableDataInfo;
15
import com.ruoyi.common.enums.BusinessType;
16
import com.ruoyi.common.utils.poi.ExcelUtil;
17
import ${packageName}.domain.${ClassName};
18
import ${packageName}.service.I${ClassName}Service;
19

20
/**
21
 * ${functionName}Controller
22
 *
23
 * @author ${author}
24
 * @date ${datetime}
25
 */
26
@Controller
27
@RequestMapping("/${moduleName}/${businessName}")
28
public class ${ClassName}Controller extends BaseController {
29
    private String prefix = "${moduleName}/${businessName}";
30

31
    @Autowired
32
    private I${ClassName}Service ${className}Service;
33

34
    @RequiresPermissions("${permissionPrefix}:view")
35
    @GetMapping()
36
    public String ${businessName}() {
37
        return prefix + "/${businessName}";
38
    }
39

40
    /**
41
     * 查询${functionName}列表
42
     */
43
    @RequiresPermissions("${permissionPrefix}:list")
44
    @PostMapping("/list")
45
    @ResponseBody
46
    public TableDataInfo list(${ClassName} ${className}) {
47
        startPage();
48
        List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
49
        return getDataTable(list);
50
    }
51

52
    /**
53
     * 导出${functionName}列表
54
     */
55
    @RequiresPermissions("${permissionPrefix}:export")
56
    @Log(title = "${functionName}", businessType = BusinessType.EXPORT)
57
    @PostMapping("/export")
58
    @ResponseBody
59
    public AjaxResult export(HttpServletResponse response, ${ClassName} ${className}) {
60
        List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
61
        ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class);
62
        return util.exportExcel(response, list, "${functionName}数据");
63
    }
64

65
    /**
66
     * 新增${functionName}
67
     */
68
    @GetMapping("/add")
69
    public String add() {
70
        return prefix + "/add";
71
    }
72

73
    /**
74
     * 新增保存${functionName}
75
     */
76
    @RequiresPermissions("${permissionPrefix}:add")
77
    @Log(title = "${functionName}", businessType = BusinessType.INSERT)
78
    @PostMapping("/add")
79
    @ResponseBody
80
    public AjaxResult addSave(${ClassName} ${className}) {
81
        return toAjax(${className}Service.insert${ClassName}(${className}));
82
    }
83

84
    /**
85
     * 修改${functionName}
86
     */
87
    @GetMapping("/edit/{${pkColumn.javaField}}")
88
    public String edit(@PathVariable("${pkColumn.javaField}") ${pkColumn.javaType} ${pkColumn.javaField}, ModelMap mmap) {
89
        ${ClassName} ${className} = ${className}Service.select${ClassName}ById(${pkColumn.javaField});
90
        mmap.put("${className}", ${className});
91
        return prefix + "/edit";
92
    }
93

94
    /**
95
     * 修改保存${functionName}
96
     */
97
    @RequiresPermissions("${permissionPrefix}:edit")
98
    @Log(title = "${functionName}", businessType = BusinessType.UPDATE)
99
    @PostMapping("/edit")
100
    @ResponseBody
101
    public AjaxResult editSave(${ClassName} ${className}) {
102
        return toAjax(${className}Service.update${ClassName}(${className}));
103
    }
104

105
    /**
106
     * 删除${functionName}
107
     */
108
    @RequiresPermissions("${permissionPrefix}:remove")
109
    @Log(title = "${functionName}", businessType = BusinessType.DELETE)
110
    @PostMapping("/remove")
111
    @ResponseBody
112
    public AjaxResult remove(String ids) {
113
        return toAjax(${className}Service.delete${ClassName}ByIds(ids));
114
    }
115
}

Domain 模板示例#

1
## src/main/resources/vm/java/domain.java.vm
2
package ${packageName}.domain;
3

4
#foreach ($import in $importList)
5
import ${import};
6
#end
7
import org.apache.commons.lang3.builder.ToStringBuilder;
8
import org.apache.commons.lang3.builder.ToStringStyle;
9
import com.ruoyi.common.annotation.Excel;
10
import com.ruoyi.common.core.domain.BaseEntity;
11

12
/**
13
 * ${functionName}对象 ${tableName}
14
 *
15
 * @author ${author}
16
 * @date ${datetime}
17
 */
18
public class ${ClassName} extends BaseEntity {
19
    private static final long serialVersionUID = 1L;
20

21
#foreach ($column in $columns)
22
#if(!$table.isSuperColumn($column.javaField))
23
    /** ${column.columnComment} */
24
#if($column.list)
25
    @Excel(name = "${column.columnComment}"#if($column.readConverterExp), readConverterExp = "$column.readConverterExp()"#end)
26
#end
27
    private $column.javaType $column.javaField;
28

29
#end
30
#end
31
#foreach ($column in $columns)
32
#if(!$table.isSuperColumn($column.javaField))
33
    public void set${column.javaField.capitalize()}($column.javaType $column.javaField) {
34
        this.$column.javaField = $column.javaField;
35
    }
36

37
    public $column.javaType get${column.javaField.capitalize()}() {
38
        return $column.javaField;
39
    }
40

41
#end
42
#end
43
    @Override
44
    public String toString() {
45
        return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
46
#foreach ($column in $columns)
47
            .append("${column.javaField}", get${column.javaField.capitalize()}())
48
#end
49
            .toString();
50
    }
51
}

代码生成 Service#

1
package com.ruoyi.generator.service;
2

3
import java.io.ByteArrayOutputStream;
4
import java.io.File;
5
import java.io.IOException;
6
import java.io.StringWriter;
7
import java.util.*;
8
import java.util.zip.ZipEntry;
9
import java.util.zip.ZipOutputStream;
10
import org.apache.commons.io.IOUtils;
11
import org.apache.velocity.Template;
12
import org.apache.velocity.VelocityContext;
13
import org.apache.velocity.app.Velocity;
14
import org.slf4j.Logger;
15
import org.slf4j.LoggerFactory;
16
import org.springframework.beans.factory.annotation.Autowired;
17
import org.springframework.stereotype.Service;
18
import org.springframework.transaction.annotation.Transactional;
19
import com.alibaba.fastjson.JSON;
20
import com.ruoyi.common.constant.Constants;
21
import com.ruoyi.common.constant.GenConstants;
22
import com.ruoyi.common.core.text.CharsetKit;
23
import com.ruoyi.common.exception.ServiceException;
24
import com.ruoyi.common.utils.SecurityUtils;
25
import com.ruoyi.common.utils.StringUtils;
26
import com.ruoyi.generator.domain.GenTable;
27
import com.ruoyi.generator.domain.GenTableColumn;
28
import com.ruoyi.generator.mapper.GenTableColumnMapper;
29
import com.ruoyi.generator.mapper.GenTableMapper;
30
import com.ruoyi.generator.util.GenUtils;
31
import com.ruoyi.generator.util.VelocityInitializer;
32
import com.ruoyi.generator.util.VelocityUtils;
33

34
/**
35
 * 业务 服务层实现
36
 *
37
 * @author ruoyi
38
 */
39
@Service
40
public class GenTableServiceImpl implements IGenTableService {
41
    private static final Logger log = LoggerFactory.getLogger(GenTableServiceImpl.class);
42

43
    @Autowired
44
    private GenTableMapper genTableMapper;
45

46
    @Autowired
47
    private GenTableColumnMapper genTableColumnMapper;
48

49
    /**
50
     * 获取代码生成信息
51
     */
52
    @Override
53
    public GenTable selectGenTableById(Long tableId) {
54
        GenTable genTable = genTableMapper.selectGenTableById(tableId);
55
        setTableFromOptions(genTable);
56
        return genTable;
57
    }
58

59
    /**
60
     * 查询业务信息
61
     */
62
    @Override
63
    public List<GenTable> selectGenTableList(GenTable genTable) {
64
        return genTableMapper.selectGenTableList(genTable);
65
    }
66

67
    /**
68
     * 查询据库列表
69
     */
70
    @Override
71
    public List<GenTable> selectDbTableList(GenTable genTable) {
72
        return genTableMapper.selectDbTableList(genTable);
73
    }
74

75
    /**
76
     * 导入表结构
77
     */
78
    @Override
79
    @Transactional
80
    public void importGenTable(List<String> tableList) {
81
        String operName = SecurityUtils.getUsername();
82
        for (String tableName : tableList) {
83
            // 查询表信息
84
            GenTable table = genTableMapper.selectDbTableListByName(tableName);
85
            // 验证表是否已存在
86
            if (StringUtils.isNotNull(table)) {
87
                throw new ServiceException("表 " + tableName + " 已存在");
88
            }
89
            // 初始化表信息
90
            table = genTableMapper.selectDbTableByName(tableName);
91
            GenUtils.initTable(table, operName);
92
            int row = genTableMapper.insertGenTable(table);
93
            if (row > 0) {
94
                // 保存列信息
95
                List<GenTableColumn> genTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
96
                for (GenTableColumn column : genTableColumns) {
97
                    GenUtils.initColumnField(column, table);
98
                    genTableColumnMapper.insertGenTableColumn(column);
99
                }
100
            }
101
        }
102
    }
103

104
    /**
105
     * 预览代码
106
     */
107
    @Override
108
    public Map<String, String> previewCode(Long tableId) {
109
        Map<String, String> dataMap = new LinkedHashMap<>();
110
        // 查询表信息
111
        GenTable table = genTableMapper.selectGenTableById(tableId);
112
        List<GenTableColumn> columns = genTableColumnMapper.selectGenTableColumnListByTableId(tableId);
113
        setPkColumn(table, columns);
114
        VelocityInitializer.initVelocity();
115

116
        VelocityContext context = VelocityUtils.prepareContext(table);
117

118
        // 获取模板列表
119
        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
120
        for (String template : templates) {
121
            // 渲染模板
122
            StringWriter sw = new StringWriter();
123
            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
124
            tpl.merge(context, sw);
125
            dataMap.put(template, sw.toString());
126
        }
127
        return dataMap;
128
    }
129

130
    /**
131
     * 生成代码（下载方式）
132
     */
133
    @Override
134
    public byte[] downloadCode(String tableName) {
135
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
136
        ZipOutputStream zip = new ZipOutputStream(outputStream);
137
        generatorCode(tableName, zip, true);
138
        IOUtils.closeQuietly(zip);
139
        return outputStream.toByteArray();
140
    }
141

142
    /**
143
     * 生成代码（自定义路径）
144
     */
145
    @Override
146
    public void generatorCode(String tableName) {
147
        generatorCode(tableName, null, false);
148
    }
149

150
    /**
151
     * 查询表信息并生成代码
152
     */
153
    private void generatorCode(String tableName, ZipOutputStream zip, boolean download) {
154
        // 查询表信息
155
        GenTable table = genTableMapper.selectGenTableByName(tableName);
156
        List<GenTableColumn> columns = genTableColumnMapper.selectGenTableColumnListByTableId(table.getTableId());
157
        setPkColumn(table, columns);
158

159
        VelocityInitializer.initVelocity();
160

161
        VelocityContext context = VelocityUtils.prepareContext(table);
162

163
        // 获取模板列表
164
        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
165
        for (String template : templates) {
166
            // 渲染模板
167
            StringWriter sw = new StringWriter();
168
            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
169
            tpl.merge(context, sw);
170
            try {
171
                if (download) {
172
                    // 添加到zip
173
                    zip.putNextEntry(new ZipEntry(VelocityUtils.getFileName(template, table)));
174
                    IOUtils.write(sw.toString(), zip, Constants.UTF8);
175
                    IOUtils.closeQuietly(sw);
176
                    zip.closeEntry();
177
                } else {
178
                    // 写入文件
179
                    String path = getGenPath(table, template);
180
                    GenUtils.writeToFile(path, sw.toString());
181
                }
182
            } catch (IOException e) {
183
                log.error("渲染模板失败，表名：" + table.getTableName(), e);
184
            }
185
        }
186
    }
187

188
    /**
189
     * 修改保存参数校验
190
     */
191
    @Override
192
    public void validateEdit(GenTable genTable) {
193
        if (GenConstants.TPL_TREE.equals(genTable.getTplCategory())) {
194
            String options = JSON.toJSONString(genTable.getParams());
195
            TreeTable treeTable = JSON.parseObject(options, TreeTable.class);
196
            if (StringUtils.isEmpty(treeTable.getTreeCode())) {
197
                throw new ServiceException("树编码字段不能为空");
198
            } else if (StringUtils.isEmpty(treeTable.getTreeParentCode())) {
199
                throw new ServiceException("树父编码字段不能为空");
200
            } else if (StringUtils.isEmpty(treeTable.getTreeName())) {
201
                throw new ServiceException("树名称字段不能为空");
202
            }
203
        } else if (GenConstants.TPL_SUB.equals(genTable.getTplCategory())) {
204
            if (StringUtils.isEmpty(genTable.getSubTableName())) {
205
                throw new ServiceException("子表名称不能为空");
206
            } else if (StringUtils.isEmpty(genTable.getSubTableFkName())) {
207
                throw new ServiceException("子表外键名称不能为空");
208
            }
209
        }
210
    }
211
}

Velocity 工具类#

1
package com.ruoyi.generator.util;
2

3
import java.util.*;
4
import org.apache.velocity.VelocityContext;
5
import com.alibaba.fastjson.JSONObject;
6
import com.ruoyi.common.constant.GenConstants;
7
import com.ruoyi.common.utils.DateUtils;
8
import com.ruoyi.common.utils.StringUtils;
9
import com.ruoyi.generator.domain.GenTable;
10
import com.ruoyi.generator.domain.GenTableColumn;
11

12
/**
13
 * 模板工具类
14
 *
15
 * @author ruoyi
16
 */
17
public class VelocityUtils {
18
    /** 项目空间路径 */
19
    private static final String PROJECT_PATH = "main/java";
20

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

24
    /** html空间路径 */
25
    private static final String TEMPLATES_PATH = "main/resources/templates";
26

27
    /**
28
     * 设置模板变量信息
29
     */
30
    public static VelocityContext prepareContext(GenTable genTable) {
31
        String moduleName = genTable.getModuleName();
32
        String businessName = genTable.getBusinessName();
33
        String packageName = genTable.getPackageName();
34
        String tplCategory = genTable.getTplCategory();
35
        String functionName = genTable.getFunctionName();
36

37
        VelocityContext velocityContext = new VelocityContext();
38
        velocityContext.put("tplCategory", genTable.getTplCategory());
39
        velocityContext.put("tableName", genTable.getTableName());
40
        velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
41
        velocityContext.put("ClassName", genTable.getClassName());
42
        velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName()));
43
        velocityContext.put("moduleName", genTable.getModuleName());
44
        velocityContext.put("businessName", genTable.getBusinessName());
45
        velocityContext.put("basePackage", getPackagePrefix(packageName));
46
        velocityContext.put("packageName", packageName);
47
        velocityContext.put("author", genTable.getFunctionAuthor());
48
        velocityContext.put("datetime", DateUtils.getDate());
49
        velocityContext.put("pkColumn", genTable.getPkColumn());
50
        velocityContext.put("importList", getImportList(genTable.getColumns()));
51
        velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
52
        velocityContext.put("columns", genTable.getColumns());
53
        velocityContext.put("table", genTable);
54

55
        if (GenConstants.TPL_TREE.equals(tplCategory)) {
56
            setTreeVelocityContext(velocityContext, genTable);
57
        }
58

59
        if (GenConstants.TPL_SUB.equals(tplCategory)) {
60
            setSubVelocityContext(velocityContext, genTable);
61
        }
62

63
        return velocityContext;
64
    }
65

66
    /**
67
     * 获取模板信息
68
     */
69
    public static List<String> getTemplateList(String tplCategory) {
70
        List<String> templates = new ArrayList<String>();
71
        templates.add("vm/java/domain.java.vm");
72
        templates.add("vm/java/mapper.java.vm");
73
        templates.add("vm/java/service.java.vm");
74
        templates.add("vm/java/serviceImpl.java.vm");
75
        templates.add("vm/java/controller.java.vm");
76
        templates.add("vm/xml/mapper.xml.vm");
77
        templates.add("vm/html/list.html.vm");
78
        templates.add("vm/html/add.html.vm");
79
        templates.add("vm/html/edit.html.vm");
80
        templates.add("vm/sql/menu.sql.vm");
81
        return templates;
82
    }
83

84
    /**
85
     * 获取文件名
86
     */
87
    public static String getFileName(String template, GenTable genTable) {
88
        // 文件名称
89
        String fileName = "";
90
        // 包路径
91
        String packageName = genTable.getPackageName();
92
        // 模块名
93
        String moduleName = genTable.getModuleName();
94
        // 大写类名
95
        String className = genTable.getClassName();
96
        // 业务名称
97
        String businessName = genTable.getBusinessName();
98

99
        String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
100
        String mybatisPath = MYBATIS_PATH + "/" + moduleName;
101
        String htmlPath = TEMPLATES_PATH + "/" + moduleName + "/" + businessName;
102

103
        if (template.contains("domain.java.vm")) {
104
            fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
105
        } else if (template.contains("mapper.java.vm")) {
106
            fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className);
107
        } else if (template.contains("service.java.vm")) {
108
            fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className);
109
        } else if (template.contains("serviceImpl.java.vm")) {
110
            fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className);
111
        } else if (template.contains("controller.java.vm")) {
112
            fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className);
113
        } else if (template.contains("mapper.xml.vm")) {
114
            fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
115
        } else if (template.contains("list.html.vm")) {
116
            fileName = StringUtils.format("{}/{}.html", htmlPath, businessName);
117
        } else if (template.contains("add.html.vm")) {
118
            fileName = StringUtils.format("{}/add.html", htmlPath);
119
        } else if (template.contains("edit.html.vm")) {
120
            fileName = StringUtils.format("{}/edit.html", htmlPath);
121
        } else if (template.contains("menu.sql.vm")) {
122
            fileName = businessName + "Menu.sql";
123
        }
124
        return fileName;
125
    }
126

127
    /**
128
     * 获取权限前缀
129
     */
130
    public static String getPermissionPrefix(String moduleName, String businessName) {
131
        return StringUtils.format("{}:{}", moduleName, businessName);
132
    }
133
}

复习卡片#

1
// 代码生成核心流程
2
// 1. 导入表结构
3
GenTable table = genTableMapper.selectDbTableByName(tableName);
4
GenUtils.initTable(table, operName);
5
genTableMapper.insertGenTable(table);
6

7
// 2. 初始化 Velocity
8
VelocityInitializer.initVelocity();
9

10
// 3. 准备模板上下文
11
VelocityContext context = VelocityUtils.prepareContext(table);
12

13
// 4. 渲染模板
14
Template tpl = Velocity.getTemplate(template, Constants.UTF8);
15
tpl.merge(context, sw);
16

17
// 5. 生成文件
18
zip.putNextEntry(new ZipEntry(fileName));
19
IOUtils.write(sw.toString(), zip, Constants.UTF8);

类名	职责
`GenTable`	生成表实体
`GenTableColumn`	生成列实体
`GenConfig`	代码生成配置
`VelocityUtils`	Velocity 工具类
`GenUtils`	代码生成工具类
`IGenTableService`	生成表服务接口

模板类型	说明
crud	单表增删改查
tree	树表（带层级）
sub	主子表（一对多）

TIP
下一步：阶段十二：系统监控
在阶段十二中，我们将学习系统监控功能，包括服务监控、缓存监控和在线用户管理。