1. 首页
  2. 文章中心
  3. 开发工具

使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情

127 阅读 0 评论
我是靠谱客的博主 聪明帆布鞋，这篇文章主要介绍使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情，现在分享给大家，希望可以做个参考。

文章目录

  • 前言
  • 一、生成步骤
  • 二、步骤图示
    • 1、导入Groovy脚本到IDEA中
    • 2、IDEA连接数据库，选择要导出的表，选择生成脚本
    • 3、选择要生成代码的存放位置
    • 4、生成结果
  • 三、Groovy脚本详情

前言

日常的开发都用到 Mybatis Plus，但是每次开新功能都得设计表、映射实体代码，写相关service、mapper。这些过程都是繁琐而重复的，于是想通过逆向生成的方式，自动通过数据表，可以逆向生成相关的单表CRUD代码，IDEA上找了几个插件，都不太适合我，生成的东西还是得改。于是自己写了个Groovy脚本来生成

一、生成步骤

1、首先是设计数据库表，然后在IDEA的DataBase工具里连接对应的库

2、导入Groovy 脚本

3、选择要生成代码的表（支持多选），然后选择生成位置（一般放在与启动类同级的包下），点击生成即可

二、步骤图示

1、导入Groovy脚本到IDEA中

导入脚本，并放在如下位置（脚本在文末提供）

在这里插入图片描述

2、IDEA连接数据库，选择要导出的表，选择生成脚本

如图示步骤操作

在这里插入图片描述

3、选择要生成代码的存放位置

在这里插入图片描述

4、生成结果

在这里插入图片描述

三、Groovy脚本详情

此处给出脚本源码，如果生成的代码不满意，可以调整代码，改成合适自己的

如果不想复制粘贴，可以直接点击链接下载 https://download.csdn.net/download/m4330187/75543171

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
import com.intellij.database.model.DasTable
import com.intellij.database.model.ObjectKind
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

import java.io.*
import java.text.SimpleDateFormat

/*
 * Available context bindings:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */
packageName = ""
className = ""
userName = "ZhiPeng.Lin"
// 包
entityPackage = "\entity\"
mapperPackage = "\mapper\"
servicePackage = "\service\"
serviceImplPackage = "\service\impl\"

typeMapping = [
        (~/(?i)int|tinyint|smallint|mediumint/)  : "Integer",
//        (~/(?i)int/)                             : "Long",
        (~/(?i)bool|bit/)                        : "Boolean",
        (~/(?i)float|double|decimal|real/)       : "Double",
        (~/(?i)datetime|timestamp|date|time/)    : "Date",
        (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
        (~/(?i)/)                                : "String"
]


FILES.chooseDirectoryAndSave("Choose directory", "Choose where to save the generate files !!!") { dir ->
    SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
}

// 生成Entity实体文件
def generate(table, dir) {
    className = javaName(table.getName(), true)
    def fields = calcFields(table)
    packageName = getPackageName(dir)
    //
    def entityName = className + ".java"
    // 先创建文件夹
    def newDir = dir.toString() + entityPackage
    def dirFile = new File(newDir)
    if (!dirFile.exists()) {
        dirFile.mkdirs()
    }
    def file = new File(newDir, entityName)
    // 输出实体
    PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"))
    printWriter.withPrintWriter { out -> generate(out, className, fields, table) }
    generateMapper(dir)
    generateService(dir)
    generateServiceImpl(dir)
}

// 生成 Mapper 文件
def generateMapper(dir) {
    def mapperName = className + "Mapper.java"
    // 先创建文件夹
    def newDir = dir.toString() + mapperPackage
    def dirFile = new File(newDir)
    if (!dirFile.exists()) {
        dirFile.mkdirs()
    }
    def file = new File(newDir, mapperName)
    PrintWriter printWriterMapper = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"))
    // 输出mapper
    printWriterMapper.withPrintWriter { out -> generateMapper(out, className) }
}

// 生成 Service 文件
def generateService(dir) {
    def serviceName = "I" + className + "Service.java"
    // 先创建文件夹
    def newDir = dir.toString() + servicePackage
    def dirFile = new File(newDir)
    if (!dirFile.exists()) {
        dirFile.mkdirs()
    }
    def file = new File(newDir, serviceName)
    PrintWriter printWriterMapper = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"))
    printWriterMapper.withPrintWriter { out -> generateService(out, className) }
}

// 生成 ServiceImpl 文件
def generateServiceImpl(dir) {
    def serviceImplName = className + "ServiceImpl.java"
    // 先创建文件夹
    def newDir = dir.toString() + serviceImplPackage
    def dirFile = new File(newDir)
    if (!dirFile.exists()) {
        dirFile.mkdirs()
    }
    def file = new File(newDir, serviceImplName)
    PrintWriter printWriterMapper = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"))
    printWriterMapper.withPrintWriter { out -> generateServiceImpl(out, className) }
}

// 获取包所在文件夹路径
def getPackageName(dir) {
    return dir.toString().replaceAll("\\", ".").replaceAll("/", ".").replaceAll("^.*src(\.main\.java\.)?", "") + ";"
}

// Mapper 文件具体生成逻辑
def generateMapper(out, className) {
    def entityName = packageName.replaceAll(";", ".") + "entity." + className + ";"
    out.println "package " + packageName.replaceAll(";", ".") + "mapper;"
    out.println ""
    out.println "import org.apache.ibatis.annotations.Mapper;"
    out.println "import com.baomidou.mybatisplus.core.mapper.BaseMapper;"
    out.println "import $entityName"
    out.println ""
    out.println "/**n" +
            " * @Description  n" +
            " * @author $userNamen" +
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " n" +
            " */"
    out.println "@Mapper"
    out.println "public interface " + className + "Mapper extends BaseMapper<" + className + "> {n" + "}"
}
// Service 文件具体生成逻辑
def generateService(out, className) {
    def entityName = packageName.replaceAll(";", ".") + "entity." + className + ";"
    out.println "package " + packageName.replaceAll(";", ".") + "service;"
    out.println ""
    out.println "import com.baomidou.mybatisplus.extension.service.IService;"
    out.println "import $entityName"
    out.println ""
    out.println "/**n" +
            " * @Description  n" +
            " * @author $userNamen" +
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " n" +
            " */"
    out.println "public interface I" + className + "Service extends IService<" + className + "> {n" + "}"
}

// ServiceImpl 文件具体生成逻辑
def generateServiceImpl(out, className) {
    def entityName = packageName.replaceAll(";", ".") + "entity." + className + ";"
    def mapperNameTemp = packageName.replaceAll(";", ".") + "mapper." + className + "Mapper;"
    def serviceNameTemp = packageName.replaceAll(";", ".") + "service.I"+ className + "Service;"
    out.println "package " + packageName.replaceAll(";", ".") + "service.impl;"
    out.println ""
    out.println "import lombok.extern.slf4j.Slf4j;"
    out.println "import org.springframework.stereotype.Service;"
    out.println "import org.springframework.transaction.annotation.Transactional;"
    out.println "import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;"
    out.println "import $mapperNameTemp"
    out.println "import $serviceNameTemp"
    out.println "import $entityName"
    out.println ""
    out.println "/**n" +
            " * @Description  n" +
            " * @Author $userNamen" +
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " n" +
            " */"
    out.println "@Slf4j"
    out.println "@Service"
    out.println "@Transactional(rollbackFor = Exception.class)"
    out.println "public class " + className + "ServiceImpl extends ServiceImpl<" + className + "Mapper, " + className + "> implements I" + className + "Service {n" + "}"
}

// 生成实体逻辑
def generate(out, className, fields, table) {
    out.println "package " + packageName.replaceAll(";", ".") + "entity" + ";"
    out.println ""
    out.println "import com.baomidou.mybatisplus.annotation.IdType;"
    out.println "import com.baomidou.mybatisplus.annotation.TableId;"
    out.println "import com.baomidou.mybatisplus.annotation.TableField;"
    out.println "import com.baomidou.mybatisplus.annotation.TableName;"
    out.println "import java.io.Serializable;"

    out.println "import lombok.Data;"
    Set types = new HashSet()

    fields.each() {
        types.add(it.type)
    }

    if (types.contains("Date")) {
        out.println "import java.util.Date;"
    }

    if (types.contains("InputStream")) {
        out.println "import java.io.InputStream;"
    }
    out.println ""
    out.println "/**n" +
            " * @Description  n" +
            " * @author $userNamen" +
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " n" +
            " */"
    out.println "@Data"
    out.println "@TableName(value ="" + table.getName() + "")"
    out.println "public class $className  implements Serializable {"
    out.println ""
    out.println genSerialID()
    fields.each() {
        out.println ""
        // 输出注释
        if (isNotEmpty(it.commoent)) {
            out.println "t/**"
            out.println "t * ${it.commoent.toString()}."
            out.println "t */"
        }

//        下面加上
        if ((it.annos + "").indexOf("[@Id]") >= 0) out.println "t@TableId(type = IdType.AUTO)"

        if (it.annos != "") out.println " ${it.annos.replace("[@Id]", "")}"

        // 输出成员变量
        out.println "tprivate ${it.type} ${it.name};"
    }
    out.println ""
    out.println "}"
}

def calcFields(table) {
    DasUtil.getColumns(table).reduce([]) { fields, col ->
        def spec = Case.LOWER.apply(col.getDataType().getSpecification())

        def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
        def comm = [
                colName : col.getName(),
                name    : javaName(col.getName(), false),
                type    : typeStr,
                commoent: col.getComment(),
                annos   : "t@TableField(value = "" + col.getName() + "")"]
        if ("id".equals(Case.LOWER.apply(col.getName())))
            comm.annos += ["@Id"]
        fields += [comm]
    }
}

// 处理类名(例如这里的表都是以t_命名的，所以需要处理去掉生成类名时的开头的T，
// 如果你不需要那么请查找用到了 javaClassName这个方法的地方修改为 javaName 即可）
def javaClassName(str, capitalize) {
    def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
            .collect { Case.LOWER.apply(it).capitalize() }
            .join("")
            .replaceAll(/[^p{javaJavaIdentifierPart}[_]]/, "_")
    s = s[1..s.size() - 1]
    capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

def javaName(str, capitalize) {
    def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
            .collect { Case.LOWER.apply(it).capitalize() }
            .join("")
            .replaceAll(/[^p{javaJavaIdentifierPart}[_]]/, "_")
    capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

def isNotEmpty(content) {
    return content != null && content.toString().trim().length() > 0
}

static String changeStyle(String str, boolean toCamel) {
    if (!str || str.size() <= 1)
        return str

    if (toCamel) {
        String r = str.toLowerCase().split('_').collect { cc -> Case.LOWER.apply(cc).capitalize() }.join('')
        return r[0].toLowerCase() + r[1..-1]
    } else {
        str = str[0].toLowerCase() + str[1..-1]
        return str.collect { cc -> ((char) cc).isUpperCase() ? '_' + cc.toLowerCase() : cc }.join('')
    }
}

static String genSerialID() {
    return "tprivate static final long serialVersionUID =  " + Math.abs(new Random().nextLong()) + "L;"
}
复制代码
1
2
PS：此文为原创文章，转载请注明出处

最后

以上就是聪明帆布鞋最近收集整理的关于使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情的全部内容，更多相关使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(84)

相关文章

判断文件或文件目录是否存在
判断文件或文件目录是否存在
Groovy~Groovy的语法增强
Groovy~Groovy的语法增强
groovy 学习（三）groovy的高级操作groovy对xml文件的处理groovy 对文件的处理
groovy 学习（三）groovy的高级操作groovy对xml文件的处理groovy 对文件的处理
用groovy遍历jar查找目标文件
用groovy遍历jar查找目标文件
使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情
使用Groovy脚本逆向生成MybatisPlus代码前言一、生成步骤二、步骤图示三、Groovy脚本详情
Groovy源代码分析（一）
Groovy源代码分析（一）
Groovy 学习手册（7）
Groovy 学习手册（7）
Python reversed函数及用法Python reversed函数及用法
Python reversed函数及用法Python reversed函数及用法

评论列表共有 0 条评论

立即
投稿
返回
顶部