IDEA 不愧为神器，结合 Groovy 脚本，简直无敌！

文章地址：sf.gg/a/1190000020189801

松哥原创的 Spring Boot 视频教程已经杀青，感兴趣的小伙伴戳这里-->Spring Boot+Vue+微人事视频教程

*

导语: 如今已 2020 年, 有许许多多的插件或者编辑器都支持根据数据表自动生成数据实体类了, 比如 IDEA, 各种 MyBatis 的代码生成工具, 等等. 本篇介绍一下如何使用 IDEA 的 groovy 脚本文件生成带 JPA 注解的实体类。

”

一、使用 IDEA 连接数据库

需注意:

• 正式版 IDEA 才有此功能,
  社区版木有
  
• 演示图片使用的 IDEA 版本为 2018.3,
  不同版本界面可能有细小差别
  

1.1 创建新的数据连接

• ① 如果没有,
  可以上方菜单栏: 视图-工具窗口-Database 打开
  
• 新建 Oracle 数据库也是相同操作
  

1.2 配置数据连接

1. 填写一个连接名，随便填什么都行
   
2. 不用选择，默认就行
   
3. 填写数据库连接的 IP 地址，比如本地数据库可以填写：localhost 或者 127.0.0.1
   
4. 填写数据库开放的端口号，一般没设置的话默认都是 3306
   
5. 填写你需要连接的数据库名
   
6. 填写数据库的用户名
   
7. 填写数据库密码
   
8. 这里会有一个驱动需要点击下载，图中是已经下载好了
   
9. 填写自己的数据库连接 url，然后可以点击9所在按钮进行测试连接，本地连接失败检查是否开启了 mysql 服务
   

二、IDEA 自带的两种创建实体类方法

(1),如果只是创建简单的, 只有属性, getter, setter 的实体类, 而不需要 JPA/Hibernate 的实体类注解。

1. 单击打开刚刚创建的数据连接。
   
2. 打开 schemas,
   找到自己需要创建实体类的表(可以使用 ctrl 或 shift 多选)
   
3. 右键: Scripted Extensions - Generate POJOs.groovy
   
4. 选择生成路径就 OK 了
   

需注意

生成的包名可能有问题, 默认是 package com.sample, 需要自己手动修改

(2),使用了 Hibernate/Jpa 框架, 需要的是有注解的实体类, Idea 也提供了相应的方法

添加JPA模块

1. 打开项目结构
   
2. 打开模块,
   点击 + 号添加模块
   
3. 选择 JPA
   
4. 点击右下角确定后,
   关闭项目结构
   

使用 Persistence 工具生成带注解的实体类-1

1. 如果上一步没问题的话,
   IDEA 左下角侧边栏会出现 Persistence 工具栏
   
2. 打开 Persistence 工具栏,
   右键项目: Generate Persistence Mapping - By Database Schema
   

使用 Persistence 工具生成带注解的实体类-2

1. 选择数据库连接
   
2. 选择生成类所在包
   
3. 选择要生成的表
   
4. 选择要生成的字段(选择表后字段默认除了外键全选)
   
5. 修改要生成的属性名
   
6. 修改要生成的属性类型
   
7. 勾上即为生成带注解的实体类
   

生成的类实例如下:

三、更进一步, 使用自己的 Groovy 生成带注解的实体类

上面介绍了两个使用 IDEA 生成实体类的方法, 各有优缺点。

生成不带注解的实体类简单高效, 但缺点就是如果使用的是 Jpa/Hibernate 框架就不适合。

生成带注解的实体类能生成注解实体类, 但缺点就是生成的实体类的注解可能不太符合我们的注解, 只能生成到当前项目包下, 面对一些复杂的数据库如 Oracle 会显示很多系统表而且表空间切换不太方便。

我们知道 Idea 生成不带注解的实体类是通过 Groovy 脚本文件生成的, 我们也能找到这个文件, 那我们能不能修改这个文件, 让它生成带注解的实体类呢?

(1), 使用自己的 Groovy 生成带注解的实体类的好处

1. 在 Database 工具栏里,
   操作简单方便
   
2. 可以自己对脚本进行一些编辑,
   使生成的实体类达到自己的定制需求
   
3. 对 Oracle 这样的数据库生成实体类时,
   避免了系统表的影响,
   可以自己选择表空间进行操作
   
4. 可以生成在电脑上的任何位置,
   不受限制
   

(2), 使用自己的 Groovy 生成带注解的实体类的不足

1. @author 作者名需要自己修改脚本
   
2. @Table(Schema="") 的表空间名不能读取,
   需要自己修改脚本,
   设定表空间名(mysql可以直接删除这个属性的定义)(IDEA 的 Persistence 工具可以读取(Schema=""属性并生成,
   但我们不知道它是怎么获取的)
   
3. @Id 的主键生成方式不可知,
   需要生成后自己确定(mysql 用户可以直接修改脚本设定主键生成方式,
   但 Oracle 用户需要生成实体类后再逐个确认)
   

(3), 使用自己的 Groovy 生成带注解的实体类可以继续完善的地方

1. 如果需要 hashcode() 和 equals() 方法,
   也修改脚本,
   使其自动生成
   

(4), 新建一个 Groovy 脚本文件

1. Database 工具栏里,
   右键右键: Scripted Extensions - Go to Scripts Directory
   
2. 在目录下新建一个 Generate MyPOJOs.groovy
   

添加里面的内容

1. //1. 修改 idea 为自己名字 的地方可以修改作者名字为自己的
   
2. //2. schema = " 后面添加自己的表空间名称(mysql可以不添加,
   不用这个 schema 属性也行) 这里可以根据提示修改
   

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.text.SimpleDateFormat

/*
 * Available context bindings:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */
packageName = ""
typeMapping = [
        (~/(?i)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 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) }

//    new File(dir, className + ".java").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 javax.persistence.Column;"
    out.println "import javax.persistence.Entity;"
    out.println "import javax.persistence.Table;"
    out.println "import javax.persistence.Id;"
    out.println "import javax.persistence.GeneratedValue;"
    out.println "import java.io.Serializable;"
    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  idea\n" + //1. 修改idea为自己名字
            " * @Date " + new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " \n" +
            " */"
    out.println ""
    out.println "@Entity"
    out.println "@Table ( name =\"" + table.getName() + "\" , schema = \"\")" //2. schema = \"后面添加自己的表空间名称(mysql可以不添加, 不用这个schema属性也行)
    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@Id"

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


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

    // 输出get/set方法
    fields.each() {
        out.println ""
        out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"
        out.println "\t\treturn this.${it.name};"
        out.println "\t}"
        out.println ""

        out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
        out.println "\t\tthis.${it.name} = ${it.name};"
        out.println "\t}"
    }

    // 输出toString方法
    out.println ""
    out.println "\t@Override"
    out.println "\tpublic String toString() {"
    out.println "\t\treturn \"TpApiConfig{\" +"
    fields.each() {
        out.println "\t\t\t\t\"${it.name}='\" + ${it.name} + '\\'' +"
    }
    out.println "\t\t\t\t'}';"
    out.println "\t}"

    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@Column(name = \"" + col.getName() + "\" )"]
        if ("id".equals(Case.LOWER.apply(col.getName())))
            comm.annos += ["@Id"]
        fields += [comm]
    }
}

// 已经修改为使用javaName, 如果有需要可以在def className = javaName(table.getName(), true)中修改为javaClassName
// 处理类名（这里是因为我的表都是以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}[_]]/, "_")
    // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm
    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 = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }
//            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_")
//    capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
    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;"
}

表上右键, 选择自己写的脚本生成实体类。

最终生成效果如下: