Intellij IDEA 通过数据库表生成带注解的Java实体类（lombok版）_idea根据表生成实体类

前言：因为今天在写实体类的时候，发现表中的字段太多，而且又要加注解怕写错漏写，现在市面上也有许多插件，但是有些达不到代码简洁，需要修改。后来还是选择了采用groovy写了一个脚本编写，本来idea他也支持自动生成实体类的功能，改造了一下。

前期准备

1、需要引入lombok依赖，这个东西应该大家都不陌生了

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
1
2
3
4
5

2、需要引入knife4j这个依赖，其实他就是一个生成文档接口的。当然你可以选择不用，直接删掉脚本里面的就好了，如果要用的话就添加依赖。
当然还需要一点配置不配置的话可能不生效但是不影响代码运行，参考knife4j官方文档配置

<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
    <version>4.3.0</version>
</dependency>
1
2
3
4
5

3、我们要使用IDEA连接数据库，我使用的是MySQL(这里按照自己的数据库去选择)

配置数据库信息，连接成功

选择自己的数据库是哪一个，有些时候他会选中，如果没有选中的话可以做这一步操作

准备完了，开干

1、点击表名，右键。Scripted Extensions => Generate POJOs.groovy【这里有两种方式】
我们可以通过点击：Go To Scripts Directory 跳转到脚本所在的目录位置

1、就是用原来的这个文件，这里面的脚本内容需要改变一下，在后面给出代码
2、自己去创建一个文件，也要放在同一个目录下面，就像我图里面的test这个文件夹，但是生成的时候需要选择自己的对应的这个脚本

2、选择要把文件生成的位置

3、生成的效果【这个是更改了脚本之后的示例】，这边使用的都是lombok注解，别无他说这样写代码简洁还省事。但是如果要做其他操作就宁说了

Generate POJOs.groovy 脚本【可自定义，语法简单，百度一下就能看懂，也可以直接使用我这个】：

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 = ""
typeMapping = [
        (~/(?i)bigint/)                          : "Long",
        (~/(?i)int|tinyint|smallint|mediumint/)  : "Integer",
        (~/(?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 store generated files") { dir ->
    SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    packageName = getPackageName(dir)
    // 使用这个设置我们输出的字符编码
    PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, className + ".java")), "UTF-8"))
    printWriter.withPrintWriter {out -> generate(out, className, fields,table)}
}

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

def generate(out, className, fields,table) {
    out.println "package $packageName"
    out.println ""
    out.println "import java.io.Serializable;"
    out.println "import lombok.Data;"
    out.println "import lombok.NoArgsConstructor;"
    out.println "import lombok.AllArgsConstructor;"
    out.println "import io.swagger.annotations.ApiModelProperty;"
    Set types = new HashSet()

    // 控制所需类型导包
    fields.each() {
        types.add(it.type)
    }

    if (types.contains("Date")) {
        // 按照自己的序列化包导入，我采用的是jackson
        out.println "import com.fasterxml.jackson.annotation.JsonFormat;"
        out.println "import java.util.Date;"
    }

    if (types.contains("InputStream")) {
        out.println "import java.io.InputStream;"
    }
    out.println ""
    out.println "/**\n" +
            " * @description $className \n" +
            " * @author  muguang\n" +
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + "\n"+
            " */"
    out.println ""
    out.println "@Data"
    out.println "@NoArgsConstructor"
    out.println "@AllArgsConstructor"
//    out.println "@Table ( name =\""+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 */"
            out.println "\t@ApiModelProperty(value = \"${it.commoent}\")"
        }
        // 如果是日期类型，我们进行格式化
        if (typeIsDate(it.type)){
            out.println "\t@JsonFormat(pattern = \"yyyy-MM-dd\",timezone = \"GMT+8\")"
        }

        // 输出成员变量
        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: ""]
        fields += [comm]
    }
}

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
}

def typeIsDate(type){
    return type != null && type.toString().trim().equalsIgnoreCase("date")
}

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
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

到这里就结束了，我也是因为用到了就研究了一下。至于mapper、service、controller，我相信小伙伴们也不需要生成，对于你们来说都是洒洒水了。【当然也有很多插件可以生成】