IDEA反向生成实体的两种方法

网上搜了好几种IDEA反向生成实体的方法，感觉都不是很全面，都存在或多或少的一些小问题，所以自己通过使用进行下总结

第一种方式 通过groovy脚本生成 （该方式灵活，可自己加注解，自己对应相应的数据类型，推荐使用这种）

在IDEA的项目窗口栏最下面可以看到这个

如上图所示创建一个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.sql.Date

packageName = "com.sample;"
/**
 * 这里可以将数据库类型对应相应的Java类型，如果不是lang包里的类型，需要手动引入包，例如BigDecimal
 */
typeMapping = [
        (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
        (~/(?i)int/)                             : "Integer",
        (~/(?i)bool|bit/)                        : "Boolean",
        (~/(?i)float|double|decimal|real/)       : "BigDecimal",
        (~/(?i)datetime|timestamp|date|time/)    : "Date",
        (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
        (~/(?i)number/)                          : "BigDecimal",
        (~/(?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 = javaClassName(table.getName(), true)
  def fields = calcFields(table)
  //当是maven项目的时候，需要解开下面的注释
  packageName = getPackageName(dir)
  //这里一定要记得加上UTF-8，不然中文注释全是乱码
  new File(dir, className + ".java").withPrintWriter("UTF-8") { out -> generate(out, className, fields,table) }
}


def generate(out, className, fields, table) {
  out.println "package $packageName"
  out.println ""
  //引入所有JPA注解包
  out.println "import javax.persistence.*;"
  out.println "import java.io.Serializable;"

  Set types = new HashSet()

  fields.each() {
    types.add(it.type)
  }
  //引入lang包没有带的数据类型
  if (types.contains("Date")) {
    out.println "import java.util.Date;"
  }
  if (types.contains("BigDecimal")) {
    out.println "import java.math.BigDecimal;"
  }
  if (types.contains("InputStream")) {
    out.println "import java.io.InputStream;"
  }
  //注释引入 作者
  out.println ""
  out.println "/**\n" +
          " * @Description: \n" +
          " * @Date: Created in" + new java.util.Date().toString() +"\n"+
          " * @Author: author\n" +
          " * @Modified By:\n" +
          " */"
  out.println "@Entity"
  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 "\tprivate ${it.type} ${it.name};"
  }
  out.println ""
  //输出空参数构造函数
  out.println "\tpublic $className(){}"
  out.println ""

  //输出相应get/set方法
  fields.each() {
    out.println ""
    if (it.annos != "") out.println "   ${it.annos}"
    out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"
    out.println "\t\treturn ${it.name};"
    out.println "\t}"
    out.println "\t"
    out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
    out.println "\t\tthis.${it.name} = ${it.name};"
    out.println "\t}"
    out.println ""
  }
  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    : changeStyle(javaName(col.getName(), false), true),
            type    : typeStr,
            commoent: col.getComment(),
            annos   : "\t@Column(name = \"" + col.getName() + "\" )"]
    if ("id".equals(Case.LOWER.apply(col.getName()))){
      comm.annos = "\t@Id"
      //自增主键需要
      // comm.annos += "\t@GeneratedValue(strategy = GenerationType.IDENTITY)"
    }
    if("Date".equalsIgnoreCase(comm.type)){
      comm.annos="\t@Temporal(TemporalType.TIMESTAMP)\n"+comm.annos
    }
    fields += [comm]
  }
}

// 处理类名，主要是去驼峰，如果有那种以t开头的表名，请自行修改该函数
def javaClassName(str, capitalize) {
  def s = str.split(/[^\p{Alnum}]/).collect { def s = Case.LOWER.apply(it).capitalize() }.join("")
  // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm
  //s = s[1..s.size() - 1]
  capitalize ? 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 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;";
}


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

切到database窗口

如上图所示，Generate MyPOJOs.groovy为我创建的脚本，多张表可以用ctrl+单击选择多张表进行生成

2、第二种方式，（利用自带的框架支持生成，需要使用hibernate或者JPA）

找到你的IDEA persistence窗口（如下图所示，如果没有，右键项目，add Framework support，添加hibernate框架支持就可以了）

进入该界面

下面还可以选择是否生成注解和配置文件，但是我不知道该种方法如何改对应的数据类型，默认Date类型对应java.sql.Time，生成之后还要一个个实体去修改，所以我不推荐，有小伙伴知道可以让这种方式数据类型变化的可以留言告诉我哦